diff --git a/Chat/Readme.md b/Chat/Readme.md
new file mode 100644
index 00000000..25dea3f9
--- /dev/null
+++ b/Chat/Readme.md
@@ -0,0 +1,3 @@
+## Chat
+
+OpenAI based Chat module
diff --git a/Chat/function-calls.js b/Chat/function-calls.js
new file mode 100644
index 00000000..b9dc642b
--- /dev/null
+++ b/Chat/function-calls.js
@@ -0,0 +1,1073 @@
+// script for handling function calls 
+
+// error handling
+window.onerror = function (msg, url, linenumber) {
+  alert('Sorry, something went wrong.\n\n' +
+    'Please try a hard reload of this page to clear its cache.\n\n' +
+    'If the error persists open an issue on the GitHub repo.\n' +
+    'Include a copy of the log and the following error message:\n\n' +
+    msg + '\n' +
+    'URL: ' + url + '\n' +
+    'Line Number: ' + linenumber)
+  return false
+}
+window.addEventListener('unhandledrejection', function (e) {
+  throw new Error(e.reason.stack)
+})
+
+// imports
+import { mavlink_store } from '../modules/MAVLink/mavlink_store.js';
+import { MAVLink, mavlink_ws } from './shared/mavlink.js';
+import { add_text_to_debug } from "./shared/ui.js";
+
+// global variable to store wakeup messages
+window.wakeup_schedule = [];
+
+// handle function call from assistant
+async function handle_function_call(name, args) {
+  // call the function
+  switch (name) {
+    case "get_vehicle_type":
+      // get the vehicle type (e.g. Copter, Plane, Rover, Boat, etc)
+      return get_vehicle_type();
+    case "get_parameter":
+      // Get a vehicle parameter's value.  The full list of available parameters and their values is available using the get_all_parameters function
+      return await get_parameter(args);
+    case "get_wakeup_timers":
+      // Retrieves a list of all active wakeup timers. You can optionally provide a message parameter to filter timers by their associated messages. When specifying the message parameter, you can use regular expressions (regex) to match patterns within the timer messages. This is useful when you want to find timers with specific keywords or patterns in their messages. For example, to retrieve all timers containing the word 'hello', you can use the regex '.*hello.*', where the dot-star (.*) pattern matches any character sequence.
+      return get_wakeup_timers(args);
+    case "get_vehicle_location_and_yaw":
+      // Get the vehicle's current location including latitude, longitude, altitude above sea level and altitude above home
+      return get_vehicle_location_and_yaw()
+    case "send_mavlink_set_position_target_global_int":
+      // Send a mavlink SET_POSITION_TARGET_GLOBAL_INT message to the vehicle.  This message is the preferred way to command a vehicle to fly to a specified location or to fly at a specfied velocity
+      return send_mavlink_set_position_target_global_int(args);
+    case "get_vehicle_state":
+      // Get the vehicle state including armed status and (flight) mode
+      return get_vehicle_state();
+    case "get_location_plus_offset":
+      // Calculate the latitude and longitude given an existing latitude and longitude and distances (in meters) North and East
+      return get_location_plus_offset(args);
+    case "send_mavlink_command_int":
+      // Send a mavlink COMMAND_INT message to the vehicle.  Available commands including changing the flight mode, arming, disarming, takeoff and commanding the vehicle to fly to a specific location
+      return await send_mavlink_command_int(args);
+    case "get_location_plus_dist_at_bearing":
+      // Calculate the latitude and longitude given an existing latitude and longitude and a distance in meters and a bearing in degrees
+      return get_location_plus_dist_at_bearing(args);
+    case "get_parameter_description":
+      // Get vehicle parameter descriptions including description, units, min and max
+      return await get_parameter_description(args);
+    case "delete_wakeup_timers":
+      // Delete all active wakeup timers. You can optionally provide a message parameter to filter which timers will be deleted based on their message. When specifying the message parameter, you can use regular expressions (regex) to match patterns within the timer messages. This is useful when you want to delete timers with specific keywords or patterns in their message. For example, to delete all timers containing the word 'hello', you can use the regex '.*hello.*', where the dot-star (.*) pattern matches any character sequence.
+      return delete_wakeup_timers(args);
+    case "set_parameter":
+      // Set a vehicle parameter's value.  The full list of parameters is available using the get_all_parameters function
+      return await set_parameter(args);
+    case "get_mavlink_message":
+      // Get a mavlink message including all fields and values sent by the vehicle.  The list of available messages can be retrieved using the get_available_mavlink_messages
+      return get_mavlink_message(args);
+    case "get_current_datetime":
+      // Get the current date and time, e.g. 'Saturday, June 24, 2023 6:14:14 PM
+      add_text_to_debug("get_current_datetime called");
+      return getFormattedDate();
+    case "get_mode_mapping":
+      // Get a list of mode names to mode numbers available for this vehicle.  If the name or number parameter is provided only that mode's name and number will be returned.  If neither name nor number is provided the full list of available modes will be returned
+      add_text_to_debug("get_mode_mapping called");
+      return get_mode_mapping(args);
+    case "get_all_parameters":
+      // Get all available parameter names and values
+      return await get_all_parameters(args);
+    case "set_wakeup_timer":
+      // Set a timer to wake you up in a specified number of seconds in the future.  This allows taking actions in the future.  The wakeup message will appear with the user role but will look something like WAKEUP:<message>.  Multiple wakeup messages are supported
+      return set_wakeup_timer(args);
+    case "get_available_mavlink_messages":
+      return mavlink_store.get_available_message_names();
+    default:
+      add_text_to_debug("Unknown function: " + name);
+      return "Unknown function: " + name;
+  }
+}
+
+// function calls below here
+// returns "Copter", "Plane", "Rover", "Boat", etc or "Unknown"
+function get_vehicle_type() {
+  // get the latest HEARTBEAT message and perform a sanity check
+  let heartbeat_msg = mavlink_store.get_latest_message(0);
+  if (!heartbeat_msg || !heartbeat_msg.hasOwnProperty("type")) {
+    return "unknown because no HEARTBEAT message has been received from the vehicle";
+  }
+  let vehicle_type = heartbeat_msg["type"];
+
+  // get the vehicle type from the heartbeat message's type field
+  switch (vehicle_type) {
+    case mavlink20.MAV_TYPE_FIXED_WING:
+    case mavlink20.MAV_TYPE_VTOL_DUOROTOR:
+    case mavlink20.MAV_TYPE_VTOL_QUADROTOR:
+    case mavlink20.MAV_TYPE_VTOL_TILTROTOR:
+      return "Plane"
+    case mavlink20.MAV_TYPE_GROUND_ROVER:
+      return "Rover";
+    case mavlink20.MAV_TYPE_SURFACE_BOAT:
+      return "Boat";
+    case mavlink20.MAV_TYPE_SUBMARINE:
+      return "Sub";
+    case mavlink20.MAV_TYPE_QUADROTOR:
+    case mavlink20.MAV_TYPE_COAXIAL:
+    case mavlink20.MAV_TYPE_HEXAROTOR:
+    case mavlink20.MAV_TYPE_OCTOROTOR:
+    case mavlink20.MAV_TYPE_TRICOPTER:
+    case mavlink20.MAV_TYPE_DODECAROTOR:
+      return "Copter";
+    case mavlink20.MAV_TYPE_HELICOPTER:
+      return "Heli";
+    case mavlink20.MAV_TYPE_ANTENNA_TRACKER:
+      return "Tracker";
+    case mavlink20.MAV_TYPE_AIRSHIP:
+      return "Blimp";
+    default:
+      add_text_to_debug("get_vehicle_type: default, unknown");
+      return "unknown";
+  }
+
+  // if we got this far  we don't know the vehicle type
+  add_text_to_debug("get_vehicle_type: no match for type:" + heartbeat_msg.type);
+  return "unknown";
+}
+
+// return a mapping of mode names to numbers for the current vehicle type
+function get_mode_mapping(args) {
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      add_text_to_debug("get_mode_mapping: ERROR parsing args string");
+      args = {};
+    }
+  }
+
+  args = args || {};
+
+  // get name and/or number arguments
+  let mode_name = args.name ?? null;
+  if (mode_name != null) {
+    mode_name = mode_name.toUpperCase();
+  }
+
+  let mode_number = args.number ?? null;
+  if (mode_number != null) {
+    mode_number = parseInt(mode_number, 10);
+  }
+
+  // prepare list of modes
+  let mode_list = [];
+  let mode_mapping = {};
+
+  const vehicle_type = get_vehicle_type();
+  switch (vehicle_type) {
+    case "Heli":
+    case "Blimp":
+    case "Copter":
+      mode_mapping = {
+        "STABILIZE": mavlink20.COPTER_MODE_STABILIZE,
+        "ACRO": mavlink20.COPTER_MODE_ACRO,
+        "ALT_HOLD": mavlink20.COPTER_MODE_ALT_HOLD,
+        "AUTO": mavlink20.COPTER_MODE_AUTO,
+        "GUIDED": mavlink20.COPTER_MODE_GUIDED,
+        "LOITER": mavlink20.COPTER_MODE_LOITER,
+        "RTL": mavlink20.COPTER_MODE_RTL,
+        "CIRCLE": mavlink20.COPTER_MODE_CIRCLE,
+        "LAND": mavlink20.COPTER_MODE_LAND,
+        "DRIFT": mavlink20.COPTER_MODE_DRIFT,
+        "SPORT": mavlink20.COPTER_MODE_SPORT,
+        "FLIP": mavlink20.COPTER_MODE_FLIP,
+        "AUTOTUNE": mavlink20.COPTER_MODE_AUTOTUNE,
+        "POSHOLD": mavlink20.COPTER_MODE_POSHOLD,
+        "BRAKE": mavlink20.COPTER_MODE_BRAKE,
+        "THROW": mavlink20.COPTER_MODE_THROW,
+        "AVOID_ADSB": mavlink20.COPTER_MODE_AVOID_ADSB,
+        "GUIDED_NOGPS": mavlink20.COPTER_MODE_GUIDED_NOGPS,
+        "SMART_RTL": mavlink20.COPTER_MODE_SMART_RTL,
+        "FLOWHOLD": mavlink20.COPTER_MODE_FLOWHOLD,
+        "FOLLOW": mavlink20.COPTER_MODE_FOLLOW,
+        "ZIGZAG": mavlink20.COPTER_MODE_ZIGZAG,
+        "SYSTEMID": mavlink20.COPTER_MODE_SYSTEMID,
+        "AUTOROTATE": mavlink20.COPTER_MODE_AUTOROTATE,
+        "AUTO_RTL": mavlink20.COPTER_MODE_AUTO_RTL
+      };
+      break;
+    case "Plane":
+      mode_mapping = {
+        "MANUAL": mavlink20.PLANE_MODE_MANUAL,
+        "CIRCLE": mavlink20.PLANE_MODE_CIRCLE,
+        "STABILIZE": mavlink20.PLANE_MODE_STABILIZE,
+        "TRAINING": mavlink20.PLANE_MODE_TRAINING,
+        "ACRO": mavlink20.PLANE_MODE_ACRO,
+        "FLY_BY_WIRE_A": mavlink20.PLANE_MODE_FLY_BY_WIRE_A,
+        "FLY_BY_WIRE_B": mavlink20.PLANE_MODE_FLY_BY_WIRE_B,
+        "CRUISE": mavlink20.PLANE_MODE_CRUISE,
+        "AUTOTUNE": mavlink20.PLANE_MODE_AUTOTUNE,
+        "AUTO": mavlink20.PLANE_MODE_AUTO,
+        "RTL": mavlink20.PLANE_MODE_RTL,
+        "LOITER": mavlink20.PLANE_MODE_LOITER,
+        "TAKEOFF": mavlink20.PLANE_MODE_TAKEOFF,
+        "AVOID_ADSB": mavlink20.PLANE_MODE_AVOID_ADSB,
+        "GUIDED": mavlink20.PLANE_MODE_GUIDED,
+        "INITIALIZING": mavlink20.PLANE_MODE_INITIALIZING,
+        "QSTABILIZE": mavlink20.PLANE_MODE_QSTABILIZE,
+        "QHOVER": mavlink20.PLANE_MODE_QHOVER,
+        "QLOITER": mavlink20.PLANE_MODE_QLOITER,
+        "QLAND": mavlink20.PLANE_MODE_QLAND,
+        "QRTL": mavlink20.PLANE_MODE_QRTL,
+        "QAUTOTUNE": mavlink20.PLANE_MODE_QAUTOTUNE,
+        "QACRO": mavlink20.PLANE_MODE_QACRO,
+        "THERMAL": mavlink20.PLANE_MODE_THERMAL
+      };
+      break;
+    case "Boat":
+    case "Rover":
+      mode_mapping = {
+        "MANUAL": mavlink20.ROVER_MODE_MANUAL,
+        "ACRO": mavlink20.ROVER_MODE_ACRO,
+        "STEERING": mavlink20.ROVER_MODE_STEERING,
+        "HOLD": mavlink20.ROVER_MODE_HOLD,
+        "LOITER": mavlink20.ROVER_MODE_LOITER,
+        "FOLLOW": mavlink20.ROVER_MODE_FOLLOW,
+        "SIMPLE": mavlink20.ROVER_MODE_SIMPLE,
+        "AUTO": mavlink20.ROVER_MODE_AUTO,
+        "RTL": mavlink20.ROVER_MODE_RTL,
+        "SMART_RTL": mavlink20.ROVER_MODE_SMART_RTL,
+        "GUIDED": mavlink20.ROVER_MODE_GUIDED,
+        "INITIALIZING": mavlink20.ROVER_MODE_INITIALIZING
+      };
+      break;
+    case "Sub":
+      mode_mapping = {
+        "STABILIZE": mavlink20.SUB_MODE_STABILIZE,
+        "ACRO": mavlink20.SUB_MODE_ACRO,
+        "ALT_HOLD": mavlink20.SUB_MODE_ALT_HOLD,
+        "AUTO": mavlink20.SUB_MODE_AUTO,
+        "GUIDED": mavlink20.SUB_MODE_GUIDED,
+        "CIRCLE": mavlink20.SUB_MODE_CIRCLE,
+        "SURFACE": mavlink20.SUB_MODE_SURFACE,
+        "POSHOLD": mavlink20.SUB_MODE_POSHOLD,
+        "MANUAL": mavlink20.SUB_MODE_MANUAL
+      };
+      break;
+    case "Tracker":
+      mode_mapping = {
+        "MANUAL": mavlink20.TRACKER_MODE_MANUAL,
+        "STOP": mavlink20.TRACKER_MODE_STOP,
+        "SCAN": mavlink20.TRACKER_MODE_SCAN,
+        "SERVO_TEST": mavlink20.TRACKER_MODE_SERVO_TEST,
+        "AUTO": mavlink20.TRACKER_MODE_AUTO,
+        "INITIALIZING": mavlink20.TRACKER_MODE_INITIALIZING
+      };
+      break;
+    default:
+      // maybe we don't know the vehicle type
+      add_text_to_debug("get_mode_mapping: unknown vehicle type: " + vehicle_type);
+      return `get_mode_mapping: failed to retrieve mode mapping: unknown vehicle type: ${vehicle_type}`;
+  }
+
+  // handle request for all modes
+  if (mode_name === null && mode_number === null) {
+    for (let mname in mode_mapping) {
+      let mnumber = mode_mapping[mname];
+      mode_list.push({ "name": mname.toUpperCase(), "number": mnumber });
+    }
+  }
+  // handle request using mode name
+  else if (mode_name !== null) {
+    for (let mname in mode_mapping) {
+      if (mname.toUpperCase() === mode_name) {
+        mode_list.push({ "name": mname.toUpperCase(), "number": mode_mapping[mname] });
+      }
+    }
+  }
+  // handle request using mode number
+  else if (mode_number !== null) {
+    for (let mname in mode_mapping) {
+      let mnumber = mode_mapping[mname];
+      if (mnumber === mode_number) {
+        mode_list.push({ "name": mname.toUpperCase(), "number": mnumber });
+      }
+    }
+  }
+
+  // return list of modes
+  return mode_list;
+}
+
+function get_mavlink_message(args) {
+  // Check if it's a string and parse it
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      return { status: "error", message: "Invalid JSON in arguments" };
+    }
+  }
+
+  // check if name is provided
+  if (!args || !args.hasOwnProperty("message")) {
+    add_text_to_debug("get_mavlink_message: message is null");
+    return "get_mavlink_message: message is Null";
+  }
+
+  const msg = mavlink_store.find_message_by_name(args.message);
+  if (!msg) {
+    return "get_mavlink_message: message not found";
+  }
+  return msg;
+}
+
+function get_parameter(args) {
+  try {
+    return new Promise((resolve, reject) => {
+      // Check WebSocket ready
+      if (!MAVLink || !mavlink_ws || mavlink_ws.readyState !== WebSocket.OPEN) {
+        reject("MAVLink or WebSocket not ready");
+        return;
+      }
+
+      // Parse input
+      if (typeof args === "string") {
+        try {
+          args = JSON.parse(args);
+        } catch (e) {
+          add_text_to_debug("get_parameter: ERROR parsing args string");
+          reject("Invalid arguments: JSON parse error");
+          return;
+        }
+      }
+
+      if (!args || !args.name) {
+        reject("get_parameter: name not specified");
+        return;
+      }
+
+      const param_name = args.name.trim();
+
+      // Register resolver
+      const resolver = (value) => {
+        clearTimeout(timeoutId);
+        delete window.pending_param_requests[param_name];
+        resolve(value);
+      };
+
+      // Register in global pending requests
+      window.pending_param_requests[param_name] = resolver;
+
+      // Send PARAM_REQUEST_READ
+      try {
+        const message = new mavlink20.messages.param_request_read(
+          1,   // target_system
+          1,   // target_component
+          param_name, // param_id
+          -1   // use param_id
+        );
+
+        const pkt = message.pack(MAVLink);
+        mavlink_ws.send(Uint8Array.from(pkt));
+
+        add_text_to_debug(`Sent PARAM_REQUEST_READ for ${param_name}`);
+      } catch (error) {
+        delete window.pending_param_requests[param_name];
+        reject("Error sending PARAM_REQUEST_READ: " + error);
+        return;
+      }
+
+      // timeout: 5 seconds
+      const timeoutId = setTimeout(() => {
+        if (window.pending_param_requests[param_name]) {
+          delete window.pending_param_requests[param_name];
+          add_text_to_debug(`Timeout waiting for PARAM_VALUE for ${param_name}`);
+          reject(`No PARAM_VALUE received for "${param_name}" within 10 seconds. The parameter may not exist on this vehicle.`);
+        }
+      }, 5000);
+    });
+  } catch (error) {
+    add_text_to_debug("get_parameter: Error: " + error);
+    return Promise.reject("get_parameter: Error retrieving parameter");
+  }
+}
+
+// returns true if string contains regex characters
+function contains_regex(string) {
+  const regex_characters = ".^$*+?{}[]\\|()";
+  for (const char of regex_characters) {
+    if (string.includes(char)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function get_all_parameters() {
+  return new Promise((resolve, reject) => {
+    if (!MAVLink || !mavlink_ws || mavlink_ws.readyState !== WebSocket.OPEN) {
+      reject("MAVLink or WebSocket not ready");
+      return;
+    }
+
+    if (window.pending_all_params_request) {
+      reject("Another get_all_parameters request is already in progress");
+      return;
+    }
+
+    // Set up the pending request
+    window.pending_all_params_request = {
+      params: {},
+      resolve: resolve
+    };
+
+    try {
+      const message = new mavlink20.messages.param_request_list(
+        1, // target_system
+        1  // target_component
+      );
+
+      const pkt = message.pack(MAVLink);
+      mavlink_ws.send(Uint8Array.from(pkt));
+
+      add_text_to_debug("Sent PARAM_REQUEST_LIST to vehicle");
+    } catch (error) {
+      window.pending_all_params_request = null;
+      reject("Error sending PARAM_REQUEST_LIST: " + error);
+      return;
+    }
+
+    // timeout: 15 seconds
+    setTimeout(() => {
+      if (window.pending_all_params_request) {
+        window.pending_all_params_request = null;
+        reject("Timeout waiting for all parameters");
+      }
+    }, 15000);
+  });
+}
+
+// Global cache for parameter metadata
+const parameter_metadata_cache = {};
+
+const parameter_url_map = {
+  Tracker: "https://autotest.ardupilot.org/Parameters/AntennaTracker/apm.pdef.json",
+  Copter: "https://autotest.ardupilot.org/Parameters/ArduCopter/apm.pdef.json",
+  Plane: "https://autotest.ardupilot.org/Parameters/ArduPlane/apm.pdef.json",
+  Rover: "https://autotest.ardupilot.org/Parameters/Rover/apm.pdef.json",
+  Sub: "https://autotest.ardupilot.org/Parameters/ArduSub/apm.pdef.json"
+};
+
+async function load_parameter_metadata(vehicle_type) {
+  if (parameter_metadata_cache[vehicle_type]) {
+    add_text_to_debug(`Using cached parameter metadata for ${vehicle_type}`);
+    return parameter_metadata_cache[vehicle_type];
+  }
+
+  const url = parameter_url_map[vehicle_type];
+  if (!url) {
+    add_text_to_debug(`No parameter definition URL found for vehicle type: ${vehicle_type}`);
+    return null;
+  }
+
+  try {
+    add_text_to_debug(`Fetching parameter metadata for ${vehicle_type} from ${url}`);
+    const res = await fetch(url);
+    if (!res.ok) {
+      add_text_to_debug(`Failed to fetch parameter metadata for ${vehicle_type}: ${res.status}`);
+      return null;
+    }
+    add_text_to_debug(`Successfully fetched parameter metadata for ${vehicle_type}`);
+
+    const data = await res.json();
+    parameter_metadata_cache[vehicle_type] = data;
+    return data;
+
+  } catch (error) {
+    add_text_to_debug(`Error fetching parameter metadata for ${vehicle_type}:`, error);
+    return null;
+  }
+}
+
+function find_param_in_tree(tree, vehicle_type, param_upper) {
+  for (const [key, val] of Object.entries(tree)) {
+    if (typeof val === "object") {
+      if (key.toUpperCase() === param_upper) {
+        return { key, meta: val };
+      }
+      if (`${vehicle_type}:${param_upper}` === key.toUpperCase()) {
+        return { key, meta: val };
+      }
+      const result = find_param_in_tree(val, vehicle_type, param_upper);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+
+function get_single_parameter_description(param_tree, vehicle_type, param_name) {
+  const param_upper = param_name.toUpperCase();
+
+  const result = find_param_in_tree(param_tree, vehicle_type, param_upper);
+
+  if (!result) return null;
+
+  return result;
+}
+
+
+async function get_parameter_description(args) {
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      return "get_parameter_description: invalid JSON";
+    }
+  }
+
+  if (!args || !args.name) {
+    return "get_parameter_description: name not specified";
+  }
+
+  const param_name = args.name;
+  const vehicle_type = get_vehicle_type();
+  const param_tree = await load_parameter_metadata(vehicle_type);
+  if (!param_tree) {
+    return `get_parameter_description: No metadata for vehicle type: ${vehicle_type}`;
+  }
+
+  const results = {};
+
+  if (contains_regex(param_name)) {
+    const pattern = new RegExp(param_name.replace(/\*/g, ".*"), "i");
+
+    for (const [key, val] of Object.entries(param_tree)) {
+      if (pattern.test(key)) {
+        const single = get_single_parameter_description(param_tree, vehicle_type, key);
+        if (single) results[key] = single;
+      } else if (typeof val === "object") {
+        for (const [subkey] of Object.entries(val)) {
+          if (pattern.test(subkey)) {
+            const single = get_single_parameter_description(param_tree, vehicle_type, subkey);
+            if (single) results[subkey] = single;
+          }
+        }
+      }
+    }
+
+    if (Object.keys(results).length === 0) {
+      return `get_parameter_description: No parameters matched pattern: ${param_name}`;
+    }
+    return results;
+  }
+
+  // Exact
+  const single = get_single_parameter_description(param_tree, vehicle_type, param_name);
+  if (!single) {
+    return `get_parameter_description: ${param_name} parameter description not found`;
+  }
+
+  results[param_name] = single;
+  return results;
+}
+
+// send a PARAM_SET message to change a vehicle parameter
+function set_parameter(args) {
+  if (!MAVLink || !mavlink_ws) {
+    return "set_parameter: MAVLink or WebSocket not ready";
+  }
+
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      add_text_to_debug("ERROR set_parameter: Could not parse args JSON");
+      return "Invalid arguments: JSON parse error";
+    }
+  }
+
+  if (!args || !args.hasOwnProperty("name") || args.value === undefined) {
+    return "set_parameter: name and value required";
+  }
+
+  const name = args.name ? args.name.trim() : null;
+  if (!name) {
+    return "set_parameter: name cannot be empty";
+  }
+
+  const value = parseFloat(args.value);
+  const message = new mavlink20.messages.param_set(
+    1, // target system
+    1, // target component
+    name,
+    value,
+    mavlink20.MAV_PARAM_TYPE_REAL32
+  );
+
+  if (mavlink_ws.readyState === WebSocket.OPEN) {
+    try {
+      const pkt = message.pack(MAVLink);
+      mavlink_ws.send(Uint8Array.from(pkt));
+      return "set_parameter: sent";
+    } catch (error) {
+      add_text_to_debug("Error sending PARAM_SET: " + error);
+      return "set_parameter: send failed";
+    }
+  }
+  return "set_parameter: WebSocket not open";
+}
+
+function send_mavlink_set_position_target_global_int(args) {
+  if (!MAVLink || !mavlink_ws) {
+    add_text_to_debug("MAVLink or WebSocket not ready");
+    return { success: false, error: "MAVLink not initialized" };
+  }
+
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      add_text_to_debug("ERROR: Could not parse args JSON");
+      return "Invalid arguments: JSON parse error";
+    }
+  }
+
+  try {
+    const time_boot_ms = args.time_boot_ms ?? 0;
+    const target_system = args.target_system ?? 1;
+
+    const target_component = args.target_component ?? 1;
+    const coordinate_frame = args.coordinate_frame ?? 5;
+    const type_mask = args.type_mask ?? 0; // ignore all position, velocity and acceleration except for the ones we set
+
+    const lat_int = args.latitude !== undefined ? Math.round(args.latitude * 1e7) : 0;
+    const lon_int = args.longitude !== undefined ? Math.round(args.longitude * 1e7) : 0;
+    const alt = args.alt !== undefined ? args.alt : 0;  // in meters
+
+    // Velocity
+    const vx = args.vx ?? 0;
+    const vy = args.vy ?? 0;
+    const vz = args.vz ?? 0;
+
+    // Acceleration (ignored if not needed)
+    const afx = args.afx ?? 0;
+    const afy = args.afy ?? 0;
+    const afz = args.afz ?? 0;
+
+    // Yaw and yaw_rate
+    const yaw = args.yaw ?? 0;
+    const yaw_rate = args.yaw_rate ?? 0;
+
+
+    // sanity check arguments
+    if (type_mask === 3576) {
+      // if position is specified check lat, lon, alt are provided
+      if (!args.hasOwnProperty("latitude")) {
+        return "send_mavlink_set_position_target_global_int: latitude field required";
+      }
+      if (!args.hasOwnProperty("longitude")) {
+        return "send_mavlink_set_position_target_global_int: longitude field required";
+      }
+      if (!args.hasOwnProperty("alt")) {
+        return "send_mavlink_set_position_target_global_int: alt field required";
+      }
+    }
+
+    const message = new mavlink20.messages.set_position_target_global_int(
+      time_boot_ms, target_system, target_component,
+      coordinate_frame, type_mask,
+      lat_int, lon_int, alt,
+      vx, vy, vz, afx, afy, afz,
+      yaw, yaw_rate
+    );
+
+    if (mavlink_ws && mavlink_ws.readyState === WebSocket.OPEN) {
+      try {
+        const pkt = message.pack(MAVLink);
+        mavlink_ws.send(Uint8Array.from(pkt));
+
+      } catch (error) {
+        add_text_to_debug("Error sending COMMAND_INT: " + error);
+        return "command_int not sent.  Error sending COMMAND_INT: " + error;
+      }
+    } else {
+      add_text_to_debug("WebSocket not open. Cannot send COMMAND_INT.");
+    }
+  } catch (error) {
+    add_text_to_debug("Error sending SET_POSITION_TARGET_GLOBAL_INT: " + error);
+  }
+
+  return "set_position_target_global_int sent";
+}
+
+// send a mavlink COMMAND_INT message to the vehicle
+function send_mavlink_command_int(args) {
+  return new Promise((resolve, reject) => {
+    // ensure pending map
+    if (!window.pending_command_requests) {
+      window.pending_command_requests = {};
+    }
+
+    if (!MAVLink || !mavlink_ws || mavlink_ws.readyState !== WebSocket.OPEN) {
+      add_text_to_debug("MAVLink or WebSocket not ready");
+      return reject({ success: false, error: "MAVLink not initialized or WS not open" });
+    }
+
+    // parse JSON if needed
+    if (typeof args === "string") {
+      try {
+        args = JSON.parse(args);
+      } catch (e) {
+        add_text_to_debug("send_mavlink_command_int: ERROR parsing args string");
+        return reject({ success: false, error: "Invalid arguments: JSON parse error" });
+      }
+    }
+    args = args || {};
+
+    if (!args.hasOwnProperty("command")) {
+      add_text_to_debug("send_mavlink_command_int: missing command");
+      return reject({ success: false, error: "command field required" });
+    }
+
+    const command = args.command;
+    const frame = args.frame || 0; // kept for compatibility
+    const target_system = 1;
+    const target_component = 1;
+    const confirmation = 1;
+    const param1 = args.hasOwnProperty("param1") ? args.param1 : 0;
+    const param2 = args.hasOwnProperty("param2") ? args.param2 : 0;
+    const param3 = args.hasOwnProperty("param3") ? args.param3 : 0;
+    const param4 = args.hasOwnProperty("param4") ? args.param4 : 0;
+    const x = args.hasOwnProperty("x") ? args.x : 0;
+    const y = args.hasOwnProperty("y") ? args.y : 0;
+    const z = args.hasOwnProperty("z") ? args.z : 0;
+
+    // example sanity check
+    if (command === mavlink20.MAV_CMD_NAV_TAKEOFF && z === 0) {
+      return reject({ success: false, error: "MAV_CMD_NAV_TAKEOFF requires altitude in z field" });
+    }
+
+    let timeoutId;
+
+    try {
+      // Build COMMAND_LONG message
+      const message = new mavlink20.messages.command_long(
+        target_system, target_component,
+        command, confirmation,
+        param1, param2, param3, param4,
+        x, y, z
+      );
+
+      const pkt = message.pack(MAVLink);
+      mavlink_ws.send(Uint8Array.from(pkt));
+      add_text_to_debug(`Sent COMMAND_INT ${command}, awaiting ACK`);
+    } catch (error) {
+      return reject({ success: false, error: "Error sending COMMAND_INT: " + error });
+    }
+
+    // register resolver with cleanup
+    window.pending_command_requests[command] = (ackMsg) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      delete window.pending_command_requests[command];
+      add_text_to_debug(`Resolving COMMAND_INT ${command} → result ${ackMsg.result}`);
+      resolve({ success: true, ack: ackMsg });
+    };
+
+    // set a timeout to reject if no ACK arrives
+    timeoutId = setTimeout(() => {
+      if (window.pending_command_requests[command]) {
+        delete window.pending_command_requests[command];
+        add_text_to_debug(`Timeout waiting for COMMAND_ACK ${command}`);
+        reject({ success: false, error: "COMMAND_ACK timeout" });
+      }
+    }, 5000);
+  });
+}
+
+
+// get the current time and date as a string. E.g. 'Saturday, June 24, 2023 6:14:14 PM'
+function getFormattedDate() {
+  const options = {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+    hour12: true
+  };
+  return new Date().toLocaleString('en-US', options);
+}
+
+// set a wakeup timer
+function set_wakeup_timer(args) {
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      add_text_to_debug("ERROR set_wakeup_timer: Could not parse args JSON");
+      return "Invalid arguments: JSON parse error";
+    }
+  }
+
+  // check required arguments are specified
+  const seconds = args.seconds ?? -1;
+  if (seconds < 0) {
+    return "set_wakeup_timer: seconds not specified";
+  }
+  const message = args.message ?? null;
+  if (message === null) {
+    return "set_wakeup_timer: message not specified";
+  }
+
+  // add timer to wakeup schedule
+  const triggerTime = Date.now() + seconds * 1000; // seconds → milliseconds → match Date.now()
+  add_text_to_debug("set_wakeup_timer: triggerTime: " + new Date(triggerTime).toLocaleString());
+  window.wakeup_schedule.push({ time: triggerTime, message: message });
+  return "set_wakeup_timer: wakeup timer set";
+}
+
+// get wake timers
+function get_wakeup_timers(args) {
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      add_text_to_debug("ERROR set_wakeup_timer: Could not parse args JSON");
+      return "Invalid arguments: JSON parse error";
+    }
+  }
+
+  try {
+
+    // check message argument, default to null meaning all
+    const message = args.message ?? null;
+    // prepare list of matching timers
+    let matching_timers = [];
+
+    // handle simple case of all timers
+    if (message === null) {
+      matching_timers = window.wakeup_schedule;
+      add_text_to_debug("get_wakeup_timers: returning all timers");
+    }
+
+    // handle regex in message
+    else if (contains_regex(message)) {
+      const pattern = new RegExp(message, "i"); // ignore case
+      for (const wakeup_timer of window.wakeup_schedule) {
+        if (pattern.test(wakeup_timer.message)) {
+          matching_timers.push(wakeup_timer);
+        }
+      }
+      add_text_to_debug("get_wakeup_timers: returning timers matching regex: " + message);
+    }
+
+    // handle case of a specific message
+    else {
+      for (const wakeup_timer of window.wakeup_schedule) {
+        if (wakeup_timer.message === message) {
+          matching_timers.push(wakeup_timer);
+        }
+      }
+      add_text_to_debug("get_wakeup_timers: returning timers matching message: " + message);
+    }
+
+    // return matching timers
+    return matching_timers;
+
+  } catch (e) {
+    add_text_to_debug("ERROR get_wakeup_timers: " + e);
+    return "Invalid arguments: JSON parse error";
+  }
+}
+
+// delete wake timers
+function delete_wakeup_timers(args) {
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      add_text_to_debug("ERROR set_wakeup_timer: Could not parse args JSON");
+      return "Invalid arguments: JSON parse error";
+    }
+  }
+
+  // check message argument, default to all
+  const message = args.message ?? null;
+
+  // find matching timers
+  let numDeleted = 0;
+
+  // handle simple case of deleting all timers
+  if (message === null) {
+    numDeleted = window.wakeup_schedule.length;
+    window.wakeup_schedule.length = 0;
+    add_text_to_debug("delete_wakeup_timers: deleted all timers");
+  }
+  // handle regex in message
+  else if (contains_regex(message)) {
+    const pattern = new RegExp(message, "i");
+    for (let i = window.wakeup_schedule.length - 1; i >= 0; i--) {
+      if (pattern.test(window.wakeup_schedule[i].message)) {
+        window.wakeup_schedule.splice(i, 1);
+        numDeleted++;
+      }
+    }
+    add_text_to_debug("delete_wakeup_timers: deleted timers matching regex: " + message);
+  }
+  // handle simple case of a single message
+  else {
+    for (let i = window.wakeup_schedule.length - 1; i >= 0; i--) {
+      if (window.wakeup_schedule[i].message === message) {
+        window.wakeup_schedule.splice(i, 1);
+        numDeleted++;
+      }
+    }
+    add_text_to_debug("delete_wakeup_timers: deleted timers matching message: " + message);
+  }
+
+  // return number deleted and remaining
+  return `delete_wakeup_timers: deleted ${numDeleted} timers, ${window.wakeup_schedule.length} remaining`;
+}
+
+//get the vehicle's location and yaw
+function get_vehicle_location_and_yaw() {
+  // get GLOBAL_POSITION_INT
+  const gpi = mavlink_store.get_latest_message(33);
+
+  let lat_deg = 0
+  let lon_deg = 0
+  let alt_amsl_m = 0
+  let alt_rel_m = 0
+  let yaw_deg = 0
+
+  if (gpi) {
+    lat_deg = gpi.lat * 1e-7
+    lon_deg = gpi.lon * 1e-7
+    alt_amsl_m = gpi.alt * 1e-3
+    alt_rel_m = gpi.relative_alt * 1e-3
+    yaw_deg = gpi.hdg * 1e-2
+  }
+
+  const location = {
+    "latitude": lat_deg,
+    "longitude": lon_deg,
+    "altitude_amsl": alt_amsl_m,
+    "altitude_above_home": alt_rel_m,
+    "yaw": yaw_deg
+  }
+
+  return location;
+}
+
+//get vehicle state
+function get_vehicle_state() {
+  //get latest HEARTBEAT message
+  const heartbeat_msg = mavlink_store.get_latest_message(0);
+  //sanity check
+  if (!heartbeat_msg || !heartbeat_msg.hasOwnProperty("base_mode") || !heartbeat_msg.hasOwnProperty("custom_mode")) {
+    return "unknown because no HEARTBEAT message has been received from the vehicle";
+  }
+  //get the armed state flag by applying mask to base_model property
+  const armed_flag = (heartbeat_msg["base_mode"] & mavlink20.MAV_MODE_FLAG_SAFETY_ARMED) > 0;
+  //get mode number from custom_mode property
+  const mode_number = heartbeat_msg["custom_mode"];
+
+  return {
+    "armed": armed_flag,
+    "mode": mode_number
+  }
+}
+
+// Calculate the latitude and longitude given distances (in meters) North and East
+function get_location_plus_offset(args) {
+  // check if args is a string, if so, parse it
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      add_text_to_debug("ERROR: Could not parse args JSON");
+      return "Invalid arguments: JSON parse error";
+    }
+  }
+
+  const lat = args.latitude ?? 0;
+  const lon = args.longitude ?? 0;
+  const dist_north = args.distance_north ?? 0;
+  const dist_east = args.distance_east ?? 0;
+  const { latitude: lat_with_offset, longitude: lon_with_offset } =
+    get_latitude_longitude_given_offset(lat, lon, dist_north, dist_east);
+
+  return {
+    latitude: lat_with_offset,
+    longitude: lon_with_offset
+  };
+}
+
+// Calculate the latitude and longitude given a distance (in meters) and bearing (in degrees)
+function get_location_plus_dist_at_bearing(args) {
+  // If args is a string, parse it
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch (e) {
+      add_text_to_debug("get_location_plus_dist_at_bearing: ERROR parsing args string");
+      return { latitude: 0, longitude: 0 };
+    }
+  }
+
+  const lat = args.latitude ?? 0;
+  const lon = args.longitude ?? 0;
+  const distance = args.distance ?? 0;
+  const bearing_deg = args.bearing ?? 0;
+
+  const dist_north = Math.cos(bearing_deg * Math.PI / 180) * distance;
+  const dist_east = Math.sin(bearing_deg * Math.PI / 180) * distance;
+
+  const { latitude: lat_with_offset, longitude: lon_with_offset } =
+    get_latitude_longitude_given_offset(lat, lon, dist_north, dist_east);
+
+  return {
+    latitude: lat_with_offset,
+    longitude: lon_with_offset
+  };
+
+
+}
+
+// wrap latitude to range -90 to 90
+function wrap_latitude(latitude_deg) {
+  if (latitude_deg > 90) {
+    return 180 - latitude_deg;
+  }
+  if (latitude_deg < -90) {
+    return -(180 + latitude_deg);
+  }
+  return latitude_deg;
+}
+// wrap longitude to range -180 to 180
+function wrap_longitude(longitude_deg) {
+  if (longitude_deg > 180) {
+    return longitude_deg - 360;
+  }
+  if (longitude_deg < -180) {
+    return longitude_deg + 360;
+  }
+  return longitude_deg;
+}
+
+// calculate latitude and longitude given distances (in meters) North and East
+// returns latitude and longitude in degrees
+function get_latitude_longitude_given_offset(latitude, longitude, dist_north, dist_east) {
+  const lat_lon_to_meters_scaling = 89.8320495336892 * 1e-7;
+  const lat_diff = dist_north * lat_lon_to_meters_scaling;
+  const lon_diff = dist_east * lat_lon_to_meters_scaling / Math.max(0.01, Math.cos((latitude + lat_diff) * Math.PI / 180 / 2));
+  return {
+    latitude: wrap_latitude(latitude + lat_diff),
+    longitude: wrap_longitude(longitude + lon_diff)
+  };
+}
+
+// make it visible to other modules
+window.handle_function_call = handle_function_call;
diff --git a/Chat/index.html b/Chat/index.html
new file mode 100644
index 00000000..84a97579
--- /dev/null
+++ b/Chat/index.html
@@ -0,0 +1,263 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>ArduPilot AI Chat Control</title>
+  <link rel="icon" href="../images/AP_favicon.png">
+
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <script src="https://cdn.tailwindcss.com"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>
+  <link rel="stylesheet" href="https://unpkg.com/leaflet@1.7.1/dist/leaflet.css" />
+  <script src="https://unpkg.com/leaflet@1.7.1/dist/leaflet.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/leaflet-rotatedmarker@0.2.0/leaflet.rotatedMarker.min.js"></script>
+
+  <script type="text/javascript" src="../modules/MAVLink/mavlink.js"></script>
+
+  <link rel="stylesheet" href="./style.css">
+</head>
+
+<body class="antialiased">
+  <div class="flex flex-col h-screen">
+
+    <!-- Header (Only visible on Desktop) -->
+    <header
+      class="text-center p-4 shadow-sm shrink-0 lg:flex hidden rounded-b-lg bg-[var(--bg-secondary)] border-b border-[var(--border-color)]">
+      <div class="container mx-auto flex items-center justify-center gap-4 relative text-[var(--blue-accent)]">
+        <h1 class="text-xl font-bold text-[var(--blue-accent)]">ArduPilot AI Chat Control</h1>
+        <!-- Theme Toggle Button for desktop header -->
+        <div id="theme-toggle-container-desktop" class="absolute right-0 top-1/2 -translate-y-1/2">
+          <button id="themeToggleButtonDesktop"
+            class="bg-gray-200 text-gray-800 p-2 rounded-full shadow-md focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500">
+            <svg id="themeIconDesktop" xmlns="http://www.w3.org/2000/svg" class="h-6 w-6" fill="none"
+              viewBox="0 0 24 24" stroke="currentColor">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                d="M12 3v1m0 16v1m9-9h-1M4 12H3m15.364 6.364l-.707-.707M6.343 6.343l-.707-.707m12.728 0l-.707.707M6.343 17.657l-.707.707M16 12a4 4 0 11-8 0 4 4 0 018 0z" />
+            </svg>
+          </button>
+        </div>
+      </div>
+    </header>
+
+    <!-- Mode Chooser Card (Centered Overlay) -->
+    <div id="modeChooser"
+      class="absolute inset-0 z-10 flex items-center justify-center bg-gray-900/40 backdrop-blur-sm p-4">
+      <div
+        class="max-w-md w-full rounded-2xl shadow-2xl p-8 transform transition-all opacity-100 scale-100 bg-[var(--bg-secondary)] border border-[var(--border-color)]">
+        <h2 class="text-2xl font-bold text-center mb-2 text-[var(--blue-accent)]">Choose Session Mode</h2>
+        <p class="text-sm text-center mb-6 text-[var(--text-muted)]">Select how to run this session.</p>
+        <div class="grid grid-cols-1 sm:grid-cols-2 gap-4">
+          <button id="pickAssistant"
+            class="w-full font-semibold rounded-lg py-3 transition-all duration-200 ease-in-out focus:outline-none focus:ring-2 focus:ring-offset-2">
+            Assistant API
+          </button>
+          <button id="pickRealtime"
+            class="w-full font-semibold rounded-lg py-3 transition-all duration-200 ease-in-out shadow-md focus:outline-none focus:ring-2 focus:ring-offset-2">
+            Realtime API
+          </button>
+        </div>
+        <div class="text-xs mt-6 space-y-3">
+          <div>
+            <div class="font-semibold text-[var(--blue-accent)]">Realtime</div>
+            <ul class="list-disc list-inside pl-1 mt-1 space-y-1 text-[var(--text-primary)]">
+              <li>Very low latency streaming</li>
+              <li>Session lasts about 28 minutes, then auto-reconnects with a summary</li>
+              <li>History is temporary, older sessions cannot be resumed</li>
+            </ul>
+          </div>
+          <div>
+            <div class="font-semibold text-[var(--blue-accent)]">Assistant</div>
+            <ul class="list-disc list-inside pl-1 mt-1 space-y-1 text-[var(--text-primary)]">
+              <li>Slower, turn-based text interaction.</li>
+              <li>Conversation thread is stored and can be resumed later.</li>
+            </ul>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Main App Layout -->
+    <main id="appRoot" class="flex-1 container mx-auto p-2 lg:p-6 flex flex-col lg:grid lg:grid-cols-5 gap-6 hidden">
+
+      <!-- AI Chat Panel (spanning 3 columns on large screens for 60% width) -->
+      <div
+        class="lg:col-span-3 shadow-lg rounded-2xl p-3 lg:p-4 flex flex-col border overflow-hidden mobile-chat-full-height bg-[var(--bg-secondary)] border-[var(--border-color)]">
+        <!-- Chat Panel Header (flex to align title, timer, and theme toggle for mobile) -->
+        <div class="flex items-center justify-between chat-panel-header shrink-0">
+          <h2 class="text-xl font-bold text-[var(--blue-accent)]">AI Chat</h2>
+          <div class="flex items-center gap-2">
+            <!-- Session countdown (only visible on mobile here) -->
+            <div id="sessionTimer"
+              class="flex items-center gap-2 px-2 py-1 rounded-full border text-sm lg:hidden hidden">
+              <svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+                <path fill-rule="evenodd"
+                  d="M10 18a8 8 0 100-16 8 8 0 000 16zm.75-12a.75.75 0 00-1.5 0v4c0 .199.079.39.22.53l2.5 2.5a.75.75 0 101.06-1.06l-2.28-2.28V6z"
+                  clip-rule="evenodd" />
+              </svg>
+              <span id="sessionExpiryTimerText" class="font-medium">28:00</span>
+            </div>
+            <!-- Theme Toggle Button for mobile chat panel -->
+            <div id="theme-toggle-container-mobile" class="lg:hidden">
+              <button id="themeToggleButtonMobile"
+                class="bg-gray-200 text-gray-800 p-2 rounded-full shadow-md focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500">
+                <svg id="themeIconMobile" xmlns="http://www.w3.org/2000/svg" class="h-6 w-6" fill="none"
+                  viewBox="0 0 24 24" stroke="currentColor">
+                  <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                    d="M12 3v1m0 16v1m9-9h-1M4 12H3m15.364 6.364l-.707-.707M6.343 6.343l-.707-.707m12.728 0l-.707.707M6.343 17.657l-.707.707M16 12a4 4 0 11-8 0 4 4 0 018 0z" />
+                </svg>
+              </button>
+            </div>
+          </div>
+        </div>
+
+        <div id="chatBox" class="flex-1 overflow-y-auto p-3 space-y-4 flex flex-col rounded-lg mb-4">
+          <div class="assistant-text">
+            <p class="font-medium">Welcome! I'm your ArduPilot AI assistant.</p>
+            <p class="mt-2">You can control the drone with commands like:</p>
+            <ul class="list-disc pl-5 mt-2 text-sm space-y-1">
+              <li>"Arm the drone"</li>
+              <li>"Take off to 10 meters"</li>
+              <li>"Fly north for 50 meters"</li>
+              <li>"Return to launch"</li>
+            </ul>
+          </div>
+        </div>
+
+        <!-- User Input Section -->
+        <div class="mt-auto pt-4 border-t shrink-0">
+          <!-- User Message Input and Buttons -->
+          <div class="flex items-center gap-3 chat-input-row">
+            <input type="text" id="userInput" placeholder="Type your command..."
+              class="flex-1 w-full rounded-lg shadow-sm px-3 py-2 text-base transition input-row-element input-base"
+              autocomplete="off">
+
+            <div class="flex gap-3 input-button-group">
+              <button id="sendMessageButton" title="Send Message" class="btn btn-green input-row-element">
+                <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" viewBox="0 0 20 20" fill="currentColor">
+                  <path
+                    d="M10.894 2.553a1 1 0 00-1.788 0l-7 14a1 1 0 001.169 1.409l5-1.429A1 1 0 009 15.571V11a1 1 0 112 0v4.571a1 1 0 00.725.962l5 1.428a1 1 0 001.17-1.408l-7-14z" />
+                </svg>
+              </button>
+
+              <button id="recordButton" title="Use Voice" class="btn btn-yellow input-row-element">
+                <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" viewBox="0 0 20 20" fill="currentColor">
+                  <path fill="currentColor"
+                    d="M7 4a3 3 0 016 0v4a3 3 0 11-6 0V4zm4 10.93A7.001 7.001 0 0017 8a1 1 0 10-2 0A5 5 0 015 8a1 1 0 00-2 0 7.001 7.001 0 006 6.93V17H6a1 1 0 100 2h8a1 1 0 100-2h-3v-2.07z" />
+                </svg>
+              </button>
+            </div>
+          </div>
+
+          <!-- MAVLink Connection Input and Button -->
+          <div class="flex items-center gap-3 mt-4 connect-drone-row">
+            <input type="text" id="mavlink-connect-url"
+              class="flex-1 rounded-lg shadow-sm text-sm transition input-row-element input-base"
+              value="ws://127.0.0.1:56781" placeholder="WebSocket URL">
+            <button id="mavlink-connect-button"
+              class="btn btn-blue px-5 py-2 whitespace-nowrap text-sm input-row-element">
+              Connect Drone
+            </button>
+          </div>
+        </div>
+      </div>
+
+      <!-- Side Panel (spanning 2 columns on large screens for 40% width) -->
+      <div
+        class="lg:col-span-2 shadow-lg rounded-2xl p-4 flex flex-col border overflow-hidden side-panel-mobile-styling bg-[var(--bg-secondary)] border-[var(--border-color)]">
+        <div class="p-4 border-b shrink-0">
+          <h2 class="text-xl font-bold text-[var(--blue-accent)]">Configuration</h2>
+        </div>
+        <div class="flex-1 p-6 space-y-5 overflow-y-auto">
+          <div class="space-y-4">
+            <div>
+              <label for="openai_api_key" class="block text-sm font-medium mb-1">OpenAI API Key:</label>
+              <div class="flex gap-2">
+                <input type="password" id="openai_api_key"
+                  class="flex-1 rounded-lg shadow-sm p-3 transition input-row-element overflow-x-auto min-w-0 input-base input-muted"
+                  autocomplete="off">
+                <button id="toggleApiKeyButton" class="btn btn-blue p-2 input-row-element">
+                  <svg id="eyeIcon" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor">
+                    <path fill-rule="evenodd"
+                      d="M3.28 2.22a.75.75 0 0 0-1.06 1.06l14.5 14.5a.75.75 0 1 0 1.06-1.06l-1.745-1.745a10.029 10.029 0 0 0 3.3-4.38 1.651 1.651 0 0 0 0-1.185A10.004 10.004 0 0 0 9.999 3a9.956 9.956 0 0 0-4.744 1.194L3.28 2.22ZM7.752 6.69l1.092 1.092a2.5 2.5 0 0 1 3.374 3.373l1.091 1.092a4 4 0 0 0-5.557-5.557Z"
+                      clip-rule="evenodd" />
+                    <path
+                      d="m10.748 13.93 2.523 2.523a9.987 9.987 0 0 1-3.27.547c-4.258 0-7.894-2.66-9.337-6.41a1.651 1.651 0 0 1 0-1.186A10.007 10.007 0 0 1 2.839 6.02L6.07 9.252a4 4 0 0 0 4.678 4.678Z" />
+
+                  </svg>
+                </button>
+              </div>
+              <button id="openai-connect-button" class="w-full btn btn-green px-5 py-2.5 mt-3">
+                Connect AI</button>
+            </div>
+
+            <div id="assistantIdContainer">
+              <label for="assistantId" class="block text-sm font-medium mb-1">Assistant ID:</label>
+              <input type="text" id="assistantId"
+                class="w-full rounded-lg shadow-sm p-2 text-xs font-mono input-row-element input-base input-muted"
+                readonly>
+            </div>
+
+            <!-- thread id for assistant api -->
+            <div id="assistantThreadIdContainer">
+              <label for="assistantThreadId" class="block text-sm font-medium mb-1">Thread ID:</label>
+              <div class="flex items-center space-x-2">
+                <input type="text" id="assistantThreadId"
+                  class="flex-grow rounded-lg shadow-sm p-2 text-xs font-mono input-row-element min-w-0 input-base input-muted"
+                  readonly>
+                <button id="startNewChatButton"
+                  class="btn btn-red px-4 py-2 text-sm bg-red-500 hover:bg-red-600 text-white">
+                  New Chat
+                </button>
+              </div>
+            </div>
+
+            <!-- session id for realtime api -->
+            <div id="sessionIdContainer" class="hidden">
+              <label for="sessionId" class="block text-sm font-medium mb-1">Session ID:</label>
+              <input type="text" id="sessionId"
+                class="w-full rounded-lg shadow-sm p-2 text-xs font-mono input-row-element input-base input-muted"
+                readonly>
+            </div>
+
+
+            <div>
+              <label for="assistantRunStatus" class="block text-sm font-medium mb-1">Run Status:</label>
+              <input type="text" id="assistantRunStatus"
+                class="w-full rounded-lg shadow-sm p-2 text-xs input-row-element input-base input-muted" readonly>
+            </div>
+          </div>
+
+          <div class="border-t pt-5">
+            <div class="flex items-center justify-between mb-2">
+              <h3 class="text-lg font-bold">Debug Output</h3>
+              <label class="flex items-center gap-2 text-sm">
+                <input type="checkbox" id="autoScrollToggle" checked class="rounded">
+                Auto-scroll
+              </label>
+            </div>
+            <textarea id="debugOutput"
+              class="w-full rounded-lg shadow-sm p-3 text-xs font-mono h-48 resize-y input-base input-muted"
+              readonly></textarea>
+          </div>
+        </div>
+      </div>
+    </main>
+  </div>
+
+  <!-- Handles chat mode selection and initialization -->
+  <script type="module" src="./main.js"></script>
+
+  <!-- Toggle Script (Theme and API key visibility) -->
+  <script type="module" src="./toggle.js"></script>
+
+  <!-- MAVLink connection and message handling logic -->
+  <script type="module" src="./mavlink-connection.js"></script>
+
+  <!-- script for handling function calls -->
+  <script type="module" src="./function-calls.js"></script>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/Chat/main.js b/Chat/main.js
new file mode 100644
index 00000000..4eed075a
--- /dev/null
+++ b/Chat/main.js
@@ -0,0 +1,60 @@
+// Handles chat mode selection and initialization.
+
+import { add_text_to_chat, add_text_to_debug, setChatBusy } from "./shared/ui.js";
+import { loadTextFile, loadJSONFile, loadInstructions } from "./shared/resource_loader.js";
+
+let currentMode = null;   // "realtime" or "assistant"
+let modeApi = null;       // module ref that implements init and start
+
+function showApp() {
+  document.getElementById("modeChooser").classList.add("hidden");
+  document.getElementById("appRoot").classList.remove("hidden");
+}
+
+async function loadMode(mode) {
+  if (currentMode) return; // lock after first pick
+  currentMode = mode;
+
+  showApp();
+  add_text_to_debug("Mode chosen: " + mode);
+  add_text_to_debug('waiting for mode initialization...');
+
+  if (mode === "realtime") {
+    // show session timer
+    document.getElementById("sessionTimer").classList.remove("hidden");
+    document.getElementById("sessionTimer").classList.remove("lg:hidden");
+    // remove assistant ID 
+    document.getElementById("assistantIdContainer").classList.add("hidden");
+    // remove assistantThreadIdContainer 
+    document.getElementById("assistantThreadIdContainer").classList.add("hidden");
+    // add sessionIdContainer
+    document.getElementById("sessionIdContainer").classList.remove("hidden");
+
+    // load realtime mode 
+    modeApi = await import("./modes/realtime.js");
+  } else {
+    modeApi = await import("./modes/assistant.js");
+    // Assistant-only: ask to resume previous thread
+    const stored = localStorage.getItem('thread_id');
+    if (stored) {
+      const ok = confirm("Continue your previous chat? Click Cancel to start a new session.");
+      if (ok) document.getElementById('assistantThreadId').value = stored;
+      else localStorage.removeItem('thread_id');
+    }
+  }
+
+  // pass shared UI helpers and DOM ids the module needs
+  await modeApi.initMode({
+    add_text_to_chat,
+    add_text_to_debug,
+    setChatBusy,
+    loadTextFile,
+    loadJSONFile,
+    loadInstructions,
+  });
+
+  add_text_to_debug("Mode initialized");
+}
+
+document.getElementById("pickRealtime").addEventListener("click", () => loadMode("realtime"));
+document.getElementById("pickAssistant").addEventListener("click", () => loadMode("assistant"));
\ No newline at end of file
diff --git a/Chat/mavlink-connection.js b/Chat/mavlink-connection.js
new file mode 100644
index 00000000..74efe8da
--- /dev/null
+++ b/Chat/mavlink-connection.js
@@ -0,0 +1,180 @@
+// MAVLink connection and message handling logic
+
+// imports
+import { mavlink_store } from '../modules/MAVLink/mavlink_store.js';
+import { setMAVLink, setMavlinkWS } from './shared/mavlink.js';
+import { add_text_to_debug } from "./shared/ui.js";
+
+window.pending_param_requests = {}
+window.pending_all_params_request = null;
+window.pending_command_requests = {};
+
+// MAVLink connection related functions
+let connect_button = document.getElementById("mavlink-connect-button");
+let is_connected = false; // connection state
+let mavlink_ws = null; // websocket object
+let mavlink_sysid = 254; // system id
+let mavlink_compid = MAVLink20Processor.MAV_COMP_ID_MISSIONPLANNER; // component id
+let MAVLink = new MAVLink20Processor(null, mavlink_sysid, mavlink_compid);
+
+// set the MAVLink processor 
+setMAVLink(MAVLink);
+
+// toggle connection state (called by Connect/Disconnect button)
+function mavlink_toggle_connect() {
+  if (is_connected) {
+    mavlink_disconnect();
+  } else {
+    mavlink_connect();
+  }
+}
+
+// attach event listener to the connect button
+connect_button.addEventListener("click", mavlink_toggle_connect);
+
+// set the mavlink button connection state
+function mavlink_set_connect_state(connected) {
+  is_connected = connected;
+  if (connected) {
+    connect_button.innerText = "Disconnect";
+  } else {
+    connect_button.innerText = "Connect Drone";
+  }
+}
+
+// connect to the vehicle
+function mavlink_connect() {
+  // check connection URL
+  let connect_url = document.getElementById("mavlink-connect-url").value;
+  if (!connect_url) {
+    alert("Error: WebSocket URL is empty");
+    return;
+  }
+
+  if (mavlink_ws == null) {
+    // create a new websocket connection
+    mavlink_ws = new WebSocket(connect_url);
+    mavlink_ws.binaryType = "arraybuffer"
+
+    // set up event handlers
+    mavlink_ws.onopen = function () {
+      mavlink_set_connect_state(true);
+    };
+    mavlink_ws.onclose = function () {
+      mavlink_set_connect_state(false);
+    };
+    mavlink_ws.onerror = function () {
+      mavlink_disconnect();
+    };
+
+    // parse incoming message and forward
+    mavlink_ws.onmessage = (msg) => {
+      // sanity check parser has been created
+      if (MAVLink == null) {
+        return;
+      }
+      // parse message
+      for (const char of new Uint8Array(msg.data)) {
+        const mavlink_msg = MAVLink.parseChar(char)
+        if ((mavlink_msg != null) && (mavlink_msg._id != -1)) {
+          // got a message with a known ID
+          mavlink_msg_handler(mavlink_msg);
+        }
+      }
+    }
+  }
+  // set the mavlink websocket connection
+  setMavlinkWS(mavlink_ws);
+}
+
+// disconnect from the vehicle
+function mavlink_disconnect() {
+  if (mavlink_ws != null) {
+    mavlink_ws.close();
+    mavlink_ws = null;
+  }
+}
+
+// mavlink message handler
+function mavlink_msg_handler(msg) {
+
+  // sanity check msg
+  if (msg == null || msg._id == null) {
+    return;
+  }
+
+  // store the message in the message store
+  mavlink_store.store_message(msg);
+
+  switch (msg._id) {
+    case 0: // HEARTBEAT
+      //alert("custom mode:" + msg.custom_mode);
+      //alert("Got a heartbeat: " + JSON.stringify(msg));
+      break;
+    case 1: // SYS_STATUS
+      //alert("Got a system status: " + JSON.stringify(msg));
+      break;
+    case 22: // PARAM_VALUE
+      const param_id = msg.param_id.replace(/\u0000/g, '').trim();
+      const param_value = msg.param_value;
+      const param_index = msg.param_index;
+      const param_count = msg.param_count;
+
+      add_text_to_debug(`PARAM_VALUE received: ${param_id} = ${param_value}`);
+
+      // Handle single parameter pending requests
+      if (window.pending_param_requests[param_id]) {
+        window.pending_param_requests[param_id]({ [param_id]: param_value });
+        delete window.pending_param_requests[param_id];
+      }
+
+      // All parameters request resolver
+      if (window.pending_all_params_request) {
+        window.pending_all_params_request.params[param_id] = param_value;
+        if (param_index === param_count - 1) {
+          // This was the last parameter
+          window.pending_all_params_request.resolve(window.pending_all_params_request.params);
+          window.pending_all_params_request = null;
+        }
+      }
+      break;
+    case 24: // GPS_RAW_INT
+      //alert("Got a GPS raw int: " + JSON.stringify(msg));
+      break;
+    case 30: // ATTITUDE
+      //alert("Got an attitude: " + JSON.stringify(msg));
+      break;
+    case 33: // GLOBAL_POSITION_INT
+      //alert("Got a global position int: " + JSON.stringify(msg));
+      break;
+    case 35: // HIGHRES_IMU
+      //alert("Got a high resolution IMU: " + JSON.stringify(msg));
+      break;
+    case 42: // NAMED_VALUE_FLOAT
+      //alert("Got a named value float: " + JSON.stringify(msg));
+      break;
+    case 74: // VFR_HUD
+      //alert("Got a VFR HUD: " + JSON.stringify(msg));
+      break;
+    case 77: // mavlink20.MAVLINK_MSG_ID_COMMAND_ACK
+      const cmd = msg.command;
+      const result = msg.result;
+
+      add_text_to_debug(`COMMAND_ACK received: cmd=${cmd} result=${result}`);
+
+      // If someone is waiting for this command’s ACK, resolve their promise
+      if (window.pending_command_requests[cmd]) {
+        // resolve with the entire msg, or you could resolve only result
+        window.pending_command_requests[cmd](msg);
+        delete window.pending_command_requests[cmd];
+      }
+      break;
+    case 253: // STATUSTEXT
+      //alert("Got a status text: " + JSON.stringify(msg));
+      break;
+    default:
+      //alert("Got a message id: " + JSON.stringify(msg));
+      break;
+  }
+}
+
diff --git a/Chat/modes/assistant.js b/Chat/modes/assistant.js
new file mode 100644
index 00000000..816b91d3
--- /dev/null
+++ b/Chat/modes/assistant.js
@@ -0,0 +1,610 @@
+let initialized = false;
+
+import OpenAI from "https://cdn.jsdelivr.net/npm/openai@4.85.4/+esm";
+import EventEmitter from 'https://cdn.jsdelivr.net/npm/eventemitter3@5.0.1/+esm'
+
+export async function initMode(func) {
+  if (initialized) return;
+
+  const add_text_to_chat = func.add_text_to_chat;
+  const add_text_to_debug = func.add_text_to_debug;
+  const setChatBusy = func.setChatBusy;
+  const loadJSONFile = func.loadJSONFile;
+  const loadInstructions = func.loadInstructions;
+
+  let wakeup_schedule = window.wakeup_schedule;
+
+  // call check_wakeup_timers once to start the interval
+  check_wakeup_timers();
+
+  // constants
+  const OPENAI_API_KEY = ""; // replace with your OpenAI API key
+  const OPENAI_MODEL = "gpt-4o"
+  const OPENAI_ASSISTANT_NAME = "ArduPilot Vehicle Control via MAVLink"
+
+  async function loadTools() {
+    const tools = [];
+    for (const file of window.JSON_FUNCTION_FILES) {
+      const def = await loadJSONFile(file);
+      if (def) tools.push(def);
+    }
+    return tools;
+  }
+
+  // helper: create event handler if missing
+  function ensure_event_handler() {
+    if (!openai_event_handler) {
+      openai_event_handler = new EventHandler(openai);
+      if (!openai_event_handler) {
+        add_text_to_debug('Unable to create event handler');
+        return false;
+      }
+      openai_event_handler.on("event", openai_event_handler.onEvent.bind(openai_event_handler));
+    }
+    return true;
+  }
+
+  // helper: load or create thread and optionally load history
+  async function ensure_thread(loadHistory=true) {
+    if (openai_thread_id) return true;
+    let stored = localStorage.getItem('thread_id');
+    if (stored) {
+      openai_thread_id = stored;
+      const threadEl = document.getElementById("assistantThreadId");
+      if (threadEl) threadEl.value = openai_thread_id;
+      if (loadHistory) { await load_thread_history(openai_thread_id); }
+      return true;
+    }
+    openai_thread_id = await create_thread();
+    if (!openai_thread_id) {
+      add_text_to_debug('Error creating new thread');
+      return false;
+    }
+    localStorage.setItem('thread_id', openai_thread_id);
+    const threadEl = document.getElementById("assistantThreadId");
+    if (threadEl) threadEl.value = openai_thread_id;
+    return true;
+  }
+
+  // helper: finalize assistant context after obtaining assistant id
+  async function finalize_assistant_context(loadHistory=true) {
+    if (!openai_assistant_id) return false;
+    const idEl = document.getElementById("assistantId");
+    if (idEl) idEl.value = openai_assistant_id;
+    if (!(await ensure_thread(loadHistory))) return false;
+    if (!ensure_event_handler()) return false;
+    return true;
+  }
+
+  // helper: create assistant dynamically
+  async function create_assistant_when_missing() {
+    add_text_to_debug(`Assistant '${OPENAI_ASSISTANT_NAME}' not found, creating...`);
+    const instructions = await loadInstructions();
+    if (!instructions) {
+      add_text_to_debug('Failed to load assistant instructions');
+      return false;
+    }
+    const tools = await loadTools();
+    try {
+      const created = await openai.beta.assistants.create({
+        name: OPENAI_ASSISTANT_NAME,
+        instructions,
+        model: OPENAI_MODEL,
+        tools
+      });
+      if (!created?.id) {
+        add_text_to_debug('Assistant creation failed (no id)');
+        return false;
+      }
+      openai_assistant_id = created.id;
+      add_text_to_debug(`Assistant created with id ${openai_assistant_id}`);
+      return await finalize_assistant_context(false); // no history for brand new thread
+    } catch (e) {
+      add_text_to_debug('Assistant creation error: ' + e);
+      return false;
+    }
+  }
+
+  // variables 
+  let openai = null
+  let openai_assistant_id = null
+  let openai_thread_id = null
+  let openai_event_handler = null
+
+
+  // chat listener for user input and enter key
+  document.getElementById("userInput").addEventListener("keypress", function (event) {
+    if (event.key === "Enter") {
+      send_message();
+    }
+  })
+  // listener for send message button click
+  document.getElementById("sendMessageButton").addEventListener("click", send_message);
+
+  // get openai API key (use this in API calls)
+  function get_openai_api_key() {
+    if (OPENAI_API_KEY.length > 0) {
+      return OPENAI_API_KEY;
+    }
+    return document.getElementById("openai_api_key").value.trim();
+  }
+
+  // attach connection handler to the OpenAI connect button
+  const openaiConnectButton = document.getElementById("openai-connect-button");
+  if (openaiConnectButton) {
+    openaiConnectButton.addEventListener("click", () => {
+      check_connection();
+    });
+  }
+
+  const startNewChatButton = document.getElementById("startNewChatButton");
+  if (startNewChatButton) {
+    startNewChatButton.addEventListener("click", () => {
+      if (confirm("Start a new chat? This will clear the existing conversation.")) {
+        localStorage.removeItem('thread_id');
+
+        for (const id of ["assistantThreadId", "assistantId", "assistantRunStatus", "debugOutput"]) {   // 3) blank inputs now
+          const el = document.getElementById(id); if (el) el.value = "";
+        }
+        location.reload();
+      }
+    });
+  }
+
+  // unified send function; optional message param used for programmatic sends
+  async function send_message(arg) {
+    if (window.chatBusy) return; // guard against rapid multi-clicks
+    setChatBusy(true); // lock immediately to avoid races during connection setup
+
+    try {
+      if (!(await check_connection())) {
+        return;
+      }
+
+      let message;
+      let isUserMessage = true;
+      if (typeof arg === 'string') {
+        message = arg;
+        isUserMessage = false;
+      } else {
+        const inputEl = document.getElementById("userInput");
+        message = inputEl.value;
+        inputEl.value = ""; // clear early for snappier UX
+      }
+
+      if (!message || !message.trim()) {
+        add_text_to_debug("send_message: message is empty");
+        return;
+      }
+
+      // only log user messages
+      if(isUserMessage) add_text_to_chat(message, "user");
+      
+      const resp = await get_assistant_response(message);
+      // get_assistant_response streams assistant output; only log explicit errors
+      if (typeof resp === 'string' && resp.startsWith('get_assistant_response:')) {
+        add_text_to_debug(resp);
+        setChatBusy(false); // ensure unlocked on immediate error
+      }
+    } catch (err) {
+      add_text_to_debug("send_message error: " + err);
+      setChatBusy(false);
+    }
+  }
+
+  //
+  // methods below here interact directly with the OpenAI API
+  //
+
+  // check connection to OpenAI API and return true on success, false on failure
+  async function check_connection() {
+    // check openai API key
+    if (!get_openai_api_key()) {
+      setChatBusy(false)
+      return false;
+    }
+    // check openai connection
+    if (!openai) {
+      openai = new OpenAI({ apiKey: get_openai_api_key(), dangerouslyAllowBrowser: true });
+      if (!openai) {
+        setChatBusy(false)
+        return false;
+      }
+    }
+
+    // already fully initialized
+    if (openai_assistant_id && openai_thread_id && openai_event_handler) return true;
+
+    // find existing assistant id if not set
+    if (!openai_assistant_id) {
+      const foundId = await find_assistant(OPENAI_ASSISTANT_NAME);
+      if (foundId) {
+        openai_assistant_id = foundId;
+      } else {
+        const createdOk = await create_assistant_when_missing();
+        if (!createdOk) { setChatBusy(false); return false; }
+      }
+    }
+
+    // finalize (will create thread + handler if missing)
+    const ok = await finalize_assistant_context();
+    if (!ok) { setChatBusy(false); }
+    return ok;
+  }
+
+  // get assistant response based on user input
+  async function find_assistant(assistant_name) {
+    // sanity check openai connection
+    if (!openai) {
+      return null;
+    }
+
+    try {
+      // get a list of all assistants
+      const assistants_list = await openai.beta.assistants.list({ order: "desc", limit: 20 });
+
+      // iterate through assistants and find the one with the matching name
+      let assistant = assistants_list.data.find(a => a.name === assistant_name);
+
+      // return assistant ID if found, otherwise return null
+      return assistant ? assistant.id : null;
+    } catch (error) {
+      // return null in case of an error
+      return null;
+    }
+  }
+
+  // create a new thread
+  // returns thread id on success, null on failure
+  async function create_thread() {
+    // sanity check the assistant id
+    if (!openai_assistant_id) {
+      return null;
+    }
+
+    try {
+      // create a thread
+      const new_thread = await openai.beta.threads.create();
+      return new_thread ? new_thread.id : null;
+    } catch (error) {
+      add_text_to_debug("create_thread error: " + error);
+      return null;
+    }
+  }
+
+  async function load_thread_history(threadId) {
+    if (!openai) { return; }
+    try {
+      const history = await openai.beta.threads.messages.list(threadId, { order: 'asc', limit: 100 });
+      for (const msg of history.data) {
+        if (msg.role === 'assistant' || msg.role === 'user') {
+          const content = msg.content[0]?.text?.value || '';
+          if (content) {
+            add_text_to_chat(content, msg.role);
+          }
+        }
+      }
+    } catch (e) {
+      console.error('Failed to load history', e);
+    }
+  }
+
+
+  // get assistant response based on user input
+  async function get_assistant_response(input) {
+    // sanity check the assistant id
+    if (!openai_assistant_id) {
+      return "get_assistant_response: assistant not found";
+    }
+    // sanity check thread
+    if (!openai_thread_id) {
+      return "get_assistant_response: thread not found";
+    }
+
+    // add a message to the thread
+    const message = await openai.beta.threads.messages.create(openai_thread_id, { role: "user", content: input });
+
+    // run the assistant
+    const stream = await openai.beta.threads.runs.stream(openai_thread_id, { assistant_id: openai_assistant_id, stream: true })
+    stream.on('event', (event) => openai_event_handler.emit("event", event))
+  }
+
+
+
+
+  class EventHandler extends EventEmitter {
+    constructor(client) {
+      super()
+      this.client = client;
+    }
+
+    async onEvent(event) {
+      try {
+        // print status on html page
+        document.getElementById("assistantRunStatus").value = event.event;
+
+        // handle each event
+        switch (event.event) {
+          // retrieve events that are denoted with 'requires_action'
+          // since these will have our tool_calls
+          case "thread.run.requires_action":
+            await this.handleRequiresAction(
+              event.data,
+              event.data.id,
+              event.data.thread_id,
+            )
+            break;
+          case "thread.message.delta":
+          case "thread.run.step.delta":
+            let delta_text = event.data.delta.content[0].text.value
+            add_text_to_chat(delta_text, "assistant")
+            break;
+
+          // events below can be ignored
+          case "thread.created":
+          case "thread.message.completed":
+          case "thread.run.created":
+          case "thread.run.queued":
+          case "thread.run.in_progress":
+            break;
+          case "thread.run.completed":
+          case "thread.run.incomplete":
+          case "thread.run.failed":
+            setChatBusy(false)
+            break;
+          case "thread.run.step.created":
+          case "thread.run.cancelling":
+          case "thread.run.step.in_progress":
+          case "thread.run.cancelled":
+          case "thread.run.expired":
+          case "thread.run.step.created":
+          case "thread.run.step.in_progress":
+          case "thread.run.step.completed":
+          case "thread.run.step.failed":
+          // setChatBusy(false)
+          // break
+          case "thread.run.step.cancelled":
+          case "thread.run.step.expired":
+          case "thread.message.created":
+          case "thread.message.in_progress":
+            break;
+          case "thread.message.completed":
+          case "thread.message.incomplete":
+          case "error":
+          case "done":
+            setChatBusy(false)
+            break;
+
+          // catch unhandled events
+          default:
+            add_text_to_debug("Unhandled event: " + event.event)
+            console.log(event)
+        }
+
+      } catch (error) {
+        console.error("Error handling event:", error)
+      }
+    }
+
+    // handle requires action event by calling a local function and returning the result to the assistant
+    async handleRequiresAction(data, runId, threadId) {
+      try {
+        const toolOutputs = await Promise.all(
+          data.required_action.submit_tool_outputs.tool_calls.map(async (toolCall) => {
+            let output;
+            try {
+              output = await window.handle_function_call(toolCall.function.name, toolCall.function.arguments);
+            } catch (err) {
+              add_text_to_debug("handle_function_call error: " + err);
+              output = JSON.stringify({ error: err.toString() });
+            }
+
+            output = typeof output === "string" ? output : JSON.stringify(output);
+
+            add_text_to_debug("fn:" + toolCall.function.name + " output:" + output)
+            return {
+              tool_call_id: toolCall.id,
+              output: output
+            }
+          })
+        )
+
+        // submit all the tool outputs at the same time
+        await this.submitToolOutputs(toolOutputs, runId, threadId)
+      } catch (error) {
+        console.error("Error processing required action:", error)
+      }
+    }
+
+    // return function call results to the assistant
+    async submitToolOutputs(toolOutputs, runId, threadId) {
+      try {
+        // use the submitToolOutputsStream helper
+        const stream = this.client.beta.threads.runs.submitToolOutputsStream(
+          threadId,
+          runId,
+          { tool_outputs: toolOutputs },
+        )
+        for await (const event of stream) {
+          this.emit("event", event)
+        }
+      } catch (error) {
+        console.error("Error submitting tool outputs:", error)
+      }
+    }
+  }
+
+
+
+  const recordButton = document.getElementById("recordButton");
+
+  const state = {
+    mediaRecorder: null,
+    audioChunks: [],
+    stream: null,
+    audioBlob: null,
+    isRecording: false,
+    listeners: {
+      dataavailable: null,
+      stop: null
+    }
+  };
+
+  async function startRecording(options = {}) {
+    if (window.chatBusy) {
+      add_text_to_debug("Recording is busy, please wait");
+      return;
+    }
+
+    if (state.isRecording) {
+      add_text_to_debug("recording is in progress");
+      return;
+    }
+
+    state.isRecording = true;
+    state.audioChunks = [];
+
+    try {
+      const defaultOptions = {
+        mimeType: "audio/webm",
+        audioBitsPerSecond: 128000
+      };
+      const recordingOptions = { ...defaultOptions, ...options };
+
+      state.stream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+
+      if (MediaRecorder.isTypeSupported(recordingOptions.mimeType)) {
+        state.mediaRecorder = new MediaRecorder(state.stream, recordingOptions);
+      } else {
+        add_text_to_debug(recordingOptions.mimeType + " is not supported, using default codec");
+        state.mediaRecorder = new MediaRecorder(state.stream);
+      }
+
+      state.listeners.dataavailable = event => {
+        state.audioChunks.push(event.data);
+      };
+
+      state.listeners.stop = async () => {
+        state.audioBlob = new Blob(state.audioChunks, { type: recordingOptions.mimeType });
+        cleanupResources();
+        await handleTranscription(state.audioBlob);
+      };
+
+      state.mediaRecorder.addEventListener("dataavailable", state.listeners.dataavailable);
+      state.mediaRecorder.addEventListener("stop", state.listeners.stop);
+      state.mediaRecorder.start();
+
+    } catch (error) {
+      state.isRecording = false;
+      cleanupResources();
+      add_text_to_debug("Error accessing microphone: " + error);
+      setChatBusy(false);
+    }
+  }
+
+  function stopRecording() {
+    if (!state.mediaRecorder || state.mediaRecorder.state === "inactive") {
+      return false;
+    }
+    state.mediaRecorder.stop();
+    setChatBusy(true);
+    add_text_to_debug("Recording stopped, processing audio...");
+    return true;
+  }
+
+  function cleanupResources() {
+    if (state.stream) {
+      state.stream.getTracks().forEach(track => track.stop());
+      state.stream = null;
+    }
+    if (state.mediaRecorder) {
+      if (state.listeners.dataavailable) {
+        state.mediaRecorder.removeEventListener("dataavailable", state.listeners.dataavailable);
+      }
+      if (state.listeners.stop) {
+        state.mediaRecorder.removeEventListener("stop", state.listeners.stop);
+      }
+      state.mediaRecorder = null;
+    }
+    state.isRecording = false;
+  }
+
+  async function handleTranscription(blob) {
+    try {
+      // ensure OpenAI connection exists
+      // let openai = getOpenAIInstance();
+      if (!openai && check_connection) {
+        const ok = await check_connection();
+        if (!ok) {
+          add_text_to_debug("Unable to connect to OpenAI");
+          return;
+        }
+        // openai = getOpenAIInstance();
+      }
+
+      const formData = new FormData();
+      formData.append("file", blob, "recording.webm");
+      formData.append("model", "whisper-1");
+      // formData.append("language", "en");
+
+      const apiKey = openai ? openai.apiKey : document.getElementById("openai_api_key").value.trim();
+
+      const resp = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: { "Authorization": `Bearer ${apiKey}` },
+        body: formData
+      });
+      const data = await resp.json();
+      const transcript = data.text.trim();
+      add_text_to_chat(transcript, "user");
+      const response = await get_assistant_response(transcript);
+      add_text_to_chat(response, "assistant");
+    } catch (err) {
+      add_text_to_debug("Transcription error: " + err);
+    }
+  }
+
+  recordButton.addEventListener("click", () => {
+    if (state.isRecording) {
+      stopRecording();
+    } else {
+      startRecording().catch(err => {
+        add_text_to_debug("Failed to start recording: " + err);
+      });
+    }
+  });
+
+  // check if any wakeup timers have expired and send messages if they have
+  // this function never returns so it should be called from a new thread
+  function check_wakeup_timers() {
+    setInterval(() => {
+      // check if any timers are set
+      if (wakeup_schedule.length === 0) {
+        return;
+      }
+
+      const now = Date.now();
+
+      // iterate backward to safely remove expired timers
+      for (let i = wakeup_schedule.length - 1; i >= 0; i--) {
+        if (now >= wakeup_schedule[i].time) {
+          const message = "WAKEUP:" + wakeup_schedule[i].message;
+          add_text_to_debug("check_wakeup_timers: sending message: " + message);
+
+          send_message(message);
+
+          wakeup_schedule.splice(i, 1); // remove expired timer
+        }
+      }
+    }, 1000); // wait for one second
+  }
+
+
+  initialized = true;
+}
diff --git a/Chat/modes/realtime.js b/Chat/modes/realtime.js
new file mode 100644
index 00000000..d8cd35c6
--- /dev/null
+++ b/Chat/modes/realtime.js
@@ -0,0 +1,789 @@
+let initialized = false;
+
+export async function initMode(func) {
+  if (initialized) return;
+  // wire your existing globals to use ui helpers if needed
+  const add_text_to_chat = func.add_text_to_chat;
+  const add_text_to_debug = func.add_text_to_debug;
+  const setChatBusy = func.setChatBusy;
+  const loadJSONFile = func.loadJSONFile;
+  const loadInstructions = func.loadInstructions;
+
+  let wakeup_schedule = window.wakeup_schedule;
+
+  // call check_wakeup_timers once to start the interval
+  check_wakeup_timers();
+
+  // call loadInstructions
+  const assistantInstructions = await loadInstructions();
+
+  const tools = [];
+  async function loadTools() {
+    for (const file of window.JSON_FUNCTION_FILES) {
+      const def = await loadJSONFile(file);
+      if (def) {
+        // If "function" key exists and is an object
+        if (def.function && typeof def.function === "object") {
+          const { function: funcObj, ...rest } = def;
+          tools.push({
+            ...rest,      // keep "type" or any other top-level props
+            ...funcObj    // move everything from "function" up here
+          });
+        } else {
+          tools.push(def); // unchanged if it doesn't have a "function" property
+        }
+      }
+    }
+  }
+
+  // call loadTools
+  await loadTools();
+
+  /*
+     * Replace the text of an existing bubble by id.
+     * You can also toggle muted on or off with opts.muted.
+  */
+  function replace_chat_text(msgId, newText, opts = {}) {
+    const chatBox = document.getElementById("chatBox");
+    const el = chatBox.querySelector(`[data-msg-id="${msgId}"]`);
+    if (!el) {
+      // fallback, just add a new user bubble
+      return add_text_to_chat(newText, opts.role || "user", opts);
+    }
+    el.textContent = newText;
+    if (opts.muted != null) {
+      if (opts.muted) el.classList.add("muted");
+      else el.classList.remove("muted");
+    }
+    chatBox.scrollTop = chatBox.scrollHeight;
+    return msgId;
+  }
+
+
+
+
+  //
+  // methods below here interact directly with the OpenAI API
+  //
+
+  // --- RealTime API logic ---
+
+  let pc, dataChannel, localStream;
+  const pendingVoice = new Map(); // item_id -> { placeholderId }
+  let currentVoicePlaceholderId = null;
+  let currentSessionId = null;
+
+
+  let capturingSummary = false;
+  let summaryBuffer = '';
+  let summaryResolve = null;
+  let summaryReject = null;
+  let summaryTimeoutId = null;
+
+  let isSessionReady = false;
+  let sessionReadyResolvers = [];
+
+  // send helper that queues until the data channel opens
+  async function sendDC(obj) {
+    const payload = JSON.stringify(obj);
+    if (!dataChannel || dataChannel.readyState !== 'open') {
+      add_text_to_debug('Waiting for data channel to open, cannot send yet');
+      return false;
+    }
+    dataChannel.send(payload);
+    return true;
+  }
+
+  // Event listeners for button clicks
+  document.getElementById('openai-connect-button').addEventListener('click', connectOpenAI);
+
+  document.getElementById("userInput").addEventListener("keypress", function (event) {
+    if (event.key === "Enter") {
+      send_message();
+    }
+  })
+  document.getElementById('sendMessageButton').addEventListener('click', send_message);
+
+  // push-to-talk logic: unmute when pressed, mute when released
+  const recordBtn = document.getElementById('recordButton');
+  if (recordBtn) {
+    recordBtn.addEventListener("click", () => {
+      if (isRecording) {
+        stopRecording();
+      } else {
+        startRecording();
+      }
+    });
+  }
+
+  async function connectOpenAI() {
+    setChatBusy(true);
+    add_text_to_debug('Connecting to OpenAI realtime API...');
+
+    // Reset session ready state
+    isSessionReady = false;
+
+    const key = document.getElementById('openai_api_key').value.trim();
+    if (!key) { alert('Please enter your API key'); return; }
+    if (tools.length === 0) {
+      add_text_to_debug('Warning, no tools loaded');
+      return;
+    }
+    if (!assistantInstructions) {
+      add_text_to_debug('Warning, assistant instructions not loaded');
+      return;
+    }
+
+    // Start a session
+    let session;
+    try {
+      const resp = await fetch('https://api.openai.com/v1/realtime/sessions', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${key}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          model: 'gpt-4o-realtime-preview',
+          modalities: ['text', 'audio']
+        })
+      });
+      if (!resp.ok) {
+        const txt = await resp.text().catch(() => '');
+        throw new Error(`Session create failed ${resp.status} ${txt}`);
+      }
+      session = await resp.json();
+
+      try {
+        currentSessionId = session.id || null;
+        const sessionEl = document.getElementById('sessionId');
+        if (sessionEl) sessionEl.value = currentSessionId || '';
+      } catch (e) {
+        add_text_to_debug('Error setting session ID: ' + e.message);
+      }
+      setRunStatus('idle');
+
+      // start the session expiry timer
+      startSessionExpiryTimer(28.0);
+    } catch (e) {
+      add_text_to_debug('Realtime session error: ' + e.message);
+      return;
+    }
+
+    // Build peer connection
+    try {
+      pc = new RTCPeerConnection({ iceServers: session.ice_servers });
+    } catch (e) {
+      add_text_to_debug('Failed to create peer connection: ' + e.message);
+      return false;
+    }
+
+    // basic state logs
+    pc.onconnectionstatechange = () => {
+      const state = pc.connectionState;
+      add_text_to_debug('PC state: ' + state);
+
+      if (state === 'failed' || state === 'disconnected') {
+        add_text_to_debug('Peer connection ' + state + ' detected');
+      }
+    };
+    pc.onsignalingstatechange = () => add_text_to_debug('Signaling: ' + pc.signalingState);
+
+
+    // Mic, start muted
+    try {
+      localStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      localStream.getAudioTracks()[0].enabled = false;
+      localStream.getTracks().forEach(t => pc.addTrack(t, localStream));
+    } catch (e) {
+      add_text_to_debug('Mic error: ' + e.message);
+      return false;
+    }
+
+    // Data channel
+    dataChannel = pc.createDataChannel('openai_realtime');
+    dataChannel.onopen = onChannelOpen;
+    dataChannel.onmessage = onChannelMessage;
+    dataChannel.onclose = () => { add_text_to_debug('Data channel closed'); };
+    dataChannel.onerror = (e) => add_text_to_debug('Data channel error');
+
+    // Offer and answer
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+
+    try {
+      const sdpResp = await fetch(`https://api.openai.com/v1/realtime?model=${session.model}`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${key}`,
+          'Content-Type': 'application/sdp'
+        },
+        body: offer.sdp
+      });
+      if (!sdpResp.ok) {
+        const txt = await sdpResp.text().catch(() => '');
+        throw new Error(`SDP exchange failed ${sdpResp.status} ${txt}`);
+      }
+      const answerSdp = await sdpResp.text();
+      await pc.setRemoteDescription({ type: 'answer', sdp: answerSdp });
+    } catch (e) {
+      add_text_to_debug('SDP error: ' + e.message);
+      return;
+    }
+
+    add_text_to_debug('Connected to OpenAI realtime API');
+  }
+
+  function onChannelOpen() {
+    add_text_to_debug('Data channel open; sending session settings');
+
+    // Session update
+    dataChannel.send(JSON.stringify({
+      type: 'session.update',
+      session: {
+        instructions: assistantInstructions,
+        tools: tools,
+        tool_choice: 'auto',
+
+        // audio in, text out, manual push-to-talk
+        input_audio_format: 'pcm16',
+        input_audio_transcription: { model: 'whisper-1' },
+        turn_detection: null
+      }
+    }));
+
+  }
+
+  async function onChannelMessage(event) {
+    const msg = JSON.parse(event.data);
+
+    switch (msg.type) {
+      // A new assistant turn has been created
+      case 'response.created': {
+        setRunStatus(msg.type);
+        return;
+      }
+
+      // Assistant text streaming
+      case 'response.text.delta': {
+        setRunStatus(msg.type);
+
+        if (capturingSummary) {
+          // collect the summary text
+          if (typeof msg.delta === 'string') summaryBuffer += msg.delta;
+          return;
+        }
+
+        add_text_to_chat(msg.delta, 'assistant');
+        return;
+
+      }
+
+      case 'response.text.done': {
+        setRunStatus(msg.type);
+        if (capturingSummary) {
+          add_text_to_debug(`summary: ${summaryBuffer}`);
+
+          // parse and resolve
+          clearTimeout(summaryTimeoutId);
+          let result = summaryBuffer.trim();
+          // try to parse fenced JSON or a bare JSON object
+          const m = result.match(/```json\s*([\s\S]*?)```/i) || result.match(/\{[\s\S]*\}$/);
+          if (m) {
+            try {
+              const obj = JSON.parse(m[1] || m[0]);
+              result = obj.brief || result;
+            } catch (e) {
+              add_text_to_debug('Error parsing summary JSON: ' + e.message);
+            }
+          }
+
+          capturingSummary = false;
+          const res = summaryResolve; summaryResolve = summaryReject = null;
+          summaryBuffer = '';
+          if (res) res(result);
+          return; // do not print anything to chat
+        }
+
+        return;
+      }
+
+      // assistant has finished its turn
+      case 'response.done': {
+
+        // handle any tool calls, then ask the model to continue
+        const calls = Array.isArray(msg.response?.output)
+          ? msg.response.output.filter(o => o.type === 'function_call')
+          : [];
+
+        if (calls.length) {
+          setRunStatus('waiting_function_call_result');
+          for (const callItem of calls) {
+            const raw = callItem.arguments;
+            const args = typeof raw === 'string' ? JSON.parse(raw) : raw;
+
+            let result;
+            try {
+              result = await window.handle_function_call(callItem.name, args);
+            } catch (err) {
+              result = { error: String(err) };
+            }
+
+            // return the tool result
+            sendDC({
+              type: 'conversation.item.create',
+              item: {
+                type: 'function_call_output',
+                call_id: callItem.call_id,
+                output: JSON.stringify(result)
+              }
+            });
+
+            // let the model continue in text
+            sendDC({
+              type: 'response.create',
+              response: { modalities: ['text'] }
+            });
+          }
+          return;
+        }
+
+        setRunStatus(msg.type);
+        setChatBusy(false); // end of assistant's turn
+        
+        // Check if we have a pending session rotation after assistant completes its turn
+        if (pendingSessionRotation) {
+          add_text_to_debug('Assistant turn completed, starting pending session rotation');
+          setTimeout(() => performSessionRotation(), 100); // Small delay to ensure UI updates
+        }
+        
+        return;
+      }
+
+      // Any server error for this turn
+      case 'response.error': {
+        setRunStatus(msg.type);
+        add_text_to_debug('Realtime error: ' + JSON.stringify(msg));
+
+        if (capturingSummary) {
+          clearTimeout(summaryTimeoutId);
+          capturingSummary = false;
+          const rej = summaryReject; summaryResolve = summaryReject = null;
+          summaryBuffer = '';
+          if (rej) rej(new Error('response.error during summary'));
+        }
+
+        return;
+      }
+
+      // AI confirms it received the audio input
+      case 'input_audio_buffer.committed': {
+        setRunStatus(msg.type);
+
+        // attach the server item_id to the bubble we created on press
+        let phId = currentVoicePlaceholderId;
+        if (!phId) {
+          // very rare, but keep a fallback
+          phId = add_text_to_chat("🎙️ Listening…", "user", { muted: true, append: false });
+        }
+        pendingVoice.set(msg.item_id, { placeholderId: phId });
+        currentVoicePlaceholderId = null;
+        return;
+      }
+
+      case 'conversation.item.input_audio_transcription.delta': {
+        // optional live transcript, uncomment if you want to stream it
+        // add_text_to_debug('mic partial: ' + (msg.delta || ''));
+        return;
+      }
+
+      case 'conversation.item.input_audio_transcription.completed': {
+        setRunStatus(msg.type);
+
+        const entry = pendingVoice.get(msg.item_id);
+        const text = msg.transcript && msg.transcript.trim() ? msg.transcript.trim() : '(no transcript)';
+        if (entry?.placeholderId) {
+          replace_chat_text(entry.placeholderId, text, { muted: false });
+        } else {
+          add_text_to_chat(text, 'user');
+        }
+        pendingVoice.delete(msg.item_id);
+        return;
+      }
+
+      case 'conversation.item.input_audio_transcription.failed': {
+        setRunStatus(msg.type);
+
+        const entry = pendingVoice.get(msg.item_id);
+        if (entry?.placeholderId) {
+          replace_chat_text(entry.placeholderId, 'mic transcription failed', { muted: false });
+        } else {
+          add_text_to_chat('mic transcription failed', 'user');
+        }
+        add_text_to_debug('Transcription error: ' + JSON.stringify(msg.error));
+        pendingVoice.delete(msg.item_id);
+
+        // setChatBusy(false);
+        return;
+      }
+
+      case 'session.created': {
+        setRunStatus(msg.type);
+        return;
+      }
+
+      case 'session.updated': {
+        setRunStatus(msg.type);
+        setChatBusy(false);
+        
+        // Mark session as ready and resolve any waiting promises
+        isSessionReady = true;
+        sessionReadyResolvers.forEach(resolve => resolve());
+        sessionReadyResolvers = [];
+        
+        return;
+      }
+
+      case 'conversation.item.created': {
+        return;
+      }
+
+      default: {
+        // add_text_to_debug('Event: ' + msg.type);
+        return;
+      }
+    }
+  }
+
+  function setRunStatus(text) {
+    const el = document.getElementById('assistantRunStatus');
+    if (el) el.value = text;
+  }
+
+
+  function send_message(message = null) {
+    // add_text_to_debug('send_message called with: ' + message);
+    // If called as an event handler, ignore the event object
+    if (message && typeof message === "object" && message instanceof Event) {
+      add_text_to_debug('send_message called as event handler, ignoring event');
+      message = null;
+    }
+
+    if (message == null && window.chatBusy) {
+      add_text_to_debug('Chat is busy, ignoring message: ' + message);
+      return;
+    }
+
+
+    // if a message is provided, use it; otherwise get from input field
+    const input = document.getElementById('userInput');
+    const text = message ? message : input.value.trim();
+    if (!text) return;
+
+    // If user did not connect yet, auto-connect
+    if (!currentSessionId) {
+      add_text_to_debug('Session not started, auto-connecting to OpenAI');
+      setChatBusy(true);
+      connectOpenAI();
+      return;
+    }
+
+    // Only add user-typed input to the chat
+    if (!message) {
+      add_text_to_chat(text, 'user');
+    }
+
+    sendDC({
+      type: 'conversation.item.create',
+      item: {
+        type: 'message',
+        role: 'user',
+        content: [{ type: 'input_text', text }]
+      }
+    });
+
+    sendDC({
+      type: 'response.create',
+      response: { modalities: ['text'] }
+    });
+
+    input.value = '';
+    setChatBusy(true);
+  }
+
+  // Mic recording logic
+  let isRecording = false;
+
+  function ensureMicReady() {
+    if (!localStream) {
+      add_text_to_debug('Mic not ready');
+      return false;
+    }
+    const track = localStream.getAudioTracks()[0];
+    if (!track) {
+      add_text_to_debug('No audio track found');
+      return false;
+    }
+    return true;
+  }
+
+  // 
+  function startRecording() {
+    if (!pc || !dataChannel || dataChannel.readyState !== 'open') {
+      add_text_to_debug('Data channel not ready, cannot start recording');
+      return;
+    }
+
+    if (window.chatBusy) {
+      add_text_to_debug('Chat is busy, ignoring recording start');
+      return;
+    }
+
+    if (!ensureMicReady()) return;
+    if (isRecording) return;
+    isRecording = true;
+
+    // add a placeholder bubble for the voice input
+    currentVoicePlaceholderId = add_text_to_chat("🎙️ Listening…", "user", { muted: true, append: false });
+
+    // start a fresh audio buffer for this turn
+    sendDC({ type: 'input_audio_buffer.clear' });
+
+    // unmute the track so audio flows to the peer
+    localStream.getAudioTracks()[0].enabled = true;
+
+    recordBtn?.classList.add('recording');
+    add_text_to_debug('Recording start, mic unmuted');
+  }
+
+  function stopRecording() {
+    if (!ensureMicReady()) return;
+    if (!isRecording) return;
+    isRecording = false;
+
+    setChatBusy(true);
+
+    // stop audio flow
+    localStream.getAudioTracks()[0].enabled = false;
+
+    recordBtn?.classList.remove('recording');
+    add_text_to_debug('Recording stop, mic muted');
+
+    if (currentVoicePlaceholderId) {
+      replace_chat_text(currentVoicePlaceholderId, 'Transcribing…', { muted: true });
+    }
+
+    // finalize this audio turn
+    sendDC({ type: 'input_audio_buffer.commit' });
+
+    // ask the model to answer in text
+    sendDC({
+      type: 'response.create',
+      response: { modalities: ['text'] }
+    });
+  }
+
+  //
+  // methods below here are for session rotation 
+  //
+
+  async function requestSessionSummary() {
+    // if already capturing, avoid double requests
+    if (capturingSummary) {
+      return Promise.reject(new Error('summary already in progress'));
+    }
+
+    capturingSummary = true;
+    summaryBuffer = '';
+
+    // build a promise that onChannelMessage will resolve
+    const p = new Promise((resolve, reject) => {
+      summaryResolve = resolve;
+      summaryReject = reject;
+    });
+
+    const prompt =
+      `Summarize the conversation so far for continuity to a new realtime session.
+          Return JSON in one fenced code block with keys: brief, key_state, latest_decisions, todos, safety_notes.
+          Keep total under 1000 characters.`;
+
+    // ask the model
+    sendDC({
+      type: 'conversation.item.create',
+      item: {
+        type: 'message',
+        role: 'system',
+        content: [{ type: 'input_text', text: prompt }]
+      }
+    });
+    sendDC({ type: 'response.create', response: { modalities: ['text'] } });
+    add_text_to_debug('Requesting session summary');
+
+    // safety timeout
+    clearTimeout(summaryTimeoutId);
+    summaryTimeoutId = setTimeout(() => {
+      if (capturingSummary) {
+        capturingSummary = false;
+        const rej = summaryReject; summaryResolve = summaryReject = null;
+        if (rej) rej(new Error('Timeout waiting for session summary'));
+      }
+    }, 15000);
+
+    return p;
+  }
+
+
+  function waitForSessionReady() {
+    if (isSessionReady) return Promise.resolve();
+    return new Promise(resolve => sessionReadyResolvers.push(resolve));
+  }
+
+  async function rotateSession(summaryText = '') {
+    add_text_to_debug('Rotating session with summary');
+
+    try { dataChannel?.close(); } catch { add_text_to_debug('Error closing data channel'); }
+    try { pc?.close(); } catch { add_text_to_debug('Error closing peer connection'); }
+
+    // reset for the new session
+    isSessionReady = false;
+    sessionReadyResolvers = [];
+
+    await connectOpenAI();
+
+    // wait for the session to be ready
+    await waitForSessionReady();
+
+    const note = `Note:
+              - latest_decisions are actions that have already been completed. Never repeat them.
+              - todos are pending actions. Execute them only after confirming with the user.`;
+
+    // now it is safe to seed
+    if (summaryText && summaryText.trim()) {
+      sendDC({
+        type: 'conversation.item.create',
+        item: {
+          type: 'message',
+          role: 'system',
+          content: [{ type: 'input_text', text: `Previous Session memory:\n${summaryText}\n${note}` }]
+        }
+      });
+
+      sendDC({
+        type: 'response.create',
+        response: { modalities: ['text'] }
+      });
+    }
+
+    add_text_to_debug('New session created');
+  }
+
+
+  let expiryTimerId = null;
+  let pendingSessionRotation = false;
+
+  function startSessionExpiryTimer(minutes) {
+    clearSessionExpiryTimer();
+    expiryTimerId = setTimeout(async () => {
+      // Check if assistant is currently busy or we already have a pending rotation
+      if (window.chatBusy || pendingSessionRotation) {
+        add_text_to_debug('Assistant is busy, waiting for current turn to complete before session rotation');
+        pendingSessionRotation = true;
+        return; // Don't start rotation now, let response.done handle it
+      }
+
+      await performSessionRotation();
+    }, minutes * 60 * 1000);
+
+    // start the visible countdown
+    startCountdown(minutes);
+  }
+
+  async function performSessionRotation() {
+    if (pendingSessionRotation && window.chatBusy) {
+      add_text_to_debug('Session rotation still pending, assistant still busy');
+      return; // Still busy, will be called again from response.done
+    }
+
+    pendingSessionRotation = false;
+    setChatBusy(true); // Block user from sending new messages
+
+    add_text_to_debug('Pre expiry, requesting summary from model memory');
+    let summary = '';
+    try {
+      summary = await requestSessionSummary();
+    } catch (e) {
+      add_text_to_debug('Summary request failed, ' + e.message);
+    }
+    await rotateSession(summary);
+  }
+
+  function clearSessionExpiryTimer() {
+    if (expiryTimerId) {
+      clearTimeout(expiryTimerId);
+      expiryTimerId = null;
+    }
+    
+    // Reset pending rotation flag when clearing timer
+    pendingSessionRotation = false;
+
+    stopCountdown();
+  }
+
+
+  let countdownId = null;
+
+  function startCountdown(minutes) {
+    const el = document.getElementById('sessionExpiryTimerText');
+    if (!el) return;
+
+    let remaining = Math.floor(minutes * 60);
+
+    clearInterval(countdownId);
+    countdownId = setInterval(() => {
+      const mm = String(Math.floor(remaining / 60)).padStart(2, '0');
+      const ss = String(remaining % 60).padStart(2, '0');
+      el.textContent = `${mm}:${ss}`;
+
+      if (--remaining < 0) {
+        clearInterval(countdownId);
+        el.textContent = "reconnecting…";
+      }
+    }, 1000);
+  }
+
+  function stopCountdown() {
+    clearInterval(countdownId);
+    countdownId = null;
+    const el = document.getElementById('sessionExpiryTimerText');
+    if (el) el.textContent = "reconnecting…";
+  }
+
+  
+  // check if any wakeup timers have expired and send messages if they have
+  // this function never returns so it should be called from a new thread
+  function check_wakeup_timers() {
+    setInterval(() => {
+      // check if any timers are set
+      if (wakeup_schedule.length === 0) {
+        return;
+      }
+
+      const now = Date.now();
+
+      // iterate backward to safely remove expired timers
+      for (let i = wakeup_schedule.length - 1; i >= 0; i--) {
+        if (now >= wakeup_schedule[i].time) {
+          const message = "WAKEUP:" + wakeup_schedule[i].message;
+          add_text_to_debug("check_wakeup_timers: sending message: " + message);
+
+          // send_to_assistant(message);
+          send_message(message);
+
+          wakeup_schedule.splice(i, 1); // remove expired timer
+        }
+      }
+    }, 1000); // wait for one second
+  }
+
+  initialized = true;
+}
diff --git a/Chat/shared/mavlink.js b/Chat/shared/mavlink.js
new file mode 100644
index 00000000..a32d2ab8
--- /dev/null
+++ b/Chat/shared/mavlink.js
@@ -0,0 +1,10 @@
+export let MAVLink = null;
+export let mavlink_ws = null;
+
+export function setMAVLink(instance) {
+    MAVLink = instance;
+}
+
+export function setMavlinkWS(ws) {
+    mavlink_ws = ws;
+}
diff --git a/Chat/shared/resource_loader.js b/Chat/shared/resource_loader.js
new file mode 100644
index 00000000..3470110b
--- /dev/null
+++ b/Chat/shared/resource_loader.js
@@ -0,0 +1,75 @@
+// remote source for instructions, tools, and knowledge files
+const GITHUB_BASE = "https://raw.githubusercontent.com/ArduPilot/MAVProxy/master/MAVProxy/modules/mavproxy_chat/assistant_setup/";
+
+// list of JSON function definition files
+window.JSON_FUNCTION_FILES = [
+  "delete_wakeup_timers.json",
+  "get_all_parameters.json",
+  "get_available_mavlink_messages.json",
+  "get_current_datetime.json",
+  "get_location_plus_dist_at_bearing.json",
+  "get_location_plus_offset.json",
+  "get_mavlink_message.json",
+  "get_mode_mapping.json",
+  "get_parameter.json",
+  "get_parameter_description.json",
+  "get_vehicle_location_and_yaw.json",
+  "get_vehicle_state.json",
+  "get_vehicle_type.json",
+  "get_wakeup_timers.json",
+  "send_mavlink_command_int.json",
+  "send_mavlink_set_position_target_global_int.json",
+  "set_parameter.json",
+  "set_wakeup_timer.json"
+];
+
+const KNOWLEDGE_TEXT_FILES = [
+  "copter_flightmodes.txt",
+  "plane_flightmodes.txt",
+  "rover_modes.txt",
+  "sub_modes.txt"
+];
+
+export async function loadTextFile(fileName) {
+  try {
+    const url = `${GITHUB_BASE}${fileName}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+      add_text_to_debug(`Failed to fetch text file ${fileName}: ${res.status}`);
+      return "";
+    }
+    return await res.text();
+  } catch (err) {
+    add_text_to_debug(`Error fetching text file ${fileName}: ${err}`);
+    return "";
+  }
+}
+
+export async function loadJSONFile(fileName) {
+  try {
+    const url = `${GITHUB_BASE}${fileName}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+      add_text_to_debug(`Failed to fetch JSON file ${fileName}: ${res.status}`);
+      return null;
+    }
+    return await res.json();
+  } catch (err) {
+    add_text_to_debug(`Error fetching JSON file ${fileName}: ${err}`);
+    return null;
+  }
+}
+
+
+export async function loadInstructions() {
+  const base = await loadTextFile("assistant_instructions.txt");
+  if (!base) return "";
+  let knowledgeConcat = "";
+  for (const file of KNOWLEDGE_TEXT_FILES) {
+    const content = await loadTextFile(file);
+    if (content) {
+      knowledgeConcat += `\n\n# ${file}\n${content}`;
+    }
+  }
+  return base + knowledgeConcat;
+}
\ No newline at end of file
diff --git a/Chat/shared/ui.js b/Chat/shared/ui.js
new file mode 100644
index 00000000..80fa2766
--- /dev/null
+++ b/Chat/shared/ui.js
@@ -0,0 +1,48 @@
+export function add_text_to_debug(text) {
+  const ta = document.getElementById("debugOutput");
+  if (!ta) return;
+  ta.value += (ta.value ? "\n" : "") + String(text);
+  
+  // only scroll if toggle is checked
+  const autoScroll = document.getElementById("autoScrollToggle").checked;
+  if (autoScroll) {
+    ta.scrollTop = ta.scrollHeight;
+  }
+}
+
+let chatMsgCounter = 0;
+
+export function add_text_to_chat(text, role = "assistant", opts = {}) {
+  const chatBox = document.getElementById("chatBox");
+  const divClass = role === "assistant" ? "assistant-text" : "user-text";
+
+  if (role === "assistant" && opts.append !== false) {
+    const last = chatBox.querySelector(`.${divClass}:last-of-type`);
+    if (last) {
+      last.textContent += text;
+      chatBox.scrollTop = chatBox.scrollHeight;
+      return last.dataset.msgId || null;
+    }
+  }
+
+  const el = document.createElement("div");
+  el.className = divClass + (opts.muted ? " muted" : "");
+  el.textContent = text;
+  const id = `msg-${++chatMsgCounter}`;
+  el.dataset.msgId = id;
+  chatBox.appendChild(el);
+  chatBox.scrollTop = chatBox.scrollHeight;
+  return id;
+}
+
+
+window.chatBusy = false;
+
+export function setChatBusy(state) {
+  window.chatBusy = state
+  document.getElementById("sendMessageButton").disabled = state
+  document.getElementById("recordButton").disabled = state
+  document.getElementById("userInput").disabled = state
+}
+
+
diff --git a/Chat/style.css b/Chat/style.css
new file mode 100644
index 00000000..5b5e6193
--- /dev/null
+++ b/Chat/style.css
@@ -0,0 +1,551 @@
+/* CSS Variables for theming */
+:root {
+  --bg-primary: #F8F9FA;
+  --bg-secondary: #FFFFFF;
+  --bg-chat-area: #F1F3F4;
+  --assistant-msg-bg: #E6EEFA;
+  --text-primary: #202124;
+  --text-muted: #70757A;
+  --border-color: #DADCE0;
+  --input-bg: #FFFFFF;
+  --input-border: #DADCE0;
+  --debug-bg: #E8EAED;
+  --blue-accent: #4285F4;
+  --green-accent: #34A853;
+  --yellow-accent: #FBBC04;
+  --red-accent: #EA4335;
+  --blue-hover-light: #F0F6FF;
+  --pick-assistant-bg: var(--blue-accent);
+}
+
+body.dark-theme {
+  --bg-primary: #1A1A1A;
+  --bg-secondary: #202124;
+  --bg-chat-area: #1A1A1A;
+  --assistant-msg-bg: #303134;
+  --text-primary: #E8EAED;
+  --text-muted: #9AA0A6;
+  --border-color: #3c4043;
+  --input-bg: #303134;
+  --input-border: #404144;
+  --debug-bg: #1A1A1A;
+  --blue-hover-light: transparent;
+  --pick-assistant-bg: linear-gradient(90deg, #4285F4, #34A853);
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: var(--bg-chat-area);
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--blue-accent);
+  border-radius: 4px;
+  border: 2px solid transparent;
+  background-clip: content-box;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: color-mix(in srgb, var(--blue-accent) 80%, black);
+}
+
+/* Chat message styles */
+.user-text {
+  align-self: flex-end;
+  background-color: var(--blue-accent);
+  color: #FFFFFF;
+  padding: 10px 16px;
+  border-radius: 1.25rem 1.25rem 0.25rem 1.25rem;
+  max-width: 75%;
+  margin: 4px 0;
+  font-size: 0.95rem;
+  line-height: 1.5;
+  box-shadow: 0 2px 4px rgba(66, 133, 244, 0.2);
+}
+
+.assistant-text {
+  align-self: flex-start;
+  background-color: var(--assistant-msg-bg);
+  color: var(--text-primary);
+  padding: 10px 16px;
+  border-radius: 1.25rem 1.25rem 1.25rem 0.25rem;
+  max-width: 75%;
+  margin: 4px 0;
+  font-size: 0.95rem;
+  line-height: 1.5;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+
+.muted {
+  opacity: 0.6;
+  font-style: italic;
+  color: var(--text-muted);
+}
+
+/* Global styles */
+html,
+body {
+  height: 100vh;
+  overflow-y: auto;
+  overflow-x: hidden;
+  background-color: var(--bg-primary);
+  font-family: 'Inter', sans-serif;
+  color: var(--text-primary);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+html {
+  font-size: 14px;
+}
+
+@media (min-width: 768px) {
+  html {
+    font-size: 16px;
+  }
+}
+
+@media (min-width: 1024px) {
+  html {
+    font-size: 18px;
+  }
+}
+
+/* Header styling */
+header {
+  display: none;
+  background-color: var(--bg-secondary);
+  border-bottom: 1px solid var(--border-color);
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  border-radius: 0 0 0.5rem 0.5rem;
+  flex-shrink: 0;
+  padding: 1rem;
+}
+
+@media (min-width: 1024px) {
+  header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+  }
+
+  header h1 {
+    flex-grow: 1;
+    text-align: center;
+    color: var(--blue-accent);
+    margin-left: auto;
+    margin-right: auto;
+  }
+}
+
+/* Layout styles */
+#appRoot {
+  flex-direction: column;
+  padding: 0.5rem;
+  background-color: var(--bg-primary);
+}
+
+.mobile-chat-full-height {
+  height: calc(95vh - 64px);
+  flex-shrink: 0;
+  padding: 0.75rem;
+}
+
+#chatBox {
+  height: calc(100% - 140px);
+  background-color: var(--bg-chat-area);
+}
+
+@media (min-width: 1024px) {
+  #appRoot {
+    display: grid;
+    grid-template-columns: repeat(5, minmax(0, 1fr));
+    overflow-y: hidden;
+    height: calc(100vh - 64px);
+    padding: 1.5rem;
+  }
+
+  .mobile-chat-full-height {
+    height: 100%;
+    min-height: auto;
+    padding: 1rem;
+  }
+
+  .lg\:col-span-3,
+  .lg\:col-span-2 {
+    height: 100%;
+    overflow-y: auto;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1);
+  }
+}
+
+/* Input and button styles */
+.input-row-element {
+  height: 40px;
+}
+
+/* Mobile styles */
+@media (max-width: 639px) {
+  .chat-panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 1rem;
+  }
+
+  .chat-panel-header h2 {
+    margin-bottom: 0;
+  }
+
+  #userInput,
+  #mavlink-connect-url {
+    padding: 0.5rem 0.75rem;
+    font-size: 0.95rem;
+  }
+
+  .input-button-group {
+    gap: 0.5rem;
+    width: auto;
+    flex-shrink: 0;
+  }
+
+  .input-button-group button {
+    width: 40px;
+    padding: 0;
+    flex-grow: 0;
+    flex-shrink: 0;
+  }
+
+  .input-button-group svg {
+    height: 1.5rem;
+    width: 1.5rem;
+  }
+
+  .chat-input-row,
+  .connect-drone-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+
+  .connect-drone-row #mavlink-connect-button {
+    flex-shrink: 0;
+    width: auto;
+    padding: 0 1rem;
+    font-size: 0.9rem;
+    height: 40px;
+  }
+
+  #openai_api_key,
+  #assistantId,
+  #assistantThreadId,
+  #sessionId,
+  #assistantRunStatus {
+    padding: 0.5rem 0.75rem;
+    font-size: 0.95rem;
+  }
+
+  button {
+    padding-top: 0.5rem;
+    padding-bottom: 0.5rem;
+    font-size: 0.875rem;
+  }
+
+  #openai-connect-button {
+    padding: 0.75rem 1.25rem;
+    font-size: 0.95rem;
+  }
+
+  #toggleApiKeyButton svg {
+    height: 1.75rem;
+    width: 1.75rem;
+  }
+
+  #debugOutput {
+    font-size: 0.875rem;
+  }
+}
+
+/* Desktop styles */
+@media (min-width: 640px) {
+
+  #userInput,
+  #mavlink-connect-url {
+    padding: 0.75rem 1rem;
+    font-size: 1rem;
+  }
+
+  .input-button-group button {
+    padding: 0.75rem;
+  }
+
+  .input-button-group svg {
+    height: 1.5rem;
+    width: 1.5rem;
+  }
+
+  .chat-input-row,
+  .connect-drone-row {
+    display: flex;
+    flex-direction: row;
+    gap: 0.75rem;
+  }
+
+  .connect-drone-row #mavlink-connect-url {
+    flex-grow: 1;
+    width: auto;
+    padding: 0.625rem 1.25rem;
+    font-size: 0.875rem;
+  }
+
+  .connect-drone-row #mavlink-connect-button {
+    padding: 0.625rem 1.25rem;
+    font-size: 0.875rem;
+    height: auto;
+  }
+
+  #openai_api_key,
+  #assistantId,
+  #assistantThreadId,
+  #sessionId,
+  #assistantRunStatus {
+    padding: 0.75rem 1rem;
+    font-size: 1rem;
+  }
+
+  #openai-connect-button {
+    padding: 0.625rem 1.25rem;
+    font-size: 0.875rem;
+  }
+
+  button {
+    padding-top: 0.625rem;
+    padding-bottom: 0.625rem;
+    font-size: 0.875rem;
+  }
+
+  #toggleApiKeyButton svg {
+    height: 1.75rem;
+    width: 1.75rem;
+  }
+
+  #debugOutput {
+    font-size: 0.875rem;
+  }
+}
+
+/* Component-specific styles */
+#modeChooser>div {
+  background-color: var(--bg-secondary);
+  border: 1px solid var(--border-color);
+  box-shadow: 0 8px 20px rgba(0, 0, 0, 0.2);
+}
+
+#modeChooser h2,
+.chat-panel-header h2,
+.side-panel-mobile-styling h2 {
+  color: var(--blue-accent);
+}
+
+#modeChooser p {
+  color: var(--text-muted);
+}
+
+#modeChooser #pickAssistant {
+  background-color: transparent;
+  border: 1px solid var(--blue-accent);
+  color: var(--blue-accent);
+}
+
+#modeChooser #pickAssistant:hover {
+  background-color: var(--blue-hover-light);
+  color: var(--blue-accent);
+  border-color: var(--blue-accent);
+}
+
+#modeChooser #pickRealtime {
+  background: var(--pick-assistant-bg);
+  color: white;
+}
+
+#modeChooser #pickRealtime:hover {
+  opacity: 0.9;
+}
+
+#modeChooser .text-xs div {
+  color: var(--blue-accent);
+}
+
+#modeChooser .text-xs ul {
+  color: var(--text-primary);
+}
+
+#sessionTimer {
+  border: 1px solid var(--border-color);
+  background-color: var(--bg-secondary);
+}
+
+#sessionTimer svg {
+  color: var(--green-accent);
+}
+
+#sessionTimer span {
+  color: var(--text-primary);
+}
+
+.chat-input-row,
+.connect-drone-row {
+  border-top: 1px solid var(--border-color);
+  padding-top: 1rem;
+}
+
+/* Input fields */
+#userInput,
+#mavlink-connect-url,
+#openai_api_key,
+#assistantId,
+#assistantThreadId,
+#sessionId,
+#assistantRunStatus,
+#debugOutput {
+  background-color: var(--input-bg);
+  border: 1px solid var(--input-border);
+  color: var(--text-primary);
+}
+
+#userInput::placeholder,
+#mavlink-connect-url::placeholder {
+  color: var(--text-muted);
+}
+
+#userInput:focus,
+#mavlink-connect-url:focus,
+#openai_api_key:focus,
+#debugOutput:focus {
+  border-color: var(--blue-accent);
+  box-shadow: 0 0 0 2px rgba(66, 133, 244, 0.4);
+  background-color: var(--input-bg);
+}
+
+#openai_api_key,
+#assistantId,
+#assistantThreadId,
+#sessionId,
+#assistantRunStatus {
+  background-color: var(--bg-chat-area);
+}
+
+#debugOutput {
+  background-color: var(--debug-bg);
+}
+
+/* Buttons */
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  font-weight: 600;
+  border-radius: .65rem;
+  padding: .55rem .9rem;
+  gap: .35rem;
+  line-height: 1;
+  border: 1px solid transparent;
+  cursor: pointer;
+  user-select: none;
+  -webkit-user-select: none;
+  background: var(--blue-accent);
+  color: #fff;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, .08), 0 1px 1px rgba(0, 0, 0, .06);
+  transition: background .18s, box-shadow .18s, transform .15s;
+}
+
+.btn:hover {
+  box-shadow: 0 2px 4px rgba(0, 0, 0, .15);
+}
+
+.btn:active {
+  transform: translateY(1px);
+  box-shadow: 0 1px 2px rgba(0, 0, 0, .12);
+}
+
+.btn:focus {
+  outline: none;
+  box-shadow: 0 0 0 2px rgba(66, 133, 244, .35);
+}
+
+.btn[disabled],
+.btn.disabled {
+  opacity: .55;
+  cursor: not-allowed;
+  pointer-events: none;
+}
+
+.btn-small {
+  padding: .4rem .7rem;
+  font-size: .8rem;
+}
+
+.btn-large {
+  padding: .8rem 1.25rem;
+  font-size: 1rem;
+}
+
+/* Color variants */
+.btn-blue {
+  background: var(--blue-accent);
+}
+
+.btn-blue:hover {
+  background: color-mix(in srgb, var(--blue-accent) 85%, black);
+}
+
+.btn-green {
+  background: var(--green-accent);
+}
+
+.btn-green:hover {
+  background: color-mix(in srgb, var(--green-accent) 85%, black);
+}
+
+.btn-yellow {
+  background: var(--yellow-accent);
+  color: var(--text-primary);
+}
+
+.btn-yellow:hover {
+  background: color-mix(in srgb, var(--yellow-accent) 85%, black);
+}
+
+.btn-red {
+  background: var(--red-accent);
+}
+
+.btn-red:hover {
+  background: color-mix(in srgb, var(--red-accent) 85%, black);
+}
+
+/* Subtle outline style */
+.btn-outline {
+  background: transparent;
+  border: 1px solid currentColor;
+  color: var(--blue-accent);
+}
+
+.btn-outline:hover {
+  background: var(--blue-hover-light);
+}
+
+.side-panel-mobile-styling .p-4.border-b {
+  border-color: var(--border-color);
+}
+
+label {
+  color: var(--text-primary);
+}
\ No newline at end of file
diff --git a/Chat/toggle.js b/Chat/toggle.js
new file mode 100644
index 00000000..4951433b
--- /dev/null
+++ b/Chat/toggle.js
@@ -0,0 +1,110 @@
+// Toggle Script (Theme and API key visibility)
+
+document.addEventListener('DOMContentLoaded', () => {
+  const body = document.body;
+  // Use distinct IDs for desktop and mobile theme buttons/icons
+  const themeToggleButtonDesktop = document.getElementById('themeToggleButtonDesktop');
+  const themeIconDesktop = document.getElementById('themeIconDesktop');
+  const themeToggleButtonMobile = document.getElementById('themeToggleButtonMobile');
+  const themeIconMobile = document.getElementById('themeIconMobile');
+
+
+  // Function to set the theme
+  function setTheme(theme) {
+    if (theme === 'dark') {
+      body.classList.add('dark-theme');
+      localStorage.setItem('theme', 'dark');
+
+      // Update desktop theme button
+      if (themeIconDesktop) {
+        themeIconDesktop.innerHTML = `
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 3v1m0 16v1m9-9h-1M4 12H3m15.364 6.364l-.707-.707M6.343 6.343l-.707-.707m12.728 0l-.707.707M6.343 17.657l-.707.707M16 12a4 4 0 11-8 0 4 4 0 018 0z" />
+            `;
+        themeToggleButtonDesktop.classList.remove('bg-gray-200', 'text-gray-800', 'focus:ring-blue-500');
+        themeToggleButtonDesktop.classList.add('bg-gray-700', 'text-gray-100', 'focus:ring-gray-400');
+      }
+
+      // Update mobile theme button
+      if (themeIconMobile) {
+        themeIconMobile.innerHTML = `
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 3v1m0 16v1m9-9h-1M4 12H3m15.364 6.364l-.707-.707M6.343 6.343l-.707-.707m12.728 0l-.707.707M6.343 17.657l-.707.707M16 12a4 4 0 11-8 0 4 4 0 018 0z" />
+            `;
+        themeToggleButtonMobile.classList.remove('bg-gray-200', 'text-gray-800', 'focus:ring-blue-500');
+        themeToggleButtonMobile.classList.add('bg-gray-700', 'text-gray-100', 'focus:ring-gray-400');
+      }
+
+    } else {
+      body.classList.remove('dark-theme');
+      localStorage.setItem('theme', 'light');
+
+      // Update desktop theme button
+      if (themeIconDesktop) {
+        themeIconDesktop.innerHTML = `
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M20.354 15.354A9 9 0 018.646 3.646 9.003 9.003 0 0012 21a9.003 9.003 0 008.354-5.646z" />
+            `;
+        themeToggleButtonDesktop.classList.remove('bg-gray-700', 'text-gray-100', 'focus:ring-gray-400');
+        themeToggleButtonDesktop.classList.add('bg-gray-200', 'text-gray-800', 'focus:ring-blue-500');
+      }
+
+      // Update mobile theme button
+      if (themeIconMobile) {
+        themeIconMobile.innerHTML = `
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M20.354 15.354A9 9 0 018.646 3.646 9.003 9.003 0 0012 21a9.003 9.003 0 008.354-5.646z" />
+            `;
+        themeToggleButtonMobile.classList.remove('bg-gray-700', 'text-gray-100', 'focus:ring-gray-400');
+        themeToggleButtonMobile.classList.add('bg-gray-200', 'text-gray-800', 'focus:ring-blue-500');
+      }
+    }
+  }
+
+  // Check for saved theme preference on load
+  const savedTheme = localStorage.getItem('theme') || 'light'; // Default to light if no preference
+  setTheme(savedTheme);
+
+  // Add event listeners to both buttons if they exist
+  if (themeToggleButtonDesktop) {
+    themeToggleButtonDesktop.addEventListener('click', () => {
+      const currentTheme = body.classList.contains('dark-theme') ? 'dark' : 'light';
+      setTheme(currentTheme === 'light' ? 'dark' : 'light');
+    });
+  }
+
+  if (themeToggleButtonMobile) {
+    themeToggleButtonMobile.addEventListener('click', () => {
+      const currentTheme = body.classList.contains('dark-theme') ? 'dark' : 'light';
+      setTheme(currentTheme === 'light' ? 'dark' : 'light');
+    });
+  }
+
+
+  // show/hide the OpenAI API key field
+  function toggle_openai_api_key_visibility() {
+    let openai_key_input = document.getElementById("openai_api_key");
+    const eyeIconContainer = document.getElementById("eyeIcon"); // Get reference to the SVG element
+    // Eye Icon (Open)
+    const eyeOpenSVGPath = `
+                <path d="M10 12.5a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5Z" />
+                <path fill-rule="evenodd" d="M.664 10.59a1.651 1.651 0 0 1 0-1.186A10.004 10.004 0 0 1 10 3c4.257 0 7.893 2.66 9.336 6.41.147.381.146.804 0 1.186A10.004 10.004 0 0 1 10 17c-4.257 0-7.893-2.66-9.336-6.41ZM14 10a4 4 0 1 1-8 0 4 4 0 0 1 8 0Z" clip-rule="evenodd" />
+            `;
+
+    // Eye-Slash Icon (Closed)
+    const eyeClosedSVGPath = `
+                <path fill-rule="evenodd" d="M3.28 2.22a.75.75 0 0 0-1.06 1.06l14.5 14.5a.75.75 0 1 0 1.06-1.06l-1.745-1.745a10.029 10.029 0 0 0 3.3-4.38 1.651 1.651 0 0 0 0-1.185A10.004 10.004 0 0 0 9.999 3a9.956 9.956 0 0 0-4.744 1.194L3.28 2.22ZM7.752 6.69l1.092 1.092a2.5 2.5 0 0 1 3.374 3.373l1.091 1.092a4 4 0 0 0-5.557-5.557Z" clip-rule="evenodd" />
+                <path d="m10.748 13.93 2.523 2.523a9.987 9.987 0 0 1-3.27.547c-4.258 0-7.894-2.66-9.337-6.41a1.651 1.651 0 0 1 0-1.186A10.007 10.007 0 0 1 2.839 6.02L6.07 9.252a4 4 0 0 0 4.678 4.678Z" />
+            `;
+
+    if (openai_key_input.type === "password") {
+      openai_key_input.type = "text";
+      // Change icon to 'eye open'
+      eyeIconContainer.innerHTML = eyeOpenSVGPath;
+    } else {
+      openai_key_input.type = "password";
+      // Change icon to 'eye slash'
+      eyeIconContainer.innerHTML = eyeClosedSVGPath;
+    }
+  }
+
+  // listener for toggle api key visibility button click
+  document.getElementById("toggleApiKeyButton").addEventListener("click", toggle_openai_api_key_visibility);
+
+});
diff --git a/Dev/index.html b/Dev/index.html
index 1de91698..c0623347 100644
--- a/Dev/index.html
+++ b/Dev/index.html
@@ -108,6 +108,20 @@ <h2>Thrust Expo</h2>
     </td>
   </tr>
 
+  <tr>
+    <td>
+
+      <a href="../Chat" style="margin: 20px; display: inline-block;"><img src="../images/Chat_Icon.png" style="width:200px"></a>
+    </td>
+    <td style="text-align:left; vertical-align:top; max-width:960px;">
+      <h2>Chat</h2>
+      OpenAI Chat module
+      Use an AI chat to control your vehicle
+    </td>
+   </tr>
+
+
+     
   <tr>
     <td>
       <a href="../AILogAnalyzer" style="margin: 20px; display: inline-block;"><img src="../images/AILogAnalyzer_Icon.png" style="width:200px"></a>
@@ -116,6 +130,7 @@ <h2>Thrust Expo</h2>
       <h2>AI Log Analyzer</h2>
       AI Log Analyzer module
       Use an AI agent to analyze your logs file
+
     </td>
   </tr>
 
diff --git a/images/Chat_Icon.png b/images/Chat_Icon.png
new file mode 100644
index 00000000..208bae54
Binary files /dev/null and b/images/Chat_Icon.png differ
diff --git a/modules/MAVLink/local_modules/README.md b/modules/MAVLink/local_modules/README.md
new file mode 100644
index 00000000..ad5a1382
--- /dev/null
+++ b/modules/MAVLink/local_modules/README.md
@@ -0,0 +1,6 @@
+This folder is a locally modified copy of some Node/npm packages 'jspack' and 'long'. we have copied them here and tweaked them to be compatible with our needs, please see their respective README.md file for their original info, which we have not changed. 
+
+This README.md serves to make you aware that these two packages as stored here in the 'jspack' and 'long' folders ARE MODIFIED from the originals.
+By placing this statement here, and putting a notice in long.js as well, we feel are in compliance with the LICENSE file of 'long' , which requires us to tell you they are modified.
+
+We have included their original license files, in compliance with them, as both license/s permit distribution of derived works in source and/or binary form.
diff --git a/modules/MAVLink/local_modules/jspack/.npmignore b/modules/MAVLink/local_modules/jspack/.npmignore
new file mode 100644
index 00000000..be1ea81a
--- /dev/null
+++ b/modules/MAVLink/local_modules/jspack/.npmignore
@@ -0,0 +1,19 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+*.pyc
+
+pids
+logs
+results
+
+npm-debug.log
+node_modules
+
+**~
+**.swp
diff --git a/modules/MAVLink/local_modules/jspack/LICENSE b/modules/MAVLink/local_modules/jspack/LICENSE
new file mode 100644
index 00000000..d646dd72
--- /dev/null
+++ b/modules/MAVLink/local_modules/jspack/LICENSE
@@ -0,0 +1,26 @@
+Copyright (c) 2008, Fair Oaks Labs, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list
+      of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright notice, this
+      list of conditions and the following disclaimer in the documentation and/or other
+      materials provided with the distribution.
+
+    * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors may be
+      used to endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/modules/MAVLink/local_modules/jspack/README.md b/modules/MAVLink/local_modules/jspack/README.md
new file mode 100644
index 00000000..fee0cdc3
--- /dev/null
+++ b/modules/MAVLink/local_modules/jspack/README.md
@@ -0,0 +1,147 @@
+jspack - library to pack primitives to octet arrays
+====================================================
+
+[![Build status](https://travis-ci.org/birchroad/node-jspack.svg?branch=master)](https://travis-ci.org/birchroad/node-jspack)
+
+## Disclaimer
+The jspack module and documentation are essentially ports of the
+Python struct module and documentation, with such changes as were necessary. The port was originally made by Fair Oaks Labs, Inc. and published at http://code.google.com/p/jspack/
+If any Python people are miffed that their documentation got ripped off, let me know,
+and I'll gladly revise them.
+
+This module performs conversions between JavaScript values and C structs
+represented as octet arrays (i.e. JavaScript arrays of integral numbers
+between 0 and 255, inclusive).  It uses format strings (explained below) as
+compact descriptions of the layout of the C structs and the intended conversion
+to/from JavaScript values.  This can be used to handle binary data stored in
+files, or received from network connections or other sources.
+
+## Install
+    npm install jspack
+
+## Reference
+
+The module defines the following functions:
+
+### Unpack(fmt, a, p)
+Return an array containing values unpacked from the octet array a,
+beginning at position p, according to the supplied format string.  If there
+are more octets in a than required by the format string, the excess is
+ignored.  If there are fewer octets than required, Unpack() will return
+undefined.  If no value is supplied for the p argument, zero is assumed.
+
+### PackTo(fmt, a, p, values)
+Pack and store the values array into the supplied octet array a, beginning
+at position p.  If there are more values supplied than are specified in the
+format string, the excess is ignored.  If there are fewer values supplied,
+PackTo() will return false.  If there is insufficient space in a to store
+the packed values, PackTo() will return false.  On success, PackTo() returns
+the a argument. If any value is of an inappropriate type, the results are
+undefined.
+
+### Pack(fmt, values)
+Return an octet array containing the packed values array.  If there are
+more values supplied than are specified in the format string, the excess is
+ignored.  If there are fewer values supplied, Pack() will return false.  If
+any value is of an inappropriate type, the results are undefined.
+
+### CalcLength(fmt)
+Return the number of octets required to store the given format string.
+
+
+## Formats
+Format characters have the following meanings; the conversion between C and
+JavaScript values should be obvious given their types:
+
+    Format | C Type         | JavaScript Type   | Size (octets) | Notes
+    -------------------------------------------------------------------
+       A   | char[]         | Array             |     Length     |  (1)
+       x   | pad byte       | N/A               |        1       |
+       c   | char           | string (length 1) |        1       |  (2)
+       b   | signed char    | number            |        1       |  (3)
+       B   | unsigned char  | number            |        1       |  (3)
+       h   | signed short   | number            |        2       |  (3)
+       H   | unsigned short | number            |        2       |  (3)
+       i   | signed int     | number            |        4       |  (3)
+       I   | unsigned int   | number            |        4       |  (3)
+       l   | signed long    | number            |        4       |  (3)
+       L   | unsigned long  | number            |        4       |  (3)
+       q   | signed long    | number            |        8       |  (6)
+       Q   | unsigned long  | number            |        8       |  (6)
+       s   | char[]         | string            |     Length     |  (2)
+       f   | float          | number            |        4       |  (4)
+       d   | double         | number            |        8       |  (5)
+
+*Notes:*
+
+  **(1)** The "A" code simply returns a slice of the source octet array.  This is
+  primarily useful when a data structure contains bytes which are subject to
+  multiple interpretations (e.g. unions), and the data structure is being
+  decoded in multiple passes.
+
+  **(2)** The "c" and "s" codes handle strings with codepoints between 0 and 255,
+  inclusive.  The data are not bounds-checked, so strings containing  characters
+  with codepoints outside this range will encode to "octet" arrays that contain
+  values outside the range of an octet.  Furthermore, since these codes decode
+  octet arrays by assuming the octets represent UNICODE codepoints, they may
+  not "correctly" decode bytes in the range 128-255, since that range is subject
+  to multiple interpretations.  Caveat coder!
+
+  **(3)** The 8 "integer" codes clip their encoded values to the minima and maxmima
+  of their respective types:  If you invoke Struct.Pack('b', [-129]), for
+  instance, the result will be [128], which is the octet encoding of -128,
+  which is the minima of a signed char.  Similarly, Struct.Pack('h', [-32769])
+  returns [128, 0].  Fractions are truncated.
+
+  **(4)** Since JavaScript doesn't natively support 32-bit floats, whenever a float
+  is stored, the source JavaScript number must be rounded.  This module applies
+  correct rounding during this process.  Numbers with magnitude greater than or
+  equal to 2^128-2^103 round to either positive or negative Infinity. The
+  rounding algorithm assumes that JavaScript is using exactly 64 bits of
+  floating point precision; 128-bit floating point will result in subtle errors.
+
+  **(5)** This module assumes that JavaScript is using 64 bits of floating point
+  precision, so the "d" code performs no rounding.  128-bit floating point will
+  cause the "d" code to simply truncate significands to 52 bits.
+
+  **(6)** Since 64bit longs cannot be represented by numbers JavaScript, this version of
+  jspack will process longs as arrays in the form: ```[lowBits, hightBits]```. The
+  decoded long array contains a third element, the unsigned flag, which is ```false``` for signed
+  and ```true``` for unsigned values.
+  This representation is similar to what [Long.js](https://github.com/dcodeIO/Long.js), and
+  therefore the [Google Closure Libaray](https://github.com/google/closure-library), uses.
+  See [test/int64.js](test/int64.js) for examples how to work with Long.js.
+
+A format character may be preceded by an integral repeat count.  For example,
+the format string "4h" means exactly the same thing as "hhhh".
+
+Whitespace characters between formats are ignored; a count and its format must
+not be separated by whitespace, however.
+
+For the "A" format character, the count is interpreted as the size of the
+array, not a repeat count as for the other format characters; for example, "10A"
+means a single 10-octet array.  When packing, the Array is truncated or padded
+with 0 bytes as appropriate to make it conform to the specified length.  When
+unpacking, the resulting Array always has exactly the specified number of bytes.
+As a special case, "0A" means a single, empty Array.
+
+For the "s" format character, the count is interpreted as the size of the
+string, not a repeat count as for the other format characters; for example,
+"10s" means a single 10-byte string, while "10c" means 10 characters.  When
+packing, the string is truncated or padded with 0 bytes as appropriate to make
+it conform to the specified length.  When unpacking, the resulting string always
+has exactly the specified number of bytes.  As a special case, "0s" means a
+single, empty string (while "0c" means 0 characters).
+
+
+By default, C numbers are represented in network (or big-endian) byte order.
+Alternatively, the first character of the format string can be used to indicate
+byte order of the packed data, according to the following table:
+
+    Character | Byte Order
+    ----------------------------------
+        <     | little-endian
+        >     | big-endian
+        !     | network (= big-endian)
+
+If the first character is not one of these, "!" is assumed.
diff --git a/modules/MAVLink/local_modules/jspack/jspack.js b/modules/MAVLink/local_modules/jspack/jspack.js
new file mode 100644
index 00000000..20095fed
--- /dev/null
+++ b/modules/MAVLink/local_modules/jspack/jspack.js
@@ -0,0 +1,891 @@
+/**
+ * @license
+
+ Copyright © 2008 Fair Oaks Labs, Inc.
+  All rights reserved.
+
+  This file is Modified from the original, by buzz 2020:
+   - ran thru http://www.jsnice.org/ and manually renamed the variables to be clearer 
+   - added optionally enabled debugging/verbose/printfs throughout
+   - bugfixes and integration so it now passes our mavlink.js testsuite/s
+   - please see README.md in the upper level folder.
+*/
+'use strict';
+
+//var Long = require('long');
+
+let DEBUG = false;
+
+/**
+ * @return {undefined}
+ */
+function JSPack() {
+  var el;
+  /** @type {boolean} */
+  var booleanIsBigEndian = false;
+  var m = this;
+  
+  
+  /**
+   * @param {!Object} octet_array_a
+   * @param {number} offset_p
+   * @param {number} len
+   * @return {?}
+   */
+  //Raw byte arrays
+ // m._DeArray = function(octet_array_a, offset_p, len) {
+ // if (DEBUG) console.log("zzz1");
+ //   return [octet_array_a.slice(offset_p, offset_p + len)];
+  //};
+  
+  /**
+   * @param {!Array} to_octet_array_a
+   * @param {number} offset_p
+   * @param {number} len
+   * @param {!NodeList} from_array_v
+   * @return {undefined}
+   */
+ // m._EnArray = function(to_octet_array_a, offset_p, len, from_array_v) {
+ // if (DEBUG) console.log("zzz2");
+    /** @type {number} */
+  //  var i = 0;
+  //  for (; i < len; to_octet_array_a[offset_p + i] = from_array_v[i] ? from_array_v[i] : 0, i++) {
+  //  }
+  //};
+  
+  
+  /**
+   * @param {!Object} octet_array_a
+   * @param {number} offset_p
+   * @return {?}
+   */
+  // ASCII characters
+  m._DeChar = function(octet_array_a, offset_p) {
+  if (DEBUG) console.log("zzz3");
+    return String.fromCharCode(octet_array_a[offset_p]);
+  };
+  /**
+   * @param {!Array} to_octet_array_a
+   * @param {number} offset_p
+   * @param {string} from_str_array_v
+   * @return {undefined}
+   */
+ // m._EnChar = function(to_octet_array_a, offset_p, from_str_array_v) {
+ // if (DEBUG) console.log("zzz4");
+ //   /** @type {number} */
+ //   to_octet_array_a[offset_p] = from_str_array_v.charCodeAt(0);
+ // };
+  
+  
+  /**
+   * @param {!Object} octet_array_a
+   * @param {number} offset_p
+   * @return {?}
+   */
+  //Little-endian (un)signed N-byte integers
+  m._DeInt = function(octet_array_a, offset_p) {
+  if (DEBUG) console.log("zzz5");
+    /** @type {number} */
+    var lsb = booleanIsBigEndian ? el.len - 1 : 0;
+    /** @type {number} */
+    var nsb = booleanIsBigEndian ? -1 : 1;
+    /** @type {number} */
+    var stop = lsb + nsb * el.len;
+    var rv;
+    var i;
+    var f;
+    /** @type {number} */
+    rv = 0;
+    /** @type {number} */
+    i = lsb;
+    /** @type {number} */
+    f = 1;
+    for (; i != stop; rv = rv + octet_array_a[offset_p + i] * f, i = i + nsb, f = f * 256) {
+    }
+    if (el.bSigned && rv & Math.pow(2, el.len * 8 - 1)) {
+      /** @type {number} */
+      rv = rv - Math.pow(2, el.len * 8);
+    }
+    return rv;
+  };
+  
+  
+  /**
+   * @param {!Array} octet_array_a
+   * @param {number} offset_p
+   * @param {number} val
+   * @return {undefined}
+   */
+  m._EnInt = function(octet_array_a, offset_p, val) {
+  if (DEBUG) console.log("chunk-from: "+val);
+    /** @type {number} */
+    var lsb = booleanIsBigEndian ? el.len - 1 : 0;
+    /** @type {number} */
+    var nsb = booleanIsBigEndian ? -1 : 1;
+    /** @type {number} */
+    var stop = lsb + nsb * el.len;
+    var i;
+    // range limit:
+    if (val < el.min ) {
+        val = el.min;
+        console.log("value limited to MIN:"+val);   
+    }
+    if (val > el.max ) {
+        val =  el.max;
+        console.log("value limited to MAX:"+val);   
+    }
+    /** @type {number} */
+    i = lsb;
+  if (DEBUG) console.log("booleanIsBigEndian:"+booleanIsBigEndian);   
+  if (DEBUG) console.log("el.len:"+el.len);   
+  if (DEBUG) console.log("lsb:"+lsb);   
+  if (DEBUG) console.log("nsb:"+nsb);   
+  if (DEBUG) console.log("i:"+i);   
+  if (DEBUG) console.log("stop:"+stop);   
+    for (; i != stop; ) {
+
+         var to = JSON.stringify(val&255);
+        if (DEBUG) console.log("chunk as bytes: "+to);
+
+        octet_array_a[offset_p + i] = val & 255;
+        i = i + nsb;
+        val = val >> 8;
+
+
+    }
+  };
+  
+  
+  /**
+   * @param {!Object} octet_array_a
+   * @param {number} offset_p
+   * @param {number} len
+   * @return {?}
+   */
+  // ASCII character strings
+  m._DeString = function(octet_array_a, offset_p, len) {
+  if (DEBUG) console.log("zzz7");
+    /** @type {!Array} */
+    var retval = new Array(len);
+    /** @type {number} */
+    var i = 0;
+    for (; i < len; retval[i] = String.fromCharCode(octet_array_a[offset_p + i]), i++) {
+    }
+    return retval.join("");
+  };
+  /**
+   * @param {!Array} octet_array_a
+   * @param {number} offset_p
+   * @param {number} len
+   * @param {string} strval
+   * @return {undefined}
+   */
+  m._EnString = function(octet_array_a, offset_p, len, strval) {
+  if (DEBUG) console.log("zzz8");
+    var t;
+    /** @type {number} */
+    if ( DEBUG ) console.log("strencode before: "+octet_array_a+"\np:"+offset_p+" len:"+len+" strval:"+strval) 
+    var i = 0;
+    //if (DEBUG) console.log("strval:"+strval);
+//console.trace("Here I am!")
+
+    // we all strings to be passed in as a string of characters, or a an array or buffer of them is ok too
+
+    if (typeof strval.charCodeAt === "function") { 
+      for (; i < len; octet_array_a[offset_p + i] = (t = strval.charCodeAt(i)) ? t : 0, i++) {
+        if ( t > 255 ) console.log("ERROR ERROR ERROR ERROR ERROR ERROR - It seems u passed unicode/utf-8/etc to jspack, not 8 bit ascii. please use .toString('binary'); not .toString();");
+      }
+      if ( DEBUG ) console.log("strencode from CHAR-string."); 
+
+    } else if (Array.isArray(strval)) { 
+      for (; i < len; octet_array_a[offset_p + i] = (t = strval[i]) ? t : 0, i++) {
+        // referring directly to 't' inside this loop is bad, seems delayed by an iteration, but strval[i] is ok.
+        if ( strval[i] > 255 )  console.log("ERROR ERROR ERROR ERROR ERROR ERROR - It seems u passed unicode/utf-8/etc, or array data with values > 255, to jspack, not 8 bit ascii.\n(bad Array data)"+strval[i]);
+      }
+      if ( DEBUG ) console.log("strencode from ARRAY."); 
+
+    } else if (Buffer.isBuffer(strval)) { 
+      for (; i < len; octet_array_a[offset_p + i] = (t = strval[i]) ? t : 0, i++) {
+        if ( strval[i] > 255 ) console.log("ERROR ERROR ERROR ERROR ERROR ERROR - It seems u passed unicode/utf-8/etc to jspack, not 8 bit ascii. \n(bad Buffer data)"+strval[i]);
+      }
+      if ( DEBUG ) console.log("strencode from Buffer."); 
+
+    } else {
+        console.log("ERROR encoding string _EnString:  array:"+octet_array_a+" p:"+offset_p+" len:"+len+" strval:"+JSON.stringify(strval)) 
+}
+  };
+  
+  
+  /**
+   * @param {!Object} octet_array_a
+   * @param {number} offset_p
+   * @return {?}
+   */
+  // Little-endian N-bit IEEE 754 floating point
+  m._De754 = function(octet_array_a, offset_p) {
+  if (DEBUG) console.log("zzz9");
+    var bool_s;
+    var exponent;
+    var mantissa;
+    var i;
+    var d;
+    var nBits;
+    var mantissaLen;
+    var exponentLen;
+    var eBias;
+    var eMax;
+    mantissaLen = el.mLen;
+    /** @type {number} */
+    exponentLen = el.len * 8 - el.mLen - 1;
+    /** @type {number} */
+    eMax = (1 << exponentLen) - 1;
+    /** @type {number} */
+    eBias = eMax >> 1;
+    /** @type {number} */
+    i = booleanIsBigEndian ? 0 : el.len - 1;
+    /** @type {number} */
+    d = booleanIsBigEndian ? 1 : -1;
+    bool_s = octet_array_a[offset_p + i];
+    /** @type {number} */
+    i = i + d;
+    /** @type {number} */
+    nBits = -7;
+    /** @type {number} */
+    exponent = bool_s & (1 << -nBits) - 1;
+    /** @type {number} */
+    bool_s = bool_s >> -nBits;
+    /** @type {number} */
+    nBits = nBits + exponentLen;
+    for (; nBits > 0; exponent = exponent * 256 + octet_array_a[offset_p + i], i = i + d, nBits = nBits - 8) {
+    }
+    /** @type {number} */
+    mantissa = exponent & (1 << -nBits) - 1;
+    /** @type {number} */
+    exponent = exponent >> -nBits;
+    nBits = nBits + mantissaLen;
+    for (; nBits > 0; mantissa = mantissa * 256 + octet_array_a[offset_p + i], i = i + d, nBits = nBits - 8) {
+    }
+    switch(exponent) {
+      case 0:
+        /** @type {number} */
+        // Zero, or denormalized number
+        exponent = 1 - eBias;
+        break;
+      case eMax:
+        // NaN, or +/-Infinity
+        return mantissa ? NaN : (bool_s ? -1 : 1) * Infinity;
+      default:
+        // Normalized number
+        mantissa = mantissa + Math.pow(2, mantissaLen);
+        /** @type {number} */
+        exponent = exponent - eBias;
+        break;
+    }
+    return (bool_s ? -1 : 1) * mantissa * Math.pow(2, exponent - mantissaLen);
+  };
+  /**
+   * @param {!Array} octet_array_a
+   * @param {number} offset_p
+   * @param {number} v
+   * @return {undefined}
+   */
+  m._En754 = function(octet_array_a, offset_p, v) {
+  if (DEBUG) console.log("zzz_10");
+    var bool_s;
+    var exponent;
+    var mantissa;
+    var i;
+    var d;
+    var c;
+    var mantissaLen;
+    var exponentLen;
+    var eBias;
+    var eMax;
+    mantissaLen = el.mLen;
+    /** @type {number} */
+    exponentLen = el.len * 8 - el.mLen - 1;
+    /** @type {number} */
+    eMax = (1 << exponentLen) - 1;
+    /** @type {number} */
+    eBias = eMax >> 1;
+    /** @type {number} */
+    bool_s = v < 0 ? 1 : 0;
+    /** @type {number} */
+    v = Math.abs(v);
+    if (isNaN(v) || v == Infinity) {
+      /** @type {number} */
+      mantissa = isNaN(v) ? 1 : 0;
+      /** @type {number} */
+      exponent = eMax;
+    } else {
+      /** @type {number} */
+      exponent = Math.floor(Math.log(v) / Math.LN2);// Calculate log2 of the value
+      if (v * (c = Math.pow(2, -exponent)) < 1) { // Math.log() isn't 100% reliable
+        exponent--;
+        /** @type {number} */
+        c = c * 2;
+      }
+      // Round by adding 1/2 the significand's LSD
+      if (exponent + eBias >= 1) {
+        /** @type {number} */
+        v = v + el.rt / c; // Normalized:  mLen significand digits
+      } else {
+        /** @type {number} */
+        v = v + el.rt * Math.pow(2, 1 - eBias);// Denormalized:  <= mLen significand digits
+      }
+      if (v * c >= 2) {
+        exponent++;
+        /** @type {number} */
+        c = c / 2; 	// Rounding can increment the exponent
+      }
+      if (exponent + eBias >= eMax) {
+        // Overflow
+        /** @type {number} */
+        mantissa = 0;
+        /** @type {number} */
+        exponent = eMax;
+      } else {
+        if (exponent + eBias >= 1) {
+          	// Normalized - term order matters, as Math.pow(2, 52-e) and v*Math.pow(2, 52) can overflow
+          /** @type {number} */
+          mantissa = (v * c - 1) * Math.pow(2, mantissaLen);
+          /** @type {number} */
+          exponent = exponent + eBias;
+        } else {
+          // Denormalized - also catches the '0' case, somewhat by chance
+          /** @type {number} */
+          mantissa = v * Math.pow(2, eBias - 1) * Math.pow(2, mantissaLen);
+          /** @type {number} */
+          exponent = 0;
+        }
+      }
+    }
+    /** @type {number} */
+    i = booleanIsBigEndian ? el.len - 1 : 0;
+    /** @type {number} */
+    d = booleanIsBigEndian ? -1 : 1;
+    for (; mantissaLen >= 8; octet_array_a[offset_p + i] = mantissa & 255, i = i + d, mantissa = mantissa / 256, mantissaLen = mantissaLen - 8) {
+    }
+    /** @type {number} */
+    exponent = exponent << mantissaLen | mantissa;
+    exponentLen = exponentLen + mantissaLen;
+    for (; exponentLen > 0; octet_array_a[offset_p + i] = exponent & 255, i = i + d, exponent = exponent / 256, exponentLen = exponentLen - 8) {
+    }
+    octet_array_a[offset_p + i - d] |= bool_s * 128;
+  };
+  
+  
+  /**
+   * @param {!Object} octet_array_a
+   * @param {number} offset_p
+   * @return {?}
+   */
+  	// Convert int64 to array with 3 elements: [lowBits, highBits, unsignedFlag]
+	// '>>>' trick to convert signed 32bit int to unsigned int (because << always results in a signed 32bit int)
+  m._DeInt64 = function(octet_array_a, offset_p) {
+  if (DEBUG) console.log("zzz_11");
+    /** @type {number} */
+    var lsb = booleanIsBigEndian ? 0 : 7;
+    /** @type {number} */
+    var nsb = booleanIsBigEndian ? 1 : -1;
+    /** @type {number} */
+    var stop = lsb + nsb * 8;
+    /** @type {!Array} */
+    var nextIdLookup = [0, 0, !el.bSigned];
+    var i;
+    var f;
+    var indexLookupKey;
+    /** @type {number} */
+    i = lsb;
+    /** @type {number} */
+    indexLookupKey = 1;
+    /** @type {number} */
+    f = 0;
+    for (; i != stop; nextIdLookup[indexLookupKey] = (nextIdLookup[indexLookupKey] << 8 >>> 0) + octet_array_a[offset_p + i], i = i + nsb, f++, indexLookupKey = f < 4 ? 1 : 0) {
+
+    if ( DEBUG ) console.log("jsPacking int64:"+octet_array_a[offset_p + i]);
+
+    }
+    return nextIdLookup;
+  };
+  /**
+   * @param {!Array} octet_array_a
+   * @param {number} offset_p
+   * @param {!Object} v
+   * @return {undefined}
+   */
+  m._EnInt64 = function(octet_array_a, offset_p, v) {
+
+  if (v.length != 2) { //todo put this error back
+     console.log("ERROR ERROR: jspack needs an array of at least length TWO to pack an int64 "+v+' len:'+v.length); 
+  } 
+//  if (DEBUG) console.log("zzz_12 v:"+v);
+    /** @type {number} */
+    var lsb = booleanIsBigEndian ? 0 : 7;
+    /** @type {number} */
+    var nsb = booleanIsBigEndian ? 1 : -1;
+    /** @type {number} */
+    var stop = lsb + nsb * 8;
+    var i;
+    var f;
+    var j;
+    var shift;
+    /** @type {number} */
+    i = lsb;
+    /** @type {number} */
+    j = 1;
+    /** @type {number} */
+    f = 0;
+    /** @type {number} */
+    shift = 24;
+
+    for (; i != stop; octet_array_a[offset_p + i] = v[j] >> shift & 255, i = i + nsb, f++, j = f < 4 ? 1 : 0, shift = 24 - 8 * (f % 4)) {
+    var x = v[j] >> shift & 255 ; 
+    var vj = v[j];
+
+    if ( DEBUG )  console.log('js qqqq  vj:'+vj+' j:'+j+' x:'+x+' a:'+octet_array_a+' i:'+i+" offset_p:"+offset_p+" v:"+v); 
+    }
+  };
+  
+  
+  
+  	// Class data
+  /** @type {string} */
+  m._sPattern = "(\\d+)?([AxcbBhHsfdiIlLqQ])";
+
+  m._lenLut	= {'A':1, 'x':1, 'c':1, 'b':1, 'B':1, 'h':2, 'H':2, 's':1, 'f':4, 'd':8, 'i':4, 'I':4, 'l':4, 'L':4, 'q':8, 'Q':8};
+  
+  m._elLookUpTable	= {	'A': {en:m._EnArray, de:m._DeArray},
+				's': {en:m._EnString, de:m._DeString},
+				'c': {en:m._EnChar, de:m._DeChar},
+				'b': {en:m._EnInt, de:m._DeInt, len:1, bSigned:true, min:-Math.pow(2, 7), max:Math.pow(2, 7)-1},
+				'B': {en:m._EnInt, de:m._DeInt, len:1, bSigned:false, min:0, max:Math.pow(2, 8)-1},
+				'h': {en:m._EnInt, de:m._DeInt, len:2, bSigned:true, min:-Math.pow(2, 15), max:Math.pow(2, 15)-1},
+				'H': {en:m._EnInt, de:m._DeInt, len:2, bSigned:false, min:0, max:Math.pow(2, 16)-1},
+				'i': {en:m._EnInt, de:m._DeInt, len:4, bSigned:true, min:-Math.pow(2, 31), max:Math.pow(2, 31)-1},
+				'I': {en:m._EnInt, de:m._DeInt, len:4, bSigned:false, min:0, max:Math.pow(2, 32)-1},
+				'l': {en:m._EnInt, de:m._DeInt, len:4, bSigned:true, min:-Math.pow(2, 31), max:Math.pow(2, 31)-1},
+				'L': {en:m._EnInt, de:m._DeInt, len:4, bSigned:false, min:0, max:Math.pow(2, 32)-1},
+				'f': {en:m._En754, de:m._De754, len:4, mLen:23, rt:Math.pow(2, -24)-Math.pow(2, -77)},
+				'd': {en:m._En754, de:m._De754, len:8, mLen:52, rt:0},
+				'q': {en:m._EnInt64, de:m._DeInt64, bSigned:true, len:8  },   // 64bit fields need 8 bytes..
+				'Q': {en:m._EnInt64, de:m._DeInt64, bSigned:false, len:8 }}; // quirk of longs is they come in with a length of 2 in an array
+  
+  
+  /**
+   * @param {number} num_elements_n
+   * @param {number} size_s
+   * @param {!Object} octet_array_a
+   * @param {number} offset_p
+   * @return {?}
+   */
+  	// Unpack a series of n elements of size s from array a at offset p with fxn
+  m._UnpackSeries = function(num_elements_n, size_s, octet_array_a, offset_p) {
+  if (DEBUG) console.log("zzz_13");
+    var fxn = el.de;
+    /** @type {!Array} */
+    var rv = [];
+    /** @type {number} */
+    var o = 0;
+    for (; o < num_elements_n; rv.push(fxn(octet_array_a, offset_p + o * size_s)), o++) {
+    }
+    return rv;
+  };
+  /**
+   * @param {number} num_elements_n
+   * @param {number} size_s
+   * @param {!Array} to_octet_array_a
+   * @param {number} array_a_offset_p
+   * @param {(Array|NodeList|null)} from_array_v
+   * @param {number} array_v_offset_i
+   * @return {undefined}
+   */
+  	// Pack a series of n elements of size s from array v at offset i to array a at offset p with fxn
+  
+  m._PackSeries = function(num_elements_n, size_s, to_octet_array_a, array_a_offset_p, from_array_v, array_v_offset_i) {
+  if (DEBUG) console.log("pack-series: ");
+
+
+    if ( DEBUG ) console.log('js before  0:'+0+' num_elements_n:'+num_elements_n+' size_s:'+size_s+' to_a:'+to_octet_array_a+' i:'+array_v_offset_i+" offset_p:"+array_a_offset_p+" v:"+from_array_v); 
+    var fxn = el.en;
+    /** @type {number} */
+    var o = 0;
+    for (; o < num_elements_n;  o++) {
+        //if (DEBUG) console.log("14 called fxn with o:"+o);
+        var z = from_array_v[array_v_offset_i + o]; 
+        var to = JSON.stringify(z);
+        var too = JSON.stringify(from_array_v);
+          if (DEBUG) console.log('js pre-ffff  z:'+z+' to:'+to+' too:'+too+'');
+        // handle flattened arrays - non-array things don't have a .length
+        try {
+        if (z.length == undefined ) {
+                    //from_array_v = [ from_array_v ] ; 
+                      if (DEBUG) console.log('Z FIX');
+        }} catch (e){}
+        var z = from_array_v[array_v_offset_i + o]; 
+        var to = JSON.stringify(z);
+        var too = JSON.stringify(from_array_v);
+
+        // if we only have one thing to back and its got an 8 byte target len ( it's a 64bit long),  and length of source array is 2 ( low and high bits ) 
+        // we treat it as a singular thing... we use this for Q type, which gets passed in as [lowBits, hightBits]
+        if (( num_elements_n == 1 ) && (size_s == 8) && (from_array_v.length == 2) ) {  
+            z = from_array_v; 
+            if (DEBUG) console.log("js handling Q 64bit array"); 
+        } 
+
+
+        if (DEBUG) console.log('js partial  z:'+z+' to:'+to+' too:'+too+' num_elements_n:'+num_elements_n+' size_s:'+size_s+' to_a:'+to_octet_array_a+' v_offset_i:'+array_v_offset_i+" a_offset_p:"+array_a_offset_p+" from_v:"+from_array_v); 
+
+        fxn(to_octet_array_a, array_a_offset_p + o * size_s, z);
+
+    }
+        if (DEBUG) console.log('js after  to_a:'+to_octet_array_a);
+  };
+  
+  
+  /**
+   * @param {string} fmt
+   * @param {!Object} octet_array_a
+   * @param {number} offset_p
+   * @return {?}
+   */
+  	// Unpack the octet array a, beginning at offset p, according to the fmt string
+  m.Unpack = function(fmt, octet_array_a, offset_p) {
+  if (DEBUG) console.log("zzz_15");
+    /** @type {boolean} */
+    // Set the private bBE flag based on the format string - assume big-endianness
+    booleanIsBigEndian = fmt.charAt(0) != "<";
+    /** @type {number} */
+    offset_p = offset_p ? offset_p : 0;
+    /** @type {!RegExp} */
+    var re = new RegExp(this._sPattern, "g");
+    var re_match;
+    var repeat_count_n;
+    var element_size_s;
+    /** @type {!Array} */
+    var rv = [];
+    
+    //loop over chars in the format string with regex due to optional digits
+    for (; re_match = re.exec(fmt);) {
+      /** @type {number} */
+      repeat_count_n = re_match[1] == undefined || re_match[1] == "" ? 1 : parseInt(re_match[1]);
+      element_size_s = this._lenLut[re_match[2]];
+      if (offset_p + repeat_count_n * element_size_s > octet_array_a.length) {
+        return undefined;
+      }
+      switch(re_match[2]) {
+        case "A":
+        case "s":
+          rv.push(this._elLookUpTable[re_match[2]].de(octet_array_a, offset_p, repeat_count_n));
+          break;
+        case "c":
+        case "b":
+        case "B":
+        case "h":
+        case "H":
+        case "i":
+        case "I":
+        case "l":
+        case "L":
+        case "f":
+        case "d":
+        case "q":
+        case "Q":
+          el = this._elLookUpTable[re_match[2]];
+          
+          //rv.push(this._UnpackSeries(repeat_count_n, element_size_s, octet_array_a, offset_p));
+
+          // unpack arrays to an actual array type within the field array result:
+          // https://github.com/AndreasAntener/node-jspack/commit/4f16680101303a6b4a1b0deba8cf7d20fc68213e
+          if (repeat_count_n > 1) {
+            // Field is array, unpack into separate array and push as such
+            var arr = [];
+            arr.push(this._UnpackSeries(repeat_count_n, element_size_s, octet_array_a, offset_p));
+            rv.push(arr);
+          } else {
+            rv.push(this._UnpackSeries(repeat_count_n, element_size_s, octet_array_a, offset_p));
+          }
+
+          break;
+      }
+      /** @type {number} */
+      offset_p = offset_p + repeat_count_n * element_size_s;
+    }
+    return Array.prototype.concat.apply([], rv);
+  };
+  
+
+  // cross check the list of input data matches the size of bytes we'll be assembling
+  // this is a slightly tweaked implementation of the previous 'PackTo' commented out below.
+  // it has a more-consistent approach to input and output arrays, paying particular attention to Q,q, long, etc
+  m.WouldPack = function(fmt, octet_array_a, offset_p, values) {
+    //if (DEBUG) console.log("zzz_16 fmt:"+JSON.stringify(fmt)+" values:"+JSON.stringify(values));
+    // @type {boolean} /
+    // Set the private bBE flag based on the format string - assume big-endianness
+    booleanIsBigEndian = fmt.charAt(0) != "<";
+    // @type {!RegExp} /
+    var re = new RegExp(this._sPattern, "g");
+
+    var m;
+    var n;
+    var s;
+    var values_i = 0; // current index into the values[] 
+
+    var j;
+    for (; m = re.exec(fmt);) {
+
+        // leading optional prefix num or 1
+        n = m[1] == undefined || m[1] == "" ? 1 : parseInt(m[1]);
+
+        s = this._lenLut[m[2]];
+
+
+        if (DEBUG) console.log("character: "+m[2]+"  how many(n)?: "+n);
+        el = this._elLookUpTable[m[2]];
+
+        //if (DEBUG) console.log("using lookup table:"+JSON.stringify(el));
+        var bytes_consumed_per_element = el["len"];
+        bytes_consumed_per_element = bytes_consumed_per_element == undefined ? 1 : bytes_consumed_per_element ; // undefined means 1
+        if (DEBUG) console.log("bytes_consumed_per_element:"+JSON.stringify(bytes_consumed_per_element));
+        if (DEBUG) console.log("current_values_idx:"+JSON.stringify(values_i) +" values:"+JSON.stringify(values[values_i])  )  ;
+
+
+        // do per-case behaviours  'A' , 's' and 'x' are special, everything else gets the same
+        switch(m[2]) {
+        //------------------------------------------
+        case "A":
+        case "s":
+          if (values_i + 1 > values.length) {
+            console.log("JSPACK-ERROR: values_i + 1 > values.length  values_i:"+values_i+" values.length:"+values.length); 
+            //return false;
+          }
+          if (DEBUG) console.log("all values:"+JSON.stringify(values));
+          this._elLookUpTable[m[2]].en(octet_array_a, offset_p, n, values[values_i]);
+          // @type {number} /
+          values_i = values_i + 1;
+          break;
+        //------------------------------------------
+        case "x":
+          // @type {number} /
+          j = 0;
+          for (; j < n; j++) {
+            // @type {number} /
+            octet_array_a[offset_p + j] = 0;
+          }
+          break;
+        //------------------------------------------
+        // everything else
+        default:
+
+          // if n > 1 , ie it's multiple occurrences of a 'thing'
+          if (n > 1 ) {
+
+            // if we were handed an array at this idx, we need the array to be the same length as n
+            if (Array.isArray(values[values_i])) {
+
+                // Value series is array, iterate through that, only increment by 1
+                if ((values_i + 1) > values.length) { 
+                if (DEBUG) console.log("JSPACK-ERROR: value series is array but (values_i + 1) > values.length. i:"+values_i+" values.length:"+values.length); 
+                //return false; 
+                }
+                  if (DEBUG) console.log("(dst IS array) (source IS array)");
+                this._PackSeries(n, s, octet_array_a, offset_p, values[values_i], 0);
+                values_i += 1;
+            }
+             else {
+              if (DEBUG) console.log("ERROR: (dst IS array) (source is not array)");            
+            }
+          } 
+
+          // if n == 1, it just one of a thing
+          if (n == 1 ) {
+
+          // type Q can have the source as an array when there is only 1 of them.
+            if (Array.isArray(values[values_i]) ) {
+
+                if (( m[2] == 'Q' ) || ( m[2] == 'q' ) ) {  
+                this._PackSeries(n, s, octet_array_a, offset_p, values[values_i], 0);
+                values_i += 1;
+                }
+                if (DEBUG) console.log("(dst is not array) (source IS array)");
+
+            } else {
+                  if ((values_i + n ) > values.length) { 
+                        if (DEBUG) console.log("JSPACK-ERROR: value series NOT array but (values_i + n ) > values.length. i:"+values_i+" n:"+n+" values.length:"+values.length+" values:"+JSON.stringify(values));  
+                        //return false; 
+                  }
+                  if (DEBUG) console.log("(dst is not array)  (source is not array)");
+                  this._PackSeries(n, s, octet_array_a, offset_p, values, values_i);
+                  values_i += n;
+            }
+          }
+
+          if (DEBUG) console.log("");
+          break;
+        //------------------------------------------
+        }
+
+      offset_p = offset_p + n * s;
+
+    }
+    if (DEBUG) console.log("wouldpack completed, result array_a is:"+JSON.stringify(octet_array_a));
+    return octet_array_a
+  }
+
+
+
+  /**
+   * @param {string} fmt
+   * @param {!Array} octet_array_a
+   * @param {number} offset_p
+   * @param {!NodeList} values
+   * @return {?}
+   */
+/* 
+  	// Pack the supplied values into the octet array a, beginning at offset p, according to the fmt string
+  m.PackTo = function(fmt, octet_array_a, offset_p, values) {
+  if (DEBUG) console.log("zzz_16 fmt:"+JSON.stringify(fmt)+" values:"+JSON.stringify(values));
+    // @type {boolean} /
+    // Set the private bBE flag based on the format string - assume big-endianness
+    booleanIsBigEndian = fmt.charAt(0) != "<";
+    // @type {!RegExp} /
+    var re = new RegExp(this._sPattern, "g");
+    var m;
+    var n;
+    var s;
+    // @type {number} /
+    var i = 0;
+    var j;
+    for (; m = re.exec(fmt);) {
+      // @type {number} /
+      n = m[1] == undefined || m[1] == "" ? 1 : parseInt(m[1]);
+      s = this._lenLut[m[2]];
+      if (offset_p + n * s > octet_array_a.length) {
+        console.log("JSPACK-ERROR: offset_p + n * s > octet_array_a.length  offset_p:"+offset_p+" n:"+n+" s:"+s+" octet_array_a.length:"+octet_array_a.length+" octet_array_a:"+JSON.stringify(octet_array_a));  
+        return false;
+      }
+      if (DEBUG) console.log("\n---------------------------------------------\n");
+      if (DEBUG) console.log("handling format specifier:"+m[2]+"  how many:"+n);
+      switch(m[2]) {
+        case "A":
+        case "s":
+          if (i + 1 > values.length) {
+            console.log("JSPACK-ERROR: i + 1 > values.length  i:"+i+" values.length:"+values.length); 
+            return false;
+          }
+          if (DEBUG) console.log("zzz_16A values:"+JSON.stringify(values));
+          this._elLookUpTable[m[2]].en(octet_array_a, offset_p, n, values[i]);
+          // @type {number} /
+          i = i + 1;
+          break;
+        case "c":
+        case "b":
+        case "B":
+        case "h":
+        case "H":
+        case "i":
+        case "I":
+        case "l":
+        case "L":
+        case "f":
+        case "d":
+        case "q":
+        case "Q":
+          if (DEBUG) console.log("16 blerg");
+          el = this._elLookUpTable[m[2]];
+          if (DEBUG) console.log("using lookup table:"+JSON.stringify(el));
+          //if (i + n > values.length) { return false;  }
+          //this._PackSeries(n, s, octet_array_a, offset_p, values, i);
+          //i = i + n;
+          //added support for packing value series when they are supplied as arrays within the values array
+          // https://github.com/AndreasAntener/node-jspack/commit/8de80d20aa06dea15527b3073c6c8631abda0f17
+          if (n > 1 && Array.isArray(values[i])) {
+            // Value series is array, iterate through that, only increment by 1
+            if ((i + 1) > values.length) { 
+              console.log("JSPACK-ERROR: value series is array but (i + 1) > values.length. i:"+i+" values.length:"+values.length); 
+              return false; 
+            }
+            if (DEBUG) console.log("zzz_16 option 1 (source is array)");
+            this._PackSeries(n, s, octet_array_a, offset_p, values[i], 0);
+            i += 1;
+          } else {
+              if ((i + n) > values.length) { 
+                    console.log("JSPACK-ERROR: value series NOT array but (i + n) > values.length. i:"+i+" n:"+n+" values.length:"+values.length+" values:"+JSON.stringify(values));  
+                    //return false; 
+              }
+              if (DEBUG) console.log("zzz_16 option 2 (source is not array)");
+            this._PackSeries(n, s, octet_array_a, offset_p, values, i);
+            i += n;
+          }
+
+          if (DEBUG) console.log("end case");
+          break;
+        case "x":
+          // @type {number} /
+          j = 0;
+          for (; j < n; j++) {
+            // @type {number} /
+            octet_array_a[offset_p + j] = 0;
+          }
+          break;
+      }
+      // @type {number} /
+      offset_p = offset_p + n * s;
+    }
+    console.log("pack completed, result array_a is:"+JSON.stringify(octet_array_a));
+    return octet_array_a;
+  };
+  */
+  
+  /**
+   * @param {string} fmt
+   * @param {(Node|NodeList|null|string)} values
+   * @return {?}
+   */
+  	// Pack the supplied values into a new octet array, according to the fmt string
+  m.Pack = function(fmt, values) {
+  if (DEBUG) console.log("\n\n------------------------------------------------------------------------------------------------------------\n\n");
+  if (DEBUG) console.log("initial unpacked values:"+JSON.stringify(values));
+  if (DEBUG) console.log("initial   format string:"+JSON.stringify(fmt));
+  if (DEBUG) console.log("\n\nwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww\n\n");
+    return this.WouldPack(fmt, new Array(this.CalcLength(fmt)), 0, values);
+  //if (DEBUG) console.log("\n\nmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm\n\n");
+   // return this.PackTo(fmt, new Array(this.CalcLength(fmt)), 0, values);
+  };
+
+  /**
+   * @param {string} fmt
+   * @param {(Node|NodeList|null|string)} values
+   * @return {?}
+   */
+  	// Pack the supplied values into a new octet array, according to the fmt string
+  m.oldPack = function(fmt, values) {
+  if (DEBUG) console.log("\n\n------------------------------------------------------------------------------------------------------------\n\n");
+  if (DEBUG) console.log("initial unpacked values:"+JSON.stringify(values));
+  if (DEBUG) console.log("initial   format string:"+JSON.stringify(fmt));
+    return this.PackTo(fmt, new Array(this.CalcLength(fmt)), 0, values);
+  };
+  
+  /**
+   * @param {string} fmt
+   * @return {?}
+   */
+  	// Determine the number of bytes represented by the format string
+  m.CalcLength = function(fmt) {
+
+    /** @type {!RegExp} */
+    var re = new RegExp(this._sPattern, "g");
+    var m;
+    /** @type {number} */
+    var value = 0;
+    for (; m = re.exec(fmt);) {
+      /** @type {number} */
+      value = value + (m[1] == undefined || m[1] == "" ? 1 : parseInt(m[1])) * this._lenLut[m[2]];
+    }
+  if (DEBUG) console.log("number of bytes in format string?: "+value+"\n");
+    return value;
+  };
+}
+
+export default JSPack
+
diff --git a/modules/MAVLink/local_modules/jspack/package.json b/modules/MAVLink/local_modules/jspack/package.json
new file mode 100644
index 00000000..f9c36896
--- /dev/null
+++ b/modules/MAVLink/local_modules/jspack/package.json
@@ -0,0 +1,64 @@
+{
+  "_from": "jspack@0.0.4",
+  "_id": "jspack@0.0.4",
+  "_inBundle": false,
+  "_integrity": "sha1-Mt01x/3LPjRWwY+7fvntC8YjgXc=",
+  "_location": "/jspack",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": false,
+    "raw": "jspack@0.0.4",
+    "name": "jspack",
+    "escapedName": "jspack",
+    "rawSpec": "0.0.4",
+    "saveSpec": null,
+    "fetchSpec": "0.0.4"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "local_modules/jspack",
+  "_shasum": "32dd35c7fdcb3e3456c18fbb7ef9ed0bc6238177",
+  "_spec": "jspack@0.0.4",
+  "_where": "/home/buzz/GCS/mavlink/pymavlink/generator/javascript",
+  "author": {
+    "name": "https://github.com/pgriess"
+  },
+  "bugs": {
+    "url": "https://github.com/birchroad/node-jspack/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "JavaScript library to pack primitives to octet arrays, including int64 support, packaged for NodeJS.",
+  "devDependencies": {
+    "long": "",
+    "mocha": "",
+    "should": "",
+    "sinon": ""
+  },
+  "homepage": "https://github.com/birchroad/node-jspack",
+  "main": "./jspack.js",
+  "maintainers": [
+    {
+      "name": "Peter Magnusson",
+      "email": "peter@birchroad.net",
+      "url": "http://github.com/birchroad/node-jspack"
+    },
+    {
+      "name": "Andreas Antener",
+      "url": "https://github.com/AndreasAntener/node-jspack"
+    }
+  ],
+  "name": "jspack",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/birchroad/node-jspack.git"
+  },
+  "scripts": {
+    "pretest": "npm install",
+    "test": "mocha test"
+  },
+  "version": "0.0.4"
+}
diff --git a/modules/MAVLink/local_modules/jspack/test/int64.js b/modules/MAVLink/local_modules/jspack/test/int64.js
new file mode 100644
index 00000000..fc72eb49
--- /dev/null
+++ b/modules/MAVLink/local_modules/jspack/test/int64.js
@@ -0,0 +1,456 @@
+//  This file is MODIFIED from the original, by buzz 2020, please see README.md in the upper level folder for more details.
+var should = require('should');
+var jspack = require('../jspack.js').jspack;
+var Long = require('long');
+
+describe('Test long integration (examples):', function() {
+
+    // Demonstrating the use together with Long.js (https://github.com/dcodeIO/Long.js)
+    //
+    // Packing a long requires the input of a 2 part array containing the [low, high] bits
+    // of the specific long value.
+    // Unpacking a long results in a 3 part array containing [low, high, unsigned] bits and flag.
+    // The decoded value can be applied directly to Long.fromBits()
+    //
+    // Test number u            228290380562207 (BE: 0x00, 0x00, 0xcf, 0xa0, 0xff, 0x09, 0xff, 0x1f)
+    //                                          (LE: 0x1f, 0xff, 0x09, 0xff, 0xa0, 0xcf, 0x00, 0x00)
+    // Test number s           -228290380562207 (BE: 0xff, 0xff, 0x30, 0x5f, 0x00, 0xf6, 0x00, 0xe1)
+    //                                          (LE: 0xe1, 0x00, 0xf6, 0x00, 0x5f, 0x30, 0xff, 0xff)
+
+    it('pack <Q', function() {
+        //var num = new Long(0xff09ff1f, 0x0000cfa0, true);
+        var num = Long.fromNumber(228290380562207, true);
+
+        // Pass long representation to jspack
+        var buf = jspack.Pack('<Q', [[num.getLowBitsUnsigned(), num.getHighBitsUnsigned()]]);
+
+        buf.should.be.eql([0x1f, 0xff, 0x09, 0xff, 0xa0, 0xcf, 0x00, 0x00]);
+    });
+
+    it('unpack <Q', function() {
+        var testNum = new Long(0xff09ff1f, 0x0000cfa0, true); // unsigned
+        var buf = jspack.Unpack('<Q', [0x1f, 0xff, 0x09, 0xff, 0xa0, 0xcf, 0x00, 0x00]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+
+        // Create long by passing unpacked buffer to it (either way works)
+        var res = Long.fromBits.apply(undefined, buf[0]);
+        var res2 = new Long(buf[0][0], buf[0][1], buf[0][2]);
+
+        testNum.equals(res).should.be.true;
+        testNum.equals(res2).should.be.true;
+        res.toNumber().should.be.eql(228290380562207);
+    });
+
+    it('pack <q', function() {
+        //var num = new Long(0x00f600e1, 0xffff305f, true);
+        var num = Long.fromNumber(-228290380562207); // signed
+
+        // Pass long representation to jspack
+        var buf = jspack.Pack('<q', [[num.getLowBitsUnsigned(), num.getHighBitsUnsigned()]]);
+
+        buf.should.be.eql([0xe1, 0x00, 0xf6, 0x00, 0x5f, 0x30, 0xff, 0xff]);
+    });
+
+    it('unpack <q', function() {
+        var testNum = new Long(0x00f600e1, 0xffff305f); // signed
+        var buf = jspack.Unpack('<q', [0xe1, 0x00, 0xf6, 0x00, 0x5f, 0x30, 0xff, 0xff]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        
+        // Create long by passing unpacked buffer to it (either way works)
+        var res = Long.fromBits.apply(undefined, buf[0]);
+        var res2 = new Long(buf[0][0], buf[0][1], buf[0][2]);
+
+        testNum.equals(res).should.be.true;
+        testNum.equals(res2).should.be.true;
+        res.toNumber().should.be.eql(-228290380562207);
+    });
+
+});
+
+describe('Test signed/unsigned int64:', function() {
+
+    // Number 0xffa0ffe1ffff, packed with Python struct:
+    // little endian:
+    // 0xff, 0xff, 0xe1, 0xff, 0xa0, 0xff, 0x00, 0x00
+    // big endian:
+    // 0x00, 0x00, 0xff, 0xa0, 0xff, 0xe1, 0xff, 0xff
+
+    it('pack <Q', function() {
+        var buf = jspack.Pack('<Q', [[0xffe1ffff, 0xffa0]]);
+        buf.should.be.eql([0xff, 0xff, 0xe1, 0xff, 0xa0, 0xff, 0x00, 0x00]);
+    });
+
+    it('pack >Q', function() {
+        var buf = jspack.Pack('>Q', [[0xffe1ffff, 0xffa0]]);
+        buf.should.be.eql([0x00, 0x00, 0xff, 0xa0, 0xff, 0xe1, 0xff, 0xff]);
+    });
+
+    it('unpack <Q', function() {
+        var buf = jspack.Unpack('<Q', [0xff, 0xff, 0xe1, 0xff, 0xa0, 0xff, 0x00, 0x00]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0xffe1ffff);
+        buf[0][1].should.be.eql(0xffa0);
+        buf[0][2].should.be.true;
+    });
+
+    it('unpack >Q', function() {
+        var buf = jspack.Unpack('>Q', [0x00, 0x00, 0xff, 0xa0, 0xff, 0xe1, 0xff, 0xff]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0xffe1ffff);
+        buf[0][1].should.be.eql(0xffa0);
+        buf[0][2].should.be.true;
+    });
+
+    // Test lower-case q as well. This only test the matching of the character and the unsigned bit,
+    // the parsing is the same as for upper-case Q (since we don't actually convert to a number).
+    it('pack >q (signed)', function() {
+        var buf = jspack.Pack('>q', [[0xffe1ffff, 0xffa0]]);
+        buf.should.be.eql([0x00, 0x00, 0xff, 0xa0, 0xff, 0xe1, 0xff, 0xff]);
+    });
+
+    it('unpack <q (signed)', function() {
+        var buf = jspack.Unpack('<q', [0xff, 0xff, 0xe1, 0xff, 0xa0, 0xff, 0x00, 0x00]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0xffe1ffff);
+        buf[0][1].should.be.eql(0xffa0);
+        buf[0][2].should.be.false;
+    });
+
+});
+
+//32 bits
+function dec2bin(dec){
+    var x = (dec >>> 0).toString(2);
+    y = ("00000000000000000000000000000000" + x).slice(-32)
+    y1 = y.substring(0,8);
+    y2 = y.substring(8,16);
+    y3 = y.substring(16,24);
+    y4 = y.substring(24,32);
+    return [y,y1,y2,y3,y4];
+}
+function dec2bin_ws(dec) {
+        var str = dec2bin(dec);
+        var bb = str.slice(1); //1-4 skipping zero
+        var bbj = bb.join(' ');
+    return bbj;
+}
+
+describe('ASCII Boundary tests:', function() {
+
+    it('pack <4s correctly over the ascii 127->128->129 boundary', function() { // should work in range 0-255 if u use 'binary' encoding
+
+        this.format = '<4s';
+
+        this.ascii_bytes = new Buffer.from([ 126, 127, 128, 129]).toString('binary'); // 'binary' encoding is important here, as without it values above 128 are treated as unicode.
+        var buf = jspack.Pack(this.format, [ this.ascii_bytes]);
+        body = [ 0x7e, 0x7f, 0x80, 0x81];  // expected result
+        buf.should.be.eql(body);
+
+    });
+
+    it('long Q buzz', function() { // should work in range 0-255 if u use 'binary' encoding
+
+//from aoa_ssa
+
+        this.format = '<Q';
+
+        var num  = Long.fromNumber(93372036854775807, true); // fieldtype: uint64_t  isarray: False 
+
+       // console.log(JSON.stringify(num)); 
+
+        this.time_usec =  [num.getLowBitsUnsigned(), num.getHighBitsUnsigned()];
+
+        //console.log(JSON.stringify(this.time_usec)); 
+
+        var orderedfields = [ this.time_usec];
+        //var flattened=[].concat.apply([], orderedfields);
+        var buf = jspack.Pack(this.format, orderedfields);
+        //console.log(JSON.stringify(buf)); 
+
+        body = [  0, 0, 175, 112, 95, 185, 75, 1];  // expected result
+        buf.should.be.eql(body);
+    });
+
+
+    it('IBB buzz', function() { // should work in range 0-255 if u use 'binary' encoding
+
+//from device_op_write
+
+            this.format = '<IBBBBBBB';
+
+            this.request_id = 963497464; // fieldtype: uint32_t  isarray: False 
+            this.target_system = 17; // fieldtype: uint8_t  isarray: False 
+            this.target_component = 84; // fieldtype: uint8_t  isarray: False 
+            this.bustype = 151; // fieldtype: uint8_t  isarray: False 
+            this.bus = 218; // fieldtype: uint8_t  isarray: False 
+            this.address = 29; // fieldtype: uint8_t  isarray: False 
+            //this.busname = "JKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUV"; // fieldtype: char  isarray: False 
+            this.regstart = 216; // fieldtype: uint8_t  isarray: False 
+            this.count = 27; // fieldtype: uint8_t  isarray: False 
+            //this.data = new Buffer.from([94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221]).toString("binary");
+       // console.log(JSON.stringify(num)); 
+
+
+            var orderedfields = [ this.request_id, this.target_system, this.target_component, this.bustype, this.bus, this.address, this.regstart, this.count];
+
+            var buf = jspack.Pack(this.format, orderedfields);
+            //console.log(JSON.stringify(buf)); 
+
+            var reference = [0xf8, 0xcd, 0x6d, 0x39, 0x11, 0x54, 0x97, 0xda, 0x1d, 0xd8, 0x1b]; // while ref packet
+
+            // var body = new Buffer.from(reference.slice(10,-2)); // strip header and crc
+
+            buf.should.be.eql(reference);
+
+    });
+
+   it('signed 8-bit outside of -127-127 range', function() { 
+
+//from end of sys_status
+
+        this.format = '<b';
+
+        this.battery_remaining =  223;
+
+        var ui8 = (new Int8Array([this.battery_remaining]))[0]; // cast value that is clearly outside the -127-0-127 range to signed data
+
+        console.log(JSON.stringify(ui8)); 
+
+        var orderedfields = [ ui8 ];
+        //var flattened=[].concat.apply([], orderedfields);
+        var buf = jspack.Pack(this.format, orderedfields);
+        //console.log(JSON.stringify(buf)); 
+
+        body = [  223 ];  // expected result
+        buf.should.be.eql(body);
+    });
+
+
+   it('32 bit overflow buzz', function() { // should work in range 0-255 if u use 'binary' encoding
+
+//from aoa_ssa
+
+        this.format = '<Q';
+
+//        var ui64 = Long.fromNumber(93372036854775807, true); // fails and is clearly a bug in the Long library
+        var ui64 = Long.fromString('93372036854775807', true,10); // passes and is an ok workaround
+
+        // according to the internet 93372036854775807 =  00000001 01001011 10111001 01011111 01110000 10101110 11111111 11111111
+        // which means the LOW 32bits are: 01110000 10101110 11111111 11111111
+
+        var lb = ui64.getLowBitsUnsigned();
+        var strlb = dec2bin_ws(lb);
+        console.log("lb1:"+strlb)
+        strlb.should.be.eql('01110000 10101110 11111111 11111111');
+
+        var x = [ui64.getLowBitsUnsigned(), ui64.getHighBitsUnsigned()]
+
+        this.time_usec = [ui64.getLowBitsUnsigned(), ui64.getHighBitsUnsigned()]; // fieldtype: uint64_t  isarray: False 
+        this.AOA = 73.0; // fieldtype: float  isarray: False 
+        this.SSA = 101.0; // fieldtype: float  isarray: False 
+
+        var orderedfields = [ this.time_usec];
+
+        var buf = jspack.Pack(this.format, orderedfields);
+        console.log(JSON.stringify("thing:"+this.time_usec)); 
+
+        body = [  0xff, 0xff, 0xae, 0x70, 0x5f, 0xb9, 0x4b, 0x01,  ];  // expected result
+        buf.should.be.eql(body);
+    });
+
+
+   it('ftp ascii buzz', function() { // should work in range 0-255 if u use 'binary' encoding
+
+//from file_transfer_protocol
+
+      this.format = '<BBB251s';
+
+      this.target_network = 5; // fieldtype: uint8_t  isarray: False 
+      this.target_system = 72; // fieldtype: uint8_t  isarray: False 
+      this.target_component = 139; // fieldtype: uint8_t  isarray: False 
+      this.payload = new Buffer.from([206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200]).toString("binary"); // fieldtype: uint8_t  isarray: True 
+
+      // console.log("lb1:"+strlb)
+      var orderedfields = [ this.target_network, this.target_system, this.target_component, this.payload];
+
+        var buf = jspack.Pack(this.format, orderedfields);
+        console.log(JSON.stringify("thing:"+this.time_usec)); 
+
+        var body = [ 0x05, 0x48, 0x8b, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8];
+
+        buf.should.be.eql(body);
+    });
+
+
+   it('jpg thing buzz', function() { // should work in range 0-255 if u use 'binary' encoding
+
+//from data_transmission_handshake
+
+    this.format = '<IHHHBBB';
+
+      this.size = 963497464; // fieldtype: uint32_t  isarray: False 
+      this.width = 17443; // fieldtype: uint16_t  isarray: False 
+      this.height = 17547; // fieldtype: uint16_t  isarray: False 
+      this.packets = 17651; // fieldtype: uint16_t  isarray: False 
+      this.type = 163; // fieldtype: uint8_t  isarray: False 
+      this.payload = 230; // fieldtype: uint8_t  isarray: False 
+      this.jpg_quality = 41; // fieldtype: uint8_t  isarray: False 
+
+       var orderedfields = [ this.size, this.width, this.height, this.packets, this.type, this.payload, this.jpg_quality];
+
+        var buf = jspack.Pack(this.format, orderedfields);
+      
+        var body = [0xf8, 0xcd, 0x6d, 0x39, 0x23, 0x44, 0x8b, 0x44, 0xf3, 0x44, 0xa3, 0xe6, 0x29];
+
+        buf.should.be.eql(body);
+    });
+
+
+
+ it('header thing buzz', function() {
+
+// header 10 bytes from 'encode data_transmission_handshake from C'
+
+//    var orderedfields =  [253, this.mlen, this.incompat_flags, this.compat_flags, this.seq, this.srcSystem, this.srcComponent, ((this.msgId & 0xFF) << 8) | ((this.msgId >> 8) & 0xFF), this.msgId>>16];
+
+    this.msgId = 130;
+
+    var v1 = ((this.msgId & 0xFF) << 8) | ((this.msgId >> 8) & 0xFF);
+    var v2 = this.msgId>>16;
+
+    v1.should.be.eql(33280);
+    v2.should.be.eql(0);
+
+    var orderedfields =  [253,13,0,0,40,11,10,33280,0];
+
+    console.log("------------------------------------------------------------------------\nmavheader:"+JSON.stringify(orderedfields));
+    var hdr =  jspack.Pack('BBBBBBBHB',orderedfields);
+
+     buf = [0xfd, 0x0d, 0x00, 0x00, 0x28, 0x0b, 0x0a, 0x82, 0x00, 0x00];
+
+     buf.should.be.eql(hdr);
+    });
+
+});
+
+describe('Q Boundary tests:', function() {
+
+    it('unpack >Q full', function() {
+        var buf = jspack.Unpack('>Q', [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0xffffffff);
+        buf[0][1].should.be.eql(0xffffffff);
+        buf[0][2].should.be.true;
+    });
+
+    it('pack >Q full', function() {
+        var buf = jspack.Pack('>Q', [[0xffffffff, 0xffffffff]]);
+        buf.should.be.eql([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
+    });
+
+    it('unpack <Q full', function() {
+        var buf = jspack.Unpack('<Q', [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0xffffffff);
+        buf[0][1].should.be.eql(0xffffffff);
+        buf[0][2].should.be.true;
+    });
+
+    it('pack <Q full', function() {
+        var buf = jspack.Pack('<Q', [[0xffffffff, 0xffffffff]]);
+        buf.should.be.eql([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
+    });
+
+    it('unpack >Q zero', function() {
+        var buf = jspack.Unpack('>Q', [0, 0, 0, 0, 0, 0, 0, 0]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0);
+        buf[0][1].should.be.eql(0);
+        buf[0][2].should.be.true;
+    });
+
+    it('pack >Q zero', function() {
+        var buf = jspack.Pack('>Q', [[0, 0]]);
+        buf.should.be.eql([0, 0, 0, 0, 0, 0, 0, 0]);
+    });
+
+    it('unpack <Q zero', function() {
+        var buf = jspack.Unpack('<Q', [0, 0, 0, 0, 0, 0, 0, 0]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0);
+        buf[0][1].should.be.eql(0);
+        buf[0][2].should.be.true;
+    });
+
+    it('pack <Q zero', function() {
+        var buf = jspack.Pack('<Q', [[0, 0]]);
+        buf.should.be.eql([0, 0, 0, 0, 0, 0, 0, 0]);
+    });
+
+    it('unpack >Q one', function() {
+        var buf = jspack.Unpack('>Q', [1, 1, 1, 1, 1, 1, 1, 1]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0x01010101);
+        buf[0][1].should.be.eql(0x01010101);
+        buf[0][2].should.be.true;
+    });
+
+    it('pack >Q one', function() {
+        var buf = jspack.Pack('>Q', [[0x01010101, 0x01010101]]);
+        buf.should.be.eql([1, 1, 1, 1, 1, 1, 1, 1]);
+    });
+
+    it('unpack <Q one', function() {
+        var buf = jspack.Unpack('<Q', [1, 1, 1, 1, 1, 1, 1, 1]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0x01010101);
+        buf[0][1].should.be.eql(0x01010101);
+        buf[0][2].should.be.true;
+    });
+
+    it('pack <Q one', function() {
+        var buf = jspack.Pack('<Q', [[0x01010101, 0x01010101]]);
+        buf.should.be.eql([1, 1, 1, 1, 1, 1, 1, 1]);
+    });
+
+    it('unpack >Q 0xfe', function() {
+        var buf = jspack.Unpack('>Q', [0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0xfefefefe);
+        buf[0][1].should.be.eql(0xfefefefe);
+        buf[0][2].should.be.true;
+    });
+
+    it('pack >Q 0xfe', function() {
+        var buf = jspack.Pack('>Q', [[0xfefefefe, 0xfefefefe]]);
+        buf.should.be.eql([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]);
+    });
+
+    it('unpack <Q 0xfe', function() {
+        var buf = jspack.Unpack('<Q', [0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]);
+        buf.length.should.be.eql(1);
+        buf[0].length.should.be.eql(3);
+        buf[0][0].should.be.eql(0xfefefefe);
+        buf[0][1].should.be.eql(0xfefefefe);
+        buf[0][2].should.be.true;
+    });
+
+    it('pack <Q 0xfe', function() {
+        var buf = jspack.Pack('<Q', [[0xfefefefe, 0xfefefefe]]);
+        buf.should.be.eql([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]);
+    });
+
+});
+
diff --git a/modules/MAVLink/mavftp.js b/modules/MAVLink/mavftp.js
new file mode 100644
index 00000000..b91fc630
--- /dev/null
+++ b/modules/MAVLink/mavftp.js
@@ -0,0 +1,403 @@
+// MAVLink FTP implementation for fetching fence data
+// Based on MAVProxy's mavproxy_ftp.py
+
+class MAVFTP {
+    constructor(mavlink, ws) {
+	this.MAVLink = mavlink;
+	this.ws = ws;
+	
+	// Operation codes
+	this.OP = {
+	    None: 0,
+	    TerminateSession: 1,
+	    ResetSessions: 2,
+	    ListDirectory: 3,
+	    OpenFileRO: 4,
+	    ReadFile: 5,
+	    CreateFile: 6,
+	    WriteFile: 7,
+	    RemoveFile: 8,
+	    CreateDirectory: 9,
+	    RemoveDirectory: 10,
+	    OpenFileWO: 11,
+	    TruncateFile: 12,
+	    Rename: 13,
+	    CalcFileCRC32: 14,
+	    BurstReadFile: 15,
+	    Ack: 128,
+	    Nack: 129
+	};
+	
+	// Error codes
+	this.ERR = {
+	    None: 0,
+	    Fail: 1,
+	    FailErrno: 2,
+	    InvalidDataSize: 3,
+	    InvalidSession: 4,
+	    NoSessionsAvailable: 5,
+	    EndOfFile: 6,
+	    UnknownCommand: 7,
+	    FileExists: 8,
+	    FileProtected: 9,
+	    FileNotFound: 10
+	};
+	
+	// FTP state
+	this.seq = 0;
+	this.session = 0;
+	this.targetSystem = 1;
+	this.targetComponent = 1;
+	
+	// File transfer state
+	this.currentFile = null;
+	this.fileBuffer = null;
+	this.readGaps = [];
+	this.reachedEOF = false;
+	this.burstSize = 80;
+	this.lastOp = null;
+	this.opStartTime = null;
+	this.callback = null;
+	
+	this.HDR_LEN = 12;
+	this.MAX_PAYLOAD = 239;
+    }
+    
+    // Pack FTP operation into bytes
+    packOp(seq, session, opcode, size, req_opcode, burst_complete, offset, payload) {
+	const buffer = new ArrayBuffer(this.HDR_LEN + this.MAX_PAYLOAD);
+	const view = new DataView(buffer);
+	
+	// Header: seq(u16), session(u8), opcode(u8), size(u8), req_opcode(u8), burst_complete(u8), pad(u8), offset(u32)
+	view.setUint16(0, seq, true);
+	view.setUint8(2, session);
+	view.setUint8(3, opcode);
+	view.setUint8(4, size);
+	view.setUint8(5, req_opcode);
+	view.setUint8(6, burst_complete);
+	view.setUint8(7, 0); // pad
+	view.setUint32(8, offset, true);
+	
+	// Payload
+	if (payload) {
+	    const payloadBytes = new Uint8Array(buffer, 12);
+	    for (let i = 0; i < Math.min(payload.length, this.MAX_PAYLOAD); i++) {
+		payloadBytes[i] = payload[i];
+	    }
+	}
+	
+	return new Uint8Array(buffer);
+    }
+    
+    // Parse FTP operation from FILE_TRANSFER_PROTOCOL message
+    parseOp(payload) {
+	// Convert payload to Uint8Array if it's not already
+	// Handle case where payload is a plain array or array-like object
+	if (!(payload instanceof Uint8Array)) {
+	    payload = new Uint8Array([...payload].map((c) => c.charCodeAt(0)));
+	}
+	
+	// Ensure we have at least the header
+	if (payload.length < this.HDR_LEN) {
+	    console.error(`FTP: Payload too short (${payload.length} bytes)`);
+	    return null;
+	}
+	
+	const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+	
+	const op = {
+	    seq: view.getUint16(0, true),
+	    session: view.getUint8(2),
+	    opcode: view.getUint8(3),
+	    size: view.getUint8(4),
+	    req_opcode: view.getUint8(5),
+	    burst_complete: view.getUint8(6),
+	    offset: view.getUint32(8, true),
+	    payload: null
+	};
+	
+	// Extract payload if present and size > 0
+	if (op.size > 0 && payload.length > this.HDR_LEN) {
+	    const payloadStart = this.HDR_LEN;
+	    const payloadLength = Math.min(op.size, payload.length - this.HDR_LEN);
+	    op.payload = new Uint8Array(payload.buffer, payload.byteOffset + payloadStart, payloadLength);
+	}
+	
+	return op;
+    }
+    
+    // Send FTP operation
+    sendOp(opcode, size, req_opcode, burst_complete, offset, payload) {
+	const packedOp = this.packOp(this.seq, this.session, opcode, size, req_opcode, burst_complete, offset, payload);
+	
+	// Send via FILE_TRANSFER_PROTOCOL message
+	const msg = new mavlink20.messages.file_transfer_protocol(
+	    0, // network (0 for Mavlink 2.0)
+	    this.targetSystem,
+	    this.targetComponent,
+	    Array.from(packedOp)
+	);
+	
+	const pkt = msg.pack(this.MAVLink);
+	this.ws.send(Uint8Array.from(pkt));
+	
+	this.lastOp = { opcode, size, req_opcode, burst_complete, offset, payload };
+	
+	console.log(`FTP: Sent op ${opcode} (${this.getOpName(opcode)}) seq=${this.seq} session=${this.session} offset=${offset}`);
+	this.seq = (this.seq + 1) % 256;
+    }
+    
+    // Helper to get operation name for debugging
+    getOpName(opcode) {
+	for (let [name, code] of Object.entries(this.OP)) {
+	    if (code === opcode) return name;
+	}
+	return `Unknown(${opcode})`;
+    }
+    
+    // Terminate current session
+    terminateSession() {
+	this.sendOp(this.OP.TerminateSession, 0, 0, 0, 0, null);
+	this.session = (this.session + 1) % 256;
+	this.currentFile = null;
+	this.fileBuffer = null;
+	this.readGaps = [];
+	this.reachedEOF = false;
+	console.log("FTP: Session terminated");
+    }
+    
+    // Get file from vehicle
+    getFile(filename, callback) {
+	console.log(`FTP: Getting file ${filename}`);
+	
+	this.terminateSession();
+	this.callback = callback;
+	this.currentFile = filename;
+	this.fileBuffer = new Uint8Array(0);
+	this.readGaps = [];
+	this.reachedEOF = false;
+	this.opStartTime = Date.now();
+	
+	// Encode filename
+	const encoder = new TextEncoder();
+	const filenameBytes = encoder.encode(filename);
+	
+	// Send OpenFileRO
+	this.sendOp(this.OP.OpenFileRO, filenameBytes.length, 0, 0, 0, filenameBytes);
+    }
+    
+    // Handle incoming FILE_TRANSFER_PROTOCOL message
+    handleMessage(m) {
+	if (m._name !== "FILE_TRANSFER_PROTOCOL") return;
+	if (m.target_system !== this.MAVLink.srcSystem || m.target_component !== this.MAVLink.srcComponent) return;
+	
+	// m.payload is already a Uint8Array, pass it directly
+	const op = this.parseOp(m.payload);
+	if (!op) {
+	    console.error("FTP: Failed to parse operation");
+	    return;
+	}
+	
+	console.log(`FTP: Received ${this.getOpName(op.opcode)} for req=${this.getOpName(op.req_opcode)} size=${op.size} offset=${op.offset} seq=${op.seq}`);
+	
+	// Handle different response types
+	if (op.req_opcode === this.OP.OpenFileRO) {
+	    this.handleOpenResponse(op);
+	} else if (op.req_opcode === this.OP.BurstReadFile) {
+	    this.handleBurstReadResponse(op);
+	} else if (op.req_opcode === this.OP.ReadFile) {
+	    this.handleReadResponse(op);
+	} else if (op.req_opcode === this.OP.TerminateSession) {
+	    console.log("FTP: Session terminated ACK");
+	} else {
+	    console.log(`FTP: Unhandled response for ${this.getOpName(op.req_opcode)}`);
+	}
+    }
+    
+    // Handle OpenFileRO response
+    handleOpenResponse(op) {
+	if (op.opcode === this.OP.Ack) {
+	    console.log("FTP: File opened, starting burst read");
+	    // Start burst read from offset 0
+	    this.sendOp(this.OP.BurstReadFile, this.burstSize, 0, 0, 0, null);
+	} else if (op.opcode === this.OP.Nack) {
+	    console.error("FTP: Failed to open file - NACK received");
+	    if (this.callback) this.callback(null);
+	    this.terminateSession();
+	} else {
+	    console.error(`FTP: Unexpected response to OpenFileRO: opcode ${op.opcode}`);
+	}
+    }
+    
+    // Handle BurstReadFile response
+    handleBurstReadResponse(op) {
+	if (op.opcode === this.OP.Ack && op.payload) {
+	    // Expand buffer if needed
+	    const newSize = op.offset + op.size;
+	    if (newSize > this.fileBuffer.length) {
+		const newBuffer = new Uint8Array(newSize);
+		newBuffer.set(this.fileBuffer);
+		this.fileBuffer = newBuffer;
+	    }
+	    
+	    // Write data at offset
+	    this.fileBuffer.set(op.payload, op.offset);
+	    
+	    console.log(`FTP: Read ${op.size} bytes at offset ${op.offset}`);
+	    
+	    // Check if we need to continue
+	    if (op.burst_complete) {
+		if (op.size > 0 && op.size < this.burstSize) {
+		    // EOF reached
+		    this.reachedEOF = true;
+		    this.finishTransfer();
+		} else {
+		    // Continue reading
+		    const nextOffset = op.offset + op.size;
+		    this.sendOp(this.OP.BurstReadFile, this.burstSize, 0, 0, nextOffset, null);
+		}
+	    }
+	} else if (op.opcode === this.OP.Nack) {
+	    const errorCode = op.payload ? op.payload[0] : 0;
+	    if (errorCode === this.ERR.EndOfFile || errorCode === 0) {
+		console.log("FTP: EOF reached");
+		this.reachedEOF = true;
+		this.finishTransfer();
+	    } else {
+		console.error(`FTP: Read failed with error ${errorCode}`);
+		if (this.callback) this.callback(null);
+		this.terminateSession();
+	    }
+	}
+    }
+    
+    // Handle ReadFile response (for gap filling)
+    handleReadResponse(op) {
+	if (op.opcode === this.OP.Ack && op.payload) {
+	    // Fill gap
+	    this.fileBuffer.set(op.payload, op.offset);
+	    
+	    // Remove from gaps list
+	    this.readGaps = this.readGaps.filter(g => g.offset !== op.offset);
+	    
+	    console.log(`FTP: Filled gap at ${op.offset}, ${this.readGaps.length} gaps remaining`);
+	    
+	    if (this.readGaps.length === 0 && this.reachedEOF) {
+		this.finishTransfer();
+	    }
+	}
+    }
+    
+    // Finish file transfer
+    finishTransfer() {
+	if (!this.fileBuffer) {
+	    return;
+	}
+	const dt = (Date.now() - this.opStartTime) / 1000;
+	const size = this.fileBuffer.length;
+	const rate = (size / dt) / 1024;
+	
+	console.log(`FTP: Transfer complete - ${size} bytes in ${dt.toFixed(2)}s (${rate.toFixed(1)} KB/s)`);
+	
+	if (this.callback) {
+	    this.callback(this.fileBuffer);
+	}
+	
+	this.terminateSession();
+    }
+}
+
+// Fence data parser
+class FenceParser {
+    constructor() {
+    }
+
+    parseMissionItems(data) {
+	var header = data.buffer.slice(0,10);
+	var hdr = jspack.Unpack("<HHHHH", new Uint8Array(header));
+	const magic = hdr[0];
+	if (magic !== 0x763d) {
+	    console.error(`Invalid mission magic: 0x${magic.toString(16)}`);
+	    return null;
+	}
+	const data_type = hdr[1];
+	const options = hdr[2];
+	const start = hdr[3];
+	const count = hdr[4];
+
+	console.log(`MissionItems: count=${count}`);
+
+	var items = [];
+
+	// Read each fence item
+	for (let i = 0; i < count; i++) {
+
+	    const item_len = 38;
+	    var buf = data.buffer.slice(10+i*item_len, 10+(i+1)*item_len);
+	    var a = jspack.Unpack('<ffffiifHHBBBBBB', new Uint8Array(buf));
+	    var param1 = a[0];
+	    var param2 = a[1];
+	    var param3 = a[2];
+	    var param4 = a[3];
+	    var x = a[4];
+	    var y = a[5];
+	    var z = a[6];
+	    var seq = a[7];
+	    var command = a[8];
+	    var target_system = a[9];
+	    var target_component = a[10];
+	    var frame = a[11];
+	    var current = a[12];
+	    var autocontinue = a[13];
+	    var mission_type = a[14];
+	    const msg = new mavlink20.messages.mission_item_int(target_system, target_component, seq,
+								frame, command, current, autocontinue,
+								param1, param2, param3, param4,
+								x, y, z, mission_type);
+	    items.push(msg);
+	}
+	return items;
+    }
+    
+    parse(data) {
+	try {
+	    var items = this.parseMissionItems(data);
+	    var fences = [];
+	    var idx = 0;
+	    while (idx < items.length) {
+		var item = items[idx];
+		const fitem = {};
+		fitem.type = item.command;
+		if (item.command === mavlink20.MAV_CMD_NAV_FENCE_CIRCLE_INCLUSION ||
+		    item.command === mavlink20.MAV_CMD_NAV_FENCE_CIRCLE_EXCLUSION) {
+		    fitem.radius = item.param1;
+		    fitem.lat = item.x / 1.0e7;
+		    fitem.lng = item.y / 1.0e7;
+		    idx++;
+		} else if (item.command === mavlink20.MAV_CMD_NAV_FENCE_POLYGON_VERTEX_EXCLUSION ||
+			   item.command === mavlink20.MAV_CMD_NAV_FENCE_POLYGON_VERTEX_INCLUSION) {
+		    const num_vertices = item.param1;
+		    fitem.vertices = [];
+		    fitem.vertex_count = num_vertices;
+		    for (var i = 0; i < num_vertices; i++) {
+			var lat = items[idx+i].x / 1.0e7;
+			var lng = items[idx+i].y / 1.0e7;
+			fitem.vertices.push({ lat, lng });
+		    }
+		    idx += num_vertices;
+		} else {
+		    idx++;
+		}
+		fences.push(fitem);
+	    }
+	    return fences;
+	} catch (e) {
+	    console.error("Error parsing fence data:", e);
+	    return null;
+	}
+    }
+}
+
+// Export for use in main app
+window.MAVFTP = MAVFTP;
+window.FenceParser = FenceParser;
diff --git a/modules/MAVLink/mavlink.js b/modules/MAVLink/mavlink.js
new file mode 100644
index 00000000..2a29f743
--- /dev/null
+++ b/modules/MAVLink/mavlink.js
@@ -0,0 +1,19546 @@
+/*
+MAVLink protocol implementation for node.js (auto-generated by mavgen_javascript.py)
+
+Generated from: all.xml,ardupilotmega.xml,ASLUAV.xml,common.xml,development.xml,icarous.xml,minimal.xml,python_array_test.xml,standard.xml,test.xml,ualberta.xml,uAvionix.xml,loweheiser.xml,storm32.xml,AVSSUAS.xml,cubepilot.xml,csAirLink.xml
+
+Note: this file has been auto-generated. DO NOT EDIT
+*/
+
+// Detect environment
+const isNode = typeof process !== 'undefined' &&
+               process.versions &&
+               process.versions.node;
+
+// Handle jspack dependency
+let jspack;
+if (isNode) {
+    jspack = (global && global.jspack) || require("jspack").jspack;
+} else {
+    import("./local_modules/jspack/jspack.js").then((mod) => {
+	jspack = new mod.default()
+    }).catch((e) => {
+    });
+}
+
+// Handle Node.js specific modules
+let events, util;
+if (isNode) {
+    events = require("events");
+    util = require("util");
+} else {
+    // Browser polyfills for Node.js modules
+    util = { 
+        inherits: function(constructor, superConstructor) {
+            constructor.prototype = Object.create(superConstructor.prototype);
+            constructor.prototype.constructor = constructor;
+        }
+    };
+    
+    // Simple EventEmitter polyfill for browsers
+    events = { 
+        EventEmitter: function() {
+            this._events = {};
+            
+            this.on = function(event, listener) {
+                if (!this._events[event]) {
+                    this._events[event] = [];
+                }
+                this._events[event].push(listener);
+            };
+            
+            this.emit = function(event, ...args) {
+                if (this._events[event]) {
+                    this._events[event].forEach(listener => {
+                        try {
+                            listener.apply(this, args);
+                        } catch (e) {
+                            console.error('Error in event listener:', e);
+                        }
+                    });
+                }
+            };
+            
+            this.removeListener = function(event, listener) {
+                if (this._events[event]) {
+                    const index = this._events[event].indexOf(listener);
+                    if (index > -1) {
+                        this._events[event].splice(index, 1);
+                    }
+                }
+            };
+        }
+    };
+}
+
+
+mavlink20 = function(){};
+
+// Implement the CRC-16/MCRF4XX function (present in the Python version through the mavutil.py package)
+mavlink20.x25Crc = function(buffer, crcIN) {
+
+    var bytes = buffer;
+    var crcOUT = crcIN ===  undefined ? 0xffff : crcIN;
+    bytes.forEach(function(e) {
+        var tmp = e ^ (crcOUT & 0xff);
+        tmp = (tmp ^ (tmp << 4)) & 0xff;
+        crcOUT = (crcOUT >> 8) ^ (tmp << 8) ^ (tmp << 3) ^ (tmp >> 4);
+        crcOUT = crcOUT & 0xffff;
+    });
+    return crcOUT;
+
+}
+
+mavlink20.WIRE_PROTOCOL_VERSION = "2.0";
+mavlink20.PROTOCOL_MARKER_V1 = 0xFE 
+mavlink20.PROTOCOL_MARKER_V2 = 0xFD 
+mavlink20.HEADER_LEN_V1 = 6 
+mavlink20.HEADER_LEN_V2 = 10 
+mavlink20.HEADER_LEN = 10;
+
+mavlink20.MAVLINK_TYPE_CHAR     = 0
+mavlink20.MAVLINK_TYPE_UINT8_T  = 1
+mavlink20.MAVLINK_TYPE_INT8_T   = 2
+mavlink20.MAVLINK_TYPE_UINT16_T = 3
+mavlink20.MAVLINK_TYPE_INT16_T  = 4
+mavlink20.MAVLINK_TYPE_UINT32_T = 5
+mavlink20.MAVLINK_TYPE_INT32_T  = 6
+mavlink20.MAVLINK_TYPE_UINT64_T = 7
+mavlink20.MAVLINK_TYPE_INT64_T  = 8
+mavlink20.MAVLINK_TYPE_FLOAT    = 9
+mavlink20.MAVLINK_TYPE_DOUBLE   = 10
+
+mavlink20.MAVLINK_IFLAG_SIGNED = 0x01
+mavlink20.MAVLINK_SIGNATURE_BLOCK_LEN = 13
+
+// Mavlink headers incorporate sequence, source system (platform) and source component. 
+mavlink20.header = function(msgId, mlen, seq, srcSystem, srcComponent, incompat_flags=0, compat_flags=0) {
+
+    this.mlen = ( typeof mlen === 'undefined' ) ? 0 : mlen;
+    this.seq = ( typeof seq === 'undefined' ) ? 0 : seq;
+    this.srcSystem = ( typeof srcSystem === 'undefined' ) ? 0 : srcSystem;
+    this.srcComponent = ( typeof srcComponent === 'undefined' ) ? 0 : srcComponent;
+    this.msgId = msgId
+    this.incompat_flags = incompat_flags
+    this.compat_flags = compat_flags
+
+}
+mavlink20.header.prototype.pack = function() {
+    return jspack.Pack('BBBBBBBHB', [253, this.mlen, this.incompat_flags, this.compat_flags, this.seq, this.srcSystem, this.srcComponent, ((this.msgId & 0xFF) << 8) | ((this.msgId >> 8) & 0xFF), this.msgId>>16]);
+}
+
+// Base class declaration: mavlink.message will be the parent class for each
+// concrete implementation in mavlink.messages.
+mavlink20.message = function() {};
+
+// Convenience setter to facilitate turning the unpacked array of data into member properties
+mavlink20.message.prototype.set = function(args,verbose) {
+    // inspect
+    this.fieldnames.forEach(function(e, i) {
+        var num = parseInt(i,10);
+        if (this.hasOwnProperty(e) && isNaN(num)  ){ // asking for an attribute that's non-numeric is ok unless its already an attribute we have
+            if ( verbose >= 1) { console.log("WARNING, overwriting an existing property is DANGEROUS:"+e+" ==>"+i+"==>"+args[i]+" -> "+JSON.stringify(this)); }
+        }
+    }, this);
+
+    // then modify
+    this.fieldnames.forEach(function(e, i) {
+        this[e] = args[i];
+    }, this);
+};
+
+/*
+  sha256 implementation
+  embedded to avoid async issues in web browsers with crypto library
+  with thanks to https://geraintluff.github.io/sha256/
+*/
+mavlink20.sha256 = function(inputBytes) {
+    const K = new Uint32Array([
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
+        0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
+        0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
+        0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+        0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
+        0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+        0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
+        0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
+        0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
+        0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
+        0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+        0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    ]);
+
+    function ROTR(n, x) { return (x >>> n) | (x << (32 - n)); }
+
+    function Σ0(x) { return ROTR(2, x) ^ ROTR(13, x) ^ ROTR(22, x); }
+    function Σ1(x) { return ROTR(6, x) ^ ROTR(11, x) ^ ROTR(25, x); }
+    function σ0(x) { return ROTR(7, x) ^ ROTR(18, x) ^ (x >>> 3); }
+    function σ1(x) { return ROTR(17, x) ^ ROTR(19, x) ^ (x >>> 10); }
+
+    function Ch(x, y, z) { return (x & y) ^ (~x & z); }
+    function Maj(x, y, z) { return (x & y) ^ (x & z) ^ (y & z); }
+
+    const H = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    ]);
+
+    const l = inputBytes.length;
+    const bitLen = l * 8;
+
+    const withPadding = new Uint8Array(((l + 9 + 63) >> 6) << 6); // pad to multiple of 64 bytes
+    withPadding.set(inputBytes);
+    withPadding[l] = 0x80;
+    withPadding.set([
+        0, 0, 0, 0,
+        (bitLen >>> 24) & 0xff,
+        (bitLen >>> 16) & 0xff,
+        (bitLen >>> 8) & 0xff,
+        bitLen & 0xff
+    ], withPadding.length - 8);
+
+    const w = new Uint32Array(64);
+    for (let i = 0; i < withPadding.length; i += 64) {
+        for (let j = 0; j < 16; j++) {
+            w[j] = (
+                (withPadding[i + 4 * j] << 24) |
+                (withPadding[i + 4 * j + 1] << 16) |
+                (withPadding[i + 4 * j + 2] << 8) |
+                (withPadding[i + 4 * j + 3])
+            ) >>> 0;
+        }
+        for (let j = 16; j < 64; j++) {
+            w[j] = (σ1(w[j - 2]) + w[j - 7] + σ0(w[j - 15]) + w[j - 16]) >>> 0;
+        }
+
+        let [a, b, c, d, e, f, g, h] = H;
+
+        for (let j = 0; j < 64; j++) {
+            const T1 = (h + Σ1(e) + Ch(e, f, g) + K[j] + w[j]) >>> 0;
+            const T2 = (Σ0(a) + Maj(a, b, c)) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + T1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (T1 + T2) >>> 0;
+        }
+
+        H[0] = (H[0] + a) >>> 0;
+        H[1] = (H[1] + b) >>> 0;
+        H[2] = (H[2] + c) >>> 0;
+        H[3] = (H[3] + d) >>> 0;
+        H[4] = (H[4] + e) >>> 0;
+        H[5] = (H[5] + f) >>> 0;
+        H[6] = (H[6] + g) >>> 0;
+        H[7] = (H[7] + h) >>> 0;
+    }
+
+    const output = new Uint8Array(32);
+    for (let i = 0; i < 8; i++) {
+        output[i * 4 + 0] = (H[i] >>> 24) & 0xff;
+        output[i * 4 + 1] = (H[i] >>> 16) & 0xff;
+        output[i * 4 + 2] = (H[i] >>> 8) & 0xff;
+        output[i * 4 + 3] = H[i] & 0xff;
+    }
+
+    return output;
+}
+
+// create a message signature
+mavlink20.create_signature = function(key, msgbuf) {
+    const input = new Uint8Array(32 + msgbuf.length);
+    input.set(key, 0);
+    input.set(msgbuf, 32);
+
+    const hash = mavlink20.sha256(input);
+    const sig = hash.slice(0, 6);
+
+    return sig;
+}
+
+// sign outgoing packet
+mavlink20.message.prototype.sign_packet = function( mav) {
+    function packUint48LE(value) {
+        const bytes = []
+        for (let i = 0; i < 6; i++) {
+            bytes.push(Number((value >> BigInt(8 * i)) & 0xFFn));
+        }
+        return bytes;
+    }
+
+    var tsbuf = packUint48LE(BigInt(mav.signing.timestamp));
+
+    // first add the linkid(1 byte) and timestamp(6 bytes) that start the signature
+    this._msgbuf = this._msgbuf.concat([mav.signing.link_id])
+    this._msgbuf = this._msgbuf.concat(tsbuf);
+
+    sig = mavlink20.create_signature(mav.signing.secret_key, this._msgbuf);
+    this._msgbuf = this._msgbuf.concat( ... sig );
+
+    mav.signing.timestamp += 1;
+}
+
+// This pack function builds the header and produces a complete MAVLink message,
+// including header and message CRC.
+mavlink20.message.prototype.pack = function(mav, crc_extra, payload) {
+
+    this._payload = payload;
+    var plen = this._payload.length;
+    //in MAVLink2 we can strip trailing zeros off payloads. This allows for simple
+    // variable length arrays and smaller packets
+    while ((plen > 1) && ( (this._payload[plen-1] == 0) || (this._payload[plen-1] == null) ) ) {
+            plen = plen - 1;
+    }
+    this._payload = this._payload.slice(0, plen);
+    // signing is our first incompat flag. 
+    var incompat_flags = 0; 
+    if (mav.signing.sign_outgoing){ 
+            incompat_flags |= mavlink20.MAVLINK_IFLAG_SIGNED 
+    } 
+    // header 
+    this._header = new mavlink20.header(this._id, this._payload.length, mav.seq, mav.srcSystem, mav.srcComponent, incompat_flags, 0,);
+    // payload     
+    this._msgbuf = this._header.pack().concat(this._payload);
+    // crc -  for now, assume always using crc_extra = True.  TODO: check/fix this. 
+    var crc = mavlink20.x25Crc(this._msgbuf.slice(1));
+    crc = mavlink20.x25Crc([crc_extra], crc);
+    this._msgbuf = this._msgbuf.concat(jspack.Pack('<H', [crc] ) );
+
+    // signing 
+    this._signed     = false 
+    this._link_id    = undefined 
+
+    //console.log(mav.signing); 
+    //optionally add signing 
+    if (mav.signing.sign_outgoing){ 
+                this.sign_packet(mav) 
+    } 
+    return this._msgbuf;
+
+}
+
+
+// enums
+
+// ACCELCAL_VEHICLE_POS
+mavlink20.ACCELCAL_VEHICLE_POS_LEVEL = 1 // 
+mavlink20.ACCELCAL_VEHICLE_POS_LEFT = 2 // 
+mavlink20.ACCELCAL_VEHICLE_POS_RIGHT = 3 // 
+mavlink20.ACCELCAL_VEHICLE_POS_NOSEDOWN = 4 // 
+mavlink20.ACCELCAL_VEHICLE_POS_NOSEUP = 5 // 
+mavlink20.ACCELCAL_VEHICLE_POS_BACK = 6 // 
+mavlink20.ACCELCAL_VEHICLE_POS_SUCCESS = 16777215 // 
+mavlink20.ACCELCAL_VEHICLE_POS_FAILED = 16777216 // 
+mavlink20.ACCELCAL_VEHICLE_POS_ENUM_END = 16777217 // 
+
+// HEADING_TYPE
+mavlink20.HEADING_TYPE_COURSE_OVER_GROUND = 0 // 
+mavlink20.HEADING_TYPE_HEADING = 1 // 
+mavlink20.HEADING_TYPE_DEFAULT = 2 // 
+mavlink20.HEADING_TYPE_ENUM_END = 3 // 
+
+// MAV_CMD
+mavlink20.MAV_CMD_NAV_WAYPOINT = 16 // Navigate to waypoint. This is intended for use in missions (for guided
+                        // commands outside of missions use
+                        // MAV_CMD_DO_REPOSITION).
+mavlink20.MAV_CMD_NAV_LOITER_UNLIM = 17 // Loiter around this waypoint an unlimited amount of time
+mavlink20.MAV_CMD_NAV_LOITER_TURNS = 18 // Loiter around this waypoint for X turns
+mavlink20.MAV_CMD_NAV_LOITER_TIME = 19 // Loiter around this waypoint for X seconds
+mavlink20.MAV_CMD_NAV_RETURN_TO_LAUNCH = 20 // Return to launch location
+mavlink20.MAV_CMD_NAV_LAND = 21 // Land at location.
+mavlink20.MAV_CMD_NAV_TAKEOFF = 22 // Takeoff from ground / hand. Vehicles that support multiple takeoff
+                        // modes (e.g. VTOL quadplane) should take off
+                        // using the currently configured mode.
+mavlink20.MAV_CMD_NAV_LAND_LOCAL = 23 // Land at local position (local frame only)
+mavlink20.MAV_CMD_NAV_TAKEOFF_LOCAL = 24 // Takeoff from local position (local frame only)
+mavlink20.MAV_CMD_NAV_FOLLOW = 25 // Vehicle following, i.e. this waypoint represents the position of a
+                        // moving vehicle
+mavlink20.MAV_CMD_NAV_CONTINUE_AND_CHANGE_ALT = 30 // Continue on the current course and climb/descend to specified
+                        // altitude.  When the altitude is reached
+                        // continue to the next command (i.e., don't
+                        // proceed to the next command until the
+                        // desired altitude is reached.
+mavlink20.MAV_CMD_NAV_LOITER_TO_ALT = 31 // Begin loiter at the specified Latitude and Longitude.  If Lat=Lon=0,
+                        // then loiter at the current position.  Don't
+                        // consider the navigation command complete
+                        // (don't leave loiter) until the altitude has
+                        // been reached. Additionally, if the Heading
+                        // Required parameter is non-zero the aircraft
+                        // will not leave the loiter until heading
+                        // toward the next waypoint.
+mavlink20.MAV_CMD_DO_FOLLOW = 32 // Begin following a target
+mavlink20.MAV_CMD_DO_FOLLOW_REPOSITION = 33 // Reposition the MAV after a follow target command has been sent
+mavlink20.MAV_CMD_NAV_ROI = 80 // Sets the region of interest (ROI) for a sensor set or the vehicle
+                        // itself. This can then be used by the
+                        // vehicle's control system to control the
+                        // vehicle attitude and the attitude of
+                        // various sensors such as cameras.
+mavlink20.MAV_CMD_NAV_PATHPLANNING = 81 // Control autonomous path planning on the MAV.
+mavlink20.MAV_CMD_NAV_SPLINE_WAYPOINT = 82 // Navigate to waypoint using a spline path.
+mavlink20.MAV_CMD_NAV_ALTITUDE_WAIT = 83 // Mission command to wait for an altitude or downwards vertical speed.
+                        // This is meant for high altitude balloon
+                        // launches, allowing the aircraft to be idle
+                        // until either an altitude is reached or a
+                        // negative vertical speed is reached
+                        // (indicating early balloon burst). The
+                        // wiggle time is how often to wiggle the
+                        // control surfaces to prevent them seizing
+                        // up.
+mavlink20.MAV_CMD_NAV_VTOL_TAKEOFF = 84 // Takeoff from ground using VTOL mode, and transition to forward flight
+                        // with specified heading. The command should
+                        // be ignored by vehicles that dont support
+                        // both VTOL and fixed-wing flight
+                        // (multicopters, boats,etc.).
+mavlink20.MAV_CMD_NAV_VTOL_LAND = 85 // Land using VTOL mode
+mavlink20.MAV_CMD_NAV_GUIDED_ENABLE = 92 // Hand control over to an external controller
+mavlink20.MAV_CMD_NAV_DELAY = 93 // Delay the next navigation command a number of seconds or until a
+                        // specified time
+mavlink20.MAV_CMD_NAV_PAYLOAD_PLACE = 94 // Descend and place payload. Vehicle moves to specified location,
+                        // descends until it detects a hanging payload
+                        // has reached the ground, and then releases
+                        // the payload. If ground is not detected
+                        // before the reaching the maximum descent
+                        // value (param1), the command will complete
+                        // without releasing the payload.
+mavlink20.MAV_CMD_NAV_LAST = 95 // NOP - This command is only used to mark the upper limit of the
+                        // NAV/ACTION commands in the enumeration
+mavlink20.MAV_CMD_CONDITION_DELAY = 112 // Delay mission state machine.
+mavlink20.MAV_CMD_CONDITION_CHANGE_ALT = 113 // Ascend/descend to target altitude at specified rate. Delay mission
+                        // state machine until desired altitude
+                        // reached.
+mavlink20.MAV_CMD_CONDITION_DISTANCE = 114 // Delay mission state machine until within desired distance of next NAV
+                        // point.
+mavlink20.MAV_CMD_CONDITION_YAW = 115 // Reach a certain target angle.
+mavlink20.MAV_CMD_CONDITION_LAST = 159 // NOP - This command is only used to mark the upper limit of the
+                        // CONDITION commands in the enumeration
+mavlink20.MAV_CMD_DO_SET_MODE = 176 // Set system mode.
+mavlink20.MAV_CMD_DO_JUMP = 177 // Jump to the desired command in the mission list.  Repeat this action
+                        // only the specified number of times
+mavlink20.MAV_CMD_DO_CHANGE_SPEED = 178 // Change speed and/or throttle set points. The value persists until it
+                        // is overridden or there is a mode change
+mavlink20.MAV_CMD_DO_SET_HOME = 179 // Changes the home location either to the current location or a
+                        // specified location.
+mavlink20.MAV_CMD_DO_SET_PARAMETER = 180 // Set a system parameter.  Caution!  Use of this command requires
+                        // knowledge of the numeric enumeration value
+                        // of the parameter.
+mavlink20.MAV_CMD_DO_SET_RELAY = 181 // Set a relay to a condition.
+mavlink20.MAV_CMD_DO_REPEAT_RELAY = 182 // Cycle a relay on and off for a desired number of cycles with a desired
+                        // period.
+mavlink20.MAV_CMD_DO_SET_SERVO = 183 // Set a servo to a desired PWM value.
+mavlink20.MAV_CMD_DO_REPEAT_SERVO = 184 // Cycle a between its nominal setting and a desired PWM for a desired
+                        // number of cycles with a desired period.
+mavlink20.MAV_CMD_DO_FLIGHTTERMINATION = 185 // Terminate flight immediately
+mavlink20.MAV_CMD_DO_CHANGE_ALTITUDE = 186 // Change altitude set point.
+mavlink20.MAV_CMD_DO_RETURN_PATH_START = 188 // Mission item to specify the start of a failsafe/landing return-path
+                        // segment (the end of the segment is the next
+                        // MAV_CMD_DO_LAND_START item).           A
+                        // vehicle that is using missions for landing
+                        // (e.g. in a return mode) will join the
+                        // mission on the closest path of the return-
+                        // path segment (instead of
+                        // MAV_CMD_DO_LAND_START or the nearest
+                        // waypoint).           The main use case is
+                        // to minimize the failsafe flight path in
+                        // corridor missions, where the
+                        // inbound/outbound paths are constrained (by
+                        // geofences) to the same particular path.
+                        // The MAV_CMD_NAV_RETURN_PATH_START would be
+                        // placed at the start of the return path.
+                        // If a failsafe occurs on the outbound path
+                        // the vehicle will move to the nearest point
+                        // on the return path (which is parallel for
+                        // this kind of mission), effectively turning
+                        // round and following the shortest path to
+                        // landing.           If a failsafe occurs on
+                        // the inbound path the vehicle is already on
+                        // the return segment and will continue to
+                        // landing.           The
+                        // Latitude/Longitude/Altitude are optional,
+                        // and may be set to 0 if not needed.
+                        // If specified, the item defines the waypoint
+                        // at which the return segment starts.
+                        // If sent using as a command, the vehicle
+                        // will perform a mission landing (using the
+                        // land segment if defined) or reject the
+                        // command if mission landings are not
+                        // supported, or no mission landing is
+                        // defined. When used as a command any
+                        // position information in the command is
+                        // ignored.
+mavlink20.MAV_CMD_DO_LAND_START = 189 // Mission command to perform a landing. This is used as a marker in a
+                        // mission to tell the autopilot where a
+                        // sequence of mission items that represents a
+                        // landing starts.           It may also be
+                        // sent via a COMMAND_LONG to trigger a
+                        // landing, in which case the nearest
+                        // (geographically) landing sequence in the
+                        // mission will be used.           The
+                        // Latitude/Longitude/Altitude is optional,
+                        // and may be set to 0 if not needed. If
+                        // specified then it will be used to help find
+                        // the closest landing sequence.
+mavlink20.MAV_CMD_DO_RALLY_LAND = 190 // Mission command to perform a landing from a rally point.
+mavlink20.MAV_CMD_DO_GO_AROUND = 191 // Mission command to safely abort an autonomous landing.
+mavlink20.MAV_CMD_DO_REPOSITION = 192 // Reposition the vehicle to a specific WGS84 global position. This
+                        // command is intended for guided commands
+                        // (for missions use MAV_CMD_NAV_WAYPOINT
+                        // instead).
+mavlink20.MAV_CMD_DO_PAUSE_CONTINUE = 193 // If in a GPS controlled position mode, hold the current position or
+                        // continue.
+mavlink20.MAV_CMD_DO_SET_REVERSE = 194 // Set moving direction to forward or reverse.
+mavlink20.MAV_CMD_DO_SET_ROI_LOCATION = 195 // Sets the region of interest (ROI) to a location. This can then be used
+                        // by the vehicle's control system to control
+                        // the vehicle attitude and the attitude of
+                        // various sensors such as cameras.
+mavlink20.MAV_CMD_DO_SET_ROI_WPNEXT_OFFSET = 196 // Sets the region of interest (ROI) to be toward next waypoint, with
+                        // optional pitch/roll/yaw offset. This can
+                        // then be used by the vehicle's control
+                        // system to control the vehicle attitude and
+                        // the attitude of various sensors such as
+                        // cameras.
+mavlink20.MAV_CMD_DO_SET_ROI_NONE = 197 // Cancels any previous ROI command returning the vehicle/sensors to
+                        // default flight characteristics. This can
+                        // then be used by the vehicle's control
+                        // system to control the vehicle attitude and
+                        // the attitude of various sensors such as
+                        // cameras.
+mavlink20.MAV_CMD_DO_SET_ROI_SYSID = 198 // Mount tracks system with specified system ID. Determination of target
+                        // vehicle position may be done with
+                        // GLOBAL_POSITION_INT or any other means.
+mavlink20.MAV_CMD_DO_CONTROL_VIDEO = 200 // Control onboard camera system.
+mavlink20.MAV_CMD_DO_SET_ROI = 201 // Sets the region of interest (ROI) for a sensor set or the vehicle
+                        // itself. This can then be used by the
+                        // vehicle's control system to control the
+                        // vehicle attitude and the attitude of
+                        // various sensors such as cameras.
+mavlink20.MAV_CMD_DO_DIGICAM_CONFIGURE = 202 // Configure digital camera. This is a fallback message for systems that
+                        // have not yet implemented PARAM_EXT_XXX
+                        // messages and camera definition files (see h
+                        // ttps://mavlink.io/en/services/camera_def.ht
+                        // ml ).
+mavlink20.MAV_CMD_DO_DIGICAM_CONTROL = 203 // Control digital camera. This is a fallback message for systems that
+                        // have not yet implemented PARAM_EXT_XXX
+                        // messages and camera definition files (see h
+                        // ttps://mavlink.io/en/services/camera_def.ht
+                        // ml ).
+mavlink20.MAV_CMD_DO_MOUNT_CONFIGURE = 204 // Mission command to configure a camera or antenna mount
+mavlink20.MAV_CMD_DO_MOUNT_CONTROL = 205 // Mission command to control a camera or antenna mount
+mavlink20.MAV_CMD_DO_SET_CAM_TRIGG_DIST = 206 // Mission command to set camera trigger distance for this flight. The
+                        // camera is triggered each time this distance
+                        // is exceeded. This command can also be used
+                        // to set the shutter integration time for the
+                        // camera.
+mavlink20.MAV_CMD_DO_FENCE_ENABLE = 207 //            Enable the geofence.           This can be used in a
+                        // mission or via the command protocol.
+                        // The persistence/lifetime of the setting is
+                        // undefined.           Depending on flight
+                        // stack implementation it may persist until
+                        // superseded, or it may revert to a system
+                        // default at the end of a mission.
+                        // Flight stacks typically reset the setting
+                        // to system defaults on reboot.
+mavlink20.MAV_CMD_DO_PARACHUTE = 208 // Mission item/command to release a parachute or enable/disable auto
+                        // release.
+mavlink20.MAV_CMD_DO_MOTOR_TEST = 209 // Mission command to perform motor test.
+mavlink20.MAV_CMD_DO_INVERTED_FLIGHT = 210 // Change to/from inverted flight.
+mavlink20.MAV_CMD_DO_GRIPPER = 211 // Mission command to operate a gripper.
+mavlink20.MAV_CMD_DO_AUTOTUNE_ENABLE = 212 // Enable/disable autotune.
+mavlink20.MAV_CMD_NAV_SET_YAW_SPEED = 213 // Sets a desired vehicle turn angle and speed change.
+mavlink20.MAV_CMD_DO_SET_CAM_TRIGG_INTERVAL = 214 // Mission command to set camera trigger interval for this flight. If
+                        // triggering is enabled, the camera is
+                        // triggered each time this interval expires.
+                        // This command can also be used to set the
+                        // shutter integration time for the camera.
+mavlink20.MAV_CMD_DO_SET_RESUME_REPEAT_DIST = 215 // Set the distance to be repeated on mission resume
+mavlink20.MAV_CMD_DO_SPRAYER = 216 // Control attached liquid sprayer
+mavlink20.MAV_CMD_DO_SEND_SCRIPT_MESSAGE = 217 // Pass instructions onto scripting, a script should be checking for a
+                        // new command
+mavlink20.MAV_CMD_DO_AUX_FUNCTION = 218 // Execute auxiliary function
+mavlink20.MAV_CMD_DO_MOUNT_CONTROL_QUAT = 220 // Mission command to control a camera or antenna mount, using a
+                        // quaternion as reference.
+mavlink20.MAV_CMD_DO_GUIDED_MASTER = 221 // set id of master controller
+mavlink20.MAV_CMD_DO_GUIDED_LIMITS = 222 // Set limits for external control
+mavlink20.MAV_CMD_DO_ENGINE_CONTROL = 223 // Control vehicle engine. This is interpreted by the vehicles engine
+                        // controller to change the target engine
+                        // state. It is intended for vehicles with
+                        // internal combustion engines
+mavlink20.MAV_CMD_DO_SET_MISSION_CURRENT = 224 // Set the mission item with sequence number seq as current item. This
+                        // means that the MAV will continue to this
+                        // mission item on the shortest path (not
+                        // following the mission items in-between).
+mavlink20.MAV_CMD_DO_LAST = 240 // NOP - This command is only used to mark the upper limit of the DO
+                        // commands in the enumeration
+mavlink20.MAV_CMD_PREFLIGHT_CALIBRATION = 241 // Trigger calibration. This command will be only accepted if in pre-
+                        // flight mode. Except for Temperature
+                        // Calibration, only one sensor should be set
+                        // in a single message and all others should
+                        // be zero.
+mavlink20.MAV_CMD_PREFLIGHT_SET_SENSOR_OFFSETS = 242 // Set sensor offsets. This command will be only accepted if in pre-
+                        // flight mode.
+mavlink20.MAV_CMD_PREFLIGHT_UAVCAN = 243 // Trigger UAVCAN configuration (actuator ID assignment and direction
+                        // mapping). Note that this maps to the legacy
+                        // UAVCAN v0 function UAVCAN_ENUMERATE, which
+                        // is intended to be executed just once during
+                        // initial vehicle configuration (it is not a
+                        // normal pre-flight command and has been
+                        // poorly named).
+mavlink20.MAV_CMD_PREFLIGHT_STORAGE = 245 // Request storage of different parameter values and logs. This command
+                        // will be only accepted if in pre-flight
+                        // mode.
+mavlink20.MAV_CMD_PREFLIGHT_REBOOT_SHUTDOWN = 246 // Request the reboot or shutdown of system components.
+mavlink20.MAV_CMD_OVERRIDE_GOTO = 252 // Override current mission with command to pause mission, pause mission
+                        // and move to position, continue/resume
+                        // mission. When param 1 indicates that the
+                        // mission is paused (MAV_GOTO_DO_HOLD), param
+                        // 2 defines whether it holds in place or
+                        // moves to another position.
+mavlink20.MAV_CMD_OBLIQUE_SURVEY = 260 // Mission command to set a Camera Auto Mount Pivoting Oblique Survey
+                        // (Replaces CAM_TRIGG_DIST for this purpose).
+                        // The camera is triggered each time this
+                        // distance is exceeded, then the mount moves
+                        // to the next position. Params 4~6 set-up the
+                        // angle limits and number of positions for
+                        // oblique survey, where mount-enabled
+                        // vehicles automatically roll the camera
+                        // between shots to emulate an oblique camera
+                        // setup (providing an increased HFOV). This
+                        // command can also be used to set the shutter
+                        // integration time for the camera.
+mavlink20.MAV_CMD_DO_SET_STANDARD_MODE = 262 // Enable the specified standard MAVLink mode.           If the mode is
+                        // not supported the vehicle should ACK with
+                        // MAV_RESULT_FAILED.
+mavlink20.MAV_CMD_MISSION_START = 300 // start running a mission
+mavlink20.MAV_CMD_COMPONENT_ARM_DISARM = 400 // Arms / Disarms a component
+mavlink20.MAV_CMD_RUN_PREARM_CHECKS = 401 // Instructs system to run pre-arm checks.  This command should return
+                        // MAV_RESULT_TEMPORARILY_REJECTED in the case
+                        // the system is armed, otherwise
+                        // MAV_RESULT_ACCEPTED.  Note that the return
+                        // value from executing this command does not
+                        // indicate whether the vehicle is armable or
+                        // not, just whether the system has
+                        // successfully run/is currently running the
+                        // checks.  The result of the checks is
+                        // reflected in the SYS_STATUS message.
+mavlink20.MAV_CMD_GET_HOME_POSITION = 410 // Request the home position from the vehicle.
+mavlink20.MAV_CMD_START_RX_PAIR = 500 // Starts receiver pairing.
+mavlink20.MAV_CMD_GET_MESSAGE_INTERVAL = 510 // Request the interval between messages for a particular MAVLink message
+                        // ID. The receiver should ACK the command and
+                        // then emit its response in a
+                        // MESSAGE_INTERVAL message.
+mavlink20.MAV_CMD_SET_MESSAGE_INTERVAL = 511 // Set the interval between messages for a particular MAVLink message ID.
+                        // This interface replaces
+                        // REQUEST_DATA_STREAM.
+mavlink20.MAV_CMD_REQUEST_MESSAGE = 512 // Request the target system(s) emit a single instance of a specified
+                        // message (i.e. a "one-shot" version of
+                        // MAV_CMD_SET_MESSAGE_INTERVAL).
+mavlink20.MAV_CMD_REQUEST_PROTOCOL_VERSION = 519 // Request MAVLink protocol version compatibility. All receivers should
+                        // ACK the command and then emit their
+                        // capabilities in an PROTOCOL_VERSION message
+mavlink20.MAV_CMD_REQUEST_AUTOPILOT_CAPABILITIES = 520 // Request autopilot capabilities. The receiver should ACK the command
+                        // and then emit its capabilities in an
+                        // AUTOPILOT_VERSION message
+mavlink20.MAV_CMD_REQUEST_CAMERA_INFORMATION = 521 // Request camera information (CAMERA_INFORMATION).
+mavlink20.MAV_CMD_REQUEST_CAMERA_SETTINGS = 522 // Request camera settings (CAMERA_SETTINGS).
+mavlink20.MAV_CMD_REQUEST_STORAGE_INFORMATION = 525 // Request storage information (STORAGE_INFORMATION). Use the command's
+                        // target_component to target a specific
+                        // component's storage.
+mavlink20.MAV_CMD_STORAGE_FORMAT = 526 // Format a storage medium. Once format is complete, a
+                        // STORAGE_INFORMATION message is sent. Use
+                        // the command's target_component to target a
+                        // specific component's storage.
+mavlink20.MAV_CMD_REQUEST_CAMERA_CAPTURE_STATUS = 527 // Request camera capture status (CAMERA_CAPTURE_STATUS)
+mavlink20.MAV_CMD_REQUEST_FLIGHT_INFORMATION = 528 // Request flight information (FLIGHT_INFORMATION)
+mavlink20.MAV_CMD_RESET_CAMERA_SETTINGS = 529 // Reset all camera settings to Factory Default
+mavlink20.MAV_CMD_SET_CAMERA_MODE = 530 // Set camera running mode. Use NaN for reserved values. GCS will send a
+                        // MAV_CMD_REQUEST_VIDEO_STREAM_STATUS command
+                        // after a mode change if the camera supports
+                        // video streaming.
+mavlink20.MAV_CMD_SET_CAMERA_ZOOM = 531 // Set camera zoom. Camera must respond with a CAMERA_SETTINGS message
+                        // (on success).
+mavlink20.MAV_CMD_SET_CAMERA_FOCUS = 532 // Set camera focus. Camera must respond with a CAMERA_SETTINGS message
+                        // (on success).
+mavlink20.MAV_CMD_SET_STORAGE_USAGE = 533 // Set that a particular storage is the preferred location for saving
+                        // photos, videos, and/or other media (e.g. to
+                        // set that an SD card is used for storing
+                        // videos).           There can only be one
+                        // preferred save location for each particular
+                        // media type: setting a media usage flag will
+                        // clear/reset that same flag if set on any
+                        // other storage.           If no flag is set
+                        // the system should use its default storage.
+                        // A target system can choose to always use
+                        // default storage, in which case it should
+                        // ACK the command with
+                        // MAV_RESULT_UNSUPPORTED.           A target
+                        // system can choose to not allow a particular
+                        // storage to be set as preferred storage, in
+                        // which case it should ACK the command with
+                        // MAV_RESULT_DENIED.
+mavlink20.MAV_CMD_SET_CAMERA_SOURCE = 534 // Set camera source. Changes the camera's active sources on cameras with
+                        // multiple image sensors.
+mavlink20.MAV_CMD_JUMP_TAG = 600 // Tagged jump target. Can be jumped to with MAV_CMD_DO_JUMP_TAG.
+mavlink20.MAV_CMD_DO_JUMP_TAG = 601 // Jump to the matching tag in the mission list. Repeat this action for
+                        // the specified number of times. A mission
+                        // should contain a single matching tag for
+                        // each jump. If this is not the case then a
+                        // jump to a missing tag should complete the
+                        // mission, and a jump where there are
+                        // multiple matching tags should always select
+                        // the one with the lowest mission sequence
+                        // number.
+mavlink20.MAV_CMD_DO_SET_SYS_CMP_ID = 610 //            Set system and component id.           This allows moving
+                        // of a system and all its components to a new
+                        // system id, or moving a particular component
+                        // to a new system/component id.
+                        // Recipients must reject command addressed to
+                        // broadcast system ID.
+mavlink20.MAV_CMD_DO_SET_GLOBAL_ORIGIN = 611 // Sets the GNSS coordinates of the vehicle local origin (0,0,0)
+                        // position.           Vehicle should emit
+                        // GPS_GLOBAL_ORIGIN irrespective of whether
+                        // the origin is changed.           This
+                        // enables transform between the local
+                        // coordinate frame and the global (GNSS)
+                        // coordinate frame, which may be necessary
+                        // when (for example) indoor and outdoor
+                        // settings are connected and the MAV should
+                        // move from in- to outdoor.           This
+                        // command supersedes SET_GPS_GLOBAL_ORIGIN.
+                        // Should be sent in a COMMAND_INT (Expected
+                        // frame is MAV_FRAME_GLOBAL, and this should
+                        // be assumed when sent in COMMAND_LONG).
+mavlink20.MAV_CMD_DO_GIMBAL_MANAGER_PITCHYAW = 1000 // Set gimbal manager pitch/yaw setpoints (low rate command). It is
+                        // possible to set combinations of the values
+                        // below. E.g. an angle as well as a desired
+                        // angular rate can be used to get to this
+                        // angle at a certain angular rate, or an
+                        // angular rate only will result in continuous
+                        // turning. NaN is to be used to signal unset.
+                        // Note: only the gimbal manager will react to
+                        // this command - it will be ignored by a
+                        // gimbal device. Use
+                        // GIMBAL_MANAGER_SET_PITCHYAW if you need to
+                        // stream pitch/yaw setpoints at higher rate.
+mavlink20.MAV_CMD_DO_GIMBAL_MANAGER_CONFIGURE = 1001 // Gimbal configuration to set which sysid/compid is in primary and
+                        // secondary control.
+mavlink20.MAV_CMD_IMAGE_START_CAPTURE = 2000 // Start image capture sequence. CAMERA_IMAGE_CAPTURED must be emitted
+                        // after each capture.            Param1 (id)
+                        // may be used to specify the target camera:
+                        // 0: all cameras, 1 to 6: autopilot-connected
+                        // cameras, 7-255: MAVLink camera component
+                        // ID.           It is needed in order to
+                        // target specific cameras connected to the
+                        // autopilot, or specific sensors in a multi-
+                        // sensor camera (neither of which have a
+                        // distinct MAVLink component ID).
+                        // It is also needed to specify the target
+                        // camera in missions.            When used in
+                        // a mission, an autopilot should execute the
+                        // MAV_CMD for a specified local camera
+                        // (param1 = 1-6), or resend it as a command
+                        // if it is intended for a MAVLink camera
+                        // (param1 = 7 - 255), setting the command's
+                        // target_component as the param1 value (and
+                        // setting param1 in the command to zero).
+                        // If the param1 is 0 the autopilot should do
+                        // both.            When sent in a command the
+                        // target MAVLink address is set using
+                        // target_component.           If addressed
+                        // specifically to an autopilot: param1 should
+                        // be used in the same way as it is for
+                        // missions (though command should NACK with
+                        // MAV_RESULT_DENIED if a specified local
+                        // camera does not exist).           If
+                        // addressed to a MAVLink camera, param 1 can
+                        // be used to address all cameras (0), or to
+                        // separately address 1 to 7 individual
+                        // sensors. Other values should be NACKed with
+                        // MAV_RESULT_DENIED.           If the command
+                        // is broadcast (target_component is 0) then
+                        // param 1 should be set to 0 (any other value
+                        // should be NACKED with MAV_RESULT_DENIED).
+                        // An autopilot would trigger any local
+                        // cameras and forward the command to all
+                        // channels.
+mavlink20.MAV_CMD_IMAGE_STOP_CAPTURE = 2001 // Stop image capture sequence.            Param1 (id) may be used to
+                        // specify the target camera: 0: all cameras,
+                        // 1 to 6: autopilot-connected cameras, 7-255:
+                        // MAVLink camera component ID.           It
+                        // is needed in order to target specific
+                        // cameras connected to the autopilot, or
+                        // specific sensors in a multi-sensor camera
+                        // (neither of which have a distinct MAVLink
+                        // component ID).           It is also needed
+                        // to specify the target camera in missions.
+                        // When used in a mission, an autopilot should
+                        // execute the MAV_CMD for a specified local
+                        // camera (param1 = 1-6), or resend it as a
+                        // command if it is intended for a MAVLink
+                        // camera (param1 = 7 - 255), setting the
+                        // command's target_component as the param1
+                        // value (and setting param1 in the command to
+                        // zero).           If the param1 is 0 the
+                        // autopilot should do both.            When
+                        // sent in a command the target MAVLink
+                        // address is set using target_component.
+                        // If addressed specifically to an autopilot:
+                        // param1 should be used in the same way as it
+                        // is for missions (though command should NACK
+                        // with MAV_RESULT_DENIED if a specified local
+                        // camera does not exist).           If
+                        // addressed to a MAVLink camera, param1 can
+                        // be used to address all cameras (0), or to
+                        // separately address 1 to 7 individual
+                        // sensors. Other values should be NACKed with
+                        // MAV_RESULT_DENIED.           If the command
+                        // is broadcast (target_component is 0) then
+                        // param 1 should be set to 0 (any other value
+                        // should be NACKED with MAV_RESULT_DENIED).
+                        // An autopilot would trigger any local
+                        // cameras and forward the command to all
+                        // channels.
+mavlink20.MAV_CMD_DO_TRIGGER_CONTROL = 2003 // Enable or disable on-board camera triggering system.
+mavlink20.MAV_CMD_CAMERA_TRACK_POINT = 2004 // If the camera supports point visual tracking
+                        // (CAMERA_CAP_FLAGS_HAS_TRACKING_POINT is
+                        // set), this command allows to initiate the
+                        // tracking.
+mavlink20.MAV_CMD_CAMERA_TRACK_RECTANGLE = 2005 // If the camera supports rectangle visual tracking
+                        // (CAMERA_CAP_FLAGS_HAS_TRACKING_RECTANGLE is
+                        // set), this command allows to initiate the
+                        // tracking.
+mavlink20.MAV_CMD_CAMERA_STOP_TRACKING = 2010 // Stops ongoing tracking.
+mavlink20.MAV_CMD_VIDEO_START_CAPTURE = 2500 // Starts video capture (recording).
+mavlink20.MAV_CMD_VIDEO_STOP_CAPTURE = 2501 // Stop the current video capture (recording).
+mavlink20.MAV_CMD_VIDEO_START_STREAMING = 2502 // Start video streaming
+mavlink20.MAV_CMD_VIDEO_STOP_STREAMING = 2503 // Stop the given video stream
+mavlink20.MAV_CMD_REQUEST_VIDEO_STREAM_INFORMATION = 2504 // Request video stream information (VIDEO_STREAM_INFORMATION)
+mavlink20.MAV_CMD_REQUEST_VIDEO_STREAM_STATUS = 2505 // Request video stream status (VIDEO_STREAM_STATUS)
+mavlink20.MAV_CMD_LOGGING_START = 2510 // Request to start streaming logging data over MAVLink (see also
+                        // LOGGING_DATA message)
+mavlink20.MAV_CMD_LOGGING_STOP = 2511 // Request to stop streaming log data over MAVLink
+mavlink20.MAV_CMD_AIRFRAME_CONFIGURATION = 2520 // 
+mavlink20.MAV_CMD_CONTROL_HIGH_LATENCY = 2600 // Request to start/stop transmitting over the high latency telemetry
+mavlink20.MAV_CMD_PANORAMA_CREATE = 2800 // Create a panorama at the current position
+mavlink20.MAV_CMD_DO_VTOL_TRANSITION = 3000 // Request VTOL transition
+mavlink20.MAV_CMD_ARM_AUTHORIZATION_REQUEST = 3001 // Request authorization to arm the vehicle to a external entity, the arm
+                        // authorizer is responsible to request all
+                        // data that is needs from the vehicle before
+                        // authorize or deny the request. If approved
+                        // the progress of command_ack message should
+                        // be set with period of time that this
+                        // authorization is valid in seconds or in
+                        // case it was denied it should be set with
+                        // one of the reasons in
+                        // ARM_AUTH_DENIED_REASON.
+mavlink20.MAV_CMD_SET_GUIDED_SUBMODE_STANDARD = 4000 // This command sets the submode to standard guided when vehicle is in
+                        // guided mode. The vehicle holds position and
+                        // altitude and the user can input the desired
+                        // velocities along all three axes.
+mavlink20.MAV_CMD_SET_GUIDED_SUBMODE_CIRCLE = 4001 // This command sets submode circle when vehicle is in guided mode.
+                        // Vehicle flies along a circle facing the
+                        // center of the circle. The user can input
+                        // the velocity along the circle and change
+                        // the radius. If no input is given the
+                        // vehicle will hold position.
+mavlink20.MAV_CMD_NAV_FENCE_RETURN_POINT = 5000 // Fence return point (there can only be one such point in a geofence
+                        // definition). If rally points are supported
+                        // they should be used instead.
+mavlink20.MAV_CMD_NAV_FENCE_POLYGON_VERTEX_INCLUSION = 5001 // Fence vertex for an inclusion polygon (the polygon must not be self-
+                        // intersecting). The vehicle must stay within
+                        // this area. Minimum of 3 vertices required.
+mavlink20.MAV_CMD_NAV_FENCE_POLYGON_VERTEX_EXCLUSION = 5002 // Fence vertex for an exclusion polygon (the polygon must not be self-
+                        // intersecting). The vehicle must stay
+                        // outside this area. Minimum of 3 vertices
+                        // required.
+mavlink20.MAV_CMD_NAV_FENCE_CIRCLE_INCLUSION = 5003 // Circular fence area. The vehicle must stay inside this area.
+mavlink20.MAV_CMD_NAV_FENCE_CIRCLE_EXCLUSION = 5004 // Circular fence area. The vehicle must stay outside this area.
+mavlink20.MAV_CMD_NAV_RALLY_POINT = 5100 // Rally point. You can have multiple rally points defined.
+mavlink20.MAV_CMD_UAVCAN_GET_NODE_INFO = 5200 // Commands the vehicle to respond with a sequence of messages
+                        // UAVCAN_NODE_INFO, one message per every
+                        // UAVCAN node that is online. Note that some
+                        // of the response messages can be lost, which
+                        // the receiver can detect easily by checking
+                        // whether every received UAVCAN_NODE_STATUS
+                        // has a matching message UAVCAN_NODE_INFO
+                        // received earlier; if not, this command
+                        // should be sent again in order to request
+                        // re-transmission of the node information
+                        // messages.
+mavlink20.MAV_CMD_DO_SET_SAFETY_SWITCH_STATE = 5300 // Change state of safety switch.
+mavlink20.MAV_CMD_DO_ADSB_OUT_IDENT = 10001 // Trigger the start of an ADSB-out IDENT. This should only be used when
+                        // requested to do so by an Air Traffic
+                        // Controller in controlled airspace. This
+                        // starts the IDENT which is then typically
+                        // held for 18 seconds by the hardware per the
+                        // Mode A, C, and S transponder spec.
+mavlink20.MAV_CMD_LOWEHEISER_SET_STATE = 10151 // Set Loweheiser desired states
+mavlink20.MAV_CMD_PAYLOAD_PREPARE_DEPLOY = 30001 // Deploy payload on a Lat / Lon / Alt position. This includes the
+                        // navigation to reach the required release
+                        // position and velocity.
+mavlink20.MAV_CMD_PAYLOAD_CONTROL_DEPLOY = 30002 // Control the payload deployment.
+mavlink20.MAV_CMD_WAYPOINT_USER_1 = 31000 // User defined waypoint item. Ground Station will show the Vehicle as
+                        // flying through this item.
+mavlink20.MAV_CMD_WAYPOINT_USER_2 = 31001 // User defined waypoint item. Ground Station will show the Vehicle as
+                        // flying through this item.
+mavlink20.MAV_CMD_WAYPOINT_USER_3 = 31002 // User defined waypoint item. Ground Station will show the Vehicle as
+                        // flying through this item.
+mavlink20.MAV_CMD_WAYPOINT_USER_4 = 31003 // User defined waypoint item. Ground Station will show the Vehicle as
+                        // flying through this item.
+mavlink20.MAV_CMD_WAYPOINT_USER_5 = 31004 // User defined waypoint item. Ground Station will show the Vehicle as
+                        // flying through this item.
+mavlink20.MAV_CMD_SPATIAL_USER_1 = 31005 // User defined spatial item. Ground Station will not show the Vehicle as
+                        // flying through this item. Example: ROI
+                        // item.
+mavlink20.MAV_CMD_SPATIAL_USER_2 = 31006 // User defined spatial item. Ground Station will not show the Vehicle as
+                        // flying through this item. Example: ROI
+                        // item.
+mavlink20.MAV_CMD_SPATIAL_USER_3 = 31007 // User defined spatial item. Ground Station will not show the Vehicle as
+                        // flying through this item. Example: ROI
+                        // item.
+mavlink20.MAV_CMD_SPATIAL_USER_4 = 31008 // User defined spatial item. Ground Station will not show the Vehicle as
+                        // flying through this item. Example: ROI
+                        // item.
+mavlink20.MAV_CMD_SPATIAL_USER_5 = 31009 // User defined spatial item. Ground Station will not show the Vehicle as
+                        // flying through this item. Example: ROI
+                        // item.
+mavlink20.MAV_CMD_USER_1 = 31010 // User defined command. Ground Station will not show the Vehicle as
+                        // flying through this item. Example:
+                        // MAV_CMD_DO_SET_PARAMETER item.
+mavlink20.MAV_CMD_USER_2 = 31011 // User defined command. Ground Station will not show the Vehicle as
+                        // flying through this item. Example:
+                        // MAV_CMD_DO_SET_PARAMETER item.
+mavlink20.MAV_CMD_USER_3 = 31012 // User defined command. Ground Station will not show the Vehicle as
+                        // flying through this item. Example:
+                        // MAV_CMD_DO_SET_PARAMETER item.
+mavlink20.MAV_CMD_USER_4 = 31013 // User defined command. Ground Station will not show the Vehicle as
+                        // flying through this item. Example:
+                        // MAV_CMD_DO_SET_PARAMETER item.
+mavlink20.MAV_CMD_USER_5 = 31014 // User defined command. Ground Station will not show the Vehicle as
+                        // flying through this item. Example:
+                        // MAV_CMD_DO_SET_PARAMETER item.
+mavlink20.MAV_CMD_CAN_FORWARD = 32000 // Request forwarding of CAN packets from the given CAN bus to this
+                        // interface. CAN Frames are sent using
+                        // CAN_FRAME and CANFD_FRAME messages
+mavlink20.MAV_CMD_RESET_MPPT = 40001 // Mission command to reset Maximum Power Point Tracker (MPPT)
+mavlink20.MAV_CMD_PAYLOAD_CONTROL = 40002 // Mission command to perform a power cycle on payload
+mavlink20.MAV_CMD_POWER_OFF_INITIATED = 42000 // A system wide power-off event has been initiated.
+mavlink20.MAV_CMD_SOLO_BTN_FLY_CLICK = 42001 // FLY button has been clicked.
+mavlink20.MAV_CMD_SOLO_BTN_FLY_HOLD = 42002 // FLY button has been held for 1.5 seconds.
+mavlink20.MAV_CMD_SOLO_BTN_PAUSE_CLICK = 42003 // PAUSE button has been clicked.
+mavlink20.MAV_CMD_FIXED_MAG_CAL = 42004 // Magnetometer calibration based on fixed position         in earth
+                        // field given by inclination, declination and
+                        // intensity.
+mavlink20.MAV_CMD_FIXED_MAG_CAL_FIELD = 42005 // Magnetometer calibration based on fixed expected field values.
+mavlink20.MAV_CMD_FIXED_MAG_CAL_YAW = 42006 // Magnetometer calibration based on provided known yaw. This allows for
+                        // fast calibration using WMM field tables in
+                        // the vehicle, given only the known yaw of
+                        // the vehicle. If Latitude and longitude are
+                        // both zero then use the current vehicle
+                        // location.
+mavlink20.MAV_CMD_SET_EKF_SOURCE_SET = 42007 // Set EKF sensor source set.
+mavlink20.MAV_CMD_DO_START_MAG_CAL = 42424 // Initiate a magnetometer calibration.
+mavlink20.MAV_CMD_DO_ACCEPT_MAG_CAL = 42425 // Accept a magnetometer calibration.
+mavlink20.MAV_CMD_DO_CANCEL_MAG_CAL = 42426 // Cancel a running magnetometer calibration.
+mavlink20.MAV_CMD_SET_FACTORY_TEST_MODE = 42427 // Command autopilot to get into factory test/diagnostic mode.
+mavlink20.MAV_CMD_DO_SEND_BANNER = 42428 // Reply with the version banner.
+mavlink20.MAV_CMD_ACCELCAL_VEHICLE_POS = 42429 // Used when doing accelerometer calibration. When sent to the GCS tells
+                        // it what position to put the vehicle in.
+                        // When sent to the vehicle says what position
+                        // the vehicle is in.
+mavlink20.MAV_CMD_GIMBAL_RESET = 42501 // Causes the gimbal to reset and boot as if it was just powered on.
+mavlink20.MAV_CMD_GIMBAL_AXIS_CALIBRATION_STATUS = 42502 // Reports progress and success or failure of gimbal axis calibration
+                        // procedure.
+mavlink20.MAV_CMD_GIMBAL_REQUEST_AXIS_CALIBRATION = 42503 // Starts commutation calibration on the gimbal.
+mavlink20.MAV_CMD_GIMBAL_FULL_RESET = 42505 // Erases gimbal application and parameters.
+mavlink20.MAV_CMD_DO_WINCH = 42600 // Command to operate winch.
+mavlink20.MAV_CMD_FLASH_BOOTLOADER = 42650 // Update the bootloader
+mavlink20.MAV_CMD_BATTERY_RESET = 42651 // Reset battery capacity for batteries that accumulate consumed battery
+                        // via integration.
+mavlink20.MAV_CMD_DEBUG_TRAP = 42700 // Issue a trap signal to the autopilot process, presumably to enter the
+                        // debugger.
+mavlink20.MAV_CMD_SCRIPTING = 42701 // Control onboard scripting.
+mavlink20.MAV_CMD_NAV_SCRIPT_TIME = 42702 // Scripting command as NAV command with wait for completion.
+mavlink20.MAV_CMD_NAV_ATTITUDE_TIME = 42703 // Maintain an attitude for a specified time.
+mavlink20.MAV_CMD_GUIDED_CHANGE_SPEED = 43000 // Change flight speed at a given rate. This slews the vehicle at a
+                        // controllable rate between it's previous
+                        // speed and the new one. (affects GUIDED
+                        // only. Outside GUIDED, aircraft ignores
+                        // these commands. Designed for onboard
+                        // companion-computer command-and-control, not
+                        // normally operator/GCS control.)
+mavlink20.MAV_CMD_GUIDED_CHANGE_ALTITUDE = 43001 // Change target altitude at a given rate. This slews the vehicle at a
+                        // controllable rate between it's previous
+                        // altitude and the new one. (affects GUIDED
+                        // only. Outside GUIDED, aircraft ignores
+                        // these commands. Designed for onboard
+                        // companion-computer command-and-control, not
+                        // normally operator/GCS control.)
+mavlink20.MAV_CMD_GUIDED_CHANGE_HEADING = 43002 // Change to target heading at a given rate, overriding previous
+                        // heading/s. This slews the vehicle at a
+                        // controllable rate between it's previous
+                        // heading and the new one. (affects GUIDED
+                        // only. Exiting GUIDED returns aircraft to
+                        // normal behaviour defined elsewhere.
+                        // Designed for onboard companion-computer
+                        // command-and-control, not normally
+                        // operator/GCS control.)
+mavlink20.MAV_CMD_EXTERNAL_POSITION_ESTIMATE = 43003 // Provide an external position estimate for use when dead-reckoning.
+                        // This is meant to be used for occasional
+                        // position resets that may be provided by a
+                        // external system such as a remote pilot
+                        // using landmarks over a video link.
+mavlink20.MAV_CMD_EXTERNAL_WIND_ESTIMATE = 43004 // Set an external estimate of wind direction and speed.           This
+                        // might be used to provide an initial wind
+                        // estimate to the estimator (EKF) in the case
+                        // where the vehicle is wind dead-reckoning,
+                        // extending the time when operating without
+                        // GPS before before position drift builds to
+                        // an unsafe level. For this use case the
+                        // command might reasonably be sent every few
+                        // minutes when operating at altitude, and the
+                        // value is cleared if the estimator resets
+                        // itself.
+mavlink20.MAV_CMD_SET_HAGL = 43005 // Provide a value for height above ground level. This can be used for
+                        // things like fixed wing and VTOL landing.
+mavlink20.MAV_CMD_STORM32_DO_GIMBAL_MANAGER_CONTROL_PITCHYAW = 60002 // Command to a gimbal manager to control the gimbal tilt and pan angles.
+                        // It is possible to set combinations of the
+                        // values below. E.g. an angle as well as a
+                        // desired angular rate can be used to get to
+                        // this angle at a certain angular rate, or an
+                        // angular rate only will result in continuous
+                        // turning. NaN is to be used to signal unset.
+                        // A gimbal device is never to react to this
+                        // command.
+mavlink20.MAV_CMD_STORM32_DO_GIMBAL_MANAGER_SETUP = 60010 // Command to configure a gimbal manager. A gimbal device is never to
+                        // react to this command. The selected profile
+                        // is reported in the
+                        // STORM32_GIMBAL_MANAGER_STATUS message.
+mavlink20.MAV_CMD_QSHOT_DO_CONFIGURE = 60020 // Command to set the shot manager mode.
+mavlink20.MAV_CMD_PRS_SET_ARM = 60050 // AVSS defined command. Set PRS arm statuses.
+mavlink20.MAV_CMD_PRS_GET_ARM = 60051 // AVSS defined command. Gets PRS arm statuses
+mavlink20.MAV_CMD_PRS_GET_BATTERY = 60052 // AVSS defined command.  Get the PRS battery voltage in millivolts
+mavlink20.MAV_CMD_PRS_GET_ERR = 60053 // AVSS defined command. Get the PRS error statuses.
+mavlink20.MAV_CMD_PRS_SET_ARM_ALTI = 60070 // AVSS defined command. Set the ATS arming altitude in meters.
+mavlink20.MAV_CMD_PRS_GET_ARM_ALTI = 60071 // AVSS defined command. Get the ATS arming altitude in meters.
+mavlink20.MAV_CMD_PRS_SHUTDOWN = 60072 // AVSS defined command. Shuts down the PRS system.
+mavlink20.MAV_CMD_ENUM_END = 60073 // 
+
+// SCRIPTING_CMD
+mavlink20.SCRIPTING_CMD_REPL_START = 0 // Start a REPL session.
+mavlink20.SCRIPTING_CMD_REPL_STOP = 1 // End a REPL session.
+mavlink20.SCRIPTING_CMD_STOP = 2 // Stop execution of scripts.
+mavlink20.SCRIPTING_CMD_STOP_AND_RESTART = 3 // Stop execution of scripts and restart.
+mavlink20.SCRIPTING_CMD_ENUM_END = 4 // 
+
+// SECURE_COMMAND_OP
+mavlink20.SECURE_COMMAND_GET_SESSION_KEY = 0 // Get an 8 byte session key which is used for remote secure updates
+                        // which operate on flight controller data
+                        // such as bootloader public keys. Return data
+                        // will be 8 bytes on success. The session key
+                        // remains valid until either the flight
+                        // controller reboots or another
+                        // SECURE_COMMAND_GET_SESSION_KEY is run.
+mavlink20.SECURE_COMMAND_GET_REMOTEID_SESSION_KEY = 1 // Get an 8 byte session key which is used for remote secure updates
+                        // which operate on RemoteID module data.
+                        // Return data will be 8 bytes on success. The
+                        // session key remains valid until either the
+                        // remote ID module reboots or another
+                        // SECURE_COMMAND_GET_REMOTEID_SESSION_KEY is
+                        // run.
+mavlink20.SECURE_COMMAND_REMOVE_PUBLIC_KEYS = 2 // Remove range of public keys from the bootloader. Command data consists
+                        // of two bytes, first byte if index of first
+                        // public key to remove. Second byte is the
+                        // number of keys to remove. If all keys are
+                        // removed then secure boot is disabled and
+                        // insecure firmware can be loaded.
+mavlink20.SECURE_COMMAND_GET_PUBLIC_KEYS = 3 // Get current public keys from the bootloader. Command data consists of
+                        // two bytes, first byte is index of first
+                        // public key to fetch, 2nd byte is number of
+                        // keys to fetch. Total data needs to fit in
+                        // data portion of reply (max 6 keys for 32
+                        // byte keys). Reply data has the index of the
+                        // first key in the first byte, followed by
+                        // the keys. Returned keys may be less than
+                        // the number of keys requested if there are
+                        // less keys installed than requested.
+mavlink20.SECURE_COMMAND_SET_PUBLIC_KEYS = 4 // Set current public keys in the bootloader. Data consists of a one byte
+                        // public key index followed by the public
+                        // keys. With 32 byte keys this allows for up
+                        // to 6 keys to be set in one request. Keys
+                        // outside of the range that is being set will
+                        // remain unchanged.
+mavlink20.SECURE_COMMAND_GET_REMOTEID_CONFIG = 5 // Get config data for remote ID module. This command should be sent to
+                        // the component ID of the flight controller
+                        // which will forward it to the RemoteID
+                        // module either over mavlink or DroneCAN.
+                        // Data format is specific to the RemoteID
+                        // implementation, see RemoteID firmware
+                        // documentation for details.
+mavlink20.SECURE_COMMAND_SET_REMOTEID_CONFIG = 6 // Set config data for remote ID module. This command should be sent to
+                        // the component ID of the flight controller
+                        // which will forward it to the RemoteID
+                        // module either over mavlink or DroneCAN.
+                        // Data format is specific to the RemoteID
+                        // implementation, see RemoteID firmware
+                        // documentation for details.
+mavlink20.SECURE_COMMAND_FLASH_BOOTLOADER = 7 // Flash bootloader from local storage. Data is the filename to use for
+                        // the bootloader. This is intended to be used
+                        // with MAVFtp to upload a new bootloader to a
+                        // microSD before flashing.
+mavlink20.SECURE_COMMAND_OP_ENUM_END = 8 // 
+
+// LIMITS_STATE
+mavlink20.LIMITS_INIT = 0 // Pre-initialization.
+mavlink20.LIMITS_DISABLED = 1 // Disabled.
+mavlink20.LIMITS_ENABLED = 2 // Checking limits.
+mavlink20.LIMITS_TRIGGERED = 3 // A limit has been breached.
+mavlink20.LIMITS_RECOVERING = 4 // Taking action e.g. Return/RTL.
+mavlink20.LIMITS_RECOVERED = 5 // We're no longer in breach of a limit.
+mavlink20.LIMITS_STATE_ENUM_END = 6 // 
+
+// LIMIT_MODULE
+mavlink20.LIMIT_GPSLOCK = 1 // Pre-initialization.
+mavlink20.LIMIT_GEOFENCE = 2 // Disabled.
+mavlink20.LIMIT_ALTITUDE = 4 // Checking limits.
+mavlink20.LIMIT_MODULE_ENUM_END = 5 // 
+
+// RALLY_FLAGS
+mavlink20.FAVORABLE_WIND = 1 // Flag set when requiring favorable winds for landing.
+mavlink20.LAND_IMMEDIATELY = 2 // Flag set when plane is to immediately descend to break altitude and
+                        // land without GCS intervention. Flag not set
+                        // when plane is to loiter at Rally point
+                        // until commanded to land.
+mavlink20.ALT_FRAME_VALID = 4 // True if the following altitude frame value is valid.
+mavlink20.ALT_FRAME = 24 // 2 bit value representing altitude frame. 0: absolute, 1: relative
+                        // home, 2: relative origin, 3: relative
+                        // terrain
+mavlink20.RALLY_FLAGS_ENUM_END = 25 // 
+
+// CAMERA_STATUS_TYPES
+mavlink20.CAMERA_STATUS_TYPE_HEARTBEAT = 0 // Camera heartbeat, announce camera component ID at 1Hz.
+mavlink20.CAMERA_STATUS_TYPE_TRIGGER = 1 // Camera image triggered.
+mavlink20.CAMERA_STATUS_TYPE_DISCONNECT = 2 // Camera connection lost.
+mavlink20.CAMERA_STATUS_TYPE_ERROR = 3 // Camera unknown error.
+mavlink20.CAMERA_STATUS_TYPE_LOWBATT = 4 // Camera battery low. Parameter p1 shows reported voltage.
+mavlink20.CAMERA_STATUS_TYPE_LOWSTORE = 5 // Camera storage low. Parameter p1 shows reported shots remaining.
+mavlink20.CAMERA_STATUS_TYPE_LOWSTOREV = 6 // Camera storage low. Parameter p1 shows reported video minutes
+                        // remaining.
+mavlink20.CAMERA_STATUS_TYPES_ENUM_END = 7 // 
+
+// CAMERA_FEEDBACK_FLAGS
+mavlink20.CAMERA_FEEDBACK_PHOTO = 0 // Shooting photos, not video.
+mavlink20.CAMERA_FEEDBACK_VIDEO = 1 // Shooting video, not stills.
+mavlink20.CAMERA_FEEDBACK_BADEXPOSURE = 2 // Unable to achieve requested exposure (e.g. shutter speed too low).
+mavlink20.CAMERA_FEEDBACK_CLOSEDLOOP = 3 // Closed loop feedback from camera, we know for sure it has successfully
+                        // taken a picture.
+mavlink20.CAMERA_FEEDBACK_OPENLOOP = 4 // Open loop camera, an image trigger has been requested but we can't
+                        // know for sure it has successfully taken a
+                        // picture.
+mavlink20.CAMERA_FEEDBACK_FLAGS_ENUM_END = 5 // 
+
+// MAV_MODE_GIMBAL
+mavlink20.MAV_MODE_GIMBAL_UNINITIALIZED = 0 // Gimbal is powered on but has not started initializing yet.
+mavlink20.MAV_MODE_GIMBAL_CALIBRATING_PITCH = 1 // Gimbal is currently running calibration on the pitch axis.
+mavlink20.MAV_MODE_GIMBAL_CALIBRATING_ROLL = 2 // Gimbal is currently running calibration on the roll axis.
+mavlink20.MAV_MODE_GIMBAL_CALIBRATING_YAW = 3 // Gimbal is currently running calibration on the yaw axis.
+mavlink20.MAV_MODE_GIMBAL_INITIALIZED = 4 // Gimbal has finished calibrating and initializing, but is relaxed
+                        // pending reception of first rate command
+                        // from copter.
+mavlink20.MAV_MODE_GIMBAL_ACTIVE = 5 // Gimbal is actively stabilizing.
+mavlink20.MAV_MODE_GIMBAL_RATE_CMD_TIMEOUT = 6 // Gimbal is relaxed because it missed more than 10 expected rate command
+                        // messages in a row. Gimbal will move back to
+                        // active mode when it receives a new rate
+                        // command.
+mavlink20.MAV_MODE_GIMBAL_ENUM_END = 7 // 
+
+// GIMBAL_AXIS
+mavlink20.GIMBAL_AXIS_YAW = 0 // Gimbal yaw axis.
+mavlink20.GIMBAL_AXIS_PITCH = 1 // Gimbal pitch axis.
+mavlink20.GIMBAL_AXIS_ROLL = 2 // Gimbal roll axis.
+mavlink20.GIMBAL_AXIS_ENUM_END = 3 // 
+
+// GIMBAL_AXIS_CALIBRATION_STATUS
+mavlink20.GIMBAL_AXIS_CALIBRATION_STATUS_IN_PROGRESS = 0 // Axis calibration is in progress.
+mavlink20.GIMBAL_AXIS_CALIBRATION_STATUS_SUCCEEDED = 1 // Axis calibration succeeded.
+mavlink20.GIMBAL_AXIS_CALIBRATION_STATUS_FAILED = 2 // Axis calibration failed.
+mavlink20.GIMBAL_AXIS_CALIBRATION_STATUS_ENUM_END = 3 // 
+
+// GIMBAL_AXIS_CALIBRATION_REQUIRED
+mavlink20.GIMBAL_AXIS_CALIBRATION_REQUIRED_UNKNOWN = 0 // Whether or not this axis requires calibration is unknown at this time.
+mavlink20.GIMBAL_AXIS_CALIBRATION_REQUIRED_TRUE = 1 // This axis requires calibration.
+mavlink20.GIMBAL_AXIS_CALIBRATION_REQUIRED_FALSE = 2 // This axis does not require calibration.
+mavlink20.GIMBAL_AXIS_CALIBRATION_REQUIRED_ENUM_END = 3 // 
+
+// GOPRO_HEARTBEAT_STATUS
+mavlink20.GOPRO_HEARTBEAT_STATUS_DISCONNECTED = 0 // No GoPro connected.
+mavlink20.GOPRO_HEARTBEAT_STATUS_INCOMPATIBLE = 1 // The detected GoPro is not HeroBus compatible.
+mavlink20.GOPRO_HEARTBEAT_STATUS_CONNECTED = 2 // A HeroBus compatible GoPro is connected.
+mavlink20.GOPRO_HEARTBEAT_STATUS_ERROR = 3 // An unrecoverable error was encountered with the connected GoPro, it
+                        // may require a power cycle.
+mavlink20.GOPRO_HEARTBEAT_STATUS_ENUM_END = 4 // 
+
+// GOPRO_HEARTBEAT_FLAGS
+mavlink20.GOPRO_FLAG_RECORDING = 1 // GoPro is currently recording.
+mavlink20.GOPRO_HEARTBEAT_FLAGS_ENUM_END = 2 // 
+
+// GOPRO_REQUEST_STATUS
+mavlink20.GOPRO_REQUEST_SUCCESS = 0 // The write message with ID indicated succeeded.
+mavlink20.GOPRO_REQUEST_FAILED = 1 // The write message with ID indicated failed.
+mavlink20.GOPRO_REQUEST_STATUS_ENUM_END = 2 // 
+
+// GOPRO_COMMAND
+mavlink20.GOPRO_COMMAND_POWER = 0 // (Get/Set).
+mavlink20.GOPRO_COMMAND_CAPTURE_MODE = 1 // (Get/Set).
+mavlink20.GOPRO_COMMAND_SHUTTER = 2 // (___/Set).
+mavlink20.GOPRO_COMMAND_BATTERY = 3 // (Get/___).
+mavlink20.GOPRO_COMMAND_MODEL = 4 // (Get/___).
+mavlink20.GOPRO_COMMAND_VIDEO_SETTINGS = 5 // (Get/Set).
+mavlink20.GOPRO_COMMAND_LOW_LIGHT = 6 // (Get/Set).
+mavlink20.GOPRO_COMMAND_PHOTO_RESOLUTION = 7 // (Get/Set).
+mavlink20.GOPRO_COMMAND_PHOTO_BURST_RATE = 8 // (Get/Set).
+mavlink20.GOPRO_COMMAND_PROTUNE = 9 // (Get/Set).
+mavlink20.GOPRO_COMMAND_PROTUNE_WHITE_BALANCE = 10 // (Get/Set) Hero 3+ Only.
+mavlink20.GOPRO_COMMAND_PROTUNE_COLOUR = 11 // (Get/Set) Hero 3+ Only.
+mavlink20.GOPRO_COMMAND_PROTUNE_GAIN = 12 // (Get/Set) Hero 3+ Only.
+mavlink20.GOPRO_COMMAND_PROTUNE_SHARPNESS = 13 // (Get/Set) Hero 3+ Only.
+mavlink20.GOPRO_COMMAND_PROTUNE_EXPOSURE = 14 // (Get/Set) Hero 3+ Only.
+mavlink20.GOPRO_COMMAND_TIME = 15 // (Get/Set).
+mavlink20.GOPRO_COMMAND_CHARGING = 16 // (Get/Set).
+mavlink20.GOPRO_COMMAND_ENUM_END = 17 // 
+
+// GOPRO_CAPTURE_MODE
+mavlink20.GOPRO_CAPTURE_MODE_VIDEO = 0 // Video mode.
+mavlink20.GOPRO_CAPTURE_MODE_PHOTO = 1 // Photo mode.
+mavlink20.GOPRO_CAPTURE_MODE_BURST = 2 // Burst mode, Hero 3+ only.
+mavlink20.GOPRO_CAPTURE_MODE_TIME_LAPSE = 3 // Time lapse mode, Hero 3+ only.
+mavlink20.GOPRO_CAPTURE_MODE_MULTI_SHOT = 4 // Multi shot mode, Hero 4 only.
+mavlink20.GOPRO_CAPTURE_MODE_PLAYBACK = 5 // Playback mode, Hero 4 only, silver only except when LCD or HDMI is
+                        // connected to black.
+mavlink20.GOPRO_CAPTURE_MODE_SETUP = 6 // Playback mode, Hero 4 only.
+mavlink20.GOPRO_CAPTURE_MODE_UNKNOWN = 255 // Mode not yet known.
+mavlink20.GOPRO_CAPTURE_MODE_ENUM_END = 256 // 
+
+// GOPRO_RESOLUTION
+mavlink20.GOPRO_RESOLUTION_480p = 0 // 848 x 480 (480p).
+mavlink20.GOPRO_RESOLUTION_720p = 1 // 1280 x 720 (720p).
+mavlink20.GOPRO_RESOLUTION_960p = 2 // 1280 x 960 (960p).
+mavlink20.GOPRO_RESOLUTION_1080p = 3 // 1920 x 1080 (1080p).
+mavlink20.GOPRO_RESOLUTION_1440p = 4 // 1920 x 1440 (1440p).
+mavlink20.GOPRO_RESOLUTION_2_7k_17_9 = 5 // 2704 x 1440 (2.7k-17:9).
+mavlink20.GOPRO_RESOLUTION_2_7k_16_9 = 6 // 2704 x 1524 (2.7k-16:9).
+mavlink20.GOPRO_RESOLUTION_2_7k_4_3 = 7 // 2704 x 2028 (2.7k-4:3).
+mavlink20.GOPRO_RESOLUTION_4k_16_9 = 8 // 3840 x 2160 (4k-16:9).
+mavlink20.GOPRO_RESOLUTION_4k_17_9 = 9 // 4096 x 2160 (4k-17:9).
+mavlink20.GOPRO_RESOLUTION_720p_SUPERVIEW = 10 // 1280 x 720 (720p-SuperView).
+mavlink20.GOPRO_RESOLUTION_1080p_SUPERVIEW = 11 // 1920 x 1080 (1080p-SuperView).
+mavlink20.GOPRO_RESOLUTION_2_7k_SUPERVIEW = 12 // 2704 x 1520 (2.7k-SuperView).
+mavlink20.GOPRO_RESOLUTION_4k_SUPERVIEW = 13 // 3840 x 2160 (4k-SuperView).
+mavlink20.GOPRO_RESOLUTION_ENUM_END = 14 // 
+
+// GOPRO_FRAME_RATE
+mavlink20.GOPRO_FRAME_RATE_12 = 0 // 12 FPS.
+mavlink20.GOPRO_FRAME_RATE_15 = 1 // 15 FPS.
+mavlink20.GOPRO_FRAME_RATE_24 = 2 // 24 FPS.
+mavlink20.GOPRO_FRAME_RATE_25 = 3 // 25 FPS.
+mavlink20.GOPRO_FRAME_RATE_30 = 4 // 30 FPS.
+mavlink20.GOPRO_FRAME_RATE_48 = 5 // 48 FPS.
+mavlink20.GOPRO_FRAME_RATE_50 = 6 // 50 FPS.
+mavlink20.GOPRO_FRAME_RATE_60 = 7 // 60 FPS.
+mavlink20.GOPRO_FRAME_RATE_80 = 8 // 80 FPS.
+mavlink20.GOPRO_FRAME_RATE_90 = 9 // 90 FPS.
+mavlink20.GOPRO_FRAME_RATE_100 = 10 // 100 FPS.
+mavlink20.GOPRO_FRAME_RATE_120 = 11 // 120 FPS.
+mavlink20.GOPRO_FRAME_RATE_240 = 12 // 240 FPS.
+mavlink20.GOPRO_FRAME_RATE_12_5 = 13 // 12.5 FPS.
+mavlink20.GOPRO_FRAME_RATE_ENUM_END = 14 // 
+
+// GOPRO_FIELD_OF_VIEW
+mavlink20.GOPRO_FIELD_OF_VIEW_WIDE = 0 // 0x00: Wide.
+mavlink20.GOPRO_FIELD_OF_VIEW_MEDIUM = 1 // 0x01: Medium.
+mavlink20.GOPRO_FIELD_OF_VIEW_NARROW = 2 // 0x02: Narrow.
+mavlink20.GOPRO_FIELD_OF_VIEW_ENUM_END = 3 // 
+
+// GOPRO_VIDEO_SETTINGS_FLAGS
+mavlink20.GOPRO_VIDEO_SETTINGS_TV_MODE = 1 // 0=NTSC, 1=PAL.
+mavlink20.GOPRO_VIDEO_SETTINGS_FLAGS_ENUM_END = 2 // 
+
+// GOPRO_PHOTO_RESOLUTION
+mavlink20.GOPRO_PHOTO_RESOLUTION_5MP_MEDIUM = 0 // 5MP Medium.
+mavlink20.GOPRO_PHOTO_RESOLUTION_7MP_MEDIUM = 1 // 7MP Medium.
+mavlink20.GOPRO_PHOTO_RESOLUTION_7MP_WIDE = 2 // 7MP Wide.
+mavlink20.GOPRO_PHOTO_RESOLUTION_10MP_WIDE = 3 // 10MP Wide.
+mavlink20.GOPRO_PHOTO_RESOLUTION_12MP_WIDE = 4 // 12MP Wide.
+mavlink20.GOPRO_PHOTO_RESOLUTION_ENUM_END = 5 // 
+
+// GOPRO_PROTUNE_WHITE_BALANCE
+mavlink20.GOPRO_PROTUNE_WHITE_BALANCE_AUTO = 0 // Auto.
+mavlink20.GOPRO_PROTUNE_WHITE_BALANCE_3000K = 1 // 3000K.
+mavlink20.GOPRO_PROTUNE_WHITE_BALANCE_5500K = 2 // 5500K.
+mavlink20.GOPRO_PROTUNE_WHITE_BALANCE_6500K = 3 // 6500K.
+mavlink20.GOPRO_PROTUNE_WHITE_BALANCE_RAW = 4 // Camera Raw.
+mavlink20.GOPRO_PROTUNE_WHITE_BALANCE_ENUM_END = 5 // 
+
+// GOPRO_PROTUNE_COLOUR
+mavlink20.GOPRO_PROTUNE_COLOUR_STANDARD = 0 // Auto.
+mavlink20.GOPRO_PROTUNE_COLOUR_NEUTRAL = 1 // Neutral.
+mavlink20.GOPRO_PROTUNE_COLOUR_ENUM_END = 2 // 
+
+// GOPRO_PROTUNE_GAIN
+mavlink20.GOPRO_PROTUNE_GAIN_400 = 0 // ISO 400.
+mavlink20.GOPRO_PROTUNE_GAIN_800 = 1 // ISO 800 (Only Hero 4).
+mavlink20.GOPRO_PROTUNE_GAIN_1600 = 2 // ISO 1600.
+mavlink20.GOPRO_PROTUNE_GAIN_3200 = 3 // ISO 3200 (Only Hero 4).
+mavlink20.GOPRO_PROTUNE_GAIN_6400 = 4 // ISO 6400.
+mavlink20.GOPRO_PROTUNE_GAIN_ENUM_END = 5 // 
+
+// GOPRO_PROTUNE_SHARPNESS
+mavlink20.GOPRO_PROTUNE_SHARPNESS_LOW = 0 // Low Sharpness.
+mavlink20.GOPRO_PROTUNE_SHARPNESS_MEDIUM = 1 // Medium Sharpness.
+mavlink20.GOPRO_PROTUNE_SHARPNESS_HIGH = 2 // High Sharpness.
+mavlink20.GOPRO_PROTUNE_SHARPNESS_ENUM_END = 3 // 
+
+// GOPRO_PROTUNE_EXPOSURE
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_5_0 = 0 // -5.0 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_4_5 = 1 // -4.5 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_4_0 = 2 // -4.0 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_3_5 = 3 // -3.5 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_3_0 = 4 // -3.0 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_2_5 = 5 // -2.5 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_2_0 = 6 // -2.0 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_1_5 = 7 // -1.5 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_1_0 = 8 // -1.0 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_NEG_0_5 = 9 // -0.5 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_ZERO = 10 // 0.0 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_0_5 = 11 // +0.5 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_1_0 = 12 // +1.0 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_1_5 = 13 // +1.5 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_2_0 = 14 // +2.0 EV.
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_2_5 = 15 // +2.5 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_3_0 = 16 // +3.0 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_3_5 = 17 // +3.5 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_4_0 = 18 // +4.0 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_4_5 = 19 // +4.5 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_POS_5_0 = 20 // +5.0 EV (Hero 3+ Only).
+mavlink20.GOPRO_PROTUNE_EXPOSURE_ENUM_END = 21 // 
+
+// GOPRO_CHARGING
+mavlink20.GOPRO_CHARGING_DISABLED = 0 // Charging disabled.
+mavlink20.GOPRO_CHARGING_ENABLED = 1 // Charging enabled.
+mavlink20.GOPRO_CHARGING_ENUM_END = 2 // 
+
+// GOPRO_MODEL
+mavlink20.GOPRO_MODEL_UNKNOWN = 0 // Unknown gopro model.
+mavlink20.GOPRO_MODEL_HERO_3_PLUS_SILVER = 1 // Hero 3+ Silver (HeroBus not supported by GoPro).
+mavlink20.GOPRO_MODEL_HERO_3_PLUS_BLACK = 2 // Hero 3+ Black.
+mavlink20.GOPRO_MODEL_HERO_4_SILVER = 3 // Hero 4 Silver.
+mavlink20.GOPRO_MODEL_HERO_4_BLACK = 4 // Hero 4 Black.
+mavlink20.GOPRO_MODEL_ENUM_END = 5 // 
+
+// GOPRO_BURST_RATE
+mavlink20.GOPRO_BURST_RATE_3_IN_1_SECOND = 0 // 3 Shots / 1 Second.
+mavlink20.GOPRO_BURST_RATE_5_IN_1_SECOND = 1 // 5 Shots / 1 Second.
+mavlink20.GOPRO_BURST_RATE_10_IN_1_SECOND = 2 // 10 Shots / 1 Second.
+mavlink20.GOPRO_BURST_RATE_10_IN_2_SECOND = 3 // 10 Shots / 2 Second.
+mavlink20.GOPRO_BURST_RATE_10_IN_3_SECOND = 4 // 10 Shots / 3 Second (Hero 4 Only).
+mavlink20.GOPRO_BURST_RATE_30_IN_1_SECOND = 5 // 30 Shots / 1 Second.
+mavlink20.GOPRO_BURST_RATE_30_IN_2_SECOND = 6 // 30 Shots / 2 Second.
+mavlink20.GOPRO_BURST_RATE_30_IN_3_SECOND = 7 // 30 Shots / 3 Second.
+mavlink20.GOPRO_BURST_RATE_30_IN_6_SECOND = 8 // 30 Shots / 6 Second.
+mavlink20.GOPRO_BURST_RATE_ENUM_END = 9 // 
+
+// MAV_CMD_DO_AUX_FUNCTION_SWITCH_LEVEL
+mavlink20.MAV_CMD_DO_AUX_FUNCTION_SWITCH_LEVEL_LOW = 0 // Switch Low.
+mavlink20.MAV_CMD_DO_AUX_FUNCTION_SWITCH_LEVEL_MIDDLE = 1 // Switch Middle.
+mavlink20.MAV_CMD_DO_AUX_FUNCTION_SWITCH_LEVEL_HIGH = 2 // Switch High.
+mavlink20.MAV_CMD_DO_AUX_FUNCTION_SWITCH_LEVEL_ENUM_END = 3 // 
+
+// LED_CONTROL_PATTERN
+mavlink20.LED_CONTROL_PATTERN_OFF = 0 // LED patterns off (return control to regular vehicle control).
+mavlink20.LED_CONTROL_PATTERN_FIRMWAREUPDATE = 1 // LEDs show pattern during firmware update.
+mavlink20.LED_CONTROL_PATTERN_CUSTOM = 255 // Custom Pattern using custom bytes fields.
+mavlink20.LED_CONTROL_PATTERN_ENUM_END = 256 // 
+
+// EKF_STATUS_FLAGS
+mavlink20.EKF_ATTITUDE = 1 // Set if EKF's attitude estimate is good.
+mavlink20.EKF_VELOCITY_HORIZ = 2 // Set if EKF's horizontal velocity estimate is good.
+mavlink20.EKF_VELOCITY_VERT = 4 // Set if EKF's vertical velocity estimate is good.
+mavlink20.EKF_POS_HORIZ_REL = 8 // Set if EKF's horizontal position (relative) estimate is good.
+mavlink20.EKF_POS_HORIZ_ABS = 16 // Set if EKF's horizontal position (absolute) estimate is good.
+mavlink20.EKF_POS_VERT_ABS = 32 // Set if EKF's vertical position (absolute) estimate is good.
+mavlink20.EKF_POS_VERT_AGL = 64 // Set if EKF's vertical position (above ground) estimate is good.
+mavlink20.EKF_CONST_POS_MODE = 128 // EKF is in constant position mode and does not know it's absolute or
+                        // relative position.
+mavlink20.EKF_PRED_POS_HORIZ_REL = 256 // Set if EKF's predicted horizontal position (relative) estimate is
+                        // good.
+mavlink20.EKF_PRED_POS_HORIZ_ABS = 512 // Set if EKF's predicted horizontal position (absolute) estimate is
+                        // good.
+mavlink20.EKF_UNINITIALIZED = 1024 // Set if EKF has never been healthy.
+mavlink20.EKF_GPS_GLITCHING = 32768 // Set if EKF believes the GPS input data is faulty.
+mavlink20.EKF_STATUS_FLAGS_ENUM_END = 32769 // 
+
+// PID_TUNING_AXIS
+mavlink20.PID_TUNING_ROLL = 1 // 
+mavlink20.PID_TUNING_PITCH = 2 // 
+mavlink20.PID_TUNING_YAW = 3 // 
+mavlink20.PID_TUNING_ACCZ = 4 // 
+mavlink20.PID_TUNING_STEER = 5 // 
+mavlink20.PID_TUNING_LANDING = 6 // 
+mavlink20.PID_TUNING_AXIS_ENUM_END = 7 // 
+
+// MAV_REMOTE_LOG_DATA_BLOCK_COMMANDS
+mavlink20.MAV_REMOTE_LOG_DATA_BLOCK_STOP = 2147483645 // UAV to stop sending DataFlash blocks.
+mavlink20.MAV_REMOTE_LOG_DATA_BLOCK_START = 2147483646 // UAV to start sending DataFlash blocks.
+mavlink20.MAV_REMOTE_LOG_DATA_BLOCK_COMMANDS_ENUM_END = 2147483647 // 
+
+// MAV_REMOTE_LOG_DATA_BLOCK_STATUSES
+mavlink20.MAV_REMOTE_LOG_DATA_BLOCK_NACK = 0 // This block has NOT been received.
+mavlink20.MAV_REMOTE_LOG_DATA_BLOCK_ACK = 1 // This block has been received.
+mavlink20.MAV_REMOTE_LOG_DATA_BLOCK_STATUSES_ENUM_END = 2 // 
+
+// DEVICE_OP_BUSTYPE
+mavlink20.DEVICE_OP_BUSTYPE_I2C = 0 // I2C Device operation.
+mavlink20.DEVICE_OP_BUSTYPE_SPI = 1 // SPI Device operation.
+mavlink20.DEVICE_OP_BUSTYPE_ENUM_END = 2 // 
+
+// DEEPSTALL_STAGE
+mavlink20.DEEPSTALL_STAGE_FLY_TO_LANDING = 0 // Flying to the landing point.
+mavlink20.DEEPSTALL_STAGE_ESTIMATE_WIND = 1 // Building an estimate of the wind.
+mavlink20.DEEPSTALL_STAGE_WAIT_FOR_BREAKOUT = 2 // Waiting to breakout of the loiter to fly the approach.
+mavlink20.DEEPSTALL_STAGE_FLY_TO_ARC = 3 // Flying to the first arc point to turn around to the landing point.
+mavlink20.DEEPSTALL_STAGE_ARC = 4 // Turning around back to the deepstall landing point.
+mavlink20.DEEPSTALL_STAGE_APPROACH = 5 // Approaching the landing point.
+mavlink20.DEEPSTALL_STAGE_LAND = 6 // Stalling and steering towards the land point.
+mavlink20.DEEPSTALL_STAGE_ENUM_END = 7 // 
+
+// PLANE_MODE
+mavlink20.PLANE_MODE_MANUAL = 0 // MANUAL
+mavlink20.PLANE_MODE_CIRCLE = 1 // CIRCLE
+mavlink20.PLANE_MODE_STABILIZE = 2 // STABILIZE
+mavlink20.PLANE_MODE_TRAINING = 3 // TRAINING
+mavlink20.PLANE_MODE_ACRO = 4 // ACRO
+mavlink20.PLANE_MODE_FLY_BY_WIRE_A = 5 // FBWA
+mavlink20.PLANE_MODE_FLY_BY_WIRE_B = 6 // FBWB
+mavlink20.PLANE_MODE_CRUISE = 7 // CRUISE
+mavlink20.PLANE_MODE_AUTOTUNE = 8 // AUTOTUNE
+mavlink20.PLANE_MODE_AUTO = 10 // AUTO
+mavlink20.PLANE_MODE_RTL = 11 // RTL
+mavlink20.PLANE_MODE_LOITER = 12 // LOITER
+mavlink20.PLANE_MODE_TAKEOFF = 13 // TAKEOFF
+mavlink20.PLANE_MODE_AVOID_ADSB = 14 // AVOID ADSB
+mavlink20.PLANE_MODE_GUIDED = 15 // GUIDED
+mavlink20.PLANE_MODE_INITIALIZING = 16 // INITIALISING
+mavlink20.PLANE_MODE_QSTABILIZE = 17 // QSTABILIZE
+mavlink20.PLANE_MODE_QHOVER = 18 // QHOVER
+mavlink20.PLANE_MODE_QLOITER = 19 // QLOITER
+mavlink20.PLANE_MODE_QLAND = 20 // QLAND
+mavlink20.PLANE_MODE_QRTL = 21 // QRTL
+mavlink20.PLANE_MODE_QAUTOTUNE = 22 // QAUTOTUNE
+mavlink20.PLANE_MODE_QACRO = 23 // QACRO
+mavlink20.PLANE_MODE_THERMAL = 24 // THERMAL
+mavlink20.PLANE_MODE_LOITER_ALT_QLAND = 25 // LOITER2QLAND
+mavlink20.PLANE_MODE_AUTOLAND = 26 // AUTOLAND
+mavlink20.PLANE_MODE_ENUM_END = 27 // 
+
+// COPTER_MODE
+mavlink20.COPTER_MODE_STABILIZE = 0 // STABILIZE
+mavlink20.COPTER_MODE_ACRO = 1 // ACRO
+mavlink20.COPTER_MODE_ALT_HOLD = 2 // ALT HOLD
+mavlink20.COPTER_MODE_AUTO = 3 // AUTO
+mavlink20.COPTER_MODE_GUIDED = 4 // GUIDED
+mavlink20.COPTER_MODE_LOITER = 5 // LOITER
+mavlink20.COPTER_MODE_RTL = 6 // RTL
+mavlink20.COPTER_MODE_CIRCLE = 7 // CIRCLE
+mavlink20.COPTER_MODE_LAND = 9 // LAND
+mavlink20.COPTER_MODE_DRIFT = 11 // DRIFT
+mavlink20.COPTER_MODE_SPORT = 13 // SPORT
+mavlink20.COPTER_MODE_FLIP = 14 // FLIP
+mavlink20.COPTER_MODE_AUTOTUNE = 15 // AUTOTUNE
+mavlink20.COPTER_MODE_POSHOLD = 16 // POSHOLD
+mavlink20.COPTER_MODE_BRAKE = 17 // BRAKE
+mavlink20.COPTER_MODE_THROW = 18 // THROW
+mavlink20.COPTER_MODE_AVOID_ADSB = 19 // AVOID ADSB
+mavlink20.COPTER_MODE_GUIDED_NOGPS = 20 // GUIDED NOGPS
+mavlink20.COPTER_MODE_SMART_RTL = 21 // SMARTRTL
+mavlink20.COPTER_MODE_FLOWHOLD = 22 // FLOWHOLD
+mavlink20.COPTER_MODE_FOLLOW = 23 // FOLLOW
+mavlink20.COPTER_MODE_ZIGZAG = 24 // ZIGZAG
+mavlink20.COPTER_MODE_SYSTEMID = 25 // SYSTEMID
+mavlink20.COPTER_MODE_AUTOROTATE = 26 // AUTOROTATE
+mavlink20.COPTER_MODE_AUTO_RTL = 27 // AUTO RTL
+mavlink20.COPTER_MODE_TURTLE = 28 // TURTLE
+mavlink20.COPTER_MODE_ENUM_END = 29 // 
+
+// SUB_MODE
+mavlink20.SUB_MODE_STABILIZE = 0 // STABILIZE
+mavlink20.SUB_MODE_ACRO = 1 // ACRO
+mavlink20.SUB_MODE_ALT_HOLD = 2 // ALT HOLD
+mavlink20.SUB_MODE_AUTO = 3 // AUTO
+mavlink20.SUB_MODE_GUIDED = 4 // GUIDED
+mavlink20.SUB_MODE_CIRCLE = 7 // CIRCLE
+mavlink20.SUB_MODE_SURFACE = 9 // SURFACE
+mavlink20.SUB_MODE_POSHOLD = 16 // POSHOLD
+mavlink20.SUB_MODE_MANUAL = 19 // MANUAL
+mavlink20.SUB_MODE_MOTORDETECT = 20 // MOTORDETECT
+mavlink20.SUB_MODE_SURFTRAK = 21 // SURFTRAK
+mavlink20.SUB_MODE_ENUM_END = 22 // 
+
+// ROVER_MODE
+mavlink20.ROVER_MODE_MANUAL = 0 // MANUAL
+mavlink20.ROVER_MODE_ACRO = 1 // ACRO
+mavlink20.ROVER_MODE_STEERING = 3 // STEERING
+mavlink20.ROVER_MODE_HOLD = 4 // HOLD
+mavlink20.ROVER_MODE_LOITER = 5 // LOITER
+mavlink20.ROVER_MODE_FOLLOW = 6 // FOLLOW
+mavlink20.ROVER_MODE_SIMPLE = 7 // SIMPLE
+mavlink20.ROVER_MODE_DOCK = 8 // DOCK
+mavlink20.ROVER_MODE_CIRCLE = 9 // CIRCLE
+mavlink20.ROVER_MODE_AUTO = 10 // AUTO
+mavlink20.ROVER_MODE_RTL = 11 // RTL
+mavlink20.ROVER_MODE_SMART_RTL = 12 // SMART RTL
+mavlink20.ROVER_MODE_GUIDED = 15 // GUIDED
+mavlink20.ROVER_MODE_INITIALIZING = 16 // INITIALISING
+mavlink20.ROVER_MODE_ENUM_END = 17 // 
+
+// TRACKER_MODE
+mavlink20.TRACKER_MODE_MANUAL = 0 // MANUAL
+mavlink20.TRACKER_MODE_STOP = 1 // STOP
+mavlink20.TRACKER_MODE_SCAN = 2 // SCAN
+mavlink20.TRACKER_MODE_SERVO_TEST = 3 // SERVO TEST
+mavlink20.TRACKER_MODE_GUIDED = 4 // GUIDED
+mavlink20.TRACKER_MODE_AUTO = 10 // AUTO
+mavlink20.TRACKER_MODE_INITIALIZING = 16 // INITIALISING
+mavlink20.TRACKER_MODE_ENUM_END = 17 // 
+
+// OSD_PARAM_CONFIG_TYPE
+mavlink20.OSD_PARAM_NONE = 0 // 
+mavlink20.OSD_PARAM_SERIAL_PROTOCOL = 1 // 
+mavlink20.OSD_PARAM_SERVO_FUNCTION = 2 // 
+mavlink20.OSD_PARAM_AUX_FUNCTION = 3 // 
+mavlink20.OSD_PARAM_FLIGHT_MODE = 4 // 
+mavlink20.OSD_PARAM_FAILSAFE_ACTION = 5 // 
+mavlink20.OSD_PARAM_FAILSAFE_ACTION_1 = 6 // 
+mavlink20.OSD_PARAM_FAILSAFE_ACTION_2 = 7 // 
+mavlink20.OSD_PARAM_NUM_TYPES = 8 // 
+mavlink20.OSD_PARAM_CONFIG_TYPE_ENUM_END = 9 // 
+
+// OSD_PARAM_CONFIG_ERROR
+mavlink20.OSD_PARAM_SUCCESS = 0 // 
+mavlink20.OSD_PARAM_INVALID_SCREEN = 1 // 
+mavlink20.OSD_PARAM_INVALID_PARAMETER_INDEX = 2 // 
+mavlink20.OSD_PARAM_INVALID_PARAMETER = 3 // 
+mavlink20.OSD_PARAM_CONFIG_ERROR_ENUM_END = 4 // 
+
+// GSM_LINK_TYPE
+mavlink20.GSM_LINK_TYPE_NONE = 0 // no service
+mavlink20.GSM_LINK_TYPE_UNKNOWN = 1 // link type unknown
+mavlink20.GSM_LINK_TYPE_2G = 2 // 2G (GSM/GRPS/EDGE) link
+mavlink20.GSM_LINK_TYPE_3G = 3 // 3G link (WCDMA/HSDPA/HSPA)
+mavlink20.GSM_LINK_TYPE_4G = 4 // 4G link (LTE)
+mavlink20.GSM_LINK_TYPE_ENUM_END = 5 // 
+
+// GSM_MODEM_TYPE
+mavlink20.GSM_MODEM_TYPE_UNKNOWN = 0 // not specified
+mavlink20.GSM_MODEM_TYPE_HUAWEI_E3372 = 1 // HUAWEI LTE USB Stick E3372
+mavlink20.GSM_MODEM_TYPE_ENUM_END = 2 // 
+
+// FIRMWARE_VERSION_TYPE
+mavlink20.FIRMWARE_VERSION_TYPE_DEV = 0 // development release
+mavlink20.FIRMWARE_VERSION_TYPE_ALPHA = 64 // alpha release
+mavlink20.FIRMWARE_VERSION_TYPE_BETA = 128 // beta release
+mavlink20.FIRMWARE_VERSION_TYPE_RC = 192 // release candidate
+mavlink20.FIRMWARE_VERSION_TYPE_OFFICIAL = 255 // official stable release
+mavlink20.FIRMWARE_VERSION_TYPE_ENUM_END = 256 // 
+
+// HL_FAILURE_FLAG
+mavlink20.HL_FAILURE_FLAG_GPS = 1 // GPS failure.
+mavlink20.HL_FAILURE_FLAG_DIFFERENTIAL_PRESSURE = 2 // Differential pressure sensor failure.
+mavlink20.HL_FAILURE_FLAG_ABSOLUTE_PRESSURE = 4 // Absolute pressure sensor failure.
+mavlink20.HL_FAILURE_FLAG_3D_ACCEL = 8 // Accelerometer sensor failure.
+mavlink20.HL_FAILURE_FLAG_3D_GYRO = 16 // Gyroscope sensor failure.
+mavlink20.HL_FAILURE_FLAG_3D_MAG = 32 // Magnetometer sensor failure.
+mavlink20.HL_FAILURE_FLAG_TERRAIN = 64 // Terrain subsystem failure.
+mavlink20.HL_FAILURE_FLAG_BATTERY = 128 // Battery failure/critical low battery.
+mavlink20.HL_FAILURE_FLAG_RC_RECEIVER = 256 // RC receiver failure/no RC connection.
+mavlink20.HL_FAILURE_FLAG_OFFBOARD_LINK = 512 // Offboard link failure.
+mavlink20.HL_FAILURE_FLAG_ENGINE = 1024 // Engine failure.
+mavlink20.HL_FAILURE_FLAG_GEOFENCE = 2048 // Geofence violation.
+mavlink20.HL_FAILURE_FLAG_ESTIMATOR = 4096 // Estimator failure, for example measurement rejection or large
+                        // variances.
+mavlink20.HL_FAILURE_FLAG_MISSION = 8192 // Mission failure.
+mavlink20.HL_FAILURE_FLAG_ENUM_END = 8193 // 
+
+// MAV_GOTO
+mavlink20.MAV_GOTO_DO_HOLD = 0 // Hold at the current position.
+mavlink20.MAV_GOTO_DO_CONTINUE = 1 // Continue with the next item in mission execution.
+mavlink20.MAV_GOTO_HOLD_AT_CURRENT_POSITION = 2 // Hold at the current position of the system
+mavlink20.MAV_GOTO_HOLD_AT_SPECIFIED_POSITION = 3 // Hold at the position specified in the parameters of the DO_HOLD action
+mavlink20.MAV_GOTO_ENUM_END = 4 // 
+
+// MAV_MODE
+mavlink20.MAV_MODE_PREFLIGHT = 0 // System is not ready to fly, booting, calibrating, etc. No flag is set.
+mavlink20.MAV_MODE_MANUAL_DISARMED = 64 // System is allowed to be active, under manual (RC) control, no
+                        // stabilization
+mavlink20.MAV_MODE_TEST_DISARMED = 66 // UNDEFINED mode. This solely depends on the autopilot - use with
+                        // caution, intended for developers only.
+mavlink20.MAV_MODE_STABILIZE_DISARMED = 80 // System is allowed to be active, under assisted RC control.
+mavlink20.MAV_MODE_GUIDED_DISARMED = 88 // System is allowed to be active, under autonomous control, manual
+                        // setpoint
+mavlink20.MAV_MODE_AUTO_DISARMED = 92 // System is allowed to be active, under autonomous control and
+                        // navigation (the trajectory is decided
+                        // onboard and not pre-programmed by
+                        // waypoints)
+mavlink20.MAV_MODE_MANUAL_ARMED = 192 // System is allowed to be active, under manual (RC) control, no
+                        // stabilization
+mavlink20.MAV_MODE_TEST_ARMED = 194 // UNDEFINED mode. This solely depends on the autopilot - use with
+                        // caution, intended for developers only.
+mavlink20.MAV_MODE_STABILIZE_ARMED = 208 // System is allowed to be active, under assisted RC control.
+mavlink20.MAV_MODE_GUIDED_ARMED = 216 // System is allowed to be active, under autonomous control, manual
+                        // setpoint
+mavlink20.MAV_MODE_AUTO_ARMED = 220 // System is allowed to be active, under autonomous control and
+                        // navigation (the trajectory is decided
+                        // onboard and not pre-programmed by
+                        // waypoints)
+mavlink20.MAV_MODE_ENUM_END = 221 // 
+
+// MAV_SYS_STATUS_SENSOR
+mavlink20.MAV_SYS_STATUS_SENSOR_3D_GYRO = 1 // 0x01 3D gyro
+mavlink20.MAV_SYS_STATUS_SENSOR_3D_ACCEL = 2 // 0x02 3D accelerometer
+mavlink20.MAV_SYS_STATUS_SENSOR_3D_MAG = 4 // 0x04 3D magnetometer
+mavlink20.MAV_SYS_STATUS_SENSOR_ABSOLUTE_PRESSURE = 8 // 0x08 absolute pressure
+mavlink20.MAV_SYS_STATUS_SENSOR_DIFFERENTIAL_PRESSURE = 16 // 0x10 differential pressure
+mavlink20.MAV_SYS_STATUS_SENSOR_GPS = 32 // 0x20 GPS
+mavlink20.MAV_SYS_STATUS_SENSOR_OPTICAL_FLOW = 64 // 0x40 optical flow
+mavlink20.MAV_SYS_STATUS_SENSOR_VISION_POSITION = 128 // 0x80 computer vision position
+mavlink20.MAV_SYS_STATUS_SENSOR_LASER_POSITION = 256 // 0x100 laser based position
+mavlink20.MAV_SYS_STATUS_SENSOR_EXTERNAL_GROUND_TRUTH = 512 // 0x200 external ground truth (Vicon or Leica)
+mavlink20.MAV_SYS_STATUS_SENSOR_ANGULAR_RATE_CONTROL = 1024 // 0x400 3D angular rate control
+mavlink20.MAV_SYS_STATUS_SENSOR_ATTITUDE_STABILIZATION = 2048 // 0x800 attitude stabilization
+mavlink20.MAV_SYS_STATUS_SENSOR_YAW_POSITION = 4096 // 0x1000 yaw position
+mavlink20.MAV_SYS_STATUS_SENSOR_Z_ALTITUDE_CONTROL = 8192 // 0x2000 z/altitude control
+mavlink20.MAV_SYS_STATUS_SENSOR_XY_POSITION_CONTROL = 16384 // 0x4000 x/y position control
+mavlink20.MAV_SYS_STATUS_SENSOR_MOTOR_OUTPUTS = 32768 // 0x8000 motor outputs / control
+mavlink20.MAV_SYS_STATUS_SENSOR_RC_RECEIVER = 65536 // 0x10000 RC receiver
+mavlink20.MAV_SYS_STATUS_SENSOR_3D_GYRO2 = 131072 // 0x20000 2nd 3D gyro
+mavlink20.MAV_SYS_STATUS_SENSOR_3D_ACCEL2 = 262144 // 0x40000 2nd 3D accelerometer
+mavlink20.MAV_SYS_STATUS_SENSOR_3D_MAG2 = 524288 // 0x80000 2nd 3D magnetometer
+mavlink20.MAV_SYS_STATUS_GEOFENCE = 1048576 // 0x100000 geofence
+mavlink20.MAV_SYS_STATUS_AHRS = 2097152 // 0x200000 AHRS subsystem health
+mavlink20.MAV_SYS_STATUS_TERRAIN = 4194304 // 0x400000 Terrain subsystem health
+mavlink20.MAV_SYS_STATUS_REVERSE_MOTOR = 8388608 // 0x800000 Motors are reversed
+mavlink20.MAV_SYS_STATUS_LOGGING = 16777216 // 0x1000000 Logging
+mavlink20.MAV_SYS_STATUS_SENSOR_BATTERY = 33554432 // 0x2000000 Battery
+mavlink20.MAV_SYS_STATUS_SENSOR_PROXIMITY = 67108864 // 0x4000000 Proximity
+mavlink20.MAV_SYS_STATUS_SENSOR_SATCOM = 134217728 // 0x8000000 Satellite Communication
+mavlink20.MAV_SYS_STATUS_PREARM_CHECK = 268435456 // 0x10000000 pre-arm check status. Always healthy when armed
+mavlink20.MAV_SYS_STATUS_OBSTACLE_AVOIDANCE = 536870912 // 0x20000000 Avoidance/collision prevention
+mavlink20.MAV_SYS_STATUS_SENSOR_PROPULSION = 1073741824 // 0x40000000 propulsion (actuator, esc, motor or propellor)
+mavlink20.MAV_SYS_STATUS_SENSOR_ENUM_END = 1073741825 // 
+
+// MAV_FRAME
+mavlink20.MAV_FRAME_GLOBAL = 0 // Global (WGS84) coordinate frame + altitude relative to mean sea level
+                        // (MSL).
+mavlink20.MAV_FRAME_LOCAL_NED = 1 // NED local tangent frame (x: North, y: East, z: Down) with origin fixed
+                        // relative to earth.
+mavlink20.MAV_FRAME_MISSION = 2 // NOT a coordinate frame, indicates a mission command.
+mavlink20.MAV_FRAME_GLOBAL_RELATIVE_ALT = 3 //            Global (WGS84) coordinate frame + altitude relative to the
+                        // home position.
+mavlink20.MAV_FRAME_LOCAL_ENU = 4 // ENU local tangent frame (x: East, y: North, z: Up) with origin fixed
+                        // relative to earth.
+mavlink20.MAV_FRAME_GLOBAL_INT = 5 // Global (WGS84) coordinate frame (scaled) + altitude relative to mean
+                        // sea level (MSL).
+mavlink20.MAV_FRAME_GLOBAL_RELATIVE_ALT_INT = 6 // Global (WGS84) coordinate frame (scaled) + altitude relative to the
+                        // home position.
+mavlink20.MAV_FRAME_LOCAL_OFFSET_NED = 7 // NED local tangent frame (x: North, y: East, z: Down) with origin that
+                        // travels with the vehicle.
+mavlink20.MAV_FRAME_BODY_NED = 8 // Same as MAV_FRAME_LOCAL_NED when used to represent position values.
+                        // Same as MAV_FRAME_BODY_FRD when used with
+                        // velocity/acceleration values.
+mavlink20.MAV_FRAME_BODY_OFFSET_NED = 9 // This is the same as MAV_FRAME_BODY_FRD.
+mavlink20.MAV_FRAME_GLOBAL_TERRAIN_ALT = 10 // Global (WGS84) coordinate frame with AGL altitude (altitude at ground
+                        // level).
+mavlink20.MAV_FRAME_GLOBAL_TERRAIN_ALT_INT = 11 // Global (WGS84) coordinate frame (scaled) with AGL altitude (altitude
+                        // at ground level).
+mavlink20.MAV_FRAME_BODY_FRD = 12 // FRD local frame aligned to the vehicle's attitude (x: Forward, y:
+                        // Right, z: Down) with an origin that travels
+                        // with vehicle.
+mavlink20.MAV_FRAME_RESERVED_13 = 13 // MAV_FRAME_BODY_FLU - Body fixed frame of reference, Z-up (x: Forward,
+                        // y: Left, z: Up).
+mavlink20.MAV_FRAME_RESERVED_14 = 14 // MAV_FRAME_MOCAP_NED - Odometry local coordinate frame of data given by
+                        // a motion capture system, Z-down (x: North,
+                        // y: East, z: Down).
+mavlink20.MAV_FRAME_RESERVED_15 = 15 // MAV_FRAME_MOCAP_ENU - Odometry local coordinate frame of data given by
+                        // a motion capture system, Z-up (x: East, y:
+                        // North, z: Up).
+mavlink20.MAV_FRAME_RESERVED_16 = 16 // MAV_FRAME_VISION_NED - Odometry local coordinate frame of data given
+                        // by a vision estimation system, Z-down (x:
+                        // North, y: East, z: Down).
+mavlink20.MAV_FRAME_RESERVED_17 = 17 // MAV_FRAME_VISION_ENU - Odometry local coordinate frame of data given
+                        // by a vision estimation system, Z-up (x:
+                        // East, y: North, z: Up).
+mavlink20.MAV_FRAME_RESERVED_18 = 18 // MAV_FRAME_ESTIM_NED - Odometry local coordinate frame of data given by
+                        // an estimator running onboard the vehicle,
+                        // Z-down (x: North, y: East, z: Down).
+mavlink20.MAV_FRAME_RESERVED_19 = 19 // MAV_FRAME_ESTIM_ENU - Odometry local coordinate frame of data given by
+                        // an estimator running onboard the vehicle,
+                        // Z-up (x: East, y: North, z: Up).
+mavlink20.MAV_FRAME_LOCAL_FRD = 20 // FRD local tangent frame (x: Forward, y: Right, z: Down) with origin
+                        // fixed relative to earth. The forward axis
+                        // is aligned to the front of the vehicle in
+                        // the horizontal plane.
+mavlink20.MAV_FRAME_LOCAL_FLU = 21 // FLU local tangent frame (x: Forward, y: Left, z: Up) with origin fixed
+                        // relative to earth. The forward axis is
+                        // aligned to the front of the vehicle in the
+                        // horizontal plane.
+mavlink20.MAV_FRAME_ENUM_END = 22 // 
+
+// MAVLINK_DATA_STREAM_TYPE
+mavlink20.MAVLINK_DATA_STREAM_IMG_JPEG = 0 // 
+mavlink20.MAVLINK_DATA_STREAM_IMG_BMP = 1 // 
+mavlink20.MAVLINK_DATA_STREAM_IMG_RAW8U = 2 // 
+mavlink20.MAVLINK_DATA_STREAM_IMG_RAW32U = 3 // 
+mavlink20.MAVLINK_DATA_STREAM_IMG_PGM = 4 // 
+mavlink20.MAVLINK_DATA_STREAM_IMG_PNG = 5 // 
+mavlink20.MAVLINK_DATA_STREAM_TYPE_ENUM_END = 6 // 
+
+// FENCE_BREACH
+mavlink20.FENCE_BREACH_NONE = 0 // No last fence breach
+mavlink20.FENCE_BREACH_MINALT = 1 // Breached minimum altitude
+mavlink20.FENCE_BREACH_MAXALT = 2 // Breached maximum altitude
+mavlink20.FENCE_BREACH_BOUNDARY = 3 // Breached fence boundary
+mavlink20.FENCE_BREACH_ENUM_END = 4 // 
+
+// FENCE_MITIGATE
+mavlink20.FENCE_MITIGATE_UNKNOWN = 0 // Unknown
+mavlink20.FENCE_MITIGATE_NONE = 1 // No actions being taken
+mavlink20.FENCE_MITIGATE_VEL_LIMIT = 2 // Velocity limiting active to prevent breach
+mavlink20.FENCE_MITIGATE_ENUM_END = 3 // 
+
+// FENCE_TYPE
+mavlink20.FENCE_TYPE_ALT_MAX = 1 // Maximum altitude fence
+mavlink20.FENCE_TYPE_CIRCLE = 2 // Circle fence
+mavlink20.FENCE_TYPE_POLYGON = 4 // Polygon fence
+mavlink20.FENCE_TYPE_ALT_MIN = 8 // Minimum altitude fence
+mavlink20.FENCE_TYPE_ENUM_END = 9 // 
+
+// MAV_MOUNT_MODE
+mavlink20.MAV_MOUNT_MODE_RETRACT = 0 // Load and keep safe position (Roll,Pitch,Yaw) from permanent memory and
+                        // stop stabilization
+mavlink20.MAV_MOUNT_MODE_NEUTRAL = 1 // Load and keep neutral position (Roll,Pitch,Yaw) from permanent memory.
+mavlink20.MAV_MOUNT_MODE_MAVLINK_TARGETING = 2 // Load neutral position and start MAVLink Roll,Pitch,Yaw control with
+                        // stabilization
+mavlink20.MAV_MOUNT_MODE_RC_TARGETING = 3 // Load neutral position and start RC Roll,Pitch,Yaw control with
+                        // stabilization
+mavlink20.MAV_MOUNT_MODE_GPS_POINT = 4 // Load neutral position and start to point to Lat,Lon,Alt
+mavlink20.MAV_MOUNT_MODE_SYSID_TARGET = 5 // Gimbal tracks system with specified system ID
+mavlink20.MAV_MOUNT_MODE_HOME_LOCATION = 6 // Gimbal tracks home position
+mavlink20.MAV_MOUNT_MODE_ENUM_END = 7 // 
+
+// GIMBAL_DEVICE_CAP_FLAGS
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_RETRACT = 1 // Gimbal device supports a retracted position.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_NEUTRAL = 2 // Gimbal device supports a horizontal, forward looking position,
+                        // stabilized.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_ROLL_AXIS = 4 // Gimbal device supports rotating around roll axis.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_ROLL_FOLLOW = 8 // Gimbal device supports to follow a roll angle relative to the vehicle.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_ROLL_LOCK = 16 // Gimbal device supports locking to a roll angle (generally that's the
+                        // default with roll stabilized).
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_PITCH_AXIS = 32 // Gimbal device supports rotating around pitch axis.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_PITCH_FOLLOW = 64 // Gimbal device supports to follow a pitch angle relative to the
+                        // vehicle.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_PITCH_LOCK = 128 // Gimbal device supports locking to a pitch angle (generally that's the
+                        // default with pitch stabilized).
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_YAW_AXIS = 256 // Gimbal device supports rotating around yaw axis.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_YAW_FOLLOW = 512 // Gimbal device supports to follow a yaw angle relative to the vehicle
+                        // (generally that's the default).
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_YAW_LOCK = 1024 // Gimbal device supports locking to an absolute heading, i.e., yaw angle
+                        // relative to North (earth frame, often this
+                        // is an option available).
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_SUPPORTS_INFINITE_YAW = 2048 // Gimbal device supports yawing/panning infinitely (e.g. using slip
+                        // disk).
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_SUPPORTS_YAW_IN_EARTH_FRAME = 4096 // Gimbal device supports yaw angles and angular velocities relative to
+                        // North (earth frame). This usually requires
+                        // support by an autopilot via
+                        // AUTOPILOT_STATE_FOR_GIMBAL_DEVICE. Support
+                        // can go on and off during runtime, which is
+                        // reported by the flag GIMBAL_DEVICE_FLAGS_CA
+                        // N_ACCEPT_YAW_IN_EARTH_FRAME.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_HAS_RC_INPUTS = 8192 // Gimbal device supports radio control inputs as an alternative input
+                        // for controlling the gimbal orientation.
+mavlink20.GIMBAL_DEVICE_CAP_FLAGS_ENUM_END = 8193 // 
+
+// GIMBAL_MANAGER_CAP_FLAGS
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_RETRACT = 1 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_RETRACT.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_NEUTRAL = 2 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_NEUTRAL.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_ROLL_AXIS = 4 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_ROLL_AXIS.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_ROLL_FOLLOW = 8 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_ROLL_FOLLOW.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_ROLL_LOCK = 16 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_ROLL_LOCK.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_PITCH_AXIS = 32 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_PITCH_AXIS.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_PITCH_FOLLOW = 64 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_PITCH_FOLLOW.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_PITCH_LOCK = 128 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_PITCH_LOCK.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_YAW_AXIS = 256 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_YAW_AXIS.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_YAW_FOLLOW = 512 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_YAW_FOLLOW.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_YAW_LOCK = 1024 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_YAW_LOCK.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_SUPPORTS_INFINITE_YAW = 2048 // Based on GIMBAL_DEVICE_CAP_FLAGS_SUPPORTS_INFINITE_YAW.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_SUPPORTS_YAW_IN_EARTH_FRAME = 4096 // Based on GIMBAL_DEVICE_CAP_FLAGS_SUPPORTS_YAW_IN_EARTH_FRAME.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_HAS_RC_INPUTS = 8192 // Based on GIMBAL_DEVICE_CAP_FLAGS_HAS_RC_INPUTS.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_CAN_POINT_LOCATION_LOCAL = 65536 // Gimbal manager supports to point to a local position.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_CAN_POINT_LOCATION_GLOBAL = 131072 // Gimbal manager supports to point to a global latitude, longitude,
+                        // altitude position.
+mavlink20.GIMBAL_MANAGER_CAP_FLAGS_ENUM_END = 131073 // 
+
+// GIMBAL_DEVICE_FLAGS
+mavlink20.GIMBAL_DEVICE_FLAGS_RETRACT = 1 // Set to retracted safe position (no stabilization), takes precedence
+                        // over all other flags.
+mavlink20.GIMBAL_DEVICE_FLAGS_NEUTRAL = 2 // Set to neutral/default position, taking precedence over all other
+                        // flags except RETRACT. Neutral is commonly
+                        // forward-facing and horizontal
+                        // (roll=pitch=yaw=0) but may be any
+                        // orientation.
+mavlink20.GIMBAL_DEVICE_FLAGS_ROLL_LOCK = 4 // Lock roll angle to absolute angle relative to horizon (not relative to
+                        // vehicle). This is generally the default
+                        // with a stabilizing gimbal.
+mavlink20.GIMBAL_DEVICE_FLAGS_PITCH_LOCK = 8 // Lock pitch angle to absolute angle relative to horizon (not relative
+                        // to vehicle). This is generally the default
+                        // with a stabilizing gimbal.
+mavlink20.GIMBAL_DEVICE_FLAGS_YAW_LOCK = 16 // Lock yaw angle to absolute angle relative to North (not relative to
+                        // vehicle). If this flag is set, the yaw
+                        // angle and z component of angular velocity
+                        // are relative to North (earth frame, x-axis
+                        // pointing North), else they are relative to
+                        // the vehicle heading (vehicle frame, earth
+                        // frame rotated so that the x-axis is
+                        // pointing forward).
+mavlink20.GIMBAL_DEVICE_FLAGS_YAW_IN_VEHICLE_FRAME = 32 // Yaw angle and z component of angular velocity are relative to the
+                        // vehicle heading (vehicle frame, earth frame
+                        // rotated such that the x-axis is pointing
+                        // forward).
+mavlink20.GIMBAL_DEVICE_FLAGS_YAW_IN_EARTH_FRAME = 64 // Yaw angle and z component of angular velocity are relative to North
+                        // (earth frame, x-axis is pointing North).
+mavlink20.GIMBAL_DEVICE_FLAGS_ACCEPTS_YAW_IN_EARTH_FRAME = 128 // Gimbal device can accept yaw angle inputs relative to North (earth
+                        // frame). This flag is only for reporting
+                        // (attempts to set this flag are ignored).
+mavlink20.GIMBAL_DEVICE_FLAGS_RC_EXCLUSIVE = 256 // The gimbal orientation is set exclusively by the RC signals feed to
+                        // the gimbal's radio control inputs. MAVLink
+                        // messages for setting the gimbal orientation
+                        // (GIMBAL_DEVICE_SET_ATTITUDE) are ignored.
+mavlink20.GIMBAL_DEVICE_FLAGS_RC_MIXED = 512 // The gimbal orientation is determined by combining/mixing the RC
+                        // signals feed to the gimbal's radio control
+                        // inputs and the MAVLink messages for setting
+                        // the gimbal orientation
+                        // (GIMBAL_DEVICE_SET_ATTITUDE). How these two
+                        // controls are combined or mixed is not
+                        // defined by the protocol but is up to the
+                        // implementation.
+mavlink20.GIMBAL_DEVICE_FLAGS_ENUM_END = 513 // 
+
+// GIMBAL_MANAGER_FLAGS
+mavlink20.GIMBAL_MANAGER_FLAGS_RETRACT = 1 // Based on GIMBAL_DEVICE_FLAGS_RETRACT.
+mavlink20.GIMBAL_MANAGER_FLAGS_NEUTRAL = 2 // Based on GIMBAL_DEVICE_FLAGS_NEUTRAL.
+mavlink20.GIMBAL_MANAGER_FLAGS_ROLL_LOCK = 4 // Based on GIMBAL_DEVICE_FLAGS_ROLL_LOCK.
+mavlink20.GIMBAL_MANAGER_FLAGS_PITCH_LOCK = 8 // Based on GIMBAL_DEVICE_FLAGS_PITCH_LOCK.
+mavlink20.GIMBAL_MANAGER_FLAGS_YAW_LOCK = 16 // Based on GIMBAL_DEVICE_FLAGS_YAW_LOCK.
+mavlink20.GIMBAL_MANAGER_FLAGS_YAW_IN_VEHICLE_FRAME = 32 // Based on GIMBAL_DEVICE_FLAGS_YAW_IN_VEHICLE_FRAME.
+mavlink20.GIMBAL_MANAGER_FLAGS_YAW_IN_EARTH_FRAME = 64 // Based on GIMBAL_DEVICE_FLAGS_YAW_IN_EARTH_FRAME.
+mavlink20.GIMBAL_MANAGER_FLAGS_ACCEPTS_YAW_IN_EARTH_FRAME = 128 // Based on GIMBAL_DEVICE_FLAGS_ACCEPTS_YAW_IN_EARTH_FRAME.
+mavlink20.GIMBAL_MANAGER_FLAGS_RC_EXCLUSIVE = 256 // Based on GIMBAL_DEVICE_FLAGS_RC_EXCLUSIVE.
+mavlink20.GIMBAL_MANAGER_FLAGS_RC_MIXED = 512 // Based on GIMBAL_DEVICE_FLAGS_RC_MIXED.
+mavlink20.GIMBAL_MANAGER_FLAGS_ENUM_END = 513 // 
+
+// GIMBAL_DEVICE_ERROR_FLAGS
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_AT_ROLL_LIMIT = 1 // Gimbal device is limited by hardware roll limit.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_AT_PITCH_LIMIT = 2 // Gimbal device is limited by hardware pitch limit.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_AT_YAW_LIMIT = 4 // Gimbal device is limited by hardware yaw limit.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_ENCODER_ERROR = 8 // There is an error with the gimbal encoders.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_POWER_ERROR = 16 // There is an error with the gimbal power source.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_MOTOR_ERROR = 32 // There is an error with the gimbal motors.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_SOFTWARE_ERROR = 64 // There is an error with the gimbal's software.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_COMMS_ERROR = 128 // There is an error with the gimbal's communication.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_CALIBRATION_RUNNING = 256 // Gimbal device is currently calibrating.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_NO_MANAGER = 512 // Gimbal device is not assigned to a gimbal manager.
+mavlink20.GIMBAL_DEVICE_ERROR_FLAGS_ENUM_END = 513 // 
+
+// GRIPPER_ACTIONS
+mavlink20.GRIPPER_ACTION_RELEASE = 0 // Gripper release cargo.
+mavlink20.GRIPPER_ACTION_GRAB = 1 // Gripper grab onto cargo.
+mavlink20.GRIPPER_ACTIONS_ENUM_END = 2 // 
+
+// WINCH_ACTIONS
+mavlink20.WINCH_RELAXED = 0 // Allow motor to freewheel.
+mavlink20.WINCH_RELATIVE_LENGTH_CONTROL = 1 // Wind or unwind specified length of line, optionally using specified
+                        // rate.
+mavlink20.WINCH_RATE_CONTROL = 2 // Wind or unwind line at specified rate.
+mavlink20.WINCH_LOCK = 3 // Perform the locking sequence to relieve motor while in the fully
+                        // retracted position. Only action and
+                        // instance command parameters are used,
+                        // others are ignored.
+mavlink20.WINCH_DELIVER = 4 // Sequence of drop, slow down, touch down, reel up, lock. Only action
+                        // and instance command parameters are used,
+                        // others are ignored.
+mavlink20.WINCH_HOLD = 5 // Engage motor and hold current position. Only action and instance
+                        // command parameters are used, others are
+                        // ignored.
+mavlink20.WINCH_RETRACT = 6 // Return the reel to the fully retracted position. Only action and
+                        // instance command parameters are used,
+                        // others are ignored.
+mavlink20.WINCH_LOAD_LINE = 7 // Load the reel with line. The winch will calculate the total loaded
+                        // length and stop when the tension exceeds a
+                        // threshold. Only action and instance command
+                        // parameters are used, others are ignored.
+mavlink20.WINCH_ABANDON_LINE = 8 // Spool out the entire length of the line. Only action and instance
+                        // command parameters are used, others are
+                        // ignored.
+mavlink20.WINCH_ACTIONS_ENUM_END = 9 // 
+
+// UAVCAN_NODE_HEALTH
+mavlink20.UAVCAN_NODE_HEALTH_OK = 0 // The node is functioning properly.
+mavlink20.UAVCAN_NODE_HEALTH_WARNING = 1 // A critical parameter went out of range or the node has encountered a
+                        // minor failure.
+mavlink20.UAVCAN_NODE_HEALTH_ERROR = 2 // The node has encountered a major failure.
+mavlink20.UAVCAN_NODE_HEALTH_CRITICAL = 3 // The node has suffered a fatal malfunction.
+mavlink20.UAVCAN_NODE_HEALTH_ENUM_END = 4 // 
+
+// UAVCAN_NODE_MODE
+mavlink20.UAVCAN_NODE_MODE_OPERATIONAL = 0 // The node is performing its primary functions.
+mavlink20.UAVCAN_NODE_MODE_INITIALIZATION = 1 // The node is initializing; this mode is entered immediately after
+                        // startup.
+mavlink20.UAVCAN_NODE_MODE_MAINTENANCE = 2 // The node is under maintenance.
+mavlink20.UAVCAN_NODE_MODE_SOFTWARE_UPDATE = 3 // The node is in the process of updating its software.
+mavlink20.UAVCAN_NODE_MODE_OFFLINE = 7 // The node is no longer available online.
+mavlink20.UAVCAN_NODE_MODE_ENUM_END = 8 // 
+
+// STORAGE_STATUS
+mavlink20.STORAGE_STATUS_EMPTY = 0 // Storage is missing (no microSD card loaded for example.)
+mavlink20.STORAGE_STATUS_UNFORMATTED = 1 // Storage present but unformatted.
+mavlink20.STORAGE_STATUS_READY = 2 // Storage present and ready.
+mavlink20.STORAGE_STATUS_NOT_SUPPORTED = 3 // Camera does not supply storage status information. Capacity
+                        // information in STORAGE_INFORMATION fields
+                        // will be ignored.
+mavlink20.STORAGE_STATUS_ENUM_END = 4 // 
+
+// STORAGE_TYPE
+mavlink20.STORAGE_TYPE_UNKNOWN = 0 // Storage type is not known.
+mavlink20.STORAGE_TYPE_USB_STICK = 1 // Storage type is USB device.
+mavlink20.STORAGE_TYPE_SD = 2 // Storage type is SD card.
+mavlink20.STORAGE_TYPE_MICROSD = 3 // Storage type is microSD card.
+mavlink20.STORAGE_TYPE_CF = 4 // Storage type is CFast.
+mavlink20.STORAGE_TYPE_CFE = 5 // Storage type is CFexpress.
+mavlink20.STORAGE_TYPE_XQD = 6 // Storage type is XQD.
+mavlink20.STORAGE_TYPE_HD = 7 // Storage type is HD mass storage type.
+mavlink20.STORAGE_TYPE_OTHER = 254 // Storage type is other, not listed type.
+mavlink20.STORAGE_TYPE_ENUM_END = 255 // 
+
+// STORAGE_USAGE_FLAG
+mavlink20.STORAGE_USAGE_FLAG_SET = 1 // Always set to 1 (indicates STORAGE_INFORMATION.storage_usage is
+                        // supported).
+mavlink20.STORAGE_USAGE_FLAG_PHOTO = 2 // Storage for saving photos.
+mavlink20.STORAGE_USAGE_FLAG_VIDEO = 4 // Storage for saving videos.
+mavlink20.STORAGE_USAGE_FLAG_LOGS = 8 // Storage for saving logs.
+mavlink20.STORAGE_USAGE_FLAG_ENUM_END = 9 // 
+
+// AUTOTUNE_AXIS
+mavlink20.AUTOTUNE_AXIS_ROLL = 1 // Autotune roll axis.
+mavlink20.AUTOTUNE_AXIS_PITCH = 2 // Autotune pitch axis.
+mavlink20.AUTOTUNE_AXIS_YAW = 4 // Autotune yaw axis.
+mavlink20.AUTOTUNE_AXIS_ENUM_END = 5 // 
+
+// MAV_DATA_STREAM
+mavlink20.MAV_DATA_STREAM_ALL = 0 // Enable all data streams
+mavlink20.MAV_DATA_STREAM_RAW_SENSORS = 1 // Enable IMU_RAW, GPS_RAW, GPS_STATUS packets.
+mavlink20.MAV_DATA_STREAM_EXTENDED_STATUS = 2 // Enable GPS_STATUS, CONTROL_STATUS, AUX_STATUS
+mavlink20.MAV_DATA_STREAM_RC_CHANNELS = 3 // Enable RC_CHANNELS_SCALED, RC_CHANNELS_RAW, SERVO_OUTPUT_RAW
+mavlink20.MAV_DATA_STREAM_RAW_CONTROLLER = 4 // Enable ATTITUDE_CONTROLLER_OUTPUT, POSITION_CONTROLLER_OUTPUT,
+                        // NAV_CONTROLLER_OUTPUT.
+mavlink20.MAV_DATA_STREAM_POSITION = 6 // Enable LOCAL_POSITION, GLOBAL_POSITION_INT messages.
+mavlink20.MAV_DATA_STREAM_EXTRA1 = 10 // Dependent on the autopilot
+mavlink20.MAV_DATA_STREAM_EXTRA2 = 11 // Dependent on the autopilot
+mavlink20.MAV_DATA_STREAM_EXTRA3 = 12 // Dependent on the autopilot
+mavlink20.MAV_DATA_STREAM_ENUM_END = 13 // 
+
+// MAV_ROI
+mavlink20.MAV_ROI_NONE = 0 // No region of interest.
+mavlink20.MAV_ROI_WPNEXT = 1 // Point toward next waypoint, with optional pitch/roll/yaw offset.
+mavlink20.MAV_ROI_WPINDEX = 2 // Point toward given waypoint.
+mavlink20.MAV_ROI_LOCATION = 3 // Point toward fixed location.
+mavlink20.MAV_ROI_TARGET = 4 // Point toward of given id.
+mavlink20.MAV_ROI_ENUM_END = 5 // 
+
+// MAV_PARAM_TYPE
+mavlink20.MAV_PARAM_TYPE_UINT8 = 1 // 8-bit unsigned integer
+mavlink20.MAV_PARAM_TYPE_INT8 = 2 // 8-bit signed integer
+mavlink20.MAV_PARAM_TYPE_UINT16 = 3 // 16-bit unsigned integer
+mavlink20.MAV_PARAM_TYPE_INT16 = 4 // 16-bit signed integer
+mavlink20.MAV_PARAM_TYPE_UINT32 = 5 // 32-bit unsigned integer
+mavlink20.MAV_PARAM_TYPE_INT32 = 6 // 32-bit signed integer
+mavlink20.MAV_PARAM_TYPE_UINT64 = 7 // 64-bit unsigned integer
+mavlink20.MAV_PARAM_TYPE_INT64 = 8 // 64-bit signed integer
+mavlink20.MAV_PARAM_TYPE_REAL32 = 9 // 32-bit floating-point
+mavlink20.MAV_PARAM_TYPE_REAL64 = 10 // 64-bit floating-point
+mavlink20.MAV_PARAM_TYPE_ENUM_END = 11 // 
+
+// MAV_PARAM_EXT_TYPE
+mavlink20.MAV_PARAM_EXT_TYPE_UINT8 = 1 // 8-bit unsigned integer
+mavlink20.MAV_PARAM_EXT_TYPE_INT8 = 2 // 8-bit signed integer
+mavlink20.MAV_PARAM_EXT_TYPE_UINT16 = 3 // 16-bit unsigned integer
+mavlink20.MAV_PARAM_EXT_TYPE_INT16 = 4 // 16-bit signed integer
+mavlink20.MAV_PARAM_EXT_TYPE_UINT32 = 5 // 32-bit unsigned integer
+mavlink20.MAV_PARAM_EXT_TYPE_INT32 = 6 // 32-bit signed integer
+mavlink20.MAV_PARAM_EXT_TYPE_UINT64 = 7 // 64-bit unsigned integer
+mavlink20.MAV_PARAM_EXT_TYPE_INT64 = 8 // 64-bit signed integer
+mavlink20.MAV_PARAM_EXT_TYPE_REAL32 = 9 // 32-bit floating-point
+mavlink20.MAV_PARAM_EXT_TYPE_REAL64 = 10 // 64-bit floating-point
+mavlink20.MAV_PARAM_EXT_TYPE_CUSTOM = 11 // Custom Type
+mavlink20.MAV_PARAM_EXT_TYPE_ENUM_END = 12 // 
+
+// MAV_RESULT
+mavlink20.MAV_RESULT_ACCEPTED = 0 // Command is valid (is supported and has valid parameters), and was
+                        // executed.
+mavlink20.MAV_RESULT_TEMPORARILY_REJECTED = 1 // Command is valid, but cannot be executed at this time. This is used to
+                        // indicate a problem that should be fixed
+                        // just by waiting (e.g. a state machine is
+                        // busy, can't arm because have not got GPS
+                        // lock, etc.). Retrying later should work.
+mavlink20.MAV_RESULT_DENIED = 2 // Command is invalid (is supported but has invalid parameters). Retrying
+                        // same command and parameters will not work.
+mavlink20.MAV_RESULT_UNSUPPORTED = 3 // Command is not supported (unknown).
+mavlink20.MAV_RESULT_FAILED = 4 // Command is valid, but execution has failed. This is used to indicate
+                        // any non-temporary or unexpected problem,
+                        // i.e. any problem that must be fixed before
+                        // the command can succeed/be retried. For
+                        // example, attempting to write a file when
+                        // out of memory, attempting to arm when
+                        // sensors are not calibrated, etc.
+mavlink20.MAV_RESULT_IN_PROGRESS = 5 // Command is valid and is being executed. This will be followed by
+                        // further progress updates, i.e. the
+                        // component may send further COMMAND_ACK
+                        // messages with result MAV_RESULT_IN_PROGRESS
+                        // (at a rate decided by the implementation),
+                        // and must terminate by sending a COMMAND_ACK
+                        // message with final result of the operation.
+                        // The COMMAND_ACK.progress field can be used
+                        // to indicate the progress of the operation.
+                        // There is no need for the sender to retry
+                        // the command, but if done during execution,
+                        // the component will return
+                        // MAV_RESULT_IN_PROGRESS with an updated
+                        // progress.
+mavlink20.MAV_RESULT_COMMAND_LONG_ONLY = 7 // Command is only accepted when sent as a COMMAND_LONG.
+mavlink20.MAV_RESULT_COMMAND_INT_ONLY = 8 // Command is only accepted when sent as a COMMAND_INT.
+mavlink20.MAV_RESULT_ENUM_END = 9 // 
+
+// MAV_MISSION_RESULT
+mavlink20.MAV_MISSION_ACCEPTED = 0 // mission accepted OK
+mavlink20.MAV_MISSION_ERROR = 1 // Generic error / not accepting mission commands at all right now.
+mavlink20.MAV_MISSION_UNSUPPORTED_FRAME = 2 // Coordinate frame is not supported.
+mavlink20.MAV_MISSION_UNSUPPORTED = 3 // Command is not supported.
+mavlink20.MAV_MISSION_NO_SPACE = 4 // Mission items exceed storage space.
+mavlink20.MAV_MISSION_INVALID = 5 // One of the parameters has an invalid value.
+mavlink20.MAV_MISSION_INVALID_PARAM1 = 6 // param1 has an invalid value.
+mavlink20.MAV_MISSION_INVALID_PARAM2 = 7 // param2 has an invalid value.
+mavlink20.MAV_MISSION_INVALID_PARAM3 = 8 // param3 has an invalid value.
+mavlink20.MAV_MISSION_INVALID_PARAM4 = 9 // param4 has an invalid value.
+mavlink20.MAV_MISSION_INVALID_PARAM5_X = 10 // x / param5 has an invalid value.
+mavlink20.MAV_MISSION_INVALID_PARAM6_Y = 11 // y / param6 has an invalid value.
+mavlink20.MAV_MISSION_INVALID_PARAM7 = 12 // z / param7 has an invalid value.
+mavlink20.MAV_MISSION_INVALID_SEQUENCE = 13 // Mission item received out of sequence
+mavlink20.MAV_MISSION_DENIED = 14 // Not accepting any mission commands from this communication partner.
+mavlink20.MAV_MISSION_OPERATION_CANCELLED = 15 // Current mission operation cancelled (e.g. mission upload, mission
+                        // download).
+mavlink20.MAV_MISSION_RESULT_ENUM_END = 16 // 
+
+// MAV_SEVERITY
+mavlink20.MAV_SEVERITY_EMERGENCY = 0 // System is unusable. This is a "panic" condition.
+mavlink20.MAV_SEVERITY_ALERT = 1 // Action should be taken immediately. Indicates error in non-critical
+                        // systems.
+mavlink20.MAV_SEVERITY_CRITICAL = 2 // Action must be taken immediately. Indicates failure in a primary
+                        // system.
+mavlink20.MAV_SEVERITY_ERROR = 3 // Indicates an error in secondary/redundant systems.
+mavlink20.MAV_SEVERITY_WARNING = 4 // Indicates about a possible future error if this is not resolved within
+                        // a given timeframe. Example would be a low
+                        // battery warning.
+mavlink20.MAV_SEVERITY_NOTICE = 5 // An unusual event has occurred, though not an error condition. This
+                        // should be investigated for the root cause.
+mavlink20.MAV_SEVERITY_INFO = 6 // Normal operational messages. Useful for logging. No action is required
+                        // for these messages.
+mavlink20.MAV_SEVERITY_DEBUG = 7 // Useful non-operational messages that can assist in debugging. These
+                        // should not occur during normal operation.
+mavlink20.MAV_SEVERITY_ENUM_END = 8 // 
+
+// MAV_POWER_STATUS
+mavlink20.MAV_POWER_STATUS_BRICK_VALID = 1 // main brick power supply valid
+mavlink20.MAV_POWER_STATUS_SERVO_VALID = 2 // main servo power supply valid for FMU
+mavlink20.MAV_POWER_STATUS_USB_CONNECTED = 4 // USB power is connected
+mavlink20.MAV_POWER_STATUS_PERIPH_OVERCURRENT = 8 // peripheral supply is in over-current state
+mavlink20.MAV_POWER_STATUS_PERIPH_HIPOWER_OVERCURRENT = 16 // hi-power peripheral supply is in over-current state
+mavlink20.MAV_POWER_STATUS_CHANGED = 32 // Power status has changed since boot
+mavlink20.MAV_POWER_STATUS_ENUM_END = 33 // 
+
+// SERIAL_CONTROL_DEV
+mavlink20.SERIAL_CONTROL_DEV_TELEM1 = 0 // First telemetry port
+mavlink20.SERIAL_CONTROL_DEV_TELEM2 = 1 // Second telemetry port
+mavlink20.SERIAL_CONTROL_DEV_GPS1 = 2 // First GPS port
+mavlink20.SERIAL_CONTROL_DEV_GPS2 = 3 // Second GPS port
+mavlink20.SERIAL_CONTROL_DEV_SHELL = 10 // system shell
+mavlink20.SERIAL_CONTROL_SERIAL0 = 100 // SERIAL0
+mavlink20.SERIAL_CONTROL_SERIAL1 = 101 // SERIAL1
+mavlink20.SERIAL_CONTROL_SERIAL2 = 102 // SERIAL2
+mavlink20.SERIAL_CONTROL_SERIAL3 = 103 // SERIAL3
+mavlink20.SERIAL_CONTROL_SERIAL4 = 104 // SERIAL4
+mavlink20.SERIAL_CONTROL_SERIAL5 = 105 // SERIAL5
+mavlink20.SERIAL_CONTROL_SERIAL6 = 106 // SERIAL6
+mavlink20.SERIAL_CONTROL_SERIAL7 = 107 // SERIAL7
+mavlink20.SERIAL_CONTROL_SERIAL8 = 108 // SERIAL8
+mavlink20.SERIAL_CONTROL_SERIAL9 = 109 // SERIAL9
+mavlink20.SERIAL_CONTROL_DEV_ENUM_END = 110 // 
+
+// SERIAL_CONTROL_FLAG
+mavlink20.SERIAL_CONTROL_FLAG_REPLY = 1 // Set if this is a reply
+mavlink20.SERIAL_CONTROL_FLAG_RESPOND = 2 // Set if the sender wants the receiver to send a response as another
+                        // SERIAL_CONTROL message
+mavlink20.SERIAL_CONTROL_FLAG_EXCLUSIVE = 4 // Set if access to the serial port should be removed from whatever
+                        // driver is currently using it, giving
+                        // exclusive access to the SERIAL_CONTROL
+                        // protocol. The port can be handed back by
+                        // sending a request without this flag set
+mavlink20.SERIAL_CONTROL_FLAG_BLOCKING = 8 // Block on writes to the serial port
+mavlink20.SERIAL_CONTROL_FLAG_MULTI = 16 // Send multiple replies until port is drained
+mavlink20.SERIAL_CONTROL_FLAG_ENUM_END = 17 // 
+
+// MAV_DISTANCE_SENSOR
+mavlink20.MAV_DISTANCE_SENSOR_LASER = 0 // Laser rangefinder, e.g. LightWare SF02/F or PulsedLight units
+mavlink20.MAV_DISTANCE_SENSOR_ULTRASOUND = 1 // Ultrasound rangefinder, e.g. MaxBotix units
+mavlink20.MAV_DISTANCE_SENSOR_INFRARED = 2 // Infrared rangefinder, e.g. Sharp units
+mavlink20.MAV_DISTANCE_SENSOR_RADAR = 3 // Radar type, e.g. uLanding units
+mavlink20.MAV_DISTANCE_SENSOR_UNKNOWN = 4 // Broken or unknown type, e.g. analog units
+mavlink20.MAV_DISTANCE_SENSOR_ENUM_END = 5 // 
+
+// MAV_SENSOR_ORIENTATION
+mavlink20.MAV_SENSOR_ROTATION_NONE = 0 // Roll: 0, Pitch: 0, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_YAW_45 = 1 // Roll: 0, Pitch: 0, Yaw: 45
+mavlink20.MAV_SENSOR_ROTATION_YAW_90 = 2 // Roll: 0, Pitch: 0, Yaw: 90
+mavlink20.MAV_SENSOR_ROTATION_YAW_135 = 3 // Roll: 0, Pitch: 0, Yaw: 135
+mavlink20.MAV_SENSOR_ROTATION_YAW_180 = 4 // Roll: 0, Pitch: 0, Yaw: 180
+mavlink20.MAV_SENSOR_ROTATION_YAW_225 = 5 // Roll: 0, Pitch: 0, Yaw: 225
+mavlink20.MAV_SENSOR_ROTATION_YAW_270 = 6 // Roll: 0, Pitch: 0, Yaw: 270
+mavlink20.MAV_SENSOR_ROTATION_YAW_315 = 7 // Roll: 0, Pitch: 0, Yaw: 315
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180 = 8 // Roll: 180, Pitch: 0, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180_YAW_45 = 9 // Roll: 180, Pitch: 0, Yaw: 45
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180_YAW_90 = 10 // Roll: 180, Pitch: 0, Yaw: 90
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180_YAW_135 = 11 // Roll: 180, Pitch: 0, Yaw: 135
+mavlink20.MAV_SENSOR_ROTATION_PITCH_180 = 12 // Roll: 0, Pitch: 180, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180_YAW_225 = 13 // Roll: 180, Pitch: 0, Yaw: 225
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180_YAW_270 = 14 // Roll: 180, Pitch: 0, Yaw: 270
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180_YAW_315 = 15 // Roll: 180, Pitch: 0, Yaw: 315
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90 = 16 // Roll: 90, Pitch: 0, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_YAW_45 = 17 // Roll: 90, Pitch: 0, Yaw: 45
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_YAW_90 = 18 // Roll: 90, Pitch: 0, Yaw: 90
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_YAW_135 = 19 // Roll: 90, Pitch: 0, Yaw: 135
+mavlink20.MAV_SENSOR_ROTATION_ROLL_270 = 20 // Roll: 270, Pitch: 0, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_270_YAW_45 = 21 // Roll: 270, Pitch: 0, Yaw: 45
+mavlink20.MAV_SENSOR_ROTATION_ROLL_270_YAW_90 = 22 // Roll: 270, Pitch: 0, Yaw: 90
+mavlink20.MAV_SENSOR_ROTATION_ROLL_270_YAW_135 = 23 // Roll: 270, Pitch: 0, Yaw: 135
+mavlink20.MAV_SENSOR_ROTATION_PITCH_90 = 24 // Roll: 0, Pitch: 90, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_PITCH_270 = 25 // Roll: 0, Pitch: 270, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_PITCH_180_YAW_90 = 26 // Roll: 0, Pitch: 180, Yaw: 90
+mavlink20.MAV_SENSOR_ROTATION_PITCH_180_YAW_270 = 27 // Roll: 0, Pitch: 180, Yaw: 270
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_PITCH_90 = 28 // Roll: 90, Pitch: 90, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180_PITCH_90 = 29 // Roll: 180, Pitch: 90, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_270_PITCH_90 = 30 // Roll: 270, Pitch: 90, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_PITCH_180 = 31 // Roll: 90, Pitch: 180, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_270_PITCH_180 = 32 // Roll: 270, Pitch: 180, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_PITCH_270 = 33 // Roll: 90, Pitch: 270, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_180_PITCH_270 = 34 // Roll: 180, Pitch: 270, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_270_PITCH_270 = 35 // Roll: 270, Pitch: 270, Yaw: 0
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_PITCH_180_YAW_90 = 36 // Roll: 90, Pitch: 180, Yaw: 90
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_YAW_270 = 37 // Roll: 90, Pitch: 0, Yaw: 270
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_PITCH_68_YAW_293 = 38 // Roll: 90, Pitch: 68, Yaw: 293
+mavlink20.MAV_SENSOR_ROTATION_PITCH_315 = 39 // Pitch: 315
+mavlink20.MAV_SENSOR_ROTATION_ROLL_90_PITCH_315 = 40 // Roll: 90, Pitch: 315
+mavlink20.MAV_SENSOR_ROTATION_CUSTOM = 100 // Custom orientation
+mavlink20.MAV_SENSOR_ORIENTATION_ENUM_END = 101 // 
+
+// MAV_PROTOCOL_CAPABILITY
+mavlink20.MAV_PROTOCOL_CAPABILITY_MISSION_FLOAT = 1 // Autopilot supports the MISSION_ITEM float message type.           Note
+                        // that MISSION_ITEM is deprecated, and
+                        // autopilots should use MISSION_INT instead.
+mavlink20.MAV_PROTOCOL_CAPABILITY_PARAM_FLOAT = 2 // Autopilot supports the new param float message type.
+mavlink20.MAV_PROTOCOL_CAPABILITY_MISSION_INT = 4 // Autopilot supports MISSION_ITEM_INT scaled integer message type.
+                        // Note that this flag must always be set if
+                        // missions are supported, because missions
+                        // must always use MISSION_ITEM_INT (rather
+                        // than MISSION_ITEM, which is deprecated).
+mavlink20.MAV_PROTOCOL_CAPABILITY_COMMAND_INT = 8 // Autopilot supports COMMAND_INT scaled integer message type.
+mavlink20.MAV_PROTOCOL_CAPABILITY_PARAM_UNION = 16 // Autopilot supports the new param union message type.
+mavlink20.MAV_PROTOCOL_CAPABILITY_FTP = 32 // Autopilot supports the File Transfer Protocol v1:
+                        // https://mavlink.io/en/services/ftp.html.
+mavlink20.MAV_PROTOCOL_CAPABILITY_SET_ATTITUDE_TARGET = 64 // Autopilot supports commanding attitude offboard.
+mavlink20.MAV_PROTOCOL_CAPABILITY_SET_POSITION_TARGET_LOCAL_NED = 128 // Autopilot supports commanding position and velocity targets in local
+                        // NED frame.
+mavlink20.MAV_PROTOCOL_CAPABILITY_SET_POSITION_TARGET_GLOBAL_INT = 256 // Autopilot supports commanding position and velocity targets in global
+                        // scaled integers.
+mavlink20.MAV_PROTOCOL_CAPABILITY_TERRAIN = 512 // Autopilot supports terrain protocol / data handling.
+mavlink20.MAV_PROTOCOL_CAPABILITY_SET_ACTUATOR_TARGET = 1024 // Autopilot supports direct actuator control.
+mavlink20.MAV_PROTOCOL_CAPABILITY_FLIGHT_TERMINATION = 2048 // Autopilot supports the MAV_CMD_DO_FLIGHTTERMINATION command (flight
+                        // termination).
+mavlink20.MAV_PROTOCOL_CAPABILITY_COMPASS_CALIBRATION = 4096 // Autopilot supports onboard compass calibration.
+mavlink20.MAV_PROTOCOL_CAPABILITY_MAVLINK2 = 8192 // Autopilot supports MAVLink version 2.
+mavlink20.MAV_PROTOCOL_CAPABILITY_MISSION_FENCE = 16384 // Autopilot supports mission fence protocol.
+mavlink20.MAV_PROTOCOL_CAPABILITY_MISSION_RALLY = 32768 // Autopilot supports mission rally point protocol.
+mavlink20.MAV_PROTOCOL_CAPABILITY_FLIGHT_INFORMATION = 65536 // Autopilot supports the flight information protocol.
+mavlink20.MAV_PROTOCOL_CAPABILITY_ENUM_END = 65537 // 
+
+// MAV_MISSION_TYPE
+mavlink20.MAV_MISSION_TYPE_MISSION = 0 // Items are mission commands for main mission.
+mavlink20.MAV_MISSION_TYPE_FENCE = 1 // Specifies GeoFence area(s). Items are MAV_CMD_NAV_FENCE_ GeoFence
+                        // items.
+mavlink20.MAV_MISSION_TYPE_RALLY = 2 // Specifies the rally points for the vehicle. Rally points are
+                        // alternative RTL points. Items are
+                        // MAV_CMD_NAV_RALLY_POINT rally point items.
+mavlink20.MAV_MISSION_TYPE_ALL = 255 // Only used in MISSION_CLEAR_ALL to clear all mission types.
+mavlink20.MAV_MISSION_TYPE_ENUM_END = 256 // 
+
+// MAV_ESTIMATOR_TYPE
+mavlink20.MAV_ESTIMATOR_TYPE_UNKNOWN = 0 // Unknown type of the estimator.
+mavlink20.MAV_ESTIMATOR_TYPE_NAIVE = 1 // This is a naive estimator without any real covariance feedback.
+mavlink20.MAV_ESTIMATOR_TYPE_VISION = 2 // Computer vision based estimate. Might be up to scale.
+mavlink20.MAV_ESTIMATOR_TYPE_VIO = 3 // Visual-inertial estimate.
+mavlink20.MAV_ESTIMATOR_TYPE_GPS = 4 // Plain GPS estimate.
+mavlink20.MAV_ESTIMATOR_TYPE_GPS_INS = 5 // Estimator integrating GPS and inertial sensing.
+mavlink20.MAV_ESTIMATOR_TYPE_MOCAP = 6 // Estimate from external motion capturing system.
+mavlink20.MAV_ESTIMATOR_TYPE_LIDAR = 7 // Estimator based on lidar sensor input.
+mavlink20.MAV_ESTIMATOR_TYPE_AUTOPILOT = 8 // Estimator on autopilot.
+mavlink20.MAV_ESTIMATOR_TYPE_ENUM_END = 9 // 
+
+// MAV_BATTERY_TYPE
+mavlink20.MAV_BATTERY_TYPE_UNKNOWN = 0 // Not specified.
+mavlink20.MAV_BATTERY_TYPE_LIPO = 1 // Lithium polymer battery
+mavlink20.MAV_BATTERY_TYPE_LIFE = 2 // Lithium-iron-phosphate battery
+mavlink20.MAV_BATTERY_TYPE_LION = 3 // Lithium-ION battery
+mavlink20.MAV_BATTERY_TYPE_NIMH = 4 // Nickel metal hydride battery
+mavlink20.MAV_BATTERY_TYPE_ENUM_END = 5 // 
+
+// MAV_BATTERY_FUNCTION
+mavlink20.MAV_BATTERY_FUNCTION_UNKNOWN = 0 // Battery function is unknown
+mavlink20.MAV_BATTERY_FUNCTION_ALL = 1 // Battery supports all flight systems
+mavlink20.MAV_BATTERY_FUNCTION_PROPULSION = 2 // Battery for the propulsion system
+mavlink20.MAV_BATTERY_FUNCTION_AVIONICS = 3 // Avionics battery
+mavlink20.MAV_BATTERY_TYPE_PAYLOAD = 4 // Payload battery
+mavlink20.MAV_BATTERY_FUNCTION_ENUM_END = 5 // 
+
+// MAV_BATTERY_CHARGE_STATE
+mavlink20.MAV_BATTERY_CHARGE_STATE_UNDEFINED = 0 // Low battery state is not provided
+mavlink20.MAV_BATTERY_CHARGE_STATE_OK = 1 // Battery is not in low state. Normal operation.
+mavlink20.MAV_BATTERY_CHARGE_STATE_LOW = 2 // Battery state is low, warn and monitor close.
+mavlink20.MAV_BATTERY_CHARGE_STATE_CRITICAL = 3 // Battery state is critical, return or abort immediately.
+mavlink20.MAV_BATTERY_CHARGE_STATE_EMERGENCY = 4 // Battery state is too low for ordinary abort sequence. Perform fastest
+                        // possible emergency stop to prevent damage.
+mavlink20.MAV_BATTERY_CHARGE_STATE_FAILED = 5 // Battery failed, damage unavoidable. Possible causes (faults) are
+                        // listed in MAV_BATTERY_FAULT.
+mavlink20.MAV_BATTERY_CHARGE_STATE_UNHEALTHY = 6 // Battery is diagnosed to be defective or an error occurred, usage is
+                        // discouraged / prohibited. Possible causes
+                        // (faults) are listed in MAV_BATTERY_FAULT.
+mavlink20.MAV_BATTERY_CHARGE_STATE_CHARGING = 7 // Battery is charging.
+mavlink20.MAV_BATTERY_CHARGE_STATE_ENUM_END = 8 // 
+
+// MAV_BATTERY_MODE
+mavlink20.MAV_BATTERY_MODE_UNKNOWN = 0 // Battery mode not supported/unknown battery mode/normal operation.
+mavlink20.MAV_BATTERY_MODE_AUTO_DISCHARGING = 1 // Battery is auto discharging (towards storage level).
+mavlink20.MAV_BATTERY_MODE_HOT_SWAP = 2 // Battery in hot-swap mode (current limited to prevent spikes that might
+                        // damage sensitive electrical circuits).
+mavlink20.MAV_BATTERY_MODE_ENUM_END = 3 // 
+
+// MAV_BATTERY_FAULT
+mavlink20.MAV_BATTERY_FAULT_DEEP_DISCHARGE = 1 // Battery has deep discharged.
+mavlink20.MAV_BATTERY_FAULT_SPIKES = 2 // Voltage spikes.
+mavlink20.MAV_BATTERY_FAULT_CELL_FAIL = 4 // One or more cells have failed. Battery should also report
+                        // MAV_BATTERY_CHARGE_STATE_FAILE (and should
+                        // not be used).
+mavlink20.MAV_BATTERY_FAULT_OVER_CURRENT = 8 // Over-current fault.
+mavlink20.MAV_BATTERY_FAULT_OVER_TEMPERATURE = 16 // Over-temperature fault.
+mavlink20.MAV_BATTERY_FAULT_UNDER_TEMPERATURE = 32 // Under-temperature fault.
+mavlink20.MAV_BATTERY_FAULT_INCOMPATIBLE_VOLTAGE = 64 // Vehicle voltage is not compatible with this battery (batteries on same
+                        // power rail should have similar voltage).
+mavlink20.MAV_BATTERY_FAULT_INCOMPATIBLE_FIRMWARE = 128 // Battery firmware is not compatible with current autopilot firmware.
+mavlink20.BATTERY_FAULT_INCOMPATIBLE_CELLS_CONFIGURATION = 256 // Battery is not compatible due to cell configuration (e.g. 5s1p when
+                        // vehicle requires 6s).
+mavlink20.MAV_BATTERY_FAULT_ENUM_END = 257 // 
+
+// MAV_GENERATOR_STATUS_FLAG
+mavlink20.MAV_GENERATOR_STATUS_FLAG_OFF = 1 // Generator is off.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_READY = 2 // Generator is ready to start generating power.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_GENERATING = 4 // Generator is generating power.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_CHARGING = 8 // Generator is charging the batteries (generating enough power to charge
+                        // and provide the load).
+mavlink20.MAV_GENERATOR_STATUS_FLAG_REDUCED_POWER = 16 // Generator is operating at a reduced maximum power.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_MAXPOWER = 32 // Generator is providing the maximum output.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_OVERTEMP_WARNING = 64 // Generator is near the maximum operating temperature, cooling is
+                        // insufficient.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_OVERTEMP_FAULT = 128 // Generator hit the maximum operating temperature and shutdown.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_ELECTRONICS_OVERTEMP_WARNING = 256 // Power electronics are near the maximum operating temperature, cooling
+                        // is insufficient.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_ELECTRONICS_OVERTEMP_FAULT = 512 // Power electronics hit the maximum operating temperature and shutdown.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_ELECTRONICS_FAULT = 1024 // Power electronics experienced a fault and shutdown.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_POWERSOURCE_FAULT = 2048 // The power source supplying the generator failed e.g. mechanical
+                        // generator stopped, tether is no longer
+                        // providing power, solar cell is in shade,
+                        // hydrogen reaction no longer happening.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_COMMUNICATION_WARNING = 4096 // Generator controller having communication problems.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_COOLING_WARNING = 8192 // Power electronic or generator cooling system error.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_POWER_RAIL_FAULT = 16384 // Generator controller power rail experienced a fault.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_OVERCURRENT_FAULT = 32768 // Generator controller exceeded the overcurrent threshold and shutdown
+                        // to prevent damage.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_BATTERY_OVERCHARGE_CURRENT_FAULT = 65536 // Generator controller detected a high current going into the batteries
+                        // and shutdown to prevent battery damage.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_OVERVOLTAGE_FAULT = 131072 // Generator controller exceeded it's overvoltage threshold and shutdown
+                        // to prevent it exceeding the voltage rating.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_BATTERY_UNDERVOLT_FAULT = 262144 // Batteries are under voltage (generator will not start).
+mavlink20.MAV_GENERATOR_STATUS_FLAG_START_INHIBITED = 524288 // Generator start is inhibited by e.g. a safety switch.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_MAINTENANCE_REQUIRED = 1048576 // Generator requires maintenance.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_WARMING_UP = 2097152 // Generator is not ready to generate yet.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_IDLE = 4194304 // Generator is idle.
+mavlink20.MAV_GENERATOR_STATUS_FLAG_ENUM_END = 4194305 // 
+
+// MAV_VTOL_STATE
+mavlink20.MAV_VTOL_STATE_UNDEFINED = 0 // MAV is not configured as VTOL
+mavlink20.MAV_VTOL_STATE_TRANSITION_TO_FW = 1 // VTOL is in transition from multicopter to fixed-wing
+mavlink20.MAV_VTOL_STATE_TRANSITION_TO_MC = 2 // VTOL is in transition from fixed-wing to multicopter
+mavlink20.MAV_VTOL_STATE_MC = 3 // VTOL is in multicopter state
+mavlink20.MAV_VTOL_STATE_FW = 4 // VTOL is in fixed-wing state
+mavlink20.MAV_VTOL_STATE_ENUM_END = 5 // 
+
+// MAV_LANDED_STATE
+mavlink20.MAV_LANDED_STATE_UNDEFINED = 0 // MAV landed state is unknown
+mavlink20.MAV_LANDED_STATE_ON_GROUND = 1 // MAV is landed (on ground)
+mavlink20.MAV_LANDED_STATE_IN_AIR = 2 // MAV is in air
+mavlink20.MAV_LANDED_STATE_TAKEOFF = 3 // MAV currently taking off
+mavlink20.MAV_LANDED_STATE_LANDING = 4 // MAV currently landing
+mavlink20.MAV_LANDED_STATE_ENUM_END = 5 // 
+
+// ADSB_ALTITUDE_TYPE
+mavlink20.ADSB_ALTITUDE_TYPE_PRESSURE_QNH = 0 // Altitude reported from a Baro source using QNH reference
+mavlink20.ADSB_ALTITUDE_TYPE_GEOMETRIC = 1 // Altitude reported from a GNSS source
+mavlink20.ADSB_ALTITUDE_TYPE_ENUM_END = 2 // 
+
+// ADSB_EMITTER_TYPE
+mavlink20.ADSB_EMITTER_TYPE_NO_INFO = 0 // 
+mavlink20.ADSB_EMITTER_TYPE_LIGHT = 1 // 
+mavlink20.ADSB_EMITTER_TYPE_SMALL = 2 // 
+mavlink20.ADSB_EMITTER_TYPE_LARGE = 3 // 
+mavlink20.ADSB_EMITTER_TYPE_HIGH_VORTEX_LARGE = 4 // 
+mavlink20.ADSB_EMITTER_TYPE_HEAVY = 5 // 
+mavlink20.ADSB_EMITTER_TYPE_HIGHLY_MANUV = 6 // 
+mavlink20.ADSB_EMITTER_TYPE_ROTOCRAFT = 7 // 
+mavlink20.ADSB_EMITTER_TYPE_UNASSIGNED = 8 // 
+mavlink20.ADSB_EMITTER_TYPE_GLIDER = 9 // 
+mavlink20.ADSB_EMITTER_TYPE_LIGHTER_AIR = 10 // 
+mavlink20.ADSB_EMITTER_TYPE_PARACHUTE = 11 // 
+mavlink20.ADSB_EMITTER_TYPE_ULTRA_LIGHT = 12 // 
+mavlink20.ADSB_EMITTER_TYPE_UNASSIGNED2 = 13 // 
+mavlink20.ADSB_EMITTER_TYPE_UAV = 14 // 
+mavlink20.ADSB_EMITTER_TYPE_SPACE = 15 // 
+mavlink20.ADSB_EMITTER_TYPE_UNASSGINED3 = 16 // 
+mavlink20.ADSB_EMITTER_TYPE_EMERGENCY_SURFACE = 17 // 
+mavlink20.ADSB_EMITTER_TYPE_SERVICE_SURFACE = 18 // 
+mavlink20.ADSB_EMITTER_TYPE_POINT_OBSTACLE = 19 // 
+mavlink20.ADSB_EMITTER_TYPE_ENUM_END = 20 // 
+
+// ADSB_FLAGS
+mavlink20.ADSB_FLAGS_VALID_COORDS = 1 // 
+mavlink20.ADSB_FLAGS_VALID_ALTITUDE = 2 // 
+mavlink20.ADSB_FLAGS_VALID_HEADING = 4 // 
+mavlink20.ADSB_FLAGS_VALID_VELOCITY = 8 // 
+mavlink20.ADSB_FLAGS_VALID_CALLSIGN = 16 // 
+mavlink20.ADSB_FLAGS_VALID_SQUAWK = 32 // 
+mavlink20.ADSB_FLAGS_SIMULATED = 64 // 
+mavlink20.ADSB_FLAGS_VERTICAL_VELOCITY_VALID = 128 // 
+mavlink20.ADSB_FLAGS_BARO_VALID = 256 // 
+mavlink20.ADSB_FLAGS_SOURCE_UAT = 32768 // 
+mavlink20.ADSB_FLAGS_ENUM_END = 32769 // 
+
+// MAV_DO_REPOSITION_FLAGS
+mavlink20.MAV_DO_REPOSITION_FLAGS_CHANGE_MODE = 1 // The aircraft should immediately transition into guided. This should
+                        // not be set for follow me applications
+mavlink20.MAV_DO_REPOSITION_FLAGS_RELATIVE_YAW = 2 // Yaw relative to the vehicle current heading (if not set, relative to
+                        // North).
+mavlink20.MAV_DO_REPOSITION_FLAGS_VTOL_HOVER = 4 // If capable, the aircraft should enter a VTOL hover at the target
+                        // position
+mavlink20.MAV_DO_REPOSITION_FLAGS_FW_LOITER = 8 // If capable, the aircraft should enter a fixed wing loiter at the
+                        // target position
+mavlink20.MAV_DO_REPOSITION_FLAGS_ENUM_END = 9 // 
+
+// SPEED_TYPE
+mavlink20.SPEED_TYPE_AIRSPEED = 0 // Airspeed
+mavlink20.SPEED_TYPE_GROUNDSPEED = 1 // Groundspeed
+mavlink20.SPEED_TYPE_CLIMB_SPEED = 2 // Climb speed
+mavlink20.SPEED_TYPE_DESCENT_SPEED = 3 // Descent speed
+mavlink20.SPEED_TYPE_ENUM_END = 4 // 
+
+// ESTIMATOR_STATUS_FLAGS
+mavlink20.ESTIMATOR_ATTITUDE = 1 // True if the attitude estimate is good
+mavlink20.ESTIMATOR_VELOCITY_HORIZ = 2 // True if the horizontal velocity estimate is good
+mavlink20.ESTIMATOR_VELOCITY_VERT = 4 // True if the  vertical velocity estimate is good
+mavlink20.ESTIMATOR_POS_HORIZ_REL = 8 // True if the horizontal position (relative) estimate is good
+mavlink20.ESTIMATOR_POS_HORIZ_ABS = 16 // True if the horizontal position (absolute) estimate is good
+mavlink20.ESTIMATOR_POS_VERT_ABS = 32 // True if the vertical position (absolute) estimate is good
+mavlink20.ESTIMATOR_POS_VERT_AGL = 64 // True if the vertical position (above ground) estimate is good
+mavlink20.ESTIMATOR_CONST_POS_MODE = 128 // True if the EKF is in a constant position mode and is not using
+                        // external measurements (eg GPS or optical
+                        // flow)
+mavlink20.ESTIMATOR_PRED_POS_HORIZ_REL = 256 // True if the EKF has sufficient data to enter a mode that will provide
+                        // a (relative) position estimate
+mavlink20.ESTIMATOR_PRED_POS_HORIZ_ABS = 512 // True if the EKF has sufficient data to enter a mode that will provide
+                        // a (absolute) position estimate
+mavlink20.ESTIMATOR_GPS_GLITCH = 1024 // True if the EKF has detected a GPS glitch
+mavlink20.ESTIMATOR_ACCEL_ERROR = 2048 // True if the EKF has detected bad accelerometer data
+mavlink20.ESTIMATOR_STATUS_FLAGS_ENUM_END = 2049 // 
+
+// MOTOR_TEST_ORDER
+mavlink20.MOTOR_TEST_ORDER_DEFAULT = 0 // Default autopilot motor test method.
+mavlink20.MOTOR_TEST_ORDER_SEQUENCE = 1 // Motor numbers are specified as their index in a predefined vehicle-
+                        // specific sequence.
+mavlink20.MOTOR_TEST_ORDER_BOARD = 2 // Motor numbers are specified as the output as labeled on the board.
+mavlink20.MOTOR_TEST_ORDER_ENUM_END = 3 // 
+
+// MOTOR_TEST_THROTTLE_TYPE
+mavlink20.MOTOR_TEST_THROTTLE_PERCENT = 0 // Throttle as a percentage (0 ~ 100)
+mavlink20.MOTOR_TEST_THROTTLE_PWM = 1 // Throttle as an absolute PWM value (normally in range of 1000~2000).
+mavlink20.MOTOR_TEST_THROTTLE_PILOT = 2 // Throttle pass-through from pilot's transmitter.
+mavlink20.MOTOR_TEST_COMPASS_CAL = 3 // Per-motor compass calibration test.
+mavlink20.MOTOR_TEST_THROTTLE_TYPE_ENUM_END = 4 // 
+
+// GPS_INPUT_IGNORE_FLAGS
+mavlink20.GPS_INPUT_IGNORE_FLAG_ALT = 1 // ignore altitude field
+mavlink20.GPS_INPUT_IGNORE_FLAG_HDOP = 2 // ignore hdop field
+mavlink20.GPS_INPUT_IGNORE_FLAG_VDOP = 4 // ignore vdop field
+mavlink20.GPS_INPUT_IGNORE_FLAG_VEL_HORIZ = 8 // ignore horizontal velocity field (vn and ve)
+mavlink20.GPS_INPUT_IGNORE_FLAG_VEL_VERT = 16 // ignore vertical velocity field (vd)
+mavlink20.GPS_INPUT_IGNORE_FLAG_SPEED_ACCURACY = 32 // ignore speed accuracy field
+mavlink20.GPS_INPUT_IGNORE_FLAG_HORIZONTAL_ACCURACY = 64 // ignore horizontal accuracy field
+mavlink20.GPS_INPUT_IGNORE_FLAG_VERTICAL_ACCURACY = 128 // ignore vertical accuracy field
+mavlink20.GPS_INPUT_IGNORE_FLAGS_ENUM_END = 129 // 
+
+// MAV_COLLISION_ACTION
+mavlink20.MAV_COLLISION_ACTION_NONE = 0 // Ignore any potential collisions
+mavlink20.MAV_COLLISION_ACTION_REPORT = 1 // Report potential collision
+mavlink20.MAV_COLLISION_ACTION_ASCEND_OR_DESCEND = 2 // Ascend or Descend to avoid threat
+mavlink20.MAV_COLLISION_ACTION_MOVE_HORIZONTALLY = 3 // Move horizontally to avoid threat
+mavlink20.MAV_COLLISION_ACTION_MOVE_PERPENDICULAR = 4 // Aircraft to move perpendicular to the collision's velocity vector
+mavlink20.MAV_COLLISION_ACTION_RTL = 5 // Aircraft to fly directly back to its launch point
+mavlink20.MAV_COLLISION_ACTION_HOVER = 6 // Aircraft to stop in place
+mavlink20.MAV_COLLISION_ACTION_ENUM_END = 7 // 
+
+// MAV_COLLISION_THREAT_LEVEL
+mavlink20.MAV_COLLISION_THREAT_LEVEL_NONE = 0 // Not a threat
+mavlink20.MAV_COLLISION_THREAT_LEVEL_LOW = 1 // Craft is mildly concerned about this threat
+mavlink20.MAV_COLLISION_THREAT_LEVEL_HIGH = 2 // Craft is panicking, and may take actions to avoid threat
+mavlink20.MAV_COLLISION_THREAT_LEVEL_ENUM_END = 3 // 
+
+// MAV_COLLISION_SRC
+mavlink20.MAV_COLLISION_SRC_ADSB = 0 // ID field references ADSB_VEHICLE packets
+mavlink20.MAV_COLLISION_SRC_MAVLINK_GPS_GLOBAL_INT = 1 // ID field references MAVLink SRC ID
+mavlink20.MAV_COLLISION_SRC_ENUM_END = 2 // 
+
+// GPS_FIX_TYPE
+mavlink20.GPS_FIX_TYPE_NO_GPS = 0 // No GPS connected
+mavlink20.GPS_FIX_TYPE_NO_FIX = 1 // No position information, GPS is connected
+mavlink20.GPS_FIX_TYPE_2D_FIX = 2 // 2D position
+mavlink20.GPS_FIX_TYPE_3D_FIX = 3 // 3D position
+mavlink20.GPS_FIX_TYPE_DGPS = 4 // DGPS/SBAS aided 3D position
+mavlink20.GPS_FIX_TYPE_RTK_FLOAT = 5 // RTK float, 3D position
+mavlink20.GPS_FIX_TYPE_RTK_FIXED = 6 // RTK Fixed, 3D position
+mavlink20.GPS_FIX_TYPE_STATIC = 7 // Static fixed, typically used for base stations
+mavlink20.GPS_FIX_TYPE_PPP = 8 // PPP, 3D position.
+mavlink20.GPS_FIX_TYPE_ENUM_END = 9 // 
+
+// RTK_BASELINE_COORDINATE_SYSTEM
+mavlink20.RTK_BASELINE_COORDINATE_SYSTEM_ECEF = 0 // Earth-centered, Earth-fixed
+mavlink20.RTK_BASELINE_COORDINATE_SYSTEM_NED = 1 // RTK basestation centered, north, east, down
+mavlink20.RTK_BASELINE_COORDINATE_SYSTEM_ENUM_END = 2 // 
+
+// LANDING_TARGET_TYPE
+mavlink20.LANDING_TARGET_TYPE_LIGHT_BEACON = 0 // Landing target signaled by light beacon (ex: IR-LOCK)
+mavlink20.LANDING_TARGET_TYPE_RADIO_BEACON = 1 // Landing target signaled by radio beacon (ex: ILS, NDB)
+mavlink20.LANDING_TARGET_TYPE_VISION_FIDUCIAL = 2 // Landing target represented by a fiducial marker (ex: ARTag)
+mavlink20.LANDING_TARGET_TYPE_VISION_OTHER = 3 // Landing target represented by a pre-defined visual shape/feature (ex:
+                        // X-marker, H-marker, square)
+mavlink20.LANDING_TARGET_TYPE_ENUM_END = 4 // 
+
+// VTOL_TRANSITION_HEADING
+mavlink20.VTOL_TRANSITION_HEADING_VEHICLE_DEFAULT = 0 // Respect the heading configuration of the vehicle.
+mavlink20.VTOL_TRANSITION_HEADING_NEXT_WAYPOINT = 1 // Use the heading pointing towards the next waypoint.
+mavlink20.VTOL_TRANSITION_HEADING_TAKEOFF = 2 // Use the heading on takeoff (while sitting on the ground).
+mavlink20.VTOL_TRANSITION_HEADING_SPECIFIED = 3 // Use the specified heading in parameter 4.
+mavlink20.VTOL_TRANSITION_HEADING_ANY = 4 // Use the current heading when reaching takeoff altitude (potentially
+                        // facing the wind when weather-vaning is
+                        // active).
+mavlink20.VTOL_TRANSITION_HEADING_ENUM_END = 5 // 
+
+// CAMERA_CAP_FLAGS
+mavlink20.CAMERA_CAP_FLAGS_CAPTURE_VIDEO = 1 // Camera is able to record video
+mavlink20.CAMERA_CAP_FLAGS_CAPTURE_IMAGE = 2 // Camera is able to capture images
+mavlink20.CAMERA_CAP_FLAGS_HAS_MODES = 4 // Camera has separate Video and Image/Photo modes
+                        // (MAV_CMD_SET_CAMERA_MODE)
+mavlink20.CAMERA_CAP_FLAGS_CAN_CAPTURE_IMAGE_IN_VIDEO_MODE = 8 // Camera can capture images while in video mode
+mavlink20.CAMERA_CAP_FLAGS_CAN_CAPTURE_VIDEO_IN_IMAGE_MODE = 16 // Camera can capture videos while in Photo/Image mode
+mavlink20.CAMERA_CAP_FLAGS_HAS_IMAGE_SURVEY_MODE = 32 // Camera has image survey mode (MAV_CMD_SET_CAMERA_MODE)
+mavlink20.CAMERA_CAP_FLAGS_HAS_BASIC_ZOOM = 64 // Camera has basic zoom control (MAV_CMD_SET_CAMERA_ZOOM)
+mavlink20.CAMERA_CAP_FLAGS_HAS_BASIC_FOCUS = 128 // Camera has basic focus control (MAV_CMD_SET_CAMERA_FOCUS)
+mavlink20.CAMERA_CAP_FLAGS_HAS_VIDEO_STREAM = 256 // Camera has video streaming capabilities (request
+                        // VIDEO_STREAM_INFORMATION with
+                        // MAV_CMD_REQUEST_MESSAGE for video streaming
+                        // info)
+mavlink20.CAMERA_CAP_FLAGS_HAS_TRACKING_POINT = 512 // Camera supports tracking of a point on the camera view.
+mavlink20.CAMERA_CAP_FLAGS_HAS_TRACKING_RECTANGLE = 1024 // Camera supports tracking of a selection rectangle on the camera view.
+mavlink20.CAMERA_CAP_FLAGS_HAS_TRACKING_GEO_STATUS = 2048 // Camera supports tracking geo status (CAMERA_TRACKING_GEO_STATUS).
+mavlink20.CAMERA_CAP_FLAGS_HAS_THERMAL_RANGE = 4096 // Camera supports absolute thermal range (request CAMERA_THERMAL_RANGE
+                        // with MAV_CMD_REQUEST_MESSAGE).
+mavlink20.CAMERA_CAP_FLAGS_ENUM_END = 4097 // 
+
+// VIDEO_STREAM_STATUS_FLAGS
+mavlink20.VIDEO_STREAM_STATUS_FLAGS_RUNNING = 1 // Stream is active (running)
+mavlink20.VIDEO_STREAM_STATUS_FLAGS_THERMAL = 2 // Stream is thermal imaging
+mavlink20.VIDEO_STREAM_STATUS_FLAGS_THERMAL_RANGE_ENABLED = 4 // Stream can report absolute thermal range (see CAMERA_THERMAL_RANGE).
+mavlink20.VIDEO_STREAM_STATUS_FLAGS_ENUM_END = 5 // 
+
+// VIDEO_STREAM_TYPE
+mavlink20.VIDEO_STREAM_TYPE_RTSP = 0 // Stream is RTSP
+mavlink20.VIDEO_STREAM_TYPE_RTPUDP = 1 // Stream is RTP UDP (URI gives the port number)
+mavlink20.VIDEO_STREAM_TYPE_TCP_MPEG = 2 // Stream is MPEG on TCP
+mavlink20.VIDEO_STREAM_TYPE_MPEG_TS = 3 // Stream is MPEG TS (URI gives the port number)
+mavlink20.VIDEO_STREAM_TYPE_ENUM_END = 4 // 
+
+// VIDEO_STREAM_ENCODING
+mavlink20.VIDEO_STREAM_ENCODING_UNKNOWN = 0 // Stream encoding is unknown
+mavlink20.VIDEO_STREAM_ENCODING_H264 = 1 // Stream encoding is H.264
+mavlink20.VIDEO_STREAM_ENCODING_H265 = 2 // Stream encoding is H.265
+mavlink20.VIDEO_STREAM_ENCODING_ENUM_END = 3 // 
+
+// CAMERA_TRACKING_STATUS_FLAGS
+mavlink20.CAMERA_TRACKING_STATUS_FLAGS_IDLE = 0 // Camera is not tracking
+mavlink20.CAMERA_TRACKING_STATUS_FLAGS_ACTIVE = 1 // Camera is tracking
+mavlink20.CAMERA_TRACKING_STATUS_FLAGS_ERROR = 2 // Camera tracking in error state
+mavlink20.CAMERA_TRACKING_STATUS_FLAGS_ENUM_END = 3 // 
+
+// CAMERA_TRACKING_MODE
+mavlink20.CAMERA_TRACKING_MODE_NONE = 0 // Not tracking
+mavlink20.CAMERA_TRACKING_MODE_POINT = 1 // Target is a point
+mavlink20.CAMERA_TRACKING_MODE_RECTANGLE = 2 // Target is a rectangle
+mavlink20.CAMERA_TRACKING_MODE_ENUM_END = 3 // 
+
+// CAMERA_TRACKING_TARGET_DATA
+mavlink20.CAMERA_TRACKING_TARGET_DATA_EMBEDDED = 1 // Target data embedded in image data (proprietary)
+mavlink20.CAMERA_TRACKING_TARGET_DATA_RENDERED = 2 // Target data rendered in image
+mavlink20.CAMERA_TRACKING_TARGET_DATA_IN_STATUS = 4 // Target data within status message (Point or Rectangle)
+mavlink20.CAMERA_TRACKING_TARGET_DATA_ENUM_END = 5 // 
+
+// CAMERA_ZOOM_TYPE
+mavlink20.ZOOM_TYPE_STEP = 0 // Zoom one step increment (-1 for wide, 1 for tele)
+mavlink20.ZOOM_TYPE_CONTINUOUS = 1 // Continuous zoom up/down until stopped (-1 for wide, 1 for tele, 0 to
+                        // stop zooming)
+mavlink20.ZOOM_TYPE_RANGE = 2 // Zoom value as proportion of full camera range (a percentage value
+                        // between 0.0 and 100.0)
+mavlink20.ZOOM_TYPE_FOCAL_LENGTH = 3 // Zoom value/variable focal length in millimetres. Note that there is no
+                        // message to get the valid zoom range of the
+                        // camera, so this can type can only be used
+                        // for cameras where the zoom range is known
+                        // (implying that this cannot reliably be used
+                        // in a GCS for an arbitrary camera)
+mavlink20.CAMERA_ZOOM_TYPE_ENUM_END = 4 // 
+
+// SET_FOCUS_TYPE
+mavlink20.FOCUS_TYPE_STEP = 0 // Focus one step increment (-1 for focusing in, 1 for focusing out
+                        // towards infinity).
+mavlink20.FOCUS_TYPE_CONTINUOUS = 1 // Continuous focus up/down until stopped (-1 for focusing in, 1 for
+                        // focusing out towards infinity, 0 to stop
+                        // focusing)
+mavlink20.FOCUS_TYPE_RANGE = 2 // Focus value as proportion of full camera focus range (a value between
+                        // 0.0 and 100.0)
+mavlink20.FOCUS_TYPE_METERS = 3 // Focus value in metres. Note that there is no message to get the valid
+                        // focus range of the camera, so this can type
+                        // can only be used for cameras where the
+                        // range is known (implying that this cannot
+                        // reliably be used in a GCS for an arbitrary
+                        // camera).
+mavlink20.FOCUS_TYPE_AUTO = 4 // Focus automatically.
+mavlink20.FOCUS_TYPE_AUTO_SINGLE = 5 // Single auto focus. Mainly used for still pictures. Usually abbreviated
+                        // as AF-S.
+mavlink20.FOCUS_TYPE_AUTO_CONTINUOUS = 6 // Continuous auto focus. Mainly used for dynamic scenes. Abbreviated as
+                        // AF-C.
+mavlink20.SET_FOCUS_TYPE_ENUM_END = 7 // 
+
+// CAMERA_SOURCE
+mavlink20.CAMERA_SOURCE_DEFAULT = 0 // Default camera source.
+mavlink20.CAMERA_SOURCE_RGB = 1 // RGB camera source.
+mavlink20.CAMERA_SOURCE_IR = 2 // IR camera source.
+mavlink20.CAMERA_SOURCE_NDVI = 3 // NDVI camera source.
+mavlink20.CAMERA_SOURCE_ENUM_END = 4 // 
+
+// PARAM_ACK
+mavlink20.PARAM_ACK_ACCEPTED = 0 // Parameter value ACCEPTED and SET
+mavlink20.PARAM_ACK_VALUE_UNSUPPORTED = 1 // Parameter value UNKNOWN/UNSUPPORTED
+mavlink20.PARAM_ACK_FAILED = 2 // Parameter failed to set
+mavlink20.PARAM_ACK_IN_PROGRESS = 3 // Parameter value received but not yet set/accepted. A subsequent
+                        // PARAM_EXT_ACK with the final result will
+                        // follow once operation is completed. This is
+                        // returned immediately for parameters that
+                        // take longer to set, indicating that the the
+                        // parameter was received and does not need to
+                        // be resent.
+mavlink20.PARAM_ACK_ENUM_END = 4 // 
+
+// CAMERA_MODE
+mavlink20.CAMERA_MODE_IMAGE = 0 // Camera is in image/photo capture mode.
+mavlink20.CAMERA_MODE_VIDEO = 1 // Camera is in video capture mode.
+mavlink20.CAMERA_MODE_IMAGE_SURVEY = 2 // Camera is in image survey capture mode. It allows for camera
+                        // controller to do specific settings for
+                        // surveys.
+mavlink20.CAMERA_MODE_ENUM_END = 3 // 
+
+// MAV_ARM_AUTH_DENIED_REASON
+mavlink20.MAV_ARM_AUTH_DENIED_REASON_GENERIC = 0 // Not a specific reason
+mavlink20.MAV_ARM_AUTH_DENIED_REASON_NONE = 1 // Authorizer will send the error as string to GCS
+mavlink20.MAV_ARM_AUTH_DENIED_REASON_INVALID_WAYPOINT = 2 // At least one waypoint have a invalid value
+mavlink20.MAV_ARM_AUTH_DENIED_REASON_TIMEOUT = 3 // Timeout in the authorizer process(in case it depends on network)
+mavlink20.MAV_ARM_AUTH_DENIED_REASON_AIRSPACE_IN_USE = 4 // Airspace of the mission in use by another vehicle, second result
+                        // parameter can have the waypoint id that
+                        // caused it to be denied.
+mavlink20.MAV_ARM_AUTH_DENIED_REASON_BAD_WEATHER = 5 // Weather is not good to fly
+mavlink20.MAV_ARM_AUTH_DENIED_REASON_ENUM_END = 6 // 
+
+// RC_TYPE
+mavlink20.RC_TYPE_SPEKTRUM_DSM2 = 0 // Spektrum DSM2
+mavlink20.RC_TYPE_SPEKTRUM_DSMX = 1 // Spektrum DSMX
+mavlink20.RC_TYPE_ENUM_END = 2 // 
+
+// ENGINE_CONTROL_OPTIONS
+mavlink20.ENGINE_CONTROL_OPTIONS_ALLOW_START_WHILE_DISARMED = 1 // Allow starting the engine once while disarmed
+mavlink20.ENGINE_CONTROL_OPTIONS_ENUM_END = 2 // 
+
+// POSITION_TARGET_TYPEMASK
+mavlink20.POSITION_TARGET_TYPEMASK_X_IGNORE = 1 // Ignore position x
+mavlink20.POSITION_TARGET_TYPEMASK_Y_IGNORE = 2 // Ignore position y
+mavlink20.POSITION_TARGET_TYPEMASK_Z_IGNORE = 4 // Ignore position z
+mavlink20.POSITION_TARGET_TYPEMASK_VX_IGNORE = 8 // Ignore velocity x
+mavlink20.POSITION_TARGET_TYPEMASK_VY_IGNORE = 16 // Ignore velocity y
+mavlink20.POSITION_TARGET_TYPEMASK_VZ_IGNORE = 32 // Ignore velocity z
+mavlink20.POSITION_TARGET_TYPEMASK_AX_IGNORE = 64 // Ignore acceleration x
+mavlink20.POSITION_TARGET_TYPEMASK_AY_IGNORE = 128 // Ignore acceleration y
+mavlink20.POSITION_TARGET_TYPEMASK_AZ_IGNORE = 256 // Ignore acceleration z
+mavlink20.POSITION_TARGET_TYPEMASK_FORCE_SET = 512 // Use force instead of acceleration
+mavlink20.POSITION_TARGET_TYPEMASK_YAW_IGNORE = 1024 // Ignore yaw
+mavlink20.POSITION_TARGET_TYPEMASK_YAW_RATE_IGNORE = 2048 // Ignore yaw rate
+mavlink20.POSITION_TARGET_TYPEMASK_ENUM_END = 2049 // 
+
+// ATTITUDE_TARGET_TYPEMASK
+mavlink20.ATTITUDE_TARGET_TYPEMASK_BODY_ROLL_RATE_IGNORE = 1 // Ignore body roll rate
+mavlink20.ATTITUDE_TARGET_TYPEMASK_BODY_PITCH_RATE_IGNORE = 2 // Ignore body pitch rate
+mavlink20.ATTITUDE_TARGET_TYPEMASK_BODY_YAW_RATE_IGNORE = 4 // Ignore body yaw rate
+mavlink20.ATTITUDE_TARGET_TYPEMASK_THROTTLE_IGNORE = 64 // Ignore throttle
+mavlink20.ATTITUDE_TARGET_TYPEMASK_ATTITUDE_IGNORE = 128 // Ignore attitude
+mavlink20.ATTITUDE_TARGET_TYPEMASK_ENUM_END = 129 // 
+
+// UTM_FLIGHT_STATE
+mavlink20.UTM_FLIGHT_STATE_UNKNOWN = 1 // The flight state can't be determined.
+mavlink20.UTM_FLIGHT_STATE_GROUND = 2 // UAS on ground.
+mavlink20.UTM_FLIGHT_STATE_AIRBORNE = 3 // UAS airborne.
+mavlink20.UTM_FLIGHT_STATE_EMERGENCY = 16 // UAS is in an emergency flight state.
+mavlink20.UTM_FLIGHT_STATE_NOCTRL = 32 // UAS has no active controls.
+mavlink20.UTM_FLIGHT_STATE_ENUM_END = 33 // 
+
+// UTM_DATA_AVAIL_FLAGS
+mavlink20.UTM_DATA_AVAIL_FLAGS_TIME_VALID = 1 // The field time contains valid data.
+mavlink20.UTM_DATA_AVAIL_FLAGS_UAS_ID_AVAILABLE = 2 // The field uas_id contains valid data.
+mavlink20.UTM_DATA_AVAIL_FLAGS_POSITION_AVAILABLE = 4 // The fields lat, lon and h_acc contain valid data.
+mavlink20.UTM_DATA_AVAIL_FLAGS_ALTITUDE_AVAILABLE = 8 // The fields alt and v_acc contain valid data.
+mavlink20.UTM_DATA_AVAIL_FLAGS_RELATIVE_ALTITUDE_AVAILABLE = 16 // The field relative_alt contains valid data.
+mavlink20.UTM_DATA_AVAIL_FLAGS_HORIZONTAL_VELO_AVAILABLE = 32 // The fields vx and vy contain valid data.
+mavlink20.UTM_DATA_AVAIL_FLAGS_VERTICAL_VELO_AVAILABLE = 64 // The field vz contains valid data.
+mavlink20.UTM_DATA_AVAIL_FLAGS_NEXT_WAYPOINT_AVAILABLE = 128 // The fields next_lat, next_lon and next_alt contain valid data.
+mavlink20.UTM_DATA_AVAIL_FLAGS_ENUM_END = 129 // 
+
+// PRECISION_LAND_MODE
+mavlink20.PRECISION_LAND_MODE_DISABLED = 0 // Normal (non-precision) landing.
+mavlink20.PRECISION_LAND_MODE_OPPORTUNISTIC = 1 // Use precision landing if beacon detected when land command accepted,
+                        // otherwise land normally.
+mavlink20.PRECISION_LAND_MODE_REQUIRED = 2 // Use precision landing, searching for beacon if not found when land
+                        // command accepted (land normally if beacon
+                        // cannot be found).
+mavlink20.PRECISION_LAND_MODE_ENUM_END = 3 // 
+
+// PARACHUTE_ACTION
+mavlink20.PARACHUTE_DISABLE = 0 // Disable auto-release of parachute (i.e. release triggered by crash
+                        // detectors).
+mavlink20.PARACHUTE_ENABLE = 1 // Enable auto-release of parachute.
+mavlink20.PARACHUTE_RELEASE = 2 // Release parachute and kill motors.
+mavlink20.PARACHUTE_ACTION_ENUM_END = 3 // 
+
+// MAV_TUNNEL_PAYLOAD_TYPE
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_UNKNOWN = 0 // Encoding of payload unknown.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED0 = 200 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED1 = 201 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED2 = 202 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED3 = 203 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED4 = 204 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED5 = 205 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED6 = 206 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED7 = 207 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED8 = 208 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_STORM32_RESERVED9 = 209 // Registered for STorM32 gimbal controller.
+mavlink20.MAV_TUNNEL_PAYLOAD_TYPE_ENUM_END = 210 // 
+
+// MAV_ODID_ID_TYPE
+mavlink20.MAV_ODID_ID_TYPE_NONE = 0 // No type defined.
+mavlink20.MAV_ODID_ID_TYPE_SERIAL_NUMBER = 1 // Manufacturer Serial Number (ANSI/CTA-2063 format).
+mavlink20.MAV_ODID_ID_TYPE_CAA_REGISTRATION_ID = 2 // CAA (Civil Aviation Authority) registered ID. Format: [ICAO Country
+                        // Code].[CAA Assigned ID].
+mavlink20.MAV_ODID_ID_TYPE_UTM_ASSIGNED_UUID = 3 // UTM (Unmanned Traffic Management) assigned UUID (RFC4122).
+mavlink20.MAV_ODID_ID_TYPE_SPECIFIC_SESSION_ID = 4 // A 20 byte ID for a specific flight/session. The exact ID type is
+                        // indicated by the first byte of uas_id and
+                        // these type values are managed by ICAO.
+mavlink20.MAV_ODID_ID_TYPE_ENUM_END = 5 // 
+
+// MAV_ODID_UA_TYPE
+mavlink20.MAV_ODID_UA_TYPE_NONE = 0 // No UA (Unmanned Aircraft) type defined.
+mavlink20.MAV_ODID_UA_TYPE_AEROPLANE = 1 // Aeroplane/Airplane. Fixed wing.
+mavlink20.MAV_ODID_UA_TYPE_HELICOPTER_OR_MULTIROTOR = 2 // Helicopter or multirotor.
+mavlink20.MAV_ODID_UA_TYPE_GYROPLANE = 3 // Gyroplane.
+mavlink20.MAV_ODID_UA_TYPE_HYBRID_LIFT = 4 // VTOL (Vertical Take-Off and Landing). Fixed wing aircraft that can
+                        // take off vertically.
+mavlink20.MAV_ODID_UA_TYPE_ORNITHOPTER = 5 // Ornithopter.
+mavlink20.MAV_ODID_UA_TYPE_GLIDER = 6 // Glider.
+mavlink20.MAV_ODID_UA_TYPE_KITE = 7 // Kite.
+mavlink20.MAV_ODID_UA_TYPE_FREE_BALLOON = 8 // Free Balloon.
+mavlink20.MAV_ODID_UA_TYPE_CAPTIVE_BALLOON = 9 // Captive Balloon.
+mavlink20.MAV_ODID_UA_TYPE_AIRSHIP = 10 // Airship. E.g. a blimp.
+mavlink20.MAV_ODID_UA_TYPE_FREE_FALL_PARACHUTE = 11 // Free Fall/Parachute (unpowered).
+mavlink20.MAV_ODID_UA_TYPE_ROCKET = 12 // Rocket.
+mavlink20.MAV_ODID_UA_TYPE_TETHERED_POWERED_AIRCRAFT = 13 // Tethered powered aircraft.
+mavlink20.MAV_ODID_UA_TYPE_GROUND_OBSTACLE = 14 // Ground Obstacle.
+mavlink20.MAV_ODID_UA_TYPE_OTHER = 15 // Other type of aircraft not listed earlier.
+mavlink20.MAV_ODID_UA_TYPE_ENUM_END = 16 // 
+
+// MAV_ODID_STATUS
+mavlink20.MAV_ODID_STATUS_UNDECLARED = 0 // The status of the (UA) Unmanned Aircraft is undefined.
+mavlink20.MAV_ODID_STATUS_GROUND = 1 // The UA is on the ground.
+mavlink20.MAV_ODID_STATUS_AIRBORNE = 2 // The UA is in the air.
+mavlink20.MAV_ODID_STATUS_EMERGENCY = 3 // The UA is having an emergency.
+mavlink20.MAV_ODID_STATUS_REMOTE_ID_SYSTEM_FAILURE = 4 // The remote ID system is failing or unreliable in some way.
+mavlink20.MAV_ODID_STATUS_ENUM_END = 5 // 
+
+// MAV_ODID_HEIGHT_REF
+mavlink20.MAV_ODID_HEIGHT_REF_OVER_TAKEOFF = 0 // The height field is relative to the take-off location.
+mavlink20.MAV_ODID_HEIGHT_REF_OVER_GROUND = 1 // The height field is relative to ground.
+mavlink20.MAV_ODID_HEIGHT_REF_ENUM_END = 2 // 
+
+// MAV_ODID_HOR_ACC
+mavlink20.MAV_ODID_HOR_ACC_UNKNOWN = 0 // The horizontal accuracy is unknown.
+mavlink20.MAV_ODID_HOR_ACC_10NM = 1 // The horizontal accuracy is smaller than 10 Nautical Miles. 18.52 km.
+mavlink20.MAV_ODID_HOR_ACC_4NM = 2 // The horizontal accuracy is smaller than 4 Nautical Miles. 7.408 km.
+mavlink20.MAV_ODID_HOR_ACC_2NM = 3 // The horizontal accuracy is smaller than 2 Nautical Miles. 3.704 km.
+mavlink20.MAV_ODID_HOR_ACC_1NM = 4 // The horizontal accuracy is smaller than 1 Nautical Miles. 1.852 km.
+mavlink20.MAV_ODID_HOR_ACC_0_5NM = 5 // The horizontal accuracy is smaller than 0.5 Nautical Miles. 926 m.
+mavlink20.MAV_ODID_HOR_ACC_0_3NM = 6 // The horizontal accuracy is smaller than 0.3 Nautical Miles. 555.6 m.
+mavlink20.MAV_ODID_HOR_ACC_0_1NM = 7 // The horizontal accuracy is smaller than 0.1 Nautical Miles. 185.2 m.
+mavlink20.MAV_ODID_HOR_ACC_0_05NM = 8 // The horizontal accuracy is smaller than 0.05 Nautical Miles. 92.6 m.
+mavlink20.MAV_ODID_HOR_ACC_30_METER = 9 // The horizontal accuracy is smaller than 30 meter.
+mavlink20.MAV_ODID_HOR_ACC_10_METER = 10 // The horizontal accuracy is smaller than 10 meter.
+mavlink20.MAV_ODID_HOR_ACC_3_METER = 11 // The horizontal accuracy is smaller than 3 meter.
+mavlink20.MAV_ODID_HOR_ACC_1_METER = 12 // The horizontal accuracy is smaller than 1 meter.
+mavlink20.MAV_ODID_HOR_ACC_ENUM_END = 13 // 
+
+// MAV_ODID_VER_ACC
+mavlink20.MAV_ODID_VER_ACC_UNKNOWN = 0 // The vertical accuracy is unknown.
+mavlink20.MAV_ODID_VER_ACC_150_METER = 1 // The vertical accuracy is smaller than 150 meter.
+mavlink20.MAV_ODID_VER_ACC_45_METER = 2 // The vertical accuracy is smaller than 45 meter.
+mavlink20.MAV_ODID_VER_ACC_25_METER = 3 // The vertical accuracy is smaller than 25 meter.
+mavlink20.MAV_ODID_VER_ACC_10_METER = 4 // The vertical accuracy is smaller than 10 meter.
+mavlink20.MAV_ODID_VER_ACC_3_METER = 5 // The vertical accuracy is smaller than 3 meter.
+mavlink20.MAV_ODID_VER_ACC_1_METER = 6 // The vertical accuracy is smaller than 1 meter.
+mavlink20.MAV_ODID_VER_ACC_ENUM_END = 7 // 
+
+// MAV_ODID_SPEED_ACC
+mavlink20.MAV_ODID_SPEED_ACC_UNKNOWN = 0 // The speed accuracy is unknown.
+mavlink20.MAV_ODID_SPEED_ACC_10_METERS_PER_SECOND = 1 // The speed accuracy is smaller than 10 meters per second.
+mavlink20.MAV_ODID_SPEED_ACC_3_METERS_PER_SECOND = 2 // The speed accuracy is smaller than 3 meters per second.
+mavlink20.MAV_ODID_SPEED_ACC_1_METERS_PER_SECOND = 3 // The speed accuracy is smaller than 1 meters per second.
+mavlink20.MAV_ODID_SPEED_ACC_0_3_METERS_PER_SECOND = 4 // The speed accuracy is smaller than 0.3 meters per second.
+mavlink20.MAV_ODID_SPEED_ACC_ENUM_END = 5 // 
+
+// MAV_ODID_TIME_ACC
+mavlink20.MAV_ODID_TIME_ACC_UNKNOWN = 0 // The timestamp accuracy is unknown.
+mavlink20.MAV_ODID_TIME_ACC_0_1_SECOND = 1 // The timestamp accuracy is smaller than or equal to 0.1 second.
+mavlink20.MAV_ODID_TIME_ACC_0_2_SECOND = 2 // The timestamp accuracy is smaller than or equal to 0.2 second.
+mavlink20.MAV_ODID_TIME_ACC_0_3_SECOND = 3 // The timestamp accuracy is smaller than or equal to 0.3 second.
+mavlink20.MAV_ODID_TIME_ACC_0_4_SECOND = 4 // The timestamp accuracy is smaller than or equal to 0.4 second.
+mavlink20.MAV_ODID_TIME_ACC_0_5_SECOND = 5 // The timestamp accuracy is smaller than or equal to 0.5 second.
+mavlink20.MAV_ODID_TIME_ACC_0_6_SECOND = 6 // The timestamp accuracy is smaller than or equal to 0.6 second.
+mavlink20.MAV_ODID_TIME_ACC_0_7_SECOND = 7 // The timestamp accuracy is smaller than or equal to 0.7 second.
+mavlink20.MAV_ODID_TIME_ACC_0_8_SECOND = 8 // The timestamp accuracy is smaller than or equal to 0.8 second.
+mavlink20.MAV_ODID_TIME_ACC_0_9_SECOND = 9 // The timestamp accuracy is smaller than or equal to 0.9 second.
+mavlink20.MAV_ODID_TIME_ACC_1_0_SECOND = 10 // The timestamp accuracy is smaller than or equal to 1.0 second.
+mavlink20.MAV_ODID_TIME_ACC_1_1_SECOND = 11 // The timestamp accuracy is smaller than or equal to 1.1 second.
+mavlink20.MAV_ODID_TIME_ACC_1_2_SECOND = 12 // The timestamp accuracy is smaller than or equal to 1.2 second.
+mavlink20.MAV_ODID_TIME_ACC_1_3_SECOND = 13 // The timestamp accuracy is smaller than or equal to 1.3 second.
+mavlink20.MAV_ODID_TIME_ACC_1_4_SECOND = 14 // The timestamp accuracy is smaller than or equal to 1.4 second.
+mavlink20.MAV_ODID_TIME_ACC_1_5_SECOND = 15 // The timestamp accuracy is smaller than or equal to 1.5 second.
+mavlink20.MAV_ODID_TIME_ACC_ENUM_END = 16 // 
+
+// MAV_ODID_AUTH_TYPE
+mavlink20.MAV_ODID_AUTH_TYPE_NONE = 0 // No authentication type is specified.
+mavlink20.MAV_ODID_AUTH_TYPE_UAS_ID_SIGNATURE = 1 // Signature for the UAS (Unmanned Aircraft System) ID.
+mavlink20.MAV_ODID_AUTH_TYPE_OPERATOR_ID_SIGNATURE = 2 // Signature for the Operator ID.
+mavlink20.MAV_ODID_AUTH_TYPE_MESSAGE_SET_SIGNATURE = 3 // Signature for the entire message set.
+mavlink20.MAV_ODID_AUTH_TYPE_NETWORK_REMOTE_ID = 4 // Authentication is provided by Network Remote ID.
+mavlink20.MAV_ODID_AUTH_TYPE_SPECIFIC_AUTHENTICATION = 5 // The exact authentication type is indicated by the first byte of
+                        // authentication_data and these type values
+                        // are managed by ICAO.
+mavlink20.MAV_ODID_AUTH_TYPE_ENUM_END = 6 // 
+
+// MAV_ODID_DESC_TYPE
+mavlink20.MAV_ODID_DESC_TYPE_TEXT = 0 // Free-form text description of the purpose of the flight.
+mavlink20.MAV_ODID_DESC_TYPE_EMERGENCY = 1 // Optional additional clarification when status ==
+                        // MAV_ODID_STATUS_EMERGENCY.
+mavlink20.MAV_ODID_DESC_TYPE_EXTENDED_STATUS = 2 // Optional additional clarification when status !=
+                        // MAV_ODID_STATUS_EMERGENCY.
+mavlink20.MAV_ODID_DESC_TYPE_ENUM_END = 3 // 
+
+// MAV_ODID_OPERATOR_LOCATION_TYPE
+mavlink20.MAV_ODID_OPERATOR_LOCATION_TYPE_TAKEOFF = 0 // The location of the operator is the same as the take-off location.
+mavlink20.MAV_ODID_OPERATOR_LOCATION_TYPE_LIVE_GNSS = 1 // The location of the operator is based on live GNSS data.
+mavlink20.MAV_ODID_OPERATOR_LOCATION_TYPE_FIXED = 2 // The location of the operator is a fixed location.
+mavlink20.MAV_ODID_OPERATOR_LOCATION_TYPE_ENUM_END = 3 // 
+
+// MAV_ODID_CLASSIFICATION_TYPE
+mavlink20.MAV_ODID_CLASSIFICATION_TYPE_UNDECLARED = 0 // The classification type for the UA is undeclared.
+mavlink20.MAV_ODID_CLASSIFICATION_TYPE_EU = 1 // The classification type for the UA follows EU (European Union)
+                        // specifications.
+mavlink20.MAV_ODID_CLASSIFICATION_TYPE_ENUM_END = 2 // 
+
+// MAV_ODID_CATEGORY_EU
+mavlink20.MAV_ODID_CATEGORY_EU_UNDECLARED = 0 // The category for the UA, according to the EU specification, is
+                        // undeclared.
+mavlink20.MAV_ODID_CATEGORY_EU_OPEN = 1 // The category for the UA, according to the EU specification, is the
+                        // Open category.
+mavlink20.MAV_ODID_CATEGORY_EU_SPECIFIC = 2 // The category for the UA, according to the EU specification, is the
+                        // Specific category.
+mavlink20.MAV_ODID_CATEGORY_EU_CERTIFIED = 3 // The category for the UA, according to the EU specification, is the
+                        // Certified category.
+mavlink20.MAV_ODID_CATEGORY_EU_ENUM_END = 4 // 
+
+// MAV_ODID_CLASS_EU
+mavlink20.MAV_ODID_CLASS_EU_UNDECLARED = 0 // The class for the UA, according to the EU specification, is
+                        // undeclared.
+mavlink20.MAV_ODID_CLASS_EU_CLASS_0 = 1 // The class for the UA, according to the EU specification, is Class 0.
+mavlink20.MAV_ODID_CLASS_EU_CLASS_1 = 2 // The class for the UA, according to the EU specification, is Class 1.
+mavlink20.MAV_ODID_CLASS_EU_CLASS_2 = 3 // The class for the UA, according to the EU specification, is Class 2.
+mavlink20.MAV_ODID_CLASS_EU_CLASS_3 = 4 // The class for the UA, according to the EU specification, is Class 3.
+mavlink20.MAV_ODID_CLASS_EU_CLASS_4 = 5 // The class for the UA, according to the EU specification, is Class 4.
+mavlink20.MAV_ODID_CLASS_EU_CLASS_5 = 6 // The class for the UA, according to the EU specification, is Class 5.
+mavlink20.MAV_ODID_CLASS_EU_CLASS_6 = 7 // The class for the UA, according to the EU specification, is Class 6.
+mavlink20.MAV_ODID_CLASS_EU_ENUM_END = 8 // 
+
+// MAV_ODID_OPERATOR_ID_TYPE
+mavlink20.MAV_ODID_OPERATOR_ID_TYPE_CAA = 0 // CAA (Civil Aviation Authority) registered operator ID.
+mavlink20.MAV_ODID_OPERATOR_ID_TYPE_ENUM_END = 1 // 
+
+// MAV_ODID_ARM_STATUS
+mavlink20.MAV_ODID_ARM_STATUS_GOOD_TO_ARM = 0 // Passing arming checks.
+mavlink20.MAV_ODID_ARM_STATUS_PRE_ARM_FAIL_GENERIC = 1 // Generic arming failure, see error string for details.
+mavlink20.MAV_ODID_ARM_STATUS_ENUM_END = 2 // 
+
+// AIS_TYPE
+mavlink20.AIS_TYPE_UNKNOWN = 0 // Not available (default).
+mavlink20.AIS_TYPE_RESERVED_1 = 1 // 
+mavlink20.AIS_TYPE_RESERVED_2 = 2 // 
+mavlink20.AIS_TYPE_RESERVED_3 = 3 // 
+mavlink20.AIS_TYPE_RESERVED_4 = 4 // 
+mavlink20.AIS_TYPE_RESERVED_5 = 5 // 
+mavlink20.AIS_TYPE_RESERVED_6 = 6 // 
+mavlink20.AIS_TYPE_RESERVED_7 = 7 // 
+mavlink20.AIS_TYPE_RESERVED_8 = 8 // 
+mavlink20.AIS_TYPE_RESERVED_9 = 9 // 
+mavlink20.AIS_TYPE_RESERVED_10 = 10 // 
+mavlink20.AIS_TYPE_RESERVED_11 = 11 // 
+mavlink20.AIS_TYPE_RESERVED_12 = 12 // 
+mavlink20.AIS_TYPE_RESERVED_13 = 13 // 
+mavlink20.AIS_TYPE_RESERVED_14 = 14 // 
+mavlink20.AIS_TYPE_RESERVED_15 = 15 // 
+mavlink20.AIS_TYPE_RESERVED_16 = 16 // 
+mavlink20.AIS_TYPE_RESERVED_17 = 17 // 
+mavlink20.AIS_TYPE_RESERVED_18 = 18 // 
+mavlink20.AIS_TYPE_RESERVED_19 = 19 // 
+mavlink20.AIS_TYPE_WIG = 20 // Wing In Ground effect.
+mavlink20.AIS_TYPE_WIG_HAZARDOUS_A = 21 // 
+mavlink20.AIS_TYPE_WIG_HAZARDOUS_B = 22 // 
+mavlink20.AIS_TYPE_WIG_HAZARDOUS_C = 23 // 
+mavlink20.AIS_TYPE_WIG_HAZARDOUS_D = 24 // 
+mavlink20.AIS_TYPE_WIG_RESERVED_1 = 25 // 
+mavlink20.AIS_TYPE_WIG_RESERVED_2 = 26 // 
+mavlink20.AIS_TYPE_WIG_RESERVED_3 = 27 // 
+mavlink20.AIS_TYPE_WIG_RESERVED_4 = 28 // 
+mavlink20.AIS_TYPE_WIG_RESERVED_5 = 29 // 
+mavlink20.AIS_TYPE_FISHING = 30 // 
+mavlink20.AIS_TYPE_TOWING = 31 // 
+mavlink20.AIS_TYPE_TOWING_LARGE = 32 // Towing: length exceeds 200m or breadth exceeds 25m.
+mavlink20.AIS_TYPE_DREDGING = 33 // Dredging or other underwater ops.
+mavlink20.AIS_TYPE_DIVING = 34 // 
+mavlink20.AIS_TYPE_MILITARY = 35 // 
+mavlink20.AIS_TYPE_SAILING = 36 // 
+mavlink20.AIS_TYPE_PLEASURE = 37 // 
+mavlink20.AIS_TYPE_RESERVED_20 = 38 // 
+mavlink20.AIS_TYPE_RESERVED_21 = 39 // 
+mavlink20.AIS_TYPE_HSC = 40 // High Speed Craft.
+mavlink20.AIS_TYPE_HSC_HAZARDOUS_A = 41 // 
+mavlink20.AIS_TYPE_HSC_HAZARDOUS_B = 42 // 
+mavlink20.AIS_TYPE_HSC_HAZARDOUS_C = 43 // 
+mavlink20.AIS_TYPE_HSC_HAZARDOUS_D = 44 // 
+mavlink20.AIS_TYPE_HSC_RESERVED_1 = 45 // 
+mavlink20.AIS_TYPE_HSC_RESERVED_2 = 46 // 
+mavlink20.AIS_TYPE_HSC_RESERVED_3 = 47 // 
+mavlink20.AIS_TYPE_HSC_RESERVED_4 = 48 // 
+mavlink20.AIS_TYPE_HSC_UNKNOWN = 49 // 
+mavlink20.AIS_TYPE_PILOT = 50 // 
+mavlink20.AIS_TYPE_SAR = 51 // Search And Rescue vessel.
+mavlink20.AIS_TYPE_TUG = 52 // 
+mavlink20.AIS_TYPE_PORT_TENDER = 53 // 
+mavlink20.AIS_TYPE_ANTI_POLLUTION = 54 // Anti-pollution equipment.
+mavlink20.AIS_TYPE_LAW_ENFORCEMENT = 55 // 
+mavlink20.AIS_TYPE_SPARE_LOCAL_1 = 56 // 
+mavlink20.AIS_TYPE_SPARE_LOCAL_2 = 57 // 
+mavlink20.AIS_TYPE_MEDICAL_TRANSPORT = 58 // 
+mavlink20.AIS_TYPE_NONECOMBATANT = 59 // Noncombatant ship according to RR Resolution No. 18.
+mavlink20.AIS_TYPE_PASSENGER = 60 // 
+mavlink20.AIS_TYPE_PASSENGER_HAZARDOUS_A = 61 // 
+mavlink20.AIS_TYPE_PASSENGER_HAZARDOUS_B = 62 // 
+mavlink20.AIS_TYPE_AIS_TYPE_PASSENGER_HAZARDOUS_C = 63 // 
+mavlink20.AIS_TYPE_PASSENGER_HAZARDOUS_D = 64 // 
+mavlink20.AIS_TYPE_PASSENGER_RESERVED_1 = 65 // 
+mavlink20.AIS_TYPE_PASSENGER_RESERVED_2 = 66 // 
+mavlink20.AIS_TYPE_PASSENGER_RESERVED_3 = 67 // 
+mavlink20.AIS_TYPE_AIS_TYPE_PASSENGER_RESERVED_4 = 68 // 
+mavlink20.AIS_TYPE_PASSENGER_UNKNOWN = 69 // 
+mavlink20.AIS_TYPE_CARGO = 70 // 
+mavlink20.AIS_TYPE_CARGO_HAZARDOUS_A = 71 // 
+mavlink20.AIS_TYPE_CARGO_HAZARDOUS_B = 72 // 
+mavlink20.AIS_TYPE_CARGO_HAZARDOUS_C = 73 // 
+mavlink20.AIS_TYPE_CARGO_HAZARDOUS_D = 74 // 
+mavlink20.AIS_TYPE_CARGO_RESERVED_1 = 75 // 
+mavlink20.AIS_TYPE_CARGO_RESERVED_2 = 76 // 
+mavlink20.AIS_TYPE_CARGO_RESERVED_3 = 77 // 
+mavlink20.AIS_TYPE_CARGO_RESERVED_4 = 78 // 
+mavlink20.AIS_TYPE_CARGO_UNKNOWN = 79 // 
+mavlink20.AIS_TYPE_TANKER = 80 // 
+mavlink20.AIS_TYPE_TANKER_HAZARDOUS_A = 81 // 
+mavlink20.AIS_TYPE_TANKER_HAZARDOUS_B = 82 // 
+mavlink20.AIS_TYPE_TANKER_HAZARDOUS_C = 83 // 
+mavlink20.AIS_TYPE_TANKER_HAZARDOUS_D = 84 // 
+mavlink20.AIS_TYPE_TANKER_RESERVED_1 = 85 // 
+mavlink20.AIS_TYPE_TANKER_RESERVED_2 = 86 // 
+mavlink20.AIS_TYPE_TANKER_RESERVED_3 = 87 // 
+mavlink20.AIS_TYPE_TANKER_RESERVED_4 = 88 // 
+mavlink20.AIS_TYPE_TANKER_UNKNOWN = 89 // 
+mavlink20.AIS_TYPE_OTHER = 90 // 
+mavlink20.AIS_TYPE_OTHER_HAZARDOUS_A = 91 // 
+mavlink20.AIS_TYPE_OTHER_HAZARDOUS_B = 92 // 
+mavlink20.AIS_TYPE_OTHER_HAZARDOUS_C = 93 // 
+mavlink20.AIS_TYPE_OTHER_HAZARDOUS_D = 94 // 
+mavlink20.AIS_TYPE_OTHER_RESERVED_1 = 95 // 
+mavlink20.AIS_TYPE_OTHER_RESERVED_2 = 96 // 
+mavlink20.AIS_TYPE_OTHER_RESERVED_3 = 97 // 
+mavlink20.AIS_TYPE_OTHER_RESERVED_4 = 98 // 
+mavlink20.AIS_TYPE_OTHER_UNKNOWN = 99 // 
+mavlink20.AIS_TYPE_ENUM_END = 100 // 
+
+// AIS_NAV_STATUS
+mavlink20.UNDER_WAY = 0 // Under way using engine.
+mavlink20.AIS_NAV_ANCHORED = 1 // 
+mavlink20.AIS_NAV_UN_COMMANDED = 2 // 
+mavlink20.AIS_NAV_RESTRICTED_MANOEUVERABILITY = 3 // 
+mavlink20.AIS_NAV_DRAUGHT_CONSTRAINED = 4 // 
+mavlink20.AIS_NAV_MOORED = 5 // 
+mavlink20.AIS_NAV_AGROUND = 6 // 
+mavlink20.AIS_NAV_FISHING = 7 // 
+mavlink20.AIS_NAV_SAILING = 8 // 
+mavlink20.AIS_NAV_RESERVED_HSC = 9 // 
+mavlink20.AIS_NAV_RESERVED_WIG = 10 // 
+mavlink20.AIS_NAV_RESERVED_1 = 11 // 
+mavlink20.AIS_NAV_RESERVED_2 = 12 // 
+mavlink20.AIS_NAV_RESERVED_3 = 13 // 
+mavlink20.AIS_NAV_AIS_SART = 14 // Search And Rescue Transponder.
+mavlink20.AIS_NAV_UNKNOWN = 15 // Not available (default).
+mavlink20.AIS_NAV_STATUS_ENUM_END = 16 // 
+
+// AIS_FLAGS
+mavlink20.AIS_FLAGS_POSITION_ACCURACY = 1 // 1 = Position accuracy less than 10m, 0 = position accuracy greater
+                        // than 10m.
+mavlink20.AIS_FLAGS_VALID_COG = 2 // 
+mavlink20.AIS_FLAGS_VALID_VELOCITY = 4 // 
+mavlink20.AIS_FLAGS_HIGH_VELOCITY = 8 // 1 = Velocity over 52.5765m/s (102.2 knots)
+mavlink20.AIS_FLAGS_VALID_TURN_RATE = 16 // 
+mavlink20.AIS_FLAGS_TURN_RATE_SIGN_ONLY = 32 // Only the sign of the returned turn rate value is valid, either greater
+                        // than 5deg/30s or less than -5deg/30s
+mavlink20.AIS_FLAGS_VALID_DIMENSIONS = 64 // 
+mavlink20.AIS_FLAGS_LARGE_BOW_DIMENSION = 128 // Distance to bow is larger than 511m
+mavlink20.AIS_FLAGS_LARGE_STERN_DIMENSION = 256 // Distance to stern is larger than 511m
+mavlink20.AIS_FLAGS_LARGE_PORT_DIMENSION = 512 // Distance to port side is larger than 63m
+mavlink20.AIS_FLAGS_LARGE_STARBOARD_DIMENSION = 1024 // Distance to starboard side is larger than 63m
+mavlink20.AIS_FLAGS_VALID_CALLSIGN = 2048 // 
+mavlink20.AIS_FLAGS_VALID_NAME = 4096 // 
+mavlink20.AIS_FLAGS_ENUM_END = 4097 // 
+
+// MAV_WINCH_STATUS_FLAG
+mavlink20.MAV_WINCH_STATUS_HEALTHY = 1 // Winch is healthy
+mavlink20.MAV_WINCH_STATUS_FULLY_RETRACTED = 2 // Winch thread is fully retracted
+mavlink20.MAV_WINCH_STATUS_MOVING = 4 // Winch motor is moving
+mavlink20.MAV_WINCH_STATUS_CLUTCH_ENGAGED = 8 // Winch clutch is engaged allowing motor to move freely
+mavlink20.MAV_WINCH_STATUS_FLAG_ENUM_END = 9 // 
+
+// MAG_CAL_STATUS
+mavlink20.MAG_CAL_NOT_STARTED = 0 // 
+mavlink20.MAG_CAL_WAITING_TO_START = 1 // 
+mavlink20.MAG_CAL_RUNNING_STEP_ONE = 2 // 
+mavlink20.MAG_CAL_RUNNING_STEP_TWO = 3 // 
+mavlink20.MAG_CAL_SUCCESS = 4 // 
+mavlink20.MAG_CAL_FAILED = 5 // 
+mavlink20.MAG_CAL_BAD_ORIENTATION = 6 // 
+mavlink20.MAG_CAL_BAD_RADIUS = 7 // 
+mavlink20.MAG_CAL_STATUS_ENUM_END = 8 // 
+
+// CAN_FILTER_OP
+mavlink20.CAN_FILTER_REPLACE = 0 // 
+mavlink20.CAN_FILTER_ADD = 1 // 
+mavlink20.CAN_FILTER_REMOVE = 2 // 
+mavlink20.CAN_FILTER_OP_ENUM_END = 3 // 
+
+// NAV_VTOL_LAND_OPTIONS
+mavlink20.NAV_VTOL_LAND_OPTIONS_DEFAULT = 0 // Default autopilot landing behaviour.
+mavlink20.NAV_VTOL_LAND_OPTIONS_FW_SPIRAL_APPROACH = 1 // Use a fixed wing spiral desent approach before landing.
+mavlink20.NAV_VTOL_LAND_OPTIONS_FW_APPROACH = 2 // Use a fixed wing approach before detransitioning and landing
+                        // vertically.
+mavlink20.NAV_VTOL_LAND_OPTIONS_ENUM_END = 3 // 
+
+// MISSION_STATE
+mavlink20.MISSION_STATE_UNKNOWN = 0 // The mission status reporting is not supported.
+mavlink20.MISSION_STATE_NO_MISSION = 1 // No mission on the vehicle.
+mavlink20.MISSION_STATE_NOT_STARTED = 2 // Mission has not started. This is the case after a mission has uploaded
+                        // but not yet started executing.
+mavlink20.MISSION_STATE_ACTIVE = 3 // Mission is active, and will execute mission items when in auto mode.
+mavlink20.MISSION_STATE_PAUSED = 4 // Mission is paused when in auto mode.
+mavlink20.MISSION_STATE_COMPLETE = 5 // Mission has executed all mission items.
+mavlink20.MISSION_STATE_ENUM_END = 6 // 
+
+// SAFETY_SWITCH_STATE
+mavlink20.SAFETY_SWITCH_STATE_SAFE = 0 // Safety switch is engaged and vehicle should be safe to approach.
+mavlink20.SAFETY_SWITCH_STATE_DANGEROUS = 1 // Safety switch is NOT engaged and motors, propellers and other
+                        // actuators should be considered active.
+mavlink20.SAFETY_SWITCH_STATE_ENUM_END = 2 // 
+
+// AIRSPEED_SENSOR_FLAGS
+mavlink20.AIRSPEED_SENSOR_UNHEALTHY = 1 // Airspeed sensor is unhealthy
+mavlink20.AIRSPEED_SENSOR_USING = 2 // True if the data from this sensor is being actively used by the flight
+                        // controller for guidance, navigation or
+                        // control.
+mavlink20.AIRSPEED_SENSOR_FLAGS_ENUM_END = 3 // 
+
+// RADIO_RC_CHANNELS_FLAGS
+mavlink20.RADIO_RC_CHANNELS_FLAGS_FAILSAFE = 1 // Failsafe is active. The content of the RC channels data in the
+                        // RADIO_RC_CHANNELS message is implementation
+                        // dependent.
+mavlink20.RADIO_RC_CHANNELS_FLAGS_OUTDATED = 2 // Channel data may be out of date. This is set when the receiver is
+                        // unable to validate incoming data from the
+                        // transmitter and has therefore resent the
+                        // last valid data it received.
+mavlink20.RADIO_RC_CHANNELS_FLAGS_ENUM_END = 3 // 
+
+// MAV_STANDARD_MODE
+mavlink20.MAV_STANDARD_MODE_NON_STANDARD = 0 // Non standard mode.           This may be used when reporting the mode
+                        // if the current flight mode is not a
+                        // standard mode.
+mavlink20.MAV_STANDARD_MODE_POSITION_HOLD = 1 // Position mode (manual).           Position-controlled and stabilized
+                        // manual mode.           When sticks are
+                        // released vehicles return to their level-
+                        // flight orientation and hold both position
+                        // and altitude against wind and external
+                        // forces.           This mode can only be set
+                        // by vehicles that can hold a fixed position.
+                        // Multicopter (MC) vehicles actively brake
+                        // and hold both position and altitude against
+                        // wind and external forces.           Hybrid
+                        // MC/FW ("VTOL") vehicles first transition to
+                        // multicopter mode (if needed) but otherwise
+                        // behave in the same way as MC vehicles.
+                        // Fixed-wing (FW) vehicles must not support
+                        // this mode.           Other vehicle types
+                        // must not support this mode (this may be
+                        // revisited through the PR process).
+mavlink20.MAV_STANDARD_MODE_ORBIT = 2 // Orbit (manual).           Position-controlled and stabilized manual
+                        // mode.           The vehicle circles around
+                        // a fixed setpoint in the horizontal plane at
+                        // a particular radius, altitude, and
+                        // direction.           Flight stacks may
+                        // further allow manual control over the
+                        // setpoint position, radius, direction,
+                        // speed, and/or altitude of the circle, but
+                        // this is not mandated.           Flight
+                        // stacks may support the [MAV_CMD_DO_ORBIT](h
+                        // ttps://mavlink.io/en/messages/common.html#M
+                        // AV_CMD_DO_ORBIT) for changing the orbit
+                        // parameters.           MC and FW vehicles
+                        // may support this mode.           Hybrid
+                        // MC/FW ("VTOL") vehicles may support this
+                        // mode in MC/FW or both modes; if the mode is
+                        // not supported by the current configuration
+                        // the vehicle should transition to the
+                        // supported configuration.           Other
+                        // vehicle types must not support this mode
+                        // (this may be revisited through the PR
+                        // process).
+mavlink20.MAV_STANDARD_MODE_CRUISE = 3 // Cruise mode (manual).           Position-controlled and stabilized
+                        // manual mode.           When sticks are
+                        // released vehicles return to their level-
+                        // flight orientation and hold their original
+                        // track against wind and external forces.
+                        // Fixed-wing (FW) vehicles level orientation
+                        // and maintain current track and altitude
+                        // against wind and external forces.
+                        // Hybrid MC/FW ("VTOL") vehicles first
+                        // transition to FW mode (if needed) but
+                        // otherwise behave in the same way as MC
+                        // vehicles.           Multicopter (MC)
+                        // vehicles must not support this mode.
+                        // Other vehicle types must not support this
+                        // mode (this may be revisited through the PR
+                        // process).
+mavlink20.MAV_STANDARD_MODE_ALTITUDE_HOLD = 4 // Altitude hold (manual).           Altitude-controlled and stabilized
+                        // manual mode.           When sticks are
+                        // released vehicles return to their level-
+                        // flight orientation and hold their altitude.
+                        // MC vehicles continue with existing momentum
+                        // and may move with wind (or other external
+                        // forces).           FW vehicles continue
+                        // with current heading, but may be moved off-
+                        // track by wind.           Hybrid MC/FW
+                        // ("VTOL") vehicles behave according to their
+                        // current configuration/mode (FW or MC).
+                        // Other vehicle types must not support this
+                        // mode (this may be revisited through the PR
+                        // process).
+mavlink20.MAV_STANDARD_MODE_RETURN_HOME = 5 // Return home mode (auto).           Automatic mode that returns vehicle
+                        // to home via a safe flight path.
+                        // It may also automatically land the vehicle
+                        // (i.e. RTL).           The precise flight
+                        // path and landing behaviour depend on
+                        // vehicle configuration and type.
+mavlink20.MAV_STANDARD_MODE_SAFE_RECOVERY = 6 // Safe recovery mode (auto).           Automatic mode that takes vehicle
+                        // to a predefined safe location via a safe
+                        // flight path (rally point or mission defined
+                        // landing) .           It may also
+                        // automatically land the vehicle.
+                        // The precise return location, flight path,
+                        // and landing behaviour depend on vehicle
+                        // configuration and type.
+mavlink20.MAV_STANDARD_MODE_MISSION = 7 // Mission mode (automatic).           Automatic mode that executes
+                        // MAVLink missions.           Missions are
+                        // executed from the current waypoint as soon
+                        // as the mode is enabled.
+mavlink20.MAV_STANDARD_MODE_LAND = 8 // Land mode (auto).           Automatic mode that lands the vehicle at
+                        // the current location.           The precise
+                        // landing behaviour depends on vehicle
+                        // configuration and type.
+mavlink20.MAV_STANDARD_MODE_TAKEOFF = 9 // Takeoff mode (auto).           Automatic takeoff mode.           The
+                        // precise takeoff behaviour depends on
+                        // vehicle configuration and type.
+mavlink20.MAV_STANDARD_MODE_ENUM_END = 10 // 
+
+// MAV_MODE_PROPERTY
+mavlink20.MAV_MODE_PROPERTY_ADVANCED = 1 // If set, this mode is an advanced mode.           For example a rate-
+                        // controlled manual mode might be advanced,
+                        // whereas a position-controlled manual mode
+                        // is not.           A GCS can optionally use
+                        // this flag to configure the UI for its
+                        // intended users.
+mavlink20.MAV_MODE_PROPERTY_NOT_USER_SELECTABLE = 2 // If set, this mode should not be added to the list of selectable modes.
+                        // The mode might still be selected by the FC
+                        // directly (for example as part of a
+                        // failsafe).
+mavlink20.MAV_MODE_PROPERTY_ENUM_END = 3 // 
+
+// GPS_SYSTEM_ERROR_FLAGS
+mavlink20.GPS_SYSTEM_ERROR_INCOMING_CORRECTIONS = 1 // There are problems with incoming correction streams.
+mavlink20.GPS_SYSTEM_ERROR_CONFIGURATION = 2 // There are problems with the configuration.
+mavlink20.GPS_SYSTEM_ERROR_SOFTWARE = 4 // There are problems with the software on the GPS receiver.
+mavlink20.GPS_SYSTEM_ERROR_ANTENNA = 8 // There are problems with an antenna connected to the GPS receiver.
+mavlink20.GPS_SYSTEM_ERROR_EVENT_CONGESTION = 16 // There are problems handling all incoming events.
+mavlink20.GPS_SYSTEM_ERROR_CPU_OVERLOAD = 32 // The GPS receiver CPU is overloaded.
+mavlink20.GPS_SYSTEM_ERROR_OUTPUT_CONGESTION = 64 // The GPS receiver is experiencing output congestion.
+mavlink20.GPS_SYSTEM_ERROR_FLAGS_ENUM_END = 65 // 
+
+// GPS_AUTHENTICATION_STATE
+mavlink20.GPS_AUTHENTICATION_STATE_UNKNOWN = 0 // The GPS receiver does not provide GPS signal authentication info.
+mavlink20.GPS_AUTHENTICATION_STATE_INITIALIZING = 1 // The GPS receiver is initializing signal authentication.
+mavlink20.GPS_AUTHENTICATION_STATE_ERROR = 2 // The GPS receiver encountered an error while initializing signal
+                        // authentication.
+mavlink20.GPS_AUTHENTICATION_STATE_OK = 3 // The GPS receiver has correctly authenticated all signals.
+mavlink20.GPS_AUTHENTICATION_STATE_DISABLED = 4 // GPS signal authentication is disabled on the receiver.
+mavlink20.GPS_AUTHENTICATION_STATE_ENUM_END = 5 // 
+
+// GPS_JAMMING_STATE
+mavlink20.GPS_JAMMING_STATE_UNKNOWN = 0 // The GPS receiver does not provide GPS signal jamming info.
+mavlink20.GPS_JAMMING_STATE_OK = 1 // The GPS receiver detected no signal jamming.
+mavlink20.GPS_JAMMING_STATE_MITIGATED = 2 // The GPS receiver detected and mitigated signal jamming.
+mavlink20.GPS_JAMMING_STATE_DETECTED = 3 // The GPS receiver detected signal jamming.
+mavlink20.GPS_JAMMING_STATE_ENUM_END = 4 // 
+
+// GPS_SPOOFING_STATE
+mavlink20.GPS_SPOOFING_STATE_UNKNOWN = 0 // The GPS receiver does not provide GPS signal spoofing info.
+mavlink20.GPS_SPOOFING_STATE_OK = 1 // The GPS receiver detected no signal spoofing.
+mavlink20.GPS_SPOOFING_STATE_MITIGATED = 2 // The GPS receiver detected and mitigated signal spoofing.
+mavlink20.GPS_SPOOFING_STATE_DETECTED = 3 // The GPS receiver detected signal spoofing but still has a fix.
+mavlink20.GPS_SPOOFING_STATE_ENUM_END = 4 // 
+
+// GPS_RAIM_STATE
+mavlink20.GPS_RAIM_STATE_UNKNOWN = 0 // RAIM capability is unknown.
+mavlink20.GPS_RAIM_STATE_DISABLED = 1 // RAIM is disabled.
+mavlink20.GPS_RAIM_STATE_OK = 2 // RAIM integrity check was successful.
+mavlink20.GPS_RAIM_STATE_FAILED = 3 // RAIM integrity check failed.
+mavlink20.GPS_RAIM_STATE_ENUM_END = 4 // 
+
+// ICAROUS_TRACK_BAND_TYPES
+mavlink20.ICAROUS_TRACK_BAND_TYPE_NONE = 0 // 
+mavlink20.ICAROUS_TRACK_BAND_TYPE_NEAR = 1 // 
+mavlink20.ICAROUS_TRACK_BAND_TYPE_RECOVERY = 2 // 
+mavlink20.ICAROUS_TRACK_BAND_TYPES_ENUM_END = 3 // 
+
+// ICAROUS_FMS_STATE
+mavlink20.ICAROUS_FMS_STATE_IDLE = 0 // 
+mavlink20.ICAROUS_FMS_STATE_TAKEOFF = 1 // 
+mavlink20.ICAROUS_FMS_STATE_CLIMB = 2 // 
+mavlink20.ICAROUS_FMS_STATE_CRUISE = 3 // 
+mavlink20.ICAROUS_FMS_STATE_APPROACH = 4 // 
+mavlink20.ICAROUS_FMS_STATE_LAND = 5 // 
+mavlink20.ICAROUS_FMS_STATE_ENUM_END = 6 // 
+
+// MAV_AUTOPILOT
+mavlink20.MAV_AUTOPILOT_GENERIC = 0 // Generic autopilot, full support for everything
+mavlink20.MAV_AUTOPILOT_RESERVED = 1 // Reserved for future use.
+mavlink20.MAV_AUTOPILOT_SLUGS = 2 // SLUGS autopilot, http://slugsuav.soe.ucsc.edu
+mavlink20.MAV_AUTOPILOT_ARDUPILOTMEGA = 3 // ArduPilot - Plane/Copter/Rover/Sub/Tracker, https://ardupilot.org
+mavlink20.MAV_AUTOPILOT_OPENPILOT = 4 // OpenPilot, http://openpilot.org
+mavlink20.MAV_AUTOPILOT_GENERIC_WAYPOINTS_ONLY = 5 // Generic autopilot only supporting simple waypoints
+mavlink20.MAV_AUTOPILOT_GENERIC_WAYPOINTS_AND_SIMPLE_NAVIGATION_ONLY = 6 // Generic autopilot supporting waypoints and other simple navigation
+                        // commands
+mavlink20.MAV_AUTOPILOT_GENERIC_MISSION_FULL = 7 // Generic autopilot supporting the full mission command set
+mavlink20.MAV_AUTOPILOT_INVALID = 8 // No valid autopilot, e.g. a GCS or other MAVLink component
+mavlink20.MAV_AUTOPILOT_PPZ = 9 // PPZ UAV - http://nongnu.org/paparazzi
+mavlink20.MAV_AUTOPILOT_UDB = 10 // UAV Dev Board
+mavlink20.MAV_AUTOPILOT_FP = 11 // FlexiPilot
+mavlink20.MAV_AUTOPILOT_PX4 = 12 // PX4 Autopilot - http://px4.io/
+mavlink20.MAV_AUTOPILOT_SMACCMPILOT = 13 // SMACCMPilot - http://smaccmpilot.org
+mavlink20.MAV_AUTOPILOT_AUTOQUAD = 14 // AutoQuad -- http://autoquad.org
+mavlink20.MAV_AUTOPILOT_ARMAZILA = 15 // Armazila -- http://armazila.com
+mavlink20.MAV_AUTOPILOT_AEROB = 16 // Aerob -- http://aerob.ru
+mavlink20.MAV_AUTOPILOT_ASLUAV = 17 // ASLUAV autopilot -- http://www.asl.ethz.ch
+mavlink20.MAV_AUTOPILOT_SMARTAP = 18 // SmartAP Autopilot - http://sky-drones.com
+mavlink20.MAV_AUTOPILOT_AIRRAILS = 19 // AirRails - http://uaventure.com
+mavlink20.MAV_AUTOPILOT_REFLEX = 20 // Fusion Reflex - https://fusion.engineering
+mavlink20.MAV_AUTOPILOT_ENUM_END = 21 // 
+
+// MAV_TYPE
+mavlink20.MAV_TYPE_GENERIC = 0 // Generic micro air vehicle
+mavlink20.MAV_TYPE_FIXED_WING = 1 // Fixed wing aircraft.
+mavlink20.MAV_TYPE_QUADROTOR = 2 // Quadrotor
+mavlink20.MAV_TYPE_COAXIAL = 3 // Coaxial helicopter
+mavlink20.MAV_TYPE_HELICOPTER = 4 // Normal helicopter with tail rotor.
+mavlink20.MAV_TYPE_ANTENNA_TRACKER = 5 // Ground installation
+mavlink20.MAV_TYPE_GCS = 6 // Operator control unit / ground control station
+mavlink20.MAV_TYPE_AIRSHIP = 7 // Airship, controlled
+mavlink20.MAV_TYPE_FREE_BALLOON = 8 // Free balloon, uncontrolled
+mavlink20.MAV_TYPE_ROCKET = 9 // Rocket
+mavlink20.MAV_TYPE_GROUND_ROVER = 10 // Ground rover
+mavlink20.MAV_TYPE_SURFACE_BOAT = 11 // Surface vessel, boat, ship
+mavlink20.MAV_TYPE_SUBMARINE = 12 // Submarine
+mavlink20.MAV_TYPE_HEXAROTOR = 13 // Hexarotor
+mavlink20.MAV_TYPE_OCTOROTOR = 14 // Octorotor
+mavlink20.MAV_TYPE_TRICOPTER = 15 // Tricopter
+mavlink20.MAV_TYPE_FLAPPING_WING = 16 // Flapping wing
+mavlink20.MAV_TYPE_KITE = 17 // Kite
+mavlink20.MAV_TYPE_ONBOARD_CONTROLLER = 18 // Onboard companion controller
+mavlink20.MAV_TYPE_VTOL_DUOROTOR = 19 // Two-rotor VTOL using control surfaces in vertical operation in
+                        // addition. Tailsitter.
+mavlink20.MAV_TYPE_VTOL_QUADROTOR = 20 // Quad-rotor VTOL using a V-shaped quad config in vertical operation.
+                        // Tailsitter.
+mavlink20.MAV_TYPE_VTOL_TILTROTOR = 21 // Tiltrotor VTOL
+mavlink20.MAV_TYPE_VTOL_RESERVED2 = 22 // VTOL reserved 2
+mavlink20.MAV_TYPE_VTOL_RESERVED3 = 23 // VTOL reserved 3
+mavlink20.MAV_TYPE_VTOL_RESERVED4 = 24 // VTOL reserved 4
+mavlink20.MAV_TYPE_VTOL_RESERVED5 = 25 // VTOL reserved 5
+mavlink20.MAV_TYPE_GIMBAL = 26 // Gimbal
+mavlink20.MAV_TYPE_ADSB = 27 // ADSB system
+mavlink20.MAV_TYPE_PARAFOIL = 28 // Steerable, nonrigid airfoil
+mavlink20.MAV_TYPE_DODECAROTOR = 29 // Dodecarotor
+mavlink20.MAV_TYPE_CAMERA = 30 // Camera
+mavlink20.MAV_TYPE_CHARGING_STATION = 31 // Charging station
+mavlink20.MAV_TYPE_FLARM = 32 // FLARM collision avoidance system
+mavlink20.MAV_TYPE_SERVO = 33 // Servo
+mavlink20.MAV_TYPE_ODID = 34 // Open Drone ID. See https://mavlink.io/en/services/opendroneid.html.
+mavlink20.MAV_TYPE_DECAROTOR = 35 // Decarotor
+mavlink20.MAV_TYPE_BATTERY = 36 // Battery
+mavlink20.MAV_TYPE_PARACHUTE = 37 // Parachute
+mavlink20.MAV_TYPE_LOG = 38 // Log
+mavlink20.MAV_TYPE_OSD = 39 // OSD
+mavlink20.MAV_TYPE_IMU = 40 // IMU
+mavlink20.MAV_TYPE_GPS = 41 // GPS
+mavlink20.MAV_TYPE_WINCH = 42 // Winch
+mavlink20.MAV_TYPE_ENUM_END = 43 // 
+
+// MAV_MODE_FLAG
+mavlink20.MAV_MODE_FLAG_CUSTOM_MODE_ENABLED = 1 // 0b00000001 Reserved for future use.
+mavlink20.MAV_MODE_FLAG_TEST_ENABLED = 2 // 0b00000010 system has a test mode enabled. This flag is intended for
+                        // temporary system tests and should not be
+                        // used for stable implementations.
+mavlink20.MAV_MODE_FLAG_AUTO_ENABLED = 4 // 0b00000100 autonomous mode enabled, system finds its own goal
+                        // positions. Guided flag can be set or not,
+                        // depends on the actual implementation.
+mavlink20.MAV_MODE_FLAG_GUIDED_ENABLED = 8 // 0b00001000 guided mode enabled, system flies waypoints / mission
+                        // items.
+mavlink20.MAV_MODE_FLAG_STABILIZE_ENABLED = 16 // 0b00010000 system stabilizes electronically its attitude (and
+                        // optionally position). It needs however
+                        // further control inputs to move around.
+mavlink20.MAV_MODE_FLAG_HIL_ENABLED = 32 // 0b00100000 hardware in the loop simulation. All motors / actuators are
+                        // blocked, but internal software is full
+                        // operational.
+mavlink20.MAV_MODE_FLAG_MANUAL_INPUT_ENABLED = 64 // 0b01000000 remote control input is enabled.
+mavlink20.MAV_MODE_FLAG_SAFETY_ARMED = 128 // 0b10000000 MAV safety set to armed. Motors are enabled / running / can
+                        // start. Ready to fly. Additional note: this
+                        // flag is to be ignore when sent in the
+                        // command MAV_CMD_DO_SET_MODE and
+                        // MAV_CMD_COMPONENT_ARM_DISARM shall be used
+                        // instead. The flag can still be used to
+                        // report the armed state.
+mavlink20.MAV_MODE_FLAG_ENUM_END = 129 // 
+
+// MAV_MODE_FLAG_DECODE_POSITION
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_CUSTOM_MODE = 1 // Eighth bit: 00000001
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_TEST = 2 // Seventh bit: 00000010
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_AUTO = 4 // Sixth bit:   00000100
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_GUIDED = 8 // Fifth bit:  00001000
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_STABILIZE = 16 // Fourth bit: 00010000
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_HIL = 32 // Third bit:  00100000
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_MANUAL = 64 // Second bit: 01000000
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_SAFETY = 128 // First bit:  10000000
+mavlink20.MAV_MODE_FLAG_DECODE_POSITION_ENUM_END = 129 // 
+
+// MAV_STATE
+mavlink20.MAV_STATE_UNINIT = 0 // Uninitialized system, state is unknown.
+mavlink20.MAV_STATE_BOOT = 1 // System is booting up.
+mavlink20.MAV_STATE_CALIBRATING = 2 // System is calibrating and not flight-ready.
+mavlink20.MAV_STATE_STANDBY = 3 // System is grounded and on standby. It can be launched any time.
+mavlink20.MAV_STATE_ACTIVE = 4 // System is active and might be already airborne. Motors are engaged.
+mavlink20.MAV_STATE_CRITICAL = 5 // System is in a non-normal flight mode. It can however still navigate.
+mavlink20.MAV_STATE_EMERGENCY = 6 // System is in a non-normal flight mode. It lost control over parts or
+                        // over the whole airframe. It is in mayday
+                        // and going down.
+mavlink20.MAV_STATE_POWEROFF = 7 // System just initialized its power-down sequence, will shut down now.
+mavlink20.MAV_STATE_FLIGHT_TERMINATION = 8 // System is terminating itself.
+mavlink20.MAV_STATE_ENUM_END = 9 // 
+
+// MAV_COMPONENT
+mavlink20.MAV_COMP_ID_ALL = 0 // Target id (target_component) used to broadcast messages to all
+                        // components of the receiving system.
+                        // Components should attempt to process
+                        // messages with this component ID and forward
+                        // to components on any other interfaces.
+                        // Note: This is not a valid *source*
+                        // component id for a message.
+mavlink20.MAV_COMP_ID_AUTOPILOT1 = 1 // System flight controller component ("autopilot"). Only one autopilot
+                        // is expected in a particular system.
+mavlink20.MAV_COMP_ID_USER1 = 25 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER2 = 26 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER3 = 27 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER4 = 28 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER5 = 29 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER6 = 30 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER7 = 31 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER8 = 32 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER9 = 33 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER10 = 34 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER11 = 35 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER12 = 36 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER13 = 37 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER14 = 38 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER15 = 39 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER16 = 40 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER17 = 41 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER18 = 42 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER19 = 43 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER20 = 44 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER21 = 45 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER22 = 46 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER23 = 47 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER24 = 48 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER25 = 49 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER26 = 50 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER27 = 51 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER28 = 52 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER29 = 53 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER30 = 54 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER31 = 55 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER32 = 56 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER33 = 57 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER34 = 58 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER35 = 59 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER36 = 60 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER37 = 61 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER38 = 62 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER39 = 63 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER40 = 64 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER41 = 65 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER42 = 66 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER43 = 67 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_TELEMETRY_RADIO = 68 // Telemetry radio (e.g. SiK radio, or other component that emits
+                        // RADIO_STATUS messages).
+mavlink20.MAV_COMP_ID_USER45 = 69 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER46 = 70 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER47 = 71 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER48 = 72 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER49 = 73 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER50 = 74 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER51 = 75 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER52 = 76 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER53 = 77 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER54 = 78 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER55 = 79 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER56 = 80 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER57 = 81 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER58 = 82 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER59 = 83 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER60 = 84 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER61 = 85 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER62 = 86 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER63 = 87 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER64 = 88 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER65 = 89 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER66 = 90 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER67 = 91 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER68 = 92 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER69 = 93 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER70 = 94 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER71 = 95 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER72 = 96 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER73 = 97 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER74 = 98 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_USER75 = 99 // Id for a component on privately managed MAVLink network. Can be used
+                        // for any purpose but may not be published by
+                        // components outside of the private network.
+mavlink20.MAV_COMP_ID_CAMERA = 100 // Camera #1.
+mavlink20.MAV_COMP_ID_CAMERA2 = 101 // Camera #2.
+mavlink20.MAV_COMP_ID_CAMERA3 = 102 // Camera #3.
+mavlink20.MAV_COMP_ID_CAMERA4 = 103 // Camera #4.
+mavlink20.MAV_COMP_ID_CAMERA5 = 104 // Camera #5.
+mavlink20.MAV_COMP_ID_CAMERA6 = 105 // Camera #6.
+mavlink20.MAV_COMP_ID_SERVO1 = 140 // Servo #1.
+mavlink20.MAV_COMP_ID_SERVO2 = 141 // Servo #2.
+mavlink20.MAV_COMP_ID_SERVO3 = 142 // Servo #3.
+mavlink20.MAV_COMP_ID_SERVO4 = 143 // Servo #4.
+mavlink20.MAV_COMP_ID_SERVO5 = 144 // Servo #5.
+mavlink20.MAV_COMP_ID_SERVO6 = 145 // Servo #6.
+mavlink20.MAV_COMP_ID_SERVO7 = 146 // Servo #7.
+mavlink20.MAV_COMP_ID_SERVO8 = 147 // Servo #8.
+mavlink20.MAV_COMP_ID_SERVO9 = 148 // Servo #9.
+mavlink20.MAV_COMP_ID_SERVO10 = 149 // Servo #10.
+mavlink20.MAV_COMP_ID_SERVO11 = 150 // Servo #11.
+mavlink20.MAV_COMP_ID_SERVO12 = 151 // Servo #12.
+mavlink20.MAV_COMP_ID_SERVO13 = 152 // Servo #13.
+mavlink20.MAV_COMP_ID_SERVO14 = 153 // Servo #14.
+mavlink20.MAV_COMP_ID_GIMBAL = 154 // Gimbal #1.
+mavlink20.MAV_COMP_ID_LOG = 155 // Logging component.
+mavlink20.MAV_COMP_ID_ADSB = 156 // Automatic Dependent Surveillance-Broadcast (ADS-B) component.
+mavlink20.MAV_COMP_ID_OSD = 157 // On Screen Display (OSD) devices for video links.
+mavlink20.MAV_COMP_ID_PERIPHERAL = 158 // Generic autopilot peripheral component ID. Meant for devices that do
+                        // not implement the parameter microservice.
+mavlink20.MAV_COMP_ID_QX1_GIMBAL = 159 // Gimbal ID for QX1.
+mavlink20.MAV_COMP_ID_FLARM = 160 // FLARM collision alert component.
+mavlink20.MAV_COMP_ID_PARACHUTE = 161 // Parachute component.
+mavlink20.MAV_COMP_ID_GIMBAL2 = 171 // Gimbal #2.
+mavlink20.MAV_COMP_ID_GIMBAL3 = 172 // Gimbal #3.
+mavlink20.MAV_COMP_ID_GIMBAL4 = 173 // Gimbal #4
+mavlink20.MAV_COMP_ID_GIMBAL5 = 174 // Gimbal #5.
+mavlink20.MAV_COMP_ID_GIMBAL6 = 175 // Gimbal #6.
+mavlink20.MAV_COMP_ID_BATTERY = 180 // Battery #1.
+mavlink20.MAV_COMP_ID_BATTERY2 = 181 // Battery #2.
+mavlink20.MAV_COMP_ID_MAVCAN = 189 // CAN over MAVLink client.
+mavlink20.MAV_COMP_ID_MISSIONPLANNER = 190 // Component that can generate/supply a mission flight plan (e.g. GCS or
+                        // developer API).
+mavlink20.MAV_COMP_ID_ONBOARD_COMPUTER = 191 // Component that lives on the onboard computer (companion computer) and
+                        // has some generic functionalities, such as
+                        // settings system parameters and monitoring
+                        // the status of some processes that don't
+                        // directly speak mavlink and so on.
+mavlink20.MAV_COMP_ID_ONBOARD_COMPUTER2 = 192 // Component that lives on the onboard computer (companion computer) and
+                        // has some generic functionalities, such as
+                        // settings system parameters and monitoring
+                        // the status of some processes that don't
+                        // directly speak mavlink and so on.
+mavlink20.MAV_COMP_ID_ONBOARD_COMPUTER3 = 193 // Component that lives on the onboard computer (companion computer) and
+                        // has some generic functionalities, such as
+                        // settings system parameters and monitoring
+                        // the status of some processes that don't
+                        // directly speak mavlink and so on.
+mavlink20.MAV_COMP_ID_ONBOARD_COMPUTER4 = 194 // Component that lives on the onboard computer (companion computer) and
+                        // has some generic functionalities, such as
+                        // settings system parameters and monitoring
+                        // the status of some processes that don't
+                        // directly speak mavlink and so on.
+mavlink20.MAV_COMP_ID_PATHPLANNER = 195 // Component that finds an optimal path between points based on a certain
+                        // constraint (e.g. minimum snap, shortest
+                        // path, cost, etc.).
+mavlink20.MAV_COMP_ID_OBSTACLE_AVOIDANCE = 196 // Component that plans a collision free path between two points.
+mavlink20.MAV_COMP_ID_VISUAL_INERTIAL_ODOMETRY = 197 // Component that provides position estimates using VIO techniques.
+mavlink20.MAV_COMP_ID_PAIRING_MANAGER = 198 // Component that manages pairing of vehicle and GCS.
+mavlink20.MAV_COMP_ID_IMU = 200 // Inertial Measurement Unit (IMU) #1.
+mavlink20.MAV_COMP_ID_IMU_2 = 201 // Inertial Measurement Unit (IMU) #2.
+mavlink20.MAV_COMP_ID_IMU_3 = 202 // Inertial Measurement Unit (IMU) #3.
+mavlink20.MAV_COMP_ID_GPS = 220 // GPS #1.
+mavlink20.MAV_COMP_ID_GPS2 = 221 // GPS #2.
+mavlink20.MAV_COMP_ID_ODID_TXRX_1 = 236 // Open Drone ID transmitter/receiver (Bluetooth/WiFi/Internet).
+mavlink20.MAV_COMP_ID_ODID_TXRX_2 = 237 // Open Drone ID transmitter/receiver (Bluetooth/WiFi/Internet).
+mavlink20.MAV_COMP_ID_ODID_TXRX_3 = 238 // Open Drone ID transmitter/receiver (Bluetooth/WiFi/Internet).
+mavlink20.MAV_COMP_ID_UDP_BRIDGE = 240 // Component to bridge MAVLink to UDP (i.e. from a UART).
+mavlink20.MAV_COMP_ID_UART_BRIDGE = 241 // Component to bridge to UART (i.e. from UDP).
+mavlink20.MAV_COMP_ID_TUNNEL_NODE = 242 // Component handling TUNNEL messages (e.g. vendor specific GUI of a
+                        // component).
+mavlink20.MAV_COMP_ID_SYSTEM_CONTROL = 250 // Component for handling system messages (e.g. to ARM, takeoff, etc.).
+mavlink20.MAV_COMPONENT_ENUM_END = 251 // 
+
+// MAV_BOOL
+mavlink20.MAV_BOOL_FALSE = 0 // False.
+mavlink20.MAV_BOOL_TRUE = 1 // True.
+mavlink20.MAV_BOOL_ENUM_END = 2 // 
+
+// UALBERTA_AUTOPILOT_MODE
+mavlink20.MODE_MANUAL_DIRECT = 1 // Raw input pulse widts sent to output
+mavlink20.MODE_MANUAL_SCALED = 2 // Inputs are normalized using calibration, the converted back to raw
+                        // pulse widths for output
+mavlink20.MODE_AUTO_PID_ATT = 3 //  dfsdfs
+mavlink20.MODE_AUTO_PID_VEL = 4 //  dfsfds
+mavlink20.MODE_AUTO_PID_POS = 5 //  dfsdfsdfs
+mavlink20.UALBERTA_AUTOPILOT_MODE_ENUM_END = 6 // 
+
+// UALBERTA_NAV_MODE
+mavlink20.NAV_AHRS_INIT = 1 // 
+mavlink20.NAV_AHRS = 2 // AHRS mode
+mavlink20.NAV_INS_GPS_INIT = 3 // INS/GPS initialization mode
+mavlink20.NAV_INS_GPS = 4 // INS/GPS mode
+mavlink20.UALBERTA_NAV_MODE_ENUM_END = 5 // 
+
+// UALBERTA_PILOT_MODE
+mavlink20.PILOT_MANUAL = 1 //  sdf
+mavlink20.PILOT_AUTO = 2 //  dfs
+mavlink20.PILOT_ROTO = 3 //  Rotomotion mode
+mavlink20.UALBERTA_PILOT_MODE_ENUM_END = 4 // 
+
+// UAVIONIX_ADSB_OUT_DYNAMIC_STATE
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_STATE_INTENT_CHANGE = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_STATE_AUTOPILOT_ENABLED = 2 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_STATE_NICBARO_CROSSCHECKED = 4 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_STATE_ON_GROUND = 8 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_STATE_IDENT = 16 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_STATE_ENUM_END = 17 // 
+
+// UAVIONIX_ADSB_OUT_RF_SELECT
+mavlink20.UAVIONIX_ADSB_OUT_RF_SELECT_RX_ENABLED = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_RF_SELECT_TX_ENABLED = 2 // 
+mavlink20.UAVIONIX_ADSB_OUT_RF_SELECT_ENUM_END = 3 // 
+
+// UAVIONIX_ADSB_OUT_DYNAMIC_GPS_FIX
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_GPS_FIX_NONE_0 = 0 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_GPS_FIX_NONE_1 = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_GPS_FIX_2D = 2 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_GPS_FIX_3D = 3 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_GPS_FIX_DGPS = 4 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_GPS_FIX_RTK = 5 // 
+mavlink20.UAVIONIX_ADSB_OUT_DYNAMIC_GPS_FIX_ENUM_END = 6 // 
+
+// UAVIONIX_ADSB_RF_HEALTH
+mavlink20.UAVIONIX_ADSB_RF_HEALTH_OK = 1 // 
+mavlink20.UAVIONIX_ADSB_RF_HEALTH_FAIL_TX = 2 // 
+mavlink20.UAVIONIX_ADSB_RF_HEALTH_FAIL_RX = 16 // 
+mavlink20.UAVIONIX_ADSB_RF_HEALTH_ENUM_END = 17 // 
+
+// UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_NO_DATA = 0 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L15M_W23M = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L25M_W28P5M = 2 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L25_34M = 3 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L35_33M = 4 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L35_38M = 5 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L45_39P5M = 6 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L45_45M = 7 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L55_45M = 8 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L55_52M = 9 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L65_59P5M = 10 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L65_67M = 11 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L75_W72P5M = 12 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L75_W80M = 13 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L85_W80M = 14 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_L85_W90M = 15 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_AIRCRAFT_SIZE_ENUM_END = 16 // 
+
+// UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_NO_DATA = 0 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_LEFT_2M = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_LEFT_4M = 2 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_LEFT_6M = 3 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_RIGHT_0M = 4 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_RIGHT_2M = 5 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_RIGHT_4M = 6 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_RIGHT_6M = 7 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LAT_ENUM_END = 8 // 
+
+// UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LON
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LON_NO_DATA = 0 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LON_APPLIED_BY_SENSOR = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_CFG_GPS_OFFSET_LON_ENUM_END = 2 // 
+
+// UAVIONIX_ADSB_EMERGENCY_STATUS
+mavlink20.UAVIONIX_ADSB_OUT_NO_EMERGENCY = 0 // 
+mavlink20.UAVIONIX_ADSB_OUT_GENERAL_EMERGENCY = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_LIFEGUARD_EMERGENCY = 2 // 
+mavlink20.UAVIONIX_ADSB_OUT_MINIMUM_FUEL_EMERGENCY = 3 // 
+mavlink20.UAVIONIX_ADSB_OUT_NO_COMM_EMERGENCY = 4 // 
+mavlink20.UAVIONIX_ADSB_OUT_UNLAWFUL_INTERFERANCE_EMERGENCY = 5 // 
+mavlink20.UAVIONIX_ADSB_OUT_DOWNED_AIRCRAFT_EMERGENCY = 6 // 
+mavlink20.UAVIONIX_ADSB_OUT_RESERVED = 7 // 
+mavlink20.UAVIONIX_ADSB_EMERGENCY_STATUS_ENUM_END = 8 // 
+
+// UAVIONIX_ADSB_OUT_CONTROL_STATE
+mavlink20.UAVIONIX_ADSB_OUT_CONTROL_STATE_EXTERNAL_BARO_CROSSCHECKED = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_CONTROL_STATE_ON_GROUND = 4 // 
+mavlink20.UAVIONIX_ADSB_OUT_CONTROL_STATE_IDENT_BUTTON_ACTIVE = 8 // 
+mavlink20.UAVIONIX_ADSB_OUT_CONTROL_STATE_MODE_A_ENABLED = 16 // 
+mavlink20.UAVIONIX_ADSB_OUT_CONTROL_STATE_MODE_C_ENABLED = 32 // 
+mavlink20.UAVIONIX_ADSB_OUT_CONTROL_STATE_MODE_S_ENABLED = 64 // 
+mavlink20.UAVIONIX_ADSB_OUT_CONTROL_STATE_1090ES_TX_ENABLED = 128 // 
+mavlink20.UAVIONIX_ADSB_OUT_CONTROL_STATE_ENUM_END = 129 // 
+
+// UAVIONIX_ADSB_XBIT
+mavlink20.UAVIONIX_ADSB_XBIT_ENABLED = 128 // 
+mavlink20.UAVIONIX_ADSB_XBIT_ENUM_END = 129 // 
+
+// UAVIONIX_ADSB_OUT_STATUS_STATE
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_ON_GROUND = 1 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_INTERROGATED_SINCE_LAST = 2 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_XBIT_ENABLED = 4 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_IDENT_ACTIVE = 8 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_MODE_A_ENABLED = 16 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_MODE_C_ENABLED = 32 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_MODE_S_ENABLED = 64 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_1090ES_TX_ENABLED = 128 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_STATE_ENUM_END = 129 // 
+
+// UAVIONIX_ADSB_OUT_STATUS_NIC_NACP
+mavlink20.UAVIONIX_ADSB_NIC_CR_20_NM = 1 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_8_NM = 2 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_4_NM = 3 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_2_NM = 4 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_1_NM = 5 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_0_3_NM = 6 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_0_2_NM = 7 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_0_1_NM = 8 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_75_M = 9 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_25_M = 10 // 
+mavlink20.UAVIONIX_ADSB_NIC_CR_7_5_M = 11 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_10_NM = 16 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_4_NM = 32 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_2_NM = 48 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_1_NM = 64 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_0_5_NM = 80 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_0_3_NM = 96 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_0_1_NM = 112 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_0_05_NM = 128 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_30_M = 144 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_10_M = 160 // 
+mavlink20.UAVIONIX_ADSB_NACP_EPU_3_M = 176 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_NIC_NACP_ENUM_END = 177 // 
+
+// UAVIONIX_ADSB_OUT_STATUS_FAULT
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_FAULT_STATUS_MESSAGE_UNAVAIL = 8 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_FAULT_GPS_NO_POS = 16 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_FAULT_GPS_UNAVAIL = 32 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_FAULT_TX_SYSTEM_FAIL = 64 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_FAULT_MAINT_REQ = 128 // 
+mavlink20.UAVIONIX_ADSB_OUT_STATUS_FAULT_ENUM_END = 129 // 
+
+// MAV_STORM32_TUNNEL_PAYLOAD_TYPE
+mavlink20.MAV_STORM32_TUNNEL_PAYLOAD_TYPE_STORM32_CH1_IN = 200 // Registered for STorM32 gimbal controller. For communication with
+                        // gimbal or camera.
+mavlink20.MAV_STORM32_TUNNEL_PAYLOAD_TYPE_STORM32_CH1_OUT = 201 // Registered for STorM32 gimbal controller. For communication with
+                        // gimbal or camera.
+mavlink20.MAV_STORM32_TUNNEL_PAYLOAD_TYPE_STORM32_CH2_IN = 202 // Registered for STorM32 gimbal controller. For communication with
+                        // gimbal.
+mavlink20.MAV_STORM32_TUNNEL_PAYLOAD_TYPE_STORM32_CH2_OUT = 203 // Registered for STorM32 gimbal controller. For communication with
+                        // gimbal.
+mavlink20.MAV_STORM32_TUNNEL_PAYLOAD_TYPE_STORM32_CH3_IN = 204 // Registered for STorM32 gimbal controller. For communication with
+                        // camera.
+mavlink20.MAV_STORM32_TUNNEL_PAYLOAD_TYPE_STORM32_CH3_OUT = 205 // Registered for STorM32 gimbal controller. For communication with
+                        // camera.
+mavlink20.MAV_STORM32_TUNNEL_PAYLOAD_TYPE_ENUM_END = 206 // 
+
+// MAV_STORM32_GIMBAL_MANAGER_CAP_FLAGS
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CAP_FLAGS_HAS_PROFILES = 1 // The gimbal manager supports several profiles.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CAP_FLAGS_ENUM_END = 2 // 
+
+// MAV_STORM32_GIMBAL_MANAGER_FLAGS
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_RC_ACTIVE = 1 // Request to set RC input to active, or report RC input is active.
+                        // Implies RC mixed. RC exclusive is achieved
+                        // by setting all clients to inactive.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_CLIENT_ONBOARD_ACTIVE = 2 // Request to set onboard/companion computer client to active, or report
+                        // this client is active.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_CLIENT_AUTOPILOT_ACTIVE = 4 // Request to set autopliot client to active, or report this client is
+                        // active.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_CLIENT_GCS_ACTIVE = 8 // Request to set GCS client to active, or report this client is active.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_CLIENT_CAMERA_ACTIVE = 16 // Request to set camera client to active, or report this client is
+                        // active.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_CLIENT_GCS2_ACTIVE = 32 // Request to set GCS2 client to active, or report this client is active.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_CLIENT_CAMERA2_ACTIVE = 64 // Request to set camera2 client to active, or report this client is
+                        // active.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_CLIENT_CUSTOM_ACTIVE = 128 // Request to set custom client to active, or report this client is
+                        // active.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_CLIENT_CUSTOM2_ACTIVE = 256 // Request to set custom2 client to active, or report this client is
+                        // active.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_SET_SUPERVISON = 512 // Request supervision. This flag is only for setting, it is not
+                        // reported.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_SET_RELEASE = 1024 // Release supervision. This flag is only for setting, it is not
+                        // reported.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_FLAGS_ENUM_END = 1025 // 
+
+// MAV_STORM32_GIMBAL_MANAGER_CLIENT
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_NONE = 0 // For convenience.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_ONBOARD = 1 // This is the onboard/companion computer client.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_AUTOPILOT = 2 // This is the autopilot client.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_GCS = 3 // This is the GCS client.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_CAMERA = 4 // This is the camera client.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_GCS2 = 5 // This is the GCS2 client.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_CAMERA2 = 6 // This is the camera2 client.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_CUSTOM = 7 // This is the custom client.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_CUSTOM2 = 8 // This is the custom2 client.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_CLIENT_ENUM_END = 9 // 
+
+// MAV_STORM32_GIMBAL_MANAGER_PROFILE
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_PROFILE_DEFAULT = 0 // Default profile. Implementation specific.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_PROFILE_CUSTOM = 1 // Not supported/deprecated.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_PROFILE_COOPERATIVE = 2 // Profile with cooperative behavior.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_PROFILE_EXCLUSIVE = 3 // Profile with exclusive behavior.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_PROFILE_PRIORITY_COOPERATIVE = 4 // Profile with priority and cooperative behavior for equal priority.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_PROFILE_PRIORITY_EXCLUSIVE = 5 // Profile with priority and exclusive behavior for equal priority.
+mavlink20.MAV_STORM32_GIMBAL_MANAGER_PROFILE_ENUM_END = 6 // 
+
+// MAV_QSHOT_MODE
+mavlink20.MAV_QSHOT_MODE_UNDEFINED = 0 // Undefined shot mode. Can be used to determine if qshots should be used
+                        // or not.
+mavlink20.MAV_QSHOT_MODE_DEFAULT = 1 // Start normal gimbal operation. Is usually used to return back from a
+                        // shot.
+mavlink20.MAV_QSHOT_MODE_GIMBAL_RETRACT = 2 // Load and keep safe gimbal position and stop stabilization.
+mavlink20.MAV_QSHOT_MODE_GIMBAL_NEUTRAL = 3 // Load neutral gimbal position and keep it while stabilizing.
+mavlink20.MAV_QSHOT_MODE_GIMBAL_MISSION = 4 // Start mission with gimbal control.
+mavlink20.MAV_QSHOT_MODE_GIMBAL_RC_CONTROL = 5 // Start RC gimbal control.
+mavlink20.MAV_QSHOT_MODE_POI_TARGETING = 6 // Start gimbal tracking the point specified by Lat, Lon, Alt.
+mavlink20.MAV_QSHOT_MODE_SYSID_TARGETING = 7 // Start gimbal tracking the system with specified system ID.
+mavlink20.MAV_QSHOT_MODE_CABLECAM_2POINT = 8 // Start 2-point cable cam quick shot.
+mavlink20.MAV_QSHOT_MODE_HOME_TARGETING = 9 // Start gimbal tracking the home location.
+mavlink20.MAV_QSHOT_MODE_ENUM_END = 10 // 
+
+// MLRS_RADIO_LINK_STATS_FLAGS
+mavlink20.MLRS_RADIO_LINK_STATS_FLAGS_RSSI_DBM = 1 // Rssi values are in negative dBm. Values 1..254 corresponds to -1..-254
+                        // dBm. 0: no reception, UINT8_MAX: unknown.
+mavlink20.MLRS_RADIO_LINK_STATS_FLAGS_RX_RECEIVE_ANTENNA2 = 2 // Rx receive antenna. When set the data received on antenna 2 are taken,
+                        // else the data stems from antenna 1.
+mavlink20.MLRS_RADIO_LINK_STATS_FLAGS_RX_TRANSMIT_ANTENNA1 = 4 // Rx transmit antenna. Data are transmitted on antenna 1.
+mavlink20.MLRS_RADIO_LINK_STATS_FLAGS_RX_TRANSMIT_ANTENNA2 = 8 // Rx transmit antenna. Data are transmitted on antenna 2.
+mavlink20.MLRS_RADIO_LINK_STATS_FLAGS_TX_RECEIVE_ANTENNA2 = 16 // Tx receive antenna. When set the data received on antenna 2 are taken,
+                        // else the data stems from antenna 1.
+mavlink20.MLRS_RADIO_LINK_STATS_FLAGS_TX_TRANSMIT_ANTENNA1 = 32 // Tx transmit antenna. Data are transmitted on antenna 1.
+mavlink20.MLRS_RADIO_LINK_STATS_FLAGS_TX_TRANSMIT_ANTENNA2 = 64 // Tx transmit antenna. Data are transmitted on antenna 2.
+mavlink20.MLRS_RADIO_LINK_STATS_FLAGS_ENUM_END = 65 // 
+
+// MLRS_RADIO_LINK_TYPE
+mavlink20.MLRS_RADIO_LINK_TYPE_GENERIC = 0 // Unknown radio link type.
+mavlink20.MLRS_RADIO_LINK_TYPE_HERELINK = 1 // Radio link is HereLink.
+mavlink20.MLRS_RADIO_LINK_TYPE_DRAGONLINK = 2 // Radio link is Dragon Link.
+mavlink20.MLRS_RADIO_LINK_TYPE_RFD900 = 3 // Radio link is RFD900.
+mavlink20.MLRS_RADIO_LINK_TYPE_CROSSFIRE = 4 // Radio link is Crossfire.
+mavlink20.MLRS_RADIO_LINK_TYPE_EXPRESSLRS = 5 // Radio link is ExpressLRS.
+mavlink20.MLRS_RADIO_LINK_TYPE_MLRS = 6 // Radio link is mLRS.
+mavlink20.MLRS_RADIO_LINK_TYPE_ENUM_END = 7 // 
+
+// MAV_AVSS_COMMAND_FAILURE_REASON
+mavlink20.PRS_NOT_STEADY = 1 // AVSS defined command failure reason. PRS not steady.
+mavlink20.PRS_DTM_NOT_ARMED = 2 // AVSS defined command failure reason. PRS DTM not armed.
+mavlink20.PRS_OTM_NOT_ARMED = 3 // AVSS defined command failure reason. PRS OTM not armed.
+mavlink20.MAV_AVSS_COMMAND_FAILURE_REASON_ENUM_END = 4 // 
+
+// AVSS_M300_OPERATION_MODE
+mavlink20.MODE_M300_MANUAL_CTRL = 0 // In manual control mode
+mavlink20.MODE_M300_ATTITUDE = 1 // In attitude mode
+mavlink20.MODE_M300_P_GPS = 6 // In GPS mode
+mavlink20.MODE_M300_HOTPOINT_MODE = 9 // In hotpoint mode
+mavlink20.MODE_M300_ASSISTED_TAKEOFF = 10 // In assisted takeoff mode
+mavlink20.MODE_M300_AUTO_TAKEOFF = 11 // In auto takeoff mode
+mavlink20.MODE_M300_AUTO_LANDING = 12 // In auto landing mode
+mavlink20.MODE_M300_NAVI_GO_HOME = 15 // In go home mode
+mavlink20.MODE_M300_NAVI_SDK_CTRL = 17 // In sdk control mode
+mavlink20.MODE_M300_S_SPORT = 31 // In sport mode
+mavlink20.MODE_M300_FORCE_AUTO_LANDING = 33 // In force auto landing mode
+mavlink20.MODE_M300_T_TRIPOD = 38 // In tripod mode
+mavlink20.MODE_M300_SEARCH_MODE = 40 // In search mode
+mavlink20.MODE_M300_ENGINE_START = 41 // In engine mode
+mavlink20.AVSS_M300_OPERATION_MODE_ENUM_END = 42 // 
+
+// AVSS_HORSEFLY_OPERATION_MODE
+mavlink20.MODE_HORSEFLY_MANUAL_CTRL = 0 // In manual control mode
+mavlink20.MODE_HORSEFLY_AUTO_TAKEOFF = 1 // In auto takeoff mode
+mavlink20.MODE_HORSEFLY_AUTO_LANDING = 2 // In auto landing mode
+mavlink20.MODE_HORSEFLY_NAVI_GO_HOME = 3 // In go home mode
+mavlink20.MODE_HORSEFLY_DROP = 4 // In drop mode
+mavlink20.AVSS_HORSEFLY_OPERATION_MODE_ENUM_END = 5 // 
+
+// AIRLINK_AUTH_RESPONSE_TYPE
+mavlink20.AIRLINK_ERROR_LOGIN_OR_PASS = 0 // Login or password error
+mavlink20.AIRLINK_AUTH_OK = 1 // Auth successful
+mavlink20.AIRLINK_AUTH_RESPONSE_TYPE_ENUM_END = 2 // 
+
+// message IDs
+mavlink20.MAVLINK_MSG_ID_BAD_DATA = -1
+mavlink20.MAVLINK_MSG_ID_SENSOR_OFFSETS = 150
+mavlink20.MAVLINK_MSG_ID_SET_MAG_OFFSETS = 151
+mavlink20.MAVLINK_MSG_ID_MEMINFO = 152
+mavlink20.MAVLINK_MSG_ID_AP_ADC = 153
+mavlink20.MAVLINK_MSG_ID_DIGICAM_CONFIGURE = 154
+mavlink20.MAVLINK_MSG_ID_DIGICAM_CONTROL = 155
+mavlink20.MAVLINK_MSG_ID_MOUNT_CONFIGURE = 156
+mavlink20.MAVLINK_MSG_ID_MOUNT_CONTROL = 157
+mavlink20.MAVLINK_MSG_ID_MOUNT_STATUS = 158
+mavlink20.MAVLINK_MSG_ID_FENCE_POINT = 160
+mavlink20.MAVLINK_MSG_ID_FENCE_FETCH_POINT = 161
+mavlink20.MAVLINK_MSG_ID_AHRS = 163
+mavlink20.MAVLINK_MSG_ID_SIMSTATE = 164
+mavlink20.MAVLINK_MSG_ID_HWSTATUS = 165
+mavlink20.MAVLINK_MSG_ID_RADIO = 166
+mavlink20.MAVLINK_MSG_ID_LIMITS_STATUS = 167
+mavlink20.MAVLINK_MSG_ID_WIND = 168
+mavlink20.MAVLINK_MSG_ID_DATA16 = 169
+mavlink20.MAVLINK_MSG_ID_DATA32 = 170
+mavlink20.MAVLINK_MSG_ID_DATA64 = 171
+mavlink20.MAVLINK_MSG_ID_DATA96 = 172
+mavlink20.MAVLINK_MSG_ID_RANGEFINDER = 173
+mavlink20.MAVLINK_MSG_ID_AIRSPEED_AUTOCAL = 174
+mavlink20.MAVLINK_MSG_ID_RALLY_POINT = 175
+mavlink20.MAVLINK_MSG_ID_RALLY_FETCH_POINT = 176
+mavlink20.MAVLINK_MSG_ID_COMPASSMOT_STATUS = 177
+mavlink20.MAVLINK_MSG_ID_AHRS2 = 178
+mavlink20.MAVLINK_MSG_ID_CAMERA_STATUS = 179
+mavlink20.MAVLINK_MSG_ID_CAMERA_FEEDBACK = 180
+mavlink20.MAVLINK_MSG_ID_BATTERY2 = 181
+mavlink20.MAVLINK_MSG_ID_AHRS3 = 182
+mavlink20.MAVLINK_MSG_ID_AUTOPILOT_VERSION_REQUEST = 183
+mavlink20.MAVLINK_MSG_ID_REMOTE_LOG_DATA_BLOCK = 184
+mavlink20.MAVLINK_MSG_ID_REMOTE_LOG_BLOCK_STATUS = 185
+mavlink20.MAVLINK_MSG_ID_LED_CONTROL = 186
+mavlink20.MAVLINK_MSG_ID_MAG_CAL_PROGRESS = 191
+mavlink20.MAVLINK_MSG_ID_EKF_STATUS_REPORT = 193
+mavlink20.MAVLINK_MSG_ID_PID_TUNING = 194
+mavlink20.MAVLINK_MSG_ID_DEEPSTALL = 195
+mavlink20.MAVLINK_MSG_ID_GIMBAL_REPORT = 200
+mavlink20.MAVLINK_MSG_ID_GIMBAL_CONTROL = 201
+mavlink20.MAVLINK_MSG_ID_GIMBAL_TORQUE_CMD_REPORT = 214
+mavlink20.MAVLINK_MSG_ID_GOPRO_HEARTBEAT = 215
+mavlink20.MAVLINK_MSG_ID_GOPRO_GET_REQUEST = 216
+mavlink20.MAVLINK_MSG_ID_GOPRO_GET_RESPONSE = 217
+mavlink20.MAVLINK_MSG_ID_GOPRO_SET_REQUEST = 218
+mavlink20.MAVLINK_MSG_ID_GOPRO_SET_RESPONSE = 219
+mavlink20.MAVLINK_MSG_ID_RPM = 226
+mavlink20.MAVLINK_MSG_ID_DEVICE_OP_READ = 11000
+mavlink20.MAVLINK_MSG_ID_DEVICE_OP_READ_REPLY = 11001
+mavlink20.MAVLINK_MSG_ID_DEVICE_OP_WRITE = 11002
+mavlink20.MAVLINK_MSG_ID_DEVICE_OP_WRITE_REPLY = 11003
+mavlink20.MAVLINK_MSG_ID_SECURE_COMMAND = 11004
+mavlink20.MAVLINK_MSG_ID_SECURE_COMMAND_REPLY = 11005
+mavlink20.MAVLINK_MSG_ID_ADAP_TUNING = 11010
+mavlink20.MAVLINK_MSG_ID_VISION_POSITION_DELTA = 11011
+mavlink20.MAVLINK_MSG_ID_AOA_SSA = 11020
+mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_1_TO_4 = 11030
+mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_5_TO_8 = 11031
+mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_9_TO_12 = 11032
+mavlink20.MAVLINK_MSG_ID_OSD_PARAM_CONFIG = 11033
+mavlink20.MAVLINK_MSG_ID_OSD_PARAM_CONFIG_REPLY = 11034
+mavlink20.MAVLINK_MSG_ID_OSD_PARAM_SHOW_CONFIG = 11035
+mavlink20.MAVLINK_MSG_ID_OSD_PARAM_SHOW_CONFIG_REPLY = 11036
+mavlink20.MAVLINK_MSG_ID_OBSTACLE_DISTANCE_3D = 11037
+mavlink20.MAVLINK_MSG_ID_WATER_DEPTH = 11038
+mavlink20.MAVLINK_MSG_ID_MCU_STATUS = 11039
+mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_13_TO_16 = 11040
+mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_17_TO_20 = 11041
+mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_21_TO_24 = 11042
+mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_25_TO_28 = 11043
+mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_29_TO_32 = 11044
+mavlink20.MAVLINK_MSG_ID_COMMAND_INT_STAMPED = 223
+mavlink20.MAVLINK_MSG_ID_COMMAND_LONG_STAMPED = 224
+mavlink20.MAVLINK_MSG_ID_SENS_POWER = 8002
+mavlink20.MAVLINK_MSG_ID_SENS_MPPT = 8003
+mavlink20.MAVLINK_MSG_ID_ASLCTRL_DATA = 8004
+mavlink20.MAVLINK_MSG_ID_ASLCTRL_DEBUG = 8005
+mavlink20.MAVLINK_MSG_ID_ASLUAV_STATUS = 8006
+mavlink20.MAVLINK_MSG_ID_EKF_EXT = 8007
+mavlink20.MAVLINK_MSG_ID_ASL_OBCTRL = 8008
+mavlink20.MAVLINK_MSG_ID_SENS_ATMOS = 8009
+mavlink20.MAVLINK_MSG_ID_SENS_BATMON = 8010
+mavlink20.MAVLINK_MSG_ID_FW_SOARING_DATA = 8011
+mavlink20.MAVLINK_MSG_ID_SENSORPOD_STATUS = 8012
+mavlink20.MAVLINK_MSG_ID_SENS_POWER_BOARD = 8013
+mavlink20.MAVLINK_MSG_ID_GSM_LINK_STATUS = 8014
+mavlink20.MAVLINK_MSG_ID_SATCOM_LINK_STATUS = 8015
+mavlink20.MAVLINK_MSG_ID_SENSOR_AIRFLOW_ANGLES = 8016
+mavlink20.MAVLINK_MSG_ID_SYS_STATUS = 1
+mavlink20.MAVLINK_MSG_ID_SYSTEM_TIME = 2
+mavlink20.MAVLINK_MSG_ID_PING = 4
+mavlink20.MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL = 5
+mavlink20.MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK = 6
+mavlink20.MAVLINK_MSG_ID_AUTH_KEY = 7
+mavlink20.MAVLINK_MSG_ID_SET_MODE = 11
+mavlink20.MAVLINK_MSG_ID_PARAM_REQUEST_READ = 20
+mavlink20.MAVLINK_MSG_ID_PARAM_REQUEST_LIST = 21
+mavlink20.MAVLINK_MSG_ID_PARAM_VALUE = 22
+mavlink20.MAVLINK_MSG_ID_PARAM_SET = 23
+mavlink20.MAVLINK_MSG_ID_GPS_RAW_INT = 24
+mavlink20.MAVLINK_MSG_ID_GPS_STATUS = 25
+mavlink20.MAVLINK_MSG_ID_SCALED_IMU = 26
+mavlink20.MAVLINK_MSG_ID_RAW_IMU = 27
+mavlink20.MAVLINK_MSG_ID_RAW_PRESSURE = 28
+mavlink20.MAVLINK_MSG_ID_SCALED_PRESSURE = 29
+mavlink20.MAVLINK_MSG_ID_ATTITUDE = 30
+mavlink20.MAVLINK_MSG_ID_ATTITUDE_QUATERNION = 31
+mavlink20.MAVLINK_MSG_ID_LOCAL_POSITION_NED = 32
+mavlink20.MAVLINK_MSG_ID_GLOBAL_POSITION_INT = 33
+mavlink20.MAVLINK_MSG_ID_RC_CHANNELS_SCALED = 34
+mavlink20.MAVLINK_MSG_ID_RC_CHANNELS_RAW = 35
+mavlink20.MAVLINK_MSG_ID_SERVO_OUTPUT_RAW = 36
+mavlink20.MAVLINK_MSG_ID_MISSION_REQUEST_PARTIAL_LIST = 37
+mavlink20.MAVLINK_MSG_ID_MISSION_WRITE_PARTIAL_LIST = 38
+mavlink20.MAVLINK_MSG_ID_MISSION_ITEM = 39
+mavlink20.MAVLINK_MSG_ID_MISSION_REQUEST = 40
+mavlink20.MAVLINK_MSG_ID_MISSION_SET_CURRENT = 41
+mavlink20.MAVLINK_MSG_ID_MISSION_CURRENT = 42
+mavlink20.MAVLINK_MSG_ID_MISSION_REQUEST_LIST = 43
+mavlink20.MAVLINK_MSG_ID_MISSION_COUNT = 44
+mavlink20.MAVLINK_MSG_ID_MISSION_CLEAR_ALL = 45
+mavlink20.MAVLINK_MSG_ID_MISSION_ITEM_REACHED = 46
+mavlink20.MAVLINK_MSG_ID_MISSION_ACK = 47
+mavlink20.MAVLINK_MSG_ID_SET_GPS_GLOBAL_ORIGIN = 48
+mavlink20.MAVLINK_MSG_ID_GPS_GLOBAL_ORIGIN = 49
+mavlink20.MAVLINK_MSG_ID_PARAM_MAP_RC = 50
+mavlink20.MAVLINK_MSG_ID_MISSION_REQUEST_INT = 51
+mavlink20.MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA = 54
+mavlink20.MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA = 55
+mavlink20.MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV = 61
+mavlink20.MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT = 62
+mavlink20.MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV = 63
+mavlink20.MAVLINK_MSG_ID_LOCAL_POSITION_NED_COV = 64
+mavlink20.MAVLINK_MSG_ID_RC_CHANNELS = 65
+mavlink20.MAVLINK_MSG_ID_REQUEST_DATA_STREAM = 66
+mavlink20.MAVLINK_MSG_ID_DATA_STREAM = 67
+mavlink20.MAVLINK_MSG_ID_MANUAL_CONTROL = 69
+mavlink20.MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE = 70
+mavlink20.MAVLINK_MSG_ID_MISSION_ITEM_INT = 73
+mavlink20.MAVLINK_MSG_ID_VFR_HUD = 74
+mavlink20.MAVLINK_MSG_ID_COMMAND_INT = 75
+mavlink20.MAVLINK_MSG_ID_COMMAND_LONG = 76
+mavlink20.MAVLINK_MSG_ID_COMMAND_ACK = 77
+mavlink20.MAVLINK_MSG_ID_MANUAL_SETPOINT = 81
+mavlink20.MAVLINK_MSG_ID_SET_ATTITUDE_TARGET = 82
+mavlink20.MAVLINK_MSG_ID_ATTITUDE_TARGET = 83
+mavlink20.MAVLINK_MSG_ID_SET_POSITION_TARGET_LOCAL_NED = 84
+mavlink20.MAVLINK_MSG_ID_POSITION_TARGET_LOCAL_NED = 85
+mavlink20.MAVLINK_MSG_ID_SET_POSITION_TARGET_GLOBAL_INT = 86
+mavlink20.MAVLINK_MSG_ID_POSITION_TARGET_GLOBAL_INT = 87
+mavlink20.MAVLINK_MSG_ID_LOCAL_POSITION_NED_SYSTEM_GLOBAL_OFFSET = 89
+mavlink20.MAVLINK_MSG_ID_HIL_STATE = 90
+mavlink20.MAVLINK_MSG_ID_HIL_CONTROLS = 91
+mavlink20.MAVLINK_MSG_ID_HIL_RC_INPUTS_RAW = 92
+mavlink20.MAVLINK_MSG_ID_HIL_ACTUATOR_CONTROLS = 93
+mavlink20.MAVLINK_MSG_ID_OPTICAL_FLOW = 100
+mavlink20.MAVLINK_MSG_ID_GLOBAL_VISION_POSITION_ESTIMATE = 101
+mavlink20.MAVLINK_MSG_ID_VISION_POSITION_ESTIMATE = 102
+mavlink20.MAVLINK_MSG_ID_VISION_SPEED_ESTIMATE = 103
+mavlink20.MAVLINK_MSG_ID_VICON_POSITION_ESTIMATE = 104
+mavlink20.MAVLINK_MSG_ID_HIGHRES_IMU = 105
+mavlink20.MAVLINK_MSG_ID_OPTICAL_FLOW_RAD = 106
+mavlink20.MAVLINK_MSG_ID_HIL_SENSOR = 107
+mavlink20.MAVLINK_MSG_ID_SIM_STATE = 108
+mavlink20.MAVLINK_MSG_ID_RADIO_STATUS = 109
+mavlink20.MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL = 110
+mavlink20.MAVLINK_MSG_ID_TIMESYNC = 111
+mavlink20.MAVLINK_MSG_ID_CAMERA_TRIGGER = 112
+mavlink20.MAVLINK_MSG_ID_HIL_GPS = 113
+mavlink20.MAVLINK_MSG_ID_HIL_OPTICAL_FLOW = 114
+mavlink20.MAVLINK_MSG_ID_HIL_STATE_QUATERNION = 115
+mavlink20.MAVLINK_MSG_ID_SCALED_IMU2 = 116
+mavlink20.MAVLINK_MSG_ID_LOG_REQUEST_LIST = 117
+mavlink20.MAVLINK_MSG_ID_LOG_ENTRY = 118
+mavlink20.MAVLINK_MSG_ID_LOG_REQUEST_DATA = 119
+mavlink20.MAVLINK_MSG_ID_LOG_DATA = 120
+mavlink20.MAVLINK_MSG_ID_LOG_ERASE = 121
+mavlink20.MAVLINK_MSG_ID_LOG_REQUEST_END = 122
+mavlink20.MAVLINK_MSG_ID_GPS_INJECT_DATA = 123
+mavlink20.MAVLINK_MSG_ID_GPS2_RAW = 124
+mavlink20.MAVLINK_MSG_ID_POWER_STATUS = 125
+mavlink20.MAVLINK_MSG_ID_SERIAL_CONTROL = 126
+mavlink20.MAVLINK_MSG_ID_GPS_RTK = 127
+mavlink20.MAVLINK_MSG_ID_GPS2_RTK = 128
+mavlink20.MAVLINK_MSG_ID_SCALED_IMU3 = 129
+mavlink20.MAVLINK_MSG_ID_DATA_TRANSMISSION_HANDSHAKE = 130
+mavlink20.MAVLINK_MSG_ID_ENCAPSULATED_DATA = 131
+mavlink20.MAVLINK_MSG_ID_DISTANCE_SENSOR = 132
+mavlink20.MAVLINK_MSG_ID_TERRAIN_REQUEST = 133
+mavlink20.MAVLINK_MSG_ID_TERRAIN_DATA = 134
+mavlink20.MAVLINK_MSG_ID_TERRAIN_CHECK = 135
+mavlink20.MAVLINK_MSG_ID_TERRAIN_REPORT = 136
+mavlink20.MAVLINK_MSG_ID_SCALED_PRESSURE2 = 137
+mavlink20.MAVLINK_MSG_ID_ATT_POS_MOCAP = 138
+mavlink20.MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET = 139
+mavlink20.MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET = 140
+mavlink20.MAVLINK_MSG_ID_ALTITUDE = 141
+mavlink20.MAVLINK_MSG_ID_RESOURCE_REQUEST = 142
+mavlink20.MAVLINK_MSG_ID_SCALED_PRESSURE3 = 143
+mavlink20.MAVLINK_MSG_ID_FOLLOW_TARGET = 144
+mavlink20.MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE = 146
+mavlink20.MAVLINK_MSG_ID_BATTERY_STATUS = 147
+mavlink20.MAVLINK_MSG_ID_AUTOPILOT_VERSION = 148
+mavlink20.MAVLINK_MSG_ID_LANDING_TARGET = 149
+mavlink20.MAVLINK_MSG_ID_FENCE_STATUS = 162
+mavlink20.MAVLINK_MSG_ID_MAG_CAL_REPORT = 192
+mavlink20.MAVLINK_MSG_ID_EFI_STATUS = 225
+mavlink20.MAVLINK_MSG_ID_ESTIMATOR_STATUS = 230
+mavlink20.MAVLINK_MSG_ID_WIND_COV = 231
+mavlink20.MAVLINK_MSG_ID_GPS_INPUT = 232
+mavlink20.MAVLINK_MSG_ID_GPS_RTCM_DATA = 233
+mavlink20.MAVLINK_MSG_ID_HIGH_LATENCY = 234
+mavlink20.MAVLINK_MSG_ID_HIGH_LATENCY2 = 235
+mavlink20.MAVLINK_MSG_ID_VIBRATION = 241
+mavlink20.MAVLINK_MSG_ID_HOME_POSITION = 242
+mavlink20.MAVLINK_MSG_ID_SET_HOME_POSITION = 243
+mavlink20.MAVLINK_MSG_ID_MESSAGE_INTERVAL = 244
+mavlink20.MAVLINK_MSG_ID_EXTENDED_SYS_STATE = 245
+mavlink20.MAVLINK_MSG_ID_ADSB_VEHICLE = 246
+mavlink20.MAVLINK_MSG_ID_COLLISION = 247
+mavlink20.MAVLINK_MSG_ID_V2_EXTENSION = 248
+mavlink20.MAVLINK_MSG_ID_MEMORY_VECT = 249
+mavlink20.MAVLINK_MSG_ID_DEBUG_VECT = 250
+mavlink20.MAVLINK_MSG_ID_NAMED_VALUE_FLOAT = 251
+mavlink20.MAVLINK_MSG_ID_NAMED_VALUE_INT = 252
+mavlink20.MAVLINK_MSG_ID_STATUSTEXT = 253
+mavlink20.MAVLINK_MSG_ID_DEBUG = 254
+mavlink20.MAVLINK_MSG_ID_SETUP_SIGNING = 256
+mavlink20.MAVLINK_MSG_ID_BUTTON_CHANGE = 257
+mavlink20.MAVLINK_MSG_ID_PLAY_TUNE = 258
+mavlink20.MAVLINK_MSG_ID_CAMERA_INFORMATION = 259
+mavlink20.MAVLINK_MSG_ID_CAMERA_SETTINGS = 260
+mavlink20.MAVLINK_MSG_ID_STORAGE_INFORMATION = 261
+mavlink20.MAVLINK_MSG_ID_CAMERA_CAPTURE_STATUS = 262
+mavlink20.MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED = 263
+mavlink20.MAVLINK_MSG_ID_FLIGHT_INFORMATION = 264
+mavlink20.MAVLINK_MSG_ID_MOUNT_ORIENTATION = 265
+mavlink20.MAVLINK_MSG_ID_LOGGING_DATA = 266
+mavlink20.MAVLINK_MSG_ID_LOGGING_DATA_ACKED = 267
+mavlink20.MAVLINK_MSG_ID_LOGGING_ACK = 268
+mavlink20.MAVLINK_MSG_ID_VIDEO_STREAM_INFORMATION = 269
+mavlink20.MAVLINK_MSG_ID_VIDEO_STREAM_STATUS = 270
+mavlink20.MAVLINK_MSG_ID_CAMERA_FOV_STATUS = 271
+mavlink20.MAVLINK_MSG_ID_CAMERA_TRACKING_IMAGE_STATUS = 275
+mavlink20.MAVLINK_MSG_ID_CAMERA_TRACKING_GEO_STATUS = 276
+mavlink20.MAVLINK_MSG_ID_CAMERA_THERMAL_RANGE = 277
+mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_INFORMATION = 280
+mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_STATUS = 281
+mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE = 282
+mavlink20.MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION = 283
+mavlink20.MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE = 284
+mavlink20.MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS = 285
+mavlink20.MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE = 286
+mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_PITCHYAW = 287
+mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_MANUAL_CONTROL = 288
+mavlink20.MAVLINK_MSG_ID_WIFI_CONFIG_AP = 299
+mavlink20.MAVLINK_MSG_ID_AIS_VESSEL = 301
+mavlink20.MAVLINK_MSG_ID_UAVCAN_NODE_STATUS = 310
+mavlink20.MAVLINK_MSG_ID_UAVCAN_NODE_INFO = 311
+mavlink20.MAVLINK_MSG_ID_PARAM_EXT_REQUEST_READ = 320
+mavlink20.MAVLINK_MSG_ID_PARAM_EXT_REQUEST_LIST = 321
+mavlink20.MAVLINK_MSG_ID_PARAM_EXT_VALUE = 322
+mavlink20.MAVLINK_MSG_ID_PARAM_EXT_SET = 323
+mavlink20.MAVLINK_MSG_ID_PARAM_EXT_ACK = 324
+mavlink20.MAVLINK_MSG_ID_OBSTACLE_DISTANCE = 330
+mavlink20.MAVLINK_MSG_ID_ODOMETRY = 331
+mavlink20.MAVLINK_MSG_ID_TRAJECTORY_REPRESENTATION_WAYPOINTS = 332
+mavlink20.MAVLINK_MSG_ID_TRAJECTORY_REPRESENTATION_BEZIER = 333
+mavlink20.MAVLINK_MSG_ID_ISBD_LINK_STATUS = 335
+mavlink20.MAVLINK_MSG_ID_RAW_RPM = 339
+mavlink20.MAVLINK_MSG_ID_UTM_GLOBAL_POSITION = 340
+mavlink20.MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY = 350
+mavlink20.MAVLINK_MSG_ID_SMART_BATTERY_INFO = 370
+mavlink20.MAVLINK_MSG_ID_GENERATOR_STATUS = 373
+mavlink20.MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS = 375
+mavlink20.MAVLINK_MSG_ID_RELAY_STATUS = 376
+mavlink20.MAVLINK_MSG_ID_TUNNEL = 385
+mavlink20.MAVLINK_MSG_ID_CAN_FRAME = 386
+mavlink20.MAVLINK_MSG_ID_CANFD_FRAME = 387
+mavlink20.MAVLINK_MSG_ID_CAN_FILTER_MODIFY = 388
+mavlink20.MAVLINK_MSG_ID_WHEEL_DISTANCE = 9000
+mavlink20.MAVLINK_MSG_ID_WINCH_STATUS = 9005
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID = 12900
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_LOCATION = 12901
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_AUTHENTICATION = 12902
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_SELF_ID = 12903
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_SYSTEM = 12904
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_OPERATOR_ID = 12905
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_ARM_STATUS = 12918
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_MESSAGE_PACK = 12915
+mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_SYSTEM_UPDATE = 12919
+mavlink20.MAVLINK_MSG_ID_HYGROMETER_SENSOR = 12920
+mavlink20.MAVLINK_MSG_ID_MISSION_CHECKSUM = 53
+mavlink20.MAVLINK_MSG_ID_AIRSPEED = 295
+mavlink20.MAVLINK_MSG_ID_RADIO_RC_CHANNELS = 420
+mavlink20.MAVLINK_MSG_ID_AVAILABLE_MODES = 435
+mavlink20.MAVLINK_MSG_ID_CURRENT_MODE = 436
+mavlink20.MAVLINK_MSG_ID_AVAILABLE_MODES_MONITOR = 437
+mavlink20.MAVLINK_MSG_ID_GNSS_INTEGRITY = 441
+mavlink20.MAVLINK_MSG_ID_ICAROUS_HEARTBEAT = 42000
+mavlink20.MAVLINK_MSG_ID_ICAROUS_KINEMATIC_BANDS = 42001
+mavlink20.MAVLINK_MSG_ID_HEARTBEAT = 0
+mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_0 = 17150
+mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_1 = 17151
+mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_3 = 17153
+mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_4 = 17154
+mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_5 = 17155
+mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_6 = 17156
+mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_7 = 17157
+mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_8 = 17158
+mavlink20.MAVLINK_MSG_ID_TEST_TYPES = 17000
+mavlink20.MAVLINK_MSG_ID_NAV_FILTER_BIAS = 220
+mavlink20.MAVLINK_MSG_ID_RADIO_CALIBRATION = 221
+mavlink20.MAVLINK_MSG_ID_UALBERTA_SYS_STATUS = 222
+mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_CFG = 10001
+mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_DYNAMIC = 10002
+mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_TRANSCEIVER_HEALTH_REPORT = 10003
+mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_CFG_REGISTRATION = 10004
+mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_CFG_FLIGHTID = 10005
+mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_GET = 10006
+mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_CONTROL = 10007
+mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_STATUS = 10008
+mavlink20.MAVLINK_MSG_ID_LOWEHEISER_GOV_EFI = 10151
+mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_INFORMATION = 60010
+mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_STATUS = 60011
+mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_CONTROL = 60012
+mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_CONTROL_PITCHYAW = 60013
+mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_CORRECT_ROLL = 60014
+mavlink20.MAVLINK_MSG_ID_QSHOT_STATUS = 60020
+mavlink20.MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_EXT = 60000
+mavlink20.MAVLINK_MSG_ID_FRSKY_PASSTHROUGH_ARRAY = 60040
+mavlink20.MAVLINK_MSG_ID_PARAM_VALUE_ARRAY = 60041
+mavlink20.MAVLINK_MSG_ID_MLRS_RADIO_LINK_STATS = 60045
+mavlink20.MAVLINK_MSG_ID_MLRS_RADIO_LINK_INFORMATION = 60046
+mavlink20.MAVLINK_MSG_ID_MLRS_RADIO_LINK_FLOW_CONTROL = 60047
+mavlink20.MAVLINK_MSG_ID_AVSS_PRS_SYS_STATUS = 60050
+mavlink20.MAVLINK_MSG_ID_AVSS_DRONE_POSITION = 60051
+mavlink20.MAVLINK_MSG_ID_AVSS_DRONE_IMU = 60052
+mavlink20.MAVLINK_MSG_ID_AVSS_DRONE_OPERATION_MODE = 60053
+mavlink20.MAVLINK_MSG_ID_CUBEPILOT_RAW_RC = 50001
+mavlink20.MAVLINK_MSG_ID_HERELINK_VIDEO_STREAM_INFORMATION = 50002
+mavlink20.MAVLINK_MSG_ID_HERELINK_TELEM = 50003
+mavlink20.MAVLINK_MSG_ID_CUBEPILOT_FIRMWARE_UPDATE_START = 50004
+mavlink20.MAVLINK_MSG_ID_CUBEPILOT_FIRMWARE_UPDATE_RESP = 50005
+mavlink20.MAVLINK_MSG_ID_AIRLINK_AUTH = 52000
+mavlink20.MAVLINK_MSG_ID_AIRLINK_AUTH_RESPONSE = 52001
+mavlink20.messages = {};
+
+
+/* 
+Offsets and calibrations values for hardware sensors. This makes it
+easier to debug the calibration process.
+
+                mag_ofs_x                 : Magnetometer X offset. (int16_t)
+                mag_ofs_y                 : Magnetometer Y offset. (int16_t)
+                mag_ofs_z                 : Magnetometer Z offset. (int16_t)
+                mag_declination           : Magnetic declination. (float)
+                raw_press                 : Raw pressure from barometer. (int32_t)
+                raw_temp                  : Raw temperature from barometer. (int32_t)
+                gyro_cal_x                : Gyro X calibration. (float)
+                gyro_cal_y                : Gyro Y calibration. (float)
+                gyro_cal_z                : Gyro Z calibration. (float)
+                accel_cal_x               : Accel X calibration. (float)
+                accel_cal_y               : Accel Y calibration. (float)
+                accel_cal_z               : Accel Z calibration. (float)
+
+*/
+    mavlink20.messages.sensor_offsets = function( ...moreargs ) {
+    [ this.mag_ofs_x , this.mag_ofs_y , this.mag_ofs_z , this.mag_declination , this.raw_press , this.raw_temp , this.gyro_cal_x , this.gyro_cal_y , this.gyro_cal_z , this.accel_cal_x , this.accel_cal_y , this.accel_cal_z ] = moreargs;
+
+    this._format = '<fiiffffffhhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_SENSOR_OFFSETS;
+    this.order_map = [9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 134;
+    this._name = 'SENSOR_OFFSETS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['mag_ofs_x', 'mag_ofs_y', 'mag_ofs_z', 'mag_declination', 'raw_press', 'raw_temp', 'gyro_cal_x', 'gyro_cal_y', 'gyro_cal_z', 'accel_cal_x', 'accel_cal_y', 'accel_cal_z'];
+
+}
+
+mavlink20.messages.sensor_offsets.prototype = new mavlink20.message;
+mavlink20.messages.sensor_offsets.prototype.pack = function(mav) {
+    var orderedfields = [ this.mag_declination, this.raw_press, this.raw_temp, this.gyro_cal_x, this.gyro_cal_y, this.gyro_cal_z, this.accel_cal_x, this.accel_cal_y, this.accel_cal_z, this.mag_ofs_x, this.mag_ofs_y, this.mag_ofs_z];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set the magnetometer offsets
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                mag_ofs_x                 : Magnetometer X offset. (int16_t)
+                mag_ofs_y                 : Magnetometer Y offset. (int16_t)
+                mag_ofs_z                 : Magnetometer Z offset. (int16_t)
+
+*/
+    mavlink20.messages.set_mag_offsets = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.mag_ofs_x , this.mag_ofs_y , this.mag_ofs_z ] = moreargs;
+
+    this._format = '<hhhBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SET_MAG_OFFSETS;
+    this.order_map = [3, 4, 0, 1, 2];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 219;
+    this._name = 'SET_MAG_OFFSETS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'mag_ofs_x', 'mag_ofs_y', 'mag_ofs_z'];
+
+}
+
+mavlink20.messages.set_mag_offsets.prototype = new mavlink20.message;
+mavlink20.messages.set_mag_offsets.prototype.pack = function(mav) {
+    var orderedfields = [ this.mag_ofs_x, this.mag_ofs_y, this.mag_ofs_z, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+State of autopilot RAM.
+
+                brkval                    : Heap top. (uint16_t)
+                freemem                   : Free memory. (uint16_t)
+                freemem32                 : Free memory (32 bit). (uint32_t)
+
+*/
+    mavlink20.messages.meminfo = function( ...moreargs ) {
+    [ this.brkval , this.freemem , this.freemem32 ] = moreargs;
+
+    this._format = '<HHI';
+    this._id = mavlink20.MAVLINK_MSG_ID_MEMINFO;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 208;
+    this._name = 'MEMINFO';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['brkval', 'freemem', 'freemem32'];
+
+}
+
+mavlink20.messages.meminfo.prototype = new mavlink20.message;
+mavlink20.messages.meminfo.prototype.pack = function(mav) {
+    var orderedfields = [ this.brkval, this.freemem, this.freemem32];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Raw ADC output.
+
+                adc1                      : ADC output 1. (uint16_t)
+                adc2                      : ADC output 2. (uint16_t)
+                adc3                      : ADC output 3. (uint16_t)
+                adc4                      : ADC output 4. (uint16_t)
+                adc5                      : ADC output 5. (uint16_t)
+                adc6                      : ADC output 6. (uint16_t)
+
+*/
+    mavlink20.messages.ap_adc = function( ...moreargs ) {
+    [ this.adc1 , this.adc2 , this.adc3 , this.adc4 , this.adc5 , this.adc6 ] = moreargs;
+
+    this._format = '<HHHHHH';
+    this._id = mavlink20.MAVLINK_MSG_ID_AP_ADC;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 188;
+    this._name = 'AP_ADC';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['adc1', 'adc2', 'adc3', 'adc4', 'adc5', 'adc6'];
+
+}
+
+mavlink20.messages.ap_adc.prototype = new mavlink20.message;
+mavlink20.messages.ap_adc.prototype.pack = function(mav) {
+    var orderedfields = [ this.adc1, this.adc2, this.adc3, this.adc4, this.adc5, this.adc6];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Configure on-board Camera Control System.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                mode                      : Mode enumeration from 1 to N //P, TV, AV, M, etc. (0 means ignore). (uint8_t)
+                shutter_speed             : Divisor number //e.g. 1000 means 1/1000 (0 means ignore). (uint16_t)
+                aperture                  : F stop number x 10 //e.g. 28 means 2.8 (0 means ignore). (uint8_t)
+                iso                       : ISO enumeration from 1 to N //e.g. 80, 100, 200, Etc (0 means ignore). (uint8_t)
+                exposure_type             : Exposure type enumeration from 1 to N (0 means ignore). (uint8_t)
+                command_id                : Command Identity (incremental loop: 0 to 255). //A command sent multiple times will be executed or pooled just once. (uint8_t)
+                engine_cut_off            : Main engine cut-off time before camera trigger (0 means no cut-off). (uint8_t)
+                extra_param               : Extra parameters enumeration (0 means ignore). (uint8_t)
+                extra_value               : Correspondent value to given extra_param. (float)
+
+*/
+    mavlink20.messages.digicam_configure = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.mode , this.shutter_speed , this.aperture , this.iso , this.exposure_type , this.command_id , this.engine_cut_off , this.extra_param , this.extra_value ] = moreargs;
+
+    this._format = '<fHBBBBBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DIGICAM_CONFIGURE;
+    this.order_map = [2, 3, 4, 1, 5, 6, 7, 8, 9, 10, 0];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 84;
+    this._name = 'DIGICAM_CONFIGURE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'mode', 'shutter_speed', 'aperture', 'iso', 'exposure_type', 'command_id', 'engine_cut_off', 'extra_param', 'extra_value'];
+
+}
+
+mavlink20.messages.digicam_configure.prototype = new mavlink20.message;
+mavlink20.messages.digicam_configure.prototype.pack = function(mav) {
+    var orderedfields = [ this.extra_value, this.shutter_speed, this.target_system, this.target_component, this.mode, this.aperture, this.iso, this.exposure_type, this.command_id, this.engine_cut_off, this.extra_param];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Control on-board Camera Control System to take shots.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                session                   : 0: stop, 1: start or keep it up //Session control e.g. show/hide lens. (uint8_t)
+                zoom_pos                  : 1 to N //Zoom's absolute position (0 means ignore). (uint8_t)
+                zoom_step                 : -100 to 100 //Zooming step value to offset zoom from the current position. (int8_t)
+                focus_lock                : 0: unlock focus or keep unlocked, 1: lock focus or keep locked, 3: re-lock focus. (uint8_t)
+                shot                      : 0: ignore, 1: shot or start filming. (uint8_t)
+                command_id                : Command Identity (incremental loop: 0 to 255)//A command sent multiple times will be executed or pooled just once. (uint8_t)
+                extra_param               : Extra parameters enumeration (0 means ignore). (uint8_t)
+                extra_value               : Correspondent value to given extra_param. (float)
+
+*/
+    mavlink20.messages.digicam_control = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.session , this.zoom_pos , this.zoom_step , this.focus_lock , this.shot , this.command_id , this.extra_param , this.extra_value ] = moreargs;
+
+    this._format = '<fBBBBbBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DIGICAM_CONTROL;
+    this.order_map = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 22;
+    this._name = 'DIGICAM_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'session', 'zoom_pos', 'zoom_step', 'focus_lock', 'shot', 'command_id', 'extra_param', 'extra_value'];
+
+}
+
+mavlink20.messages.digicam_control.prototype = new mavlink20.message;
+mavlink20.messages.digicam_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.extra_value, this.target_system, this.target_component, this.session, this.zoom_pos, this.zoom_step, this.focus_lock, this.shot, this.command_id, this.extra_param];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message to configure a camera mount, directional antenna, etc.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                mount_mode                : Mount operating mode. (uint8_t)
+                stab_roll                 : (1 = yes, 0 = no). (uint8_t)
+                stab_pitch                : (1 = yes, 0 = no). (uint8_t)
+                stab_yaw                  : (1 = yes, 0 = no). (uint8_t)
+
+*/
+    mavlink20.messages.mount_configure = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.mount_mode , this.stab_roll , this.stab_pitch , this.stab_yaw ] = moreargs;
+
+    this._format = '<BBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MOUNT_CONFIGURE;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 19;
+    this._name = 'MOUNT_CONFIGURE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'mount_mode', 'stab_roll', 'stab_pitch', 'stab_yaw'];
+
+}
+
+mavlink20.messages.mount_configure.prototype = new mavlink20.message;
+mavlink20.messages.mount_configure.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.mount_mode, this.stab_roll, this.stab_pitch, this.stab_yaw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message to control a camera mount, directional antenna, etc.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                input_a                   : Pitch (centi-degrees) or lat (degE7), depending on mount mode. (int32_t)
+                input_b                   : Roll (centi-degrees) or lon (degE7) depending on mount mode. (int32_t)
+                input_c                   : Yaw (centi-degrees) or alt (cm) depending on mount mode. (int32_t)
+                save_position             : If "1" it will save current trimmed position on EEPROM (just valid for NEUTRAL and LANDING). (uint8_t)
+
+*/
+    mavlink20.messages.mount_control = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.input_a , this.input_b , this.input_c , this.save_position ] = moreargs;
+
+    this._format = '<iiiBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MOUNT_CONTROL;
+    this.order_map = [3, 4, 0, 1, 2, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 21;
+    this._name = 'MOUNT_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'input_a', 'input_b', 'input_c', 'save_position'];
+
+}
+
+mavlink20.messages.mount_control.prototype = new mavlink20.message;
+mavlink20.messages.mount_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.input_a, this.input_b, this.input_c, this.target_system, this.target_component, this.save_position];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message with some status from autopilot to GCS about camera or antenna
+mount.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                pointing_a                : Pitch. (int32_t)
+                pointing_b                : Roll. (int32_t)
+                pointing_c                : Yaw. (int32_t)
+                mount_mode                : Mount operating mode. (uint8_t)
+
+*/
+    mavlink20.messages.mount_status = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.pointing_a , this.pointing_b , this.pointing_c , this.mount_mode ] = moreargs;
+
+    this._format = '<iiiBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MOUNT_STATUS;
+    this.order_map = [3, 4, 0, 1, 2, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 134;
+    this._name = 'MOUNT_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'pointing_a', 'pointing_b', 'pointing_c', 'mount_mode'];
+
+}
+
+mavlink20.messages.mount_status.prototype = new mavlink20.message;
+mavlink20.messages.mount_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.pointing_a, this.pointing_b, this.pointing_c, this.target_system, this.target_component, this.mount_mode];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A fence point. Used to set a point when from GCS -> MAV. Also used to
+return a point from MAV -> GCS.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                idx                       : Point index (first point is 1, 0 is for return point). (uint8_t)
+                count                     : Total number of points (for sanity checking). (uint8_t)
+                lat                       : Latitude of point. (float)
+                lng                       : Longitude of point. (float)
+
+*/
+    mavlink20.messages.fence_point = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.idx , this.count , this.lat , this.lng ] = moreargs;
+
+    this._format = '<ffBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_FENCE_POINT;
+    this.order_map = [2, 3, 4, 5, 0, 1];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 78;
+    this._name = 'FENCE_POINT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'idx', 'count', 'lat', 'lng'];
+
+}
+
+mavlink20.messages.fence_point.prototype = new mavlink20.message;
+mavlink20.messages.fence_point.prototype.pack = function(mav) {
+    var orderedfields = [ this.lat, this.lng, this.target_system, this.target_component, this.idx, this.count];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request a current fence point from MAV.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                idx                       : Point index (first point is 1, 0 is for return point). (uint8_t)
+
+*/
+    mavlink20.messages.fence_fetch_point = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.idx ] = moreargs;
+
+    this._format = '<BBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_FENCE_FETCH_POINT;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 68;
+    this._name = 'FENCE_FETCH_POINT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'idx'];
+
+}
+
+mavlink20.messages.fence_fetch_point.prototype = new mavlink20.message;
+mavlink20.messages.fence_fetch_point.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.idx];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of DCM attitude estimator.
+
+                omegaIx                   : X gyro drift estimate. (float)
+                omegaIy                   : Y gyro drift estimate. (float)
+                omegaIz                   : Z gyro drift estimate. (float)
+                accel_weight              : Average accel_weight. (float)
+                renorm_val                : Average renormalisation value. (float)
+                error_rp                  : Average error_roll_pitch value. (float)
+                error_yaw                 : Average error_yaw value. (float)
+
+*/
+    mavlink20.messages.ahrs = function( ...moreargs ) {
+    [ this.omegaIx , this.omegaIy , this.omegaIz , this.accel_weight , this.renorm_val , this.error_rp , this.error_yaw ] = moreargs;
+
+    this._format = '<fffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_AHRS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 127;
+    this._name = 'AHRS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['omegaIx', 'omegaIy', 'omegaIz', 'accel_weight', 'renorm_val', 'error_rp', 'error_yaw'];
+
+}
+
+mavlink20.messages.ahrs.prototype = new mavlink20.message;
+mavlink20.messages.ahrs.prototype.pack = function(mav) {
+    var orderedfields = [ this.omegaIx, this.omegaIy, this.omegaIz, this.accel_weight, this.renorm_val, this.error_rp, this.error_yaw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of simulation environment, if used.
+
+                roll                      : Roll angle. (float)
+                pitch                     : Pitch angle. (float)
+                yaw                       : Yaw angle. (float)
+                xacc                      : X acceleration. (float)
+                yacc                      : Y acceleration. (float)
+                zacc                      : Z acceleration. (float)
+                xgyro                     : Angular speed around X axis. (float)
+                ygyro                     : Angular speed around Y axis. (float)
+                zgyro                     : Angular speed around Z axis. (float)
+                lat                       : Latitude. (int32_t)
+                lng                       : Longitude. (int32_t)
+
+*/
+    mavlink20.messages.simstate = function( ...moreargs ) {
+    [ this.roll , this.pitch , this.yaw , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro , this.lat , this.lng ] = moreargs;
+
+    this._format = '<fffffffffii';
+    this._id = mavlink20.MAVLINK_MSG_ID_SIMSTATE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 154;
+    this._name = 'SIMSTATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['roll', 'pitch', 'yaw', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro', 'lat', 'lng'];
+
+}
+
+mavlink20.messages.simstate.prototype = new mavlink20.message;
+mavlink20.messages.simstate.prototype.pack = function(mav) {
+    var orderedfields = [ this.roll, this.pitch, this.yaw, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro, this.lat, this.lng];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of key hardware.
+
+                Vcc                       : Board voltage. (uint16_t)
+                I2Cerr                    : I2C error count. (uint8_t)
+
+*/
+    mavlink20.messages.hwstatus = function( ...moreargs ) {
+    [ this.Vcc , this.I2Cerr ] = moreargs;
+
+    this._format = '<HB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HWSTATUS;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 21;
+    this._name = 'HWSTATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['Vcc', 'I2Cerr'];
+
+}
+
+mavlink20.messages.hwstatus.prototype = new mavlink20.message;
+mavlink20.messages.hwstatus.prototype.pack = function(mav) {
+    var orderedfields = [ this.Vcc, this.I2Cerr];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status generated by radio.
+
+                rssi                      : Local signal strength. (uint8_t)
+                remrssi                   : Remote signal strength. (uint8_t)
+                txbuf                     : How full the tx buffer is. (uint8_t)
+                noise                     : Background noise level. (uint8_t)
+                remnoise                  : Remote background noise level. (uint8_t)
+                rxerrors                  : Receive errors. (uint16_t)
+                fixed                     : Count of error corrected packets. (uint16_t)
+
+*/
+    mavlink20.messages.radio = function( ...moreargs ) {
+    [ this.rssi , this.remrssi , this.txbuf , this.noise , this.remnoise , this.rxerrors , this.fixed ] = moreargs;
+
+    this._format = '<HHBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_RADIO;
+    this.order_map = [2, 3, 4, 5, 6, 0, 1];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 21;
+    this._name = 'RADIO';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['rssi', 'remrssi', 'txbuf', 'noise', 'remnoise', 'rxerrors', 'fixed'];
+
+}
+
+mavlink20.messages.radio.prototype = new mavlink20.message;
+mavlink20.messages.radio.prototype.pack = function(mav) {
+    var orderedfields = [ this.rxerrors, this.fixed, this.rssi, this.remrssi, this.txbuf, this.noise, this.remnoise];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of AP_Limits. Sent in extended status stream when AP_Limits is
+enabled.
+
+                limits_state              : State of AP_Limits. (uint8_t)
+                last_trigger              : Time (since boot) of last breach. (uint32_t)
+                last_action               : Time (since boot) of last recovery action. (uint32_t)
+                last_recovery             : Time (since boot) of last successful recovery. (uint32_t)
+                last_clear                : Time (since boot) of last all-clear. (uint32_t)
+                breach_count              : Number of fence breaches. (uint16_t)
+                mods_enabled              : AP_Limit_Module bitfield of enabled modules. (uint8_t)
+                mods_required             : AP_Limit_Module bitfield of required modules. (uint8_t)
+                mods_triggered            : AP_Limit_Module bitfield of triggered modules. (uint8_t)
+
+*/
+    mavlink20.messages.limits_status = function( ...moreargs ) {
+    [ this.limits_state , this.last_trigger , this.last_action , this.last_recovery , this.last_clear , this.breach_count , this.mods_enabled , this.mods_required , this.mods_triggered ] = moreargs;
+
+    this._format = '<IIIIHBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LIMITS_STATUS;
+    this.order_map = [5, 0, 1, 2, 3, 4, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 144;
+    this._name = 'LIMITS_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['limits_state', 'last_trigger', 'last_action', 'last_recovery', 'last_clear', 'breach_count', 'mods_enabled', 'mods_required', 'mods_triggered'];
+
+}
+
+mavlink20.messages.limits_status.prototype = new mavlink20.message;
+mavlink20.messages.limits_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.last_trigger, this.last_action, this.last_recovery, this.last_clear, this.breach_count, this.limits_state, this.mods_enabled, this.mods_required, this.mods_triggered];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Wind estimation.
+
+                direction                 : Wind direction (that wind is coming from). (float)
+                speed                     : Wind speed in ground plane. (float)
+                speed_z                   : Vertical wind speed. (float)
+
+*/
+    mavlink20.messages.wind = function( ...moreargs ) {
+    [ this.direction , this.speed , this.speed_z ] = moreargs;
+
+    this._format = '<fff';
+    this._id = mavlink20.MAVLINK_MSG_ID_WIND;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 1;
+    this._name = 'WIND';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['direction', 'speed', 'speed_z'];
+
+}
+
+mavlink20.messages.wind.prototype = new mavlink20.message;
+mavlink20.messages.wind.prototype.pack = function(mav) {
+    var orderedfields = [ this.direction, this.speed, this.speed_z];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data packet, size 16.
+
+                type                      : Data type. (uint8_t)
+                len                       : Data length. (uint8_t)
+                data                      : Raw data. (uint8_t)
+
+*/
+    mavlink20.messages.data16 = function( ...moreargs ) {
+    [ this.type , this.len , this.data ] = moreargs;
+
+    this._format = '<BB16s';
+    this._id = mavlink20.MAVLINK_MSG_ID_DATA16;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 16];
+    this.array_len_map = [0, 0, 16];
+    this.crc_extra = 234;
+    this._name = 'DATA16';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['type', 'len', 'data'];
+
+}
+
+mavlink20.messages.data16.prototype = new mavlink20.message;
+mavlink20.messages.data16.prototype.pack = function(mav) {
+    var orderedfields = [ this.type, this.len, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data packet, size 32.
+
+                type                      : Data type. (uint8_t)
+                len                       : Data length. (uint8_t)
+                data                      : Raw data. (uint8_t)
+
+*/
+    mavlink20.messages.data32 = function( ...moreargs ) {
+    [ this.type , this.len , this.data ] = moreargs;
+
+    this._format = '<BB32s';
+    this._id = mavlink20.MAVLINK_MSG_ID_DATA32;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 32];
+    this.array_len_map = [0, 0, 32];
+    this.crc_extra = 73;
+    this._name = 'DATA32';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['type', 'len', 'data'];
+
+}
+
+mavlink20.messages.data32.prototype = new mavlink20.message;
+mavlink20.messages.data32.prototype.pack = function(mav) {
+    var orderedfields = [ this.type, this.len, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data packet, size 64.
+
+                type                      : Data type. (uint8_t)
+                len                       : Data length. (uint8_t)
+                data                      : Raw data. (uint8_t)
+
+*/
+    mavlink20.messages.data64 = function( ...moreargs ) {
+    [ this.type , this.len , this.data ] = moreargs;
+
+    this._format = '<BB64s';
+    this._id = mavlink20.MAVLINK_MSG_ID_DATA64;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 64];
+    this.array_len_map = [0, 0, 64];
+    this.crc_extra = 181;
+    this._name = 'DATA64';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['type', 'len', 'data'];
+
+}
+
+mavlink20.messages.data64.prototype = new mavlink20.message;
+mavlink20.messages.data64.prototype.pack = function(mav) {
+    var orderedfields = [ this.type, this.len, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data packet, size 96.
+
+                type                      : Data type. (uint8_t)
+                len                       : Data length. (uint8_t)
+                data                      : Raw data. (uint8_t)
+
+*/
+    mavlink20.messages.data96 = function( ...moreargs ) {
+    [ this.type , this.len , this.data ] = moreargs;
+
+    this._format = '<BB96s';
+    this._id = mavlink20.MAVLINK_MSG_ID_DATA96;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 96];
+    this.array_len_map = [0, 0, 96];
+    this.crc_extra = 22;
+    this._name = 'DATA96';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['type', 'len', 'data'];
+
+}
+
+mavlink20.messages.data96.prototype = new mavlink20.message;
+mavlink20.messages.data96.prototype.pack = function(mav) {
+    var orderedfields = [ this.type, this.len, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Rangefinder reporting.
+
+                distance                  : Distance. (float)
+                voltage                   : Raw voltage if available, zero otherwise. (float)
+
+*/
+    mavlink20.messages.rangefinder = function( ...moreargs ) {
+    [ this.distance , this.voltage ] = moreargs;
+
+    this._format = '<ff';
+    this._id = mavlink20.MAVLINK_MSG_ID_RANGEFINDER;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 83;
+    this._name = 'RANGEFINDER';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['distance', 'voltage'];
+
+}
+
+mavlink20.messages.rangefinder.prototype = new mavlink20.message;
+mavlink20.messages.rangefinder.prototype.pack = function(mav) {
+    var orderedfields = [ this.distance, this.voltage];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Airspeed auto-calibration.
+
+                vx                        : GPS velocity north. (float)
+                vy                        : GPS velocity east. (float)
+                vz                        : GPS velocity down. (float)
+                diff_pressure             : Differential pressure. (float)
+                EAS2TAS                   : Estimated to true airspeed ratio. (float)
+                ratio                     : Airspeed ratio. (float)
+                state_x                   : EKF state x. (float)
+                state_y                   : EKF state y. (float)
+                state_z                   : EKF state z. (float)
+                Pax                       : EKF Pax. (float)
+                Pby                       : EKF Pby. (float)
+                Pcz                       : EKF Pcz. (float)
+
+*/
+    mavlink20.messages.airspeed_autocal = function( ...moreargs ) {
+    [ this.vx , this.vy , this.vz , this.diff_pressure , this.EAS2TAS , this.ratio , this.state_x , this.state_y , this.state_z , this.Pax , this.Pby , this.Pcz ] = moreargs;
+
+    this._format = '<ffffffffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_AIRSPEED_AUTOCAL;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 167;
+    this._name = 'AIRSPEED_AUTOCAL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['vx', 'vy', 'vz', 'diff_pressure', 'EAS2TAS', 'ratio', 'state_x', 'state_y', 'state_z', 'Pax', 'Pby', 'Pcz'];
+
+}
+
+mavlink20.messages.airspeed_autocal.prototype = new mavlink20.message;
+mavlink20.messages.airspeed_autocal.prototype.pack = function(mav) {
+    var orderedfields = [ this.vx, this.vy, this.vz, this.diff_pressure, this.EAS2TAS, this.ratio, this.state_x, this.state_y, this.state_z, this.Pax, this.Pby, this.Pcz];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A rally point. Used to set a point when from GCS -> MAV. Also used to
+return a point from MAV -> GCS.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                idx                       : Point index (first point is 0). (uint8_t)
+                count                     : Total number of points (for sanity checking). (uint8_t)
+                lat                       : Latitude of point. (int32_t)
+                lng                       : Longitude of point. (int32_t)
+                alt                       : Transit / loiter altitude relative to home. (int16_t)
+                break_alt                 : Break altitude relative to home. (int16_t)
+                land_dir                  : Heading to aim for when landing. (uint16_t)
+                flags                     : Configuration flags. (uint8_t)
+
+*/
+    mavlink20.messages.rally_point = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.idx , this.count , this.lat , this.lng , this.alt , this.break_alt , this.land_dir , this.flags ] = moreargs;
+
+    this._format = '<iihhHBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_RALLY_POINT;
+    this.order_map = [5, 6, 7, 8, 0, 1, 2, 3, 4, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 138;
+    this._name = 'RALLY_POINT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'idx', 'count', 'lat', 'lng', 'alt', 'break_alt', 'land_dir', 'flags'];
+
+}
+
+mavlink20.messages.rally_point.prototype = new mavlink20.message;
+mavlink20.messages.rally_point.prototype.pack = function(mav) {
+    var orderedfields = [ this.lat, this.lng, this.alt, this.break_alt, this.land_dir, this.target_system, this.target_component, this.idx, this.count, this.flags];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request a current rally point from MAV. MAV should respond with a
+RALLY_POINT message. MAV should not respond if the request is invalid.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                idx                       : Point index (first point is 0). (uint8_t)
+
+*/
+    mavlink20.messages.rally_fetch_point = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.idx ] = moreargs;
+
+    this._format = '<BBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_RALLY_FETCH_POINT;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 234;
+    this._name = 'RALLY_FETCH_POINT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'idx'];
+
+}
+
+mavlink20.messages.rally_fetch_point.prototype = new mavlink20.message;
+mavlink20.messages.rally_fetch_point.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.idx];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of compassmot calibration.
+
+                throttle                  : Throttle. (uint16_t)
+                current                   : Current. (float)
+                interference              : Interference. (uint16_t)
+                CompensationX             : Motor Compensation X. (float)
+                CompensationY             : Motor Compensation Y. (float)
+                CompensationZ             : Motor Compensation Z. (float)
+
+*/
+    mavlink20.messages.compassmot_status = function( ...moreargs ) {
+    [ this.throttle , this.current , this.interference , this.CompensationX , this.CompensationY , this.CompensationZ ] = moreargs;
+
+    this._format = '<ffffHH';
+    this._id = mavlink20.MAVLINK_MSG_ID_COMPASSMOT_STATUS;
+    this.order_map = [4, 0, 5, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 240;
+    this._name = 'COMPASSMOT_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['throttle', 'current', 'interference', 'CompensationX', 'CompensationY', 'CompensationZ'];
+
+}
+
+mavlink20.messages.compassmot_status.prototype = new mavlink20.message;
+mavlink20.messages.compassmot_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.current, this.CompensationX, this.CompensationY, this.CompensationZ, this.throttle, this.interference];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of secondary AHRS filter if available.
+
+                roll                      : Roll angle. (float)
+                pitch                     : Pitch angle. (float)
+                yaw                       : Yaw angle. (float)
+                altitude                  : Altitude (MSL). (float)
+                lat                       : Latitude. (int32_t)
+                lng                       : Longitude. (int32_t)
+
+*/
+    mavlink20.messages.ahrs2 = function( ...moreargs ) {
+    [ this.roll , this.pitch , this.yaw , this.altitude , this.lat , this.lng ] = moreargs;
+
+    this._format = '<ffffii';
+    this._id = mavlink20.MAVLINK_MSG_ID_AHRS2;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 47;
+    this._name = 'AHRS2';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['roll', 'pitch', 'yaw', 'altitude', 'lat', 'lng'];
+
+}
+
+mavlink20.messages.ahrs2.prototype = new mavlink20.message;
+mavlink20.messages.ahrs2.prototype.pack = function(mav) {
+    var orderedfields = [ this.roll, this.pitch, this.yaw, this.altitude, this.lat, this.lng];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Camera Event.
+
+                time_usec                 : Image timestamp (since UNIX epoch, according to camera clock). (uint64_t)
+                target_system             : System ID. (uint8_t)
+                cam_idx                   : Camera ID. (uint8_t)
+                img_idx                   : Image index. (uint16_t)
+                event_id                  : Event type. (uint8_t)
+                p1                        : Parameter 1 (meaning depends on event_id, see CAMERA_STATUS_TYPES enum). (float)
+                p2                        : Parameter 2 (meaning depends on event_id, see CAMERA_STATUS_TYPES enum). (float)
+                p3                        : Parameter 3 (meaning depends on event_id, see CAMERA_STATUS_TYPES enum). (float)
+                p4                        : Parameter 4 (meaning depends on event_id, see CAMERA_STATUS_TYPES enum). (float)
+
+*/
+    mavlink20.messages.camera_status = function( ...moreargs ) {
+    [ this.time_usec , this.target_system , this.cam_idx , this.img_idx , this.event_id , this.p1 , this.p2 , this.p3 , this.p4 ] = moreargs;
+
+    this._format = '<QffffHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_STATUS;
+    this.order_map = [0, 6, 7, 5, 8, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 189;
+    this._name = 'CAMERA_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'target_system', 'cam_idx', 'img_idx', 'event_id', 'p1', 'p2', 'p3', 'p4'];
+
+}
+
+mavlink20.messages.camera_status.prototype = new mavlink20.message;
+mavlink20.messages.camera_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.p1, this.p2, this.p3, this.p4, this.img_idx, this.target_system, this.cam_idx, this.event_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Camera Capture Feedback.
+
+                time_usec                 : Image timestamp (since UNIX epoch), as passed in by CAMERA_STATUS message (or autopilot if no CCB). (uint64_t)
+                target_system             : System ID. (uint8_t)
+                cam_idx                   : Camera ID. (uint8_t)
+                img_idx                   : Image index. (uint16_t)
+                lat                       : Latitude. (int32_t)
+                lng                       : Longitude. (int32_t)
+                alt_msl                   : Altitude (MSL). (float)
+                alt_rel                   : Altitude (Relative to HOME location). (float)
+                roll                      : Camera Roll angle (earth frame, +-180). (float)
+                pitch                     : Camera Pitch angle (earth frame, +-180). (float)
+                yaw                       : Camera Yaw (earth frame, 0-360, true). (float)
+                foc_len                   : Focal Length. (float)
+                flags                     : Feedback flags. (uint8_t)
+                completed_captures        : Completed image captures. (uint16_t)
+
+*/
+    mavlink20.messages.camera_feedback = function( ...moreargs ) {
+    [ this.time_usec , this.target_system , this.cam_idx , this.img_idx , this.lat , this.lng , this.alt_msl , this.alt_rel , this.roll , this.pitch , this.yaw , this.foc_len , this.flags , this.completed_captures ] = moreargs;
+
+    this._format = '<QiiffffffHBBBH';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_FEEDBACK;
+    this.order_map = [0, 10, 11, 9, 1, 2, 3, 4, 5, 6, 7, 8, 12, 13];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 52;
+    this._name = 'CAMERA_FEEDBACK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'target_system', 'cam_idx', 'img_idx', 'lat', 'lng', 'alt_msl', 'alt_rel', 'roll', 'pitch', 'yaw', 'foc_len', 'flags', 'completed_captures'];
+
+}
+
+mavlink20.messages.camera_feedback.prototype = new mavlink20.message;
+mavlink20.messages.camera_feedback.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.lat, this.lng, this.alt_msl, this.alt_rel, this.roll, this.pitch, this.yaw, this.foc_len, this.img_idx, this.target_system, this.cam_idx, this.flags, this.completed_captures];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+2nd Battery status
+
+                voltage                   : Voltage. (uint16_t)
+                current_battery           : Battery current, -1: autopilot does not measure the current. (int16_t)
+
+*/
+    mavlink20.messages.battery2 = function( ...moreargs ) {
+    [ this.voltage , this.current_battery ] = moreargs;
+
+    this._format = '<Hh';
+    this._id = mavlink20.MAVLINK_MSG_ID_BATTERY2;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 174;
+    this._name = 'BATTERY2';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['voltage', 'current_battery'];
+
+}
+
+mavlink20.messages.battery2.prototype = new mavlink20.message;
+mavlink20.messages.battery2.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current_battery];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of third AHRS filter if available. This is for ANU research
+group (Ali and Sean).
+
+                roll                      : Roll angle. (float)
+                pitch                     : Pitch angle. (float)
+                yaw                       : Yaw angle. (float)
+                altitude                  : Altitude (MSL). (float)
+                lat                       : Latitude. (int32_t)
+                lng                       : Longitude. (int32_t)
+                v1                        : Test variable1. (float)
+                v2                        : Test variable2. (float)
+                v3                        : Test variable3. (float)
+                v4                        : Test variable4. (float)
+
+*/
+    mavlink20.messages.ahrs3 = function( ...moreargs ) {
+    [ this.roll , this.pitch , this.yaw , this.altitude , this.lat , this.lng , this.v1 , this.v2 , this.v3 , this.v4 ] = moreargs;
+
+    this._format = '<ffffiiffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_AHRS3;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 229;
+    this._name = 'AHRS3';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['roll', 'pitch', 'yaw', 'altitude', 'lat', 'lng', 'v1', 'v2', 'v3', 'v4'];
+
+}
+
+mavlink20.messages.ahrs3.prototype = new mavlink20.message;
+mavlink20.messages.ahrs3.prototype.pack = function(mav) {
+    var orderedfields = [ this.roll, this.pitch, this.yaw, this.altitude, this.lat, this.lng, this.v1, this.v2, this.v3, this.v4];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request the autopilot version from the system/component.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+
+*/
+    mavlink20.messages.autopilot_version_request = function( ...moreargs ) {
+    [ this.target_system , this.target_component ] = moreargs;
+
+    this._format = '<BB';
+    this._id = mavlink20.MAVLINK_MSG_ID_AUTOPILOT_VERSION_REQUEST;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 85;
+    this._name = 'AUTOPILOT_VERSION_REQUEST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component'];
+
+}
+
+mavlink20.messages.autopilot_version_request.prototype = new mavlink20.message;
+mavlink20.messages.autopilot_version_request.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send a block of log data to remote location.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                seqno                     : Log data block sequence number. (uint32_t)
+                data                      : Log data block. (uint8_t)
+
+*/
+    mavlink20.messages.remote_log_data_block = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.seqno , this.data ] = moreargs;
+
+    this._format = '<IBB200s';
+    this._id = mavlink20.MAVLINK_MSG_ID_REMOTE_LOG_DATA_BLOCK;
+    this.order_map = [1, 2, 0, 3];
+    this.len_map = [1, 1, 1, 200];
+    this.array_len_map = [0, 0, 0, 200];
+    this.crc_extra = 159;
+    this._name = 'REMOTE_LOG_DATA_BLOCK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'seqno', 'data'];
+
+}
+
+mavlink20.messages.remote_log_data_block.prototype = new mavlink20.message;
+mavlink20.messages.remote_log_data_block.prototype.pack = function(mav) {
+    var orderedfields = [ this.seqno, this.target_system, this.target_component, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send Status of each log block that autopilot board might have sent.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                seqno                     : Log data block sequence number. (uint32_t)
+                status                    : Log data block status. (uint8_t)
+
+*/
+    mavlink20.messages.remote_log_block_status = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.seqno , this.status ] = moreargs;
+
+    this._format = '<IBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_REMOTE_LOG_BLOCK_STATUS;
+    this.order_map = [1, 2, 0, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 186;
+    this._name = 'REMOTE_LOG_BLOCK_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'seqno', 'status'];
+
+}
+
+mavlink20.messages.remote_log_block_status.prototype = new mavlink20.message;
+mavlink20.messages.remote_log_block_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.seqno, this.target_system, this.target_component, this.status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Control vehicle LEDs.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                instance                  : Instance (LED instance to control or 255 for all LEDs). (uint8_t)
+                pattern                   : Pattern (see LED_PATTERN_ENUM). (uint8_t)
+                custom_len                : Custom Byte Length. (uint8_t)
+                custom_bytes              : Custom Bytes. (uint8_t)
+
+*/
+    mavlink20.messages.led_control = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.instance , this.pattern , this.custom_len , this.custom_bytes ] = moreargs;
+
+    this._format = '<BBBBB24s';
+    this._id = mavlink20.MAVLINK_MSG_ID_LED_CONTROL;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 24];
+    this.array_len_map = [0, 0, 0, 0, 0, 24];
+    this.crc_extra = 72;
+    this._name = 'LED_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'instance', 'pattern', 'custom_len', 'custom_bytes'];
+
+}
+
+mavlink20.messages.led_control.prototype = new mavlink20.message;
+mavlink20.messages.led_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.instance, this.pattern, this.custom_len, this.custom_bytes];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reports progress of compass calibration.
+
+                compass_id                : Compass being calibrated. (uint8_t)
+                cal_mask                  : Bitmask of compasses being calibrated. (uint8_t)
+                cal_status                : Calibration Status. (uint8_t)
+                attempt                   : Attempt number. (uint8_t)
+                completion_pct            : Completion percentage. (uint8_t)
+                completion_mask           : Bitmask of sphere sections (see http://en.wikipedia.org/wiki/Geodesic_grid). (uint8_t)
+                direction_x               : Body frame direction vector for display. (float)
+                direction_y               : Body frame direction vector for display. (float)
+                direction_z               : Body frame direction vector for display. (float)
+
+*/
+    mavlink20.messages.mag_cal_progress = function( ...moreargs ) {
+    [ this.compass_id , this.cal_mask , this.cal_status , this.attempt , this.completion_pct , this.completion_mask , this.direction_x , this.direction_y , this.direction_z ] = moreargs;
+
+    this._format = '<fffBBBBB10s';
+    this._id = mavlink20.MAVLINK_MSG_ID_MAG_CAL_PROGRESS;
+    this.order_map = [3, 4, 5, 6, 7, 8, 0, 1, 2];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 10];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 10];
+    this.crc_extra = 92;
+    this._name = 'MAG_CAL_PROGRESS';
+
+    this._instance_field = 'compass_id';
+    this._instance_offset = 12;
+
+    this.fieldnames = ['compass_id', 'cal_mask', 'cal_status', 'attempt', 'completion_pct', 'completion_mask', 'direction_x', 'direction_y', 'direction_z'];
+
+}
+
+mavlink20.messages.mag_cal_progress.prototype = new mavlink20.message;
+mavlink20.messages.mag_cal_progress.prototype.pack = function(mav) {
+    var orderedfields = [ this.direction_x, this.direction_y, this.direction_z, this.compass_id, this.cal_mask, this.cal_status, this.attempt, this.completion_pct, this.completion_mask];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+EKF Status message including flags and variances.
+
+                flags                     : Flags. (uint16_t)
+                velocity_variance         : Velocity variance. (float)
+                pos_horiz_variance        : Horizontal Position variance. (float)
+                pos_vert_variance         : Vertical Position variance. (float)
+                compass_variance          : Compass variance. (float)
+                terrain_alt_variance        : Terrain Altitude variance. (float)
+                airspeed_variance         : Airspeed variance. (float)
+
+*/
+    mavlink20.messages.ekf_status_report = function( ...moreargs ) {
+    [ this.flags , this.velocity_variance , this.pos_horiz_variance , this.pos_vert_variance , this.compass_variance , this.terrain_alt_variance , this.airspeed_variance ] = moreargs;
+
+    this._format = '<fffffHf';
+    this._id = mavlink20.MAVLINK_MSG_ID_EKF_STATUS_REPORT;
+    this.order_map = [5, 0, 1, 2, 3, 4, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 71;
+    this._name = 'EKF_STATUS_REPORT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['flags', 'velocity_variance', 'pos_horiz_variance', 'pos_vert_variance', 'compass_variance', 'terrain_alt_variance', 'airspeed_variance'];
+
+}
+
+mavlink20.messages.ekf_status_report.prototype = new mavlink20.message;
+mavlink20.messages.ekf_status_report.prototype.pack = function(mav) {
+    var orderedfields = [ this.velocity_variance, this.pos_horiz_variance, this.pos_vert_variance, this.compass_variance, this.terrain_alt_variance, this.flags, this.airspeed_variance];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+PID tuning information.
+
+                axis                      : Axis. (uint8_t)
+                desired                   : Desired rate. (float)
+                achieved                  : Achieved rate. (float)
+                FF                        : FF component. (float)
+                P                         : P component. (float)
+                I                         : I component. (float)
+                D                         : D component. (float)
+                SRate                     : Slew rate. (float)
+                PDmod                     : P/D oscillation modifier. (float)
+
+*/
+    mavlink20.messages.pid_tuning = function( ...moreargs ) {
+    [ this.axis , this.desired , this.achieved , this.FF , this.P , this.I , this.D , this.SRate , this.PDmod ] = moreargs;
+
+    this._format = '<ffffffBff';
+    this._id = mavlink20.MAVLINK_MSG_ID_PID_TUNING;
+    this.order_map = [6, 0, 1, 2, 3, 4, 5, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 98;
+    this._name = 'PID_TUNING';
+
+    this._instance_field = 'axis';
+    this._instance_offset = 24;
+
+    this.fieldnames = ['axis', 'desired', 'achieved', 'FF', 'P', 'I', 'D', 'SRate', 'PDmod'];
+
+}
+
+mavlink20.messages.pid_tuning.prototype = new mavlink20.message;
+mavlink20.messages.pid_tuning.prototype.pack = function(mav) {
+    var orderedfields = [ this.desired, this.achieved, this.FF, this.P, this.I, this.D, this.axis, this.SRate, this.PDmod];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Deepstall path planning.
+
+                landing_lat               : Landing latitude. (int32_t)
+                landing_lon               : Landing longitude. (int32_t)
+                path_lat                  : Final heading start point, latitude. (int32_t)
+                path_lon                  : Final heading start point, longitude. (int32_t)
+                arc_entry_lat             : Arc entry point, latitude. (int32_t)
+                arc_entry_lon             : Arc entry point, longitude. (int32_t)
+                altitude                  : Altitude. (float)
+                expected_travel_distance        : Distance the aircraft expects to travel during the deepstall. (float)
+                cross_track_error         : Deepstall cross track error (only valid when in DEEPSTALL_STAGE_LAND). (float)
+                stage                     : Deepstall stage. (uint8_t)
+
+*/
+    mavlink20.messages.deepstall = function( ...moreargs ) {
+    [ this.landing_lat , this.landing_lon , this.path_lat , this.path_lon , this.arc_entry_lat , this.arc_entry_lon , this.altitude , this.expected_travel_distance , this.cross_track_error , this.stage ] = moreargs;
+
+    this._format = '<iiiiiifffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DEEPSTALL;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 120;
+    this._name = 'DEEPSTALL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['landing_lat', 'landing_lon', 'path_lat', 'path_lon', 'arc_entry_lat', 'arc_entry_lon', 'altitude', 'expected_travel_distance', 'cross_track_error', 'stage'];
+
+}
+
+mavlink20.messages.deepstall.prototype = new mavlink20.message;
+mavlink20.messages.deepstall.prototype.pack = function(mav) {
+    var orderedfields = [ this.landing_lat, this.landing_lon, this.path_lat, this.path_lon, this.arc_entry_lat, this.arc_entry_lon, this.altitude, this.expected_travel_distance, this.cross_track_error, this.stage];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+3 axis gimbal measurements.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                delta_time                : Time since last update. (float)
+                delta_angle_x             : Delta angle X. (float)
+                delta_angle_y             : Delta angle Y. (float)
+                delta_angle_z             : Delta angle X. (float)
+                delta_velocity_x          : Delta velocity X. (float)
+                delta_velocity_y          : Delta velocity Y. (float)
+                delta_velocity_z          : Delta velocity Z. (float)
+                joint_roll                : Joint ROLL. (float)
+                joint_el                  : Joint EL. (float)
+                joint_az                  : Joint AZ. (float)
+
+*/
+    mavlink20.messages.gimbal_report = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.delta_time , this.delta_angle_x , this.delta_angle_y , this.delta_angle_z , this.delta_velocity_x , this.delta_velocity_y , this.delta_velocity_z , this.joint_roll , this.joint_el , this.joint_az ] = moreargs;
+
+    this._format = '<ffffffffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_REPORT;
+    this.order_map = [10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 134;
+    this._name = 'GIMBAL_REPORT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'delta_time', 'delta_angle_x', 'delta_angle_y', 'delta_angle_z', 'delta_velocity_x', 'delta_velocity_y', 'delta_velocity_z', 'joint_roll', 'joint_el', 'joint_az'];
+
+}
+
+mavlink20.messages.gimbal_report.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_report.prototype.pack = function(mav) {
+    var orderedfields = [ this.delta_time, this.delta_angle_x, this.delta_angle_y, this.delta_angle_z, this.delta_velocity_x, this.delta_velocity_y, this.delta_velocity_z, this.joint_roll, this.joint_el, this.joint_az, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Control message for rate gimbal.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                demanded_rate_x           : Demanded angular rate X. (float)
+                demanded_rate_y           : Demanded angular rate Y. (float)
+                demanded_rate_z           : Demanded angular rate Z. (float)
+
+*/
+    mavlink20.messages.gimbal_control = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.demanded_rate_x , this.demanded_rate_y , this.demanded_rate_z ] = moreargs;
+
+    this._format = '<fffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_CONTROL;
+    this.order_map = [3, 4, 0, 1, 2];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 205;
+    this._name = 'GIMBAL_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'demanded_rate_x', 'demanded_rate_y', 'demanded_rate_z'];
+
+}
+
+mavlink20.messages.gimbal_control.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.demanded_rate_x, this.demanded_rate_y, this.demanded_rate_z, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+100 Hz gimbal torque command telemetry.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                rl_torque_cmd             : Roll Torque Command. (int16_t)
+                el_torque_cmd             : Elevation Torque Command. (int16_t)
+                az_torque_cmd             : Azimuth Torque Command. (int16_t)
+
+*/
+    mavlink20.messages.gimbal_torque_cmd_report = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.rl_torque_cmd , this.el_torque_cmd , this.az_torque_cmd ] = moreargs;
+
+    this._format = '<hhhBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_TORQUE_CMD_REPORT;
+    this.order_map = [3, 4, 0, 1, 2];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 69;
+    this._name = 'GIMBAL_TORQUE_CMD_REPORT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'rl_torque_cmd', 'el_torque_cmd', 'az_torque_cmd'];
+
+}
+
+mavlink20.messages.gimbal_torque_cmd_report.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_torque_cmd_report.prototype.pack = function(mav) {
+    var orderedfields = [ this.rl_torque_cmd, this.el_torque_cmd, this.az_torque_cmd, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Heartbeat from a HeroBus attached GoPro.
+
+                status                    : Status. (uint8_t)
+                capture_mode              : Current capture mode. (uint8_t)
+                flags                     : Additional status bits. (uint8_t)
+
+*/
+    mavlink20.messages.gopro_heartbeat = function( ...moreargs ) {
+    [ this.status , this.capture_mode , this.flags ] = moreargs;
+
+    this._format = '<BBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GOPRO_HEARTBEAT;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 101;
+    this._name = 'GOPRO_HEARTBEAT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['status', 'capture_mode', 'flags'];
+
+}
+
+mavlink20.messages.gopro_heartbeat.prototype = new mavlink20.message;
+mavlink20.messages.gopro_heartbeat.prototype.pack = function(mav) {
+    var orderedfields = [ this.status, this.capture_mode, this.flags];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request a GOPRO_COMMAND response from the GoPro.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                cmd_id                    : Command ID. (uint8_t)
+
+*/
+    mavlink20.messages.gopro_get_request = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.cmd_id ] = moreargs;
+
+    this._format = '<BBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GOPRO_GET_REQUEST;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 50;
+    this._name = 'GOPRO_GET_REQUEST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'cmd_id'];
+
+}
+
+mavlink20.messages.gopro_get_request.prototype = new mavlink20.message;
+mavlink20.messages.gopro_get_request.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.cmd_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Response from a GOPRO_COMMAND get request.
+
+                cmd_id                    : Command ID. (uint8_t)
+                status                    : Status. (uint8_t)
+                value                     : Value. (uint8_t)
+
+*/
+    mavlink20.messages.gopro_get_response = function( ...moreargs ) {
+    [ this.cmd_id , this.status , this.value ] = moreargs;
+
+    this._format = '<BB4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_GOPRO_GET_RESPONSE;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 4];
+    this.array_len_map = [0, 0, 4];
+    this.crc_extra = 202;
+    this._name = 'GOPRO_GET_RESPONSE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['cmd_id', 'status', 'value'];
+
+}
+
+mavlink20.messages.gopro_get_response.prototype = new mavlink20.message;
+mavlink20.messages.gopro_get_response.prototype.pack = function(mav) {
+    var orderedfields = [ this.cmd_id, this.status, this.value];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request to set a GOPRO_COMMAND with a desired.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                cmd_id                    : Command ID. (uint8_t)
+                value                     : Value. (uint8_t)
+
+*/
+    mavlink20.messages.gopro_set_request = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.cmd_id , this.value ] = moreargs;
+
+    this._format = '<BBB4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_GOPRO_SET_REQUEST;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 4];
+    this.array_len_map = [0, 0, 0, 4];
+    this.crc_extra = 17;
+    this._name = 'GOPRO_SET_REQUEST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'cmd_id', 'value'];
+
+}
+
+mavlink20.messages.gopro_set_request.prototype = new mavlink20.message;
+mavlink20.messages.gopro_set_request.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.cmd_id, this.value];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Response from a GOPRO_COMMAND set request.
+
+                cmd_id                    : Command ID. (uint8_t)
+                status                    : Status. (uint8_t)
+
+*/
+    mavlink20.messages.gopro_set_response = function( ...moreargs ) {
+    [ this.cmd_id , this.status ] = moreargs;
+
+    this._format = '<BB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GOPRO_SET_RESPONSE;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 162;
+    this._name = 'GOPRO_SET_RESPONSE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['cmd_id', 'status'];
+
+}
+
+mavlink20.messages.gopro_set_response.prototype = new mavlink20.message;
+mavlink20.messages.gopro_set_response.prototype.pack = function(mav) {
+    var orderedfields = [ this.cmd_id, this.status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+RPM sensor output.
+
+                rpm1                      : RPM Sensor1. (float)
+                rpm2                      : RPM Sensor2. (float)
+
+*/
+    mavlink20.messages.rpm = function( ...moreargs ) {
+    [ this.rpm1 , this.rpm2 ] = moreargs;
+
+    this._format = '<ff';
+    this._id = mavlink20.MAVLINK_MSG_ID_RPM;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 207;
+    this._name = 'RPM';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['rpm1', 'rpm2'];
+
+}
+
+mavlink20.messages.rpm.prototype = new mavlink20.message;
+mavlink20.messages.rpm.prototype.pack = function(mav) {
+    var orderedfields = [ this.rpm1, this.rpm2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Read registers for a device.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                request_id                : Request ID - copied to reply. (uint32_t)
+                bustype                   : The bus type. (uint8_t)
+                bus                       : Bus number. (uint8_t)
+                address                   : Bus address. (uint8_t)
+                busname                   : Name of device on bus (for SPI). (char)
+                regstart                  : First register to read. (uint8_t)
+                count                     : Count of registers to read. (uint8_t)
+                bank                      : Bank number. (uint8_t)
+
+*/
+    mavlink20.messages.device_op_read = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.request_id , this.bustype , this.bus , this.address , this.busname , this.regstart , this.count , this.bank ] = moreargs;
+
+    this._format = '<IBBBBB40sBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DEVICE_OP_READ;
+    this.order_map = [1, 2, 0, 3, 4, 5, 6, 7, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 40, 0, 0, 0];
+    this.crc_extra = 134;
+    this._name = 'DEVICE_OP_READ';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'request_id', 'bustype', 'bus', 'address', 'busname', 'regstart', 'count', 'bank'];
+
+}
+
+mavlink20.messages.device_op_read.prototype = new mavlink20.message;
+mavlink20.messages.device_op_read.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.target_system, this.target_component, this.bustype, this.bus, this.address, this.busname, this.regstart, this.count, this.bank];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Read registers reply.
+
+                request_id                : Request ID - copied from request. (uint32_t)
+                result                    : 0 for success, anything else is failure code. (uint8_t)
+                regstart                  : Starting register. (uint8_t)
+                count                     : Count of bytes read. (uint8_t)
+                data                      : Reply data. (uint8_t)
+                bank                      : Bank number. (uint8_t)
+
+*/
+    mavlink20.messages.device_op_read_reply = function( ...moreargs ) {
+    [ this.request_id , this.result , this.regstart , this.count , this.data , this.bank ] = moreargs;
+
+    this._format = '<IBBB128sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DEVICE_OP_READ_REPLY;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 128, 1];
+    this.array_len_map = [0, 0, 0, 0, 128, 0];
+    this.crc_extra = 15;
+    this._name = 'DEVICE_OP_READ_REPLY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['request_id', 'result', 'regstart', 'count', 'data', 'bank'];
+
+}
+
+mavlink20.messages.device_op_read_reply.prototype = new mavlink20.message;
+mavlink20.messages.device_op_read_reply.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.result, this.regstart, this.count, this.data, this.bank];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Write registers for a device.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                request_id                : Request ID - copied to reply. (uint32_t)
+                bustype                   : The bus type. (uint8_t)
+                bus                       : Bus number. (uint8_t)
+                address                   : Bus address. (uint8_t)
+                busname                   : Name of device on bus (for SPI). (char)
+                regstart                  : First register to write. (uint8_t)
+                count                     : Count of registers to write. (uint8_t)
+                data                      : Write data. (uint8_t)
+                bank                      : Bank number. (uint8_t)
+
+*/
+    mavlink20.messages.device_op_write = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.request_id , this.bustype , this.bus , this.address , this.busname , this.regstart , this.count , this.data , this.bank ] = moreargs;
+
+    this._format = '<IBBBBB40sBB128sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DEVICE_OP_WRITE;
+    this.order_map = [1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 128, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 40, 0, 0, 128, 0];
+    this.crc_extra = 234;
+    this._name = 'DEVICE_OP_WRITE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'request_id', 'bustype', 'bus', 'address', 'busname', 'regstart', 'count', 'data', 'bank'];
+
+}
+
+mavlink20.messages.device_op_write.prototype = new mavlink20.message;
+mavlink20.messages.device_op_write.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.target_system, this.target_component, this.bustype, this.bus, this.address, this.busname, this.regstart, this.count, this.data, this.bank];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Write registers reply.
+
+                request_id                : Request ID - copied from request. (uint32_t)
+                result                    : 0 for success, anything else is failure code. (uint8_t)
+
+*/
+    mavlink20.messages.device_op_write_reply = function( ...moreargs ) {
+    [ this.request_id , this.result ] = moreargs;
+
+    this._format = '<IB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DEVICE_OP_WRITE_REPLY;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 64;
+    this._name = 'DEVICE_OP_WRITE_REPLY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['request_id', 'result'];
+
+}
+
+mavlink20.messages.device_op_write_reply.prototype = new mavlink20.message;
+mavlink20.messages.device_op_write_reply.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.result];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send a secure command. Data should be signed with a private key
+corresponding with a public key known to the recipient. Signature
+should be over the concatenation of the sequence number (little-endian
+format), the operation (little-endian format) the data and the session
+key. For SECURE_COMMAND_GET_SESSION_KEY the session key should be zero
+length. The data array consists of the data followed by the signature.
+The sum of the data_length and the sig_length cannot be more than 220.
+The format of the data is command specific.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                sequence                  : Sequence ID for tagging reply. (uint32_t)
+                operation                 : Operation being requested. (uint32_t)
+                data_length               : Data length. (uint8_t)
+                sig_length                : Signature length. (uint8_t)
+                data                      : Signed data. (uint8_t)
+
+*/
+    mavlink20.messages.secure_command = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.sequence , this.operation , this.data_length , this.sig_length , this.data ] = moreargs;
+
+    this._format = '<IIBBBB220s';
+    this._id = mavlink20.MAVLINK_MSG_ID_SECURE_COMMAND;
+    this.order_map = [2, 3, 0, 1, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 220];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 220];
+    this.crc_extra = 11;
+    this._name = 'SECURE_COMMAND';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'sequence', 'operation', 'data_length', 'sig_length', 'data'];
+
+}
+
+mavlink20.messages.secure_command.prototype = new mavlink20.message;
+mavlink20.messages.secure_command.prototype.pack = function(mav) {
+    var orderedfields = [ this.sequence, this.operation, this.target_system, this.target_component, this.data_length, this.sig_length, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reply from secure command.
+
+                sequence                  : Sequence ID from request. (uint32_t)
+                operation                 : Operation that was requested. (uint32_t)
+                result                    : Result of command. (uint8_t)
+                data_length               : Data length. (uint8_t)
+                data                      : Reply data. (uint8_t)
+
+*/
+    mavlink20.messages.secure_command_reply = function( ...moreargs ) {
+    [ this.sequence , this.operation , this.result , this.data_length , this.data ] = moreargs;
+
+    this._format = '<IIBB220s';
+    this._id = mavlink20.MAVLINK_MSG_ID_SECURE_COMMAND_REPLY;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 220];
+    this.array_len_map = [0, 0, 0, 0, 220];
+    this.crc_extra = 93;
+    this._name = 'SECURE_COMMAND_REPLY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['sequence', 'operation', 'result', 'data_length', 'data'];
+
+}
+
+mavlink20.messages.secure_command_reply.prototype = new mavlink20.message;
+mavlink20.messages.secure_command_reply.prototype.pack = function(mav) {
+    var orderedfields = [ this.sequence, this.operation, this.result, this.data_length, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Adaptive Controller tuning information.
+
+                axis                      : Axis. (uint8_t)
+                desired                   : Desired rate. (float)
+                achieved                  : Achieved rate. (float)
+                error                     : Error between model and vehicle. (float)
+                theta                     : Theta estimated state predictor. (float)
+                omega                     : Omega estimated state predictor. (float)
+                sigma                     : Sigma estimated state predictor. (float)
+                theta_dot                 : Theta derivative. (float)
+                omega_dot                 : Omega derivative. (float)
+                sigma_dot                 : Sigma derivative. (float)
+                f                         : Projection operator value. (float)
+                f_dot                     : Projection operator derivative. (float)
+                u                         : u adaptive controlled output command. (float)
+
+*/
+    mavlink20.messages.adap_tuning = function( ...moreargs ) {
+    [ this.axis , this.desired , this.achieved , this.error , this.theta , this.omega , this.sigma , this.theta_dot , this.omega_dot , this.sigma_dot , this.f , this.f_dot , this.u ] = moreargs;
+
+    this._format = '<ffffffffffffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ADAP_TUNING;
+    this.order_map = [12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 46;
+    this._name = 'ADAP_TUNING';
+
+    this._instance_field = 'axis';
+    this._instance_offset = 48;
+
+    this.fieldnames = ['axis', 'desired', 'achieved', 'error', 'theta', 'omega', 'sigma', 'theta_dot', 'omega_dot', 'sigma_dot', 'f', 'f_dot', 'u'];
+
+}
+
+mavlink20.messages.adap_tuning.prototype = new mavlink20.message;
+mavlink20.messages.adap_tuning.prototype.pack = function(mav) {
+    var orderedfields = [ this.desired, this.achieved, this.error, this.theta, this.omega, this.sigma, this.theta_dot, this.omega_dot, this.sigma_dot, this.f, this.f_dot, this.u, this.axis];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Camera vision based attitude and position deltas.
+
+                time_usec                 : Timestamp (synced to UNIX time or since system boot). (uint64_t)
+                time_delta_usec           : Time since the last reported camera frame. (uint64_t)
+                angle_delta               : Defines a rotation vector [roll, pitch, yaw] to the current MAV_FRAME_BODY_FRD from the previous MAV_FRAME_BODY_FRD. (float)
+                position_delta            : Change in position to the current MAV_FRAME_BODY_FRD from the previous FRAME_BODY_FRD rotated to the current MAV_FRAME_BODY_FRD. (float)
+                confidence                : Normalised confidence value from 0 to 100. (float)
+
+*/
+    mavlink20.messages.vision_position_delta = function( ...moreargs ) {
+    [ this.time_usec , this.time_delta_usec , this.angle_delta , this.position_delta , this.confidence ] = moreargs;
+
+    this._format = '<QQ3f3ff';
+    this._id = mavlink20.MAVLINK_MSG_ID_VISION_POSITION_DELTA;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 3, 3, 1];
+    this.array_len_map = [0, 0, 3, 3, 0];
+    this.crc_extra = 106;
+    this._name = 'VISION_POSITION_DELTA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'time_delta_usec', 'angle_delta', 'position_delta', 'confidence'];
+
+}
+
+mavlink20.messages.vision_position_delta.prototype = new mavlink20.message;
+mavlink20.messages.vision_position_delta.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.time_delta_usec, this.angle_delta, this.position_delta, this.confidence];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Angle of Attack and Side Slip Angle.
+
+                time_usec                 : Timestamp (since boot or Unix epoch). (uint64_t)
+                AOA                       : Angle of Attack. (float)
+                SSA                       : Side Slip Angle. (float)
+
+*/
+    mavlink20.messages.aoa_ssa = function( ...moreargs ) {
+    [ this.time_usec , this.AOA , this.SSA ] = moreargs;
+
+    this._format = '<Qff';
+    this._id = mavlink20.MAVLINK_MSG_ID_AOA_SSA;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 205;
+    this._name = 'AOA_SSA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'AOA', 'SSA'];
+
+}
+
+mavlink20.messages.aoa_ssa.prototype = new mavlink20.message;
+mavlink20.messages.aoa_ssa.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.AOA, this.SSA];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ESC Telemetry Data for ESCs 1 to 4, matching data sent by BLHeli ESCs.
+
+                temperature               : Temperature. (uint8_t)
+                voltage                   : Voltage. (uint16_t)
+                current                   : Current. (uint16_t)
+                totalcurrent              : Total current. (uint16_t)
+                rpm                       : RPM (eRPM). (uint16_t)
+                count                     : count of telemetry packets received (wraps at 65535). (uint16_t)
+
+*/
+    mavlink20.messages.esc_telemetry_1_to_4 = function( ...moreargs ) {
+    [ this.temperature , this.voltage , this.current , this.totalcurrent , this.rpm , this.count ] = moreargs;
+
+    this._format = '<4H4H4H4H4H4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_1_TO_4;
+    this.order_map = [5, 0, 1, 2, 3, 4];
+    this.len_map = [4, 4, 4, 4, 4, 4];
+    this.array_len_map = [4, 4, 4, 4, 4, 4];
+    this.crc_extra = 144;
+    this._name = 'ESC_TELEMETRY_1_TO_4';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['temperature', 'voltage', 'current', 'totalcurrent', 'rpm', 'count'];
+
+}
+
+mavlink20.messages.esc_telemetry_1_to_4.prototype = new mavlink20.message;
+mavlink20.messages.esc_telemetry_1_to_4.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current, this.totalcurrent, this.rpm, this.count, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ESC Telemetry Data for ESCs 5 to 8, matching data sent by BLHeli ESCs.
+
+                temperature               : Temperature. (uint8_t)
+                voltage                   : Voltage. (uint16_t)
+                current                   : Current. (uint16_t)
+                totalcurrent              : Total current. (uint16_t)
+                rpm                       : RPM (eRPM). (uint16_t)
+                count                     : count of telemetry packets received (wraps at 65535). (uint16_t)
+
+*/
+    mavlink20.messages.esc_telemetry_5_to_8 = function( ...moreargs ) {
+    [ this.temperature , this.voltage , this.current , this.totalcurrent , this.rpm , this.count ] = moreargs;
+
+    this._format = '<4H4H4H4H4H4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_5_TO_8;
+    this.order_map = [5, 0, 1, 2, 3, 4];
+    this.len_map = [4, 4, 4, 4, 4, 4];
+    this.array_len_map = [4, 4, 4, 4, 4, 4];
+    this.crc_extra = 133;
+    this._name = 'ESC_TELEMETRY_5_TO_8';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['temperature', 'voltage', 'current', 'totalcurrent', 'rpm', 'count'];
+
+}
+
+mavlink20.messages.esc_telemetry_5_to_8.prototype = new mavlink20.message;
+mavlink20.messages.esc_telemetry_5_to_8.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current, this.totalcurrent, this.rpm, this.count, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ESC Telemetry Data for ESCs 9 to 12, matching data sent by BLHeli
+ESCs.
+
+                temperature               : Temperature. (uint8_t)
+                voltage                   : Voltage. (uint16_t)
+                current                   : Current. (uint16_t)
+                totalcurrent              : Total current. (uint16_t)
+                rpm                       : RPM (eRPM). (uint16_t)
+                count                     : count of telemetry packets received (wraps at 65535). (uint16_t)
+
+*/
+    mavlink20.messages.esc_telemetry_9_to_12 = function( ...moreargs ) {
+    [ this.temperature , this.voltage , this.current , this.totalcurrent , this.rpm , this.count ] = moreargs;
+
+    this._format = '<4H4H4H4H4H4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_9_TO_12;
+    this.order_map = [5, 0, 1, 2, 3, 4];
+    this.len_map = [4, 4, 4, 4, 4, 4];
+    this.array_len_map = [4, 4, 4, 4, 4, 4];
+    this.crc_extra = 85;
+    this._name = 'ESC_TELEMETRY_9_TO_12';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['temperature', 'voltage', 'current', 'totalcurrent', 'rpm', 'count'];
+
+}
+
+mavlink20.messages.esc_telemetry_9_to_12.prototype = new mavlink20.message;
+mavlink20.messages.esc_telemetry_9_to_12.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current, this.totalcurrent, this.rpm, this.count, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Configure an OSD parameter slot.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                request_id                : Request ID - copied to reply. (uint32_t)
+                osd_screen                : OSD parameter screen index. (uint8_t)
+                osd_index                 : OSD parameter display index. (uint8_t)
+                param_id                  : Onboard parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                config_type               : Config type. (uint8_t)
+                min_value                 : OSD parameter minimum value. (float)
+                max_value                 : OSD parameter maximum value. (float)
+                increment                 : OSD parameter increment. (float)
+
+*/
+    mavlink20.messages.osd_param_config = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.request_id , this.osd_screen , this.osd_index , this.param_id , this.config_type , this.min_value , this.max_value , this.increment ] = moreargs;
+
+    this._format = '<IfffBBBB16sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OSD_PARAM_CONFIG;
+    this.order_map = [4, 5, 0, 6, 7, 8, 9, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 16, 0];
+    this.crc_extra = 195;
+    this._name = 'OSD_PARAM_CONFIG';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'request_id', 'osd_screen', 'osd_index', 'param_id', 'config_type', 'min_value', 'max_value', 'increment'];
+
+}
+
+mavlink20.messages.osd_param_config.prototype = new mavlink20.message;
+mavlink20.messages.osd_param_config.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.min_value, this.max_value, this.increment, this.target_system, this.target_component, this.osd_screen, this.osd_index, this.param_id, this.config_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Configure OSD parameter reply.
+
+                request_id                : Request ID - copied from request. (uint32_t)
+                result                    : Config error type. (uint8_t)
+
+*/
+    mavlink20.messages.osd_param_config_reply = function( ...moreargs ) {
+    [ this.request_id , this.result ] = moreargs;
+
+    this._format = '<IB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OSD_PARAM_CONFIG_REPLY;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 79;
+    this._name = 'OSD_PARAM_CONFIG_REPLY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['request_id', 'result'];
+
+}
+
+mavlink20.messages.osd_param_config_reply.prototype = new mavlink20.message;
+mavlink20.messages.osd_param_config_reply.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.result];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Read a configured an OSD parameter slot.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                request_id                : Request ID - copied to reply. (uint32_t)
+                osd_screen                : OSD parameter screen index. (uint8_t)
+                osd_index                 : OSD parameter display index. (uint8_t)
+
+*/
+    mavlink20.messages.osd_param_show_config = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.request_id , this.osd_screen , this.osd_index ] = moreargs;
+
+    this._format = '<IBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OSD_PARAM_SHOW_CONFIG;
+    this.order_map = [1, 2, 0, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 128;
+    this._name = 'OSD_PARAM_SHOW_CONFIG';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'request_id', 'osd_screen', 'osd_index'];
+
+}
+
+mavlink20.messages.osd_param_show_config.prototype = new mavlink20.message;
+mavlink20.messages.osd_param_show_config.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.target_system, this.target_component, this.osd_screen, this.osd_index];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Read configured OSD parameter reply.
+
+                request_id                : Request ID - copied from request. (uint32_t)
+                result                    : Config error type. (uint8_t)
+                param_id                  : Onboard parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                config_type               : Config type. (uint8_t)
+                min_value                 : OSD parameter minimum value. (float)
+                max_value                 : OSD parameter maximum value. (float)
+                increment                 : OSD parameter increment. (float)
+
+*/
+    mavlink20.messages.osd_param_show_config_reply = function( ...moreargs ) {
+    [ this.request_id , this.result , this.param_id , this.config_type , this.min_value , this.max_value , this.increment ] = moreargs;
+
+    this._format = '<IfffB16sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OSD_PARAM_SHOW_CONFIG_REPLY;
+    this.order_map = [0, 4, 5, 6, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 16, 0];
+    this.crc_extra = 177;
+    this._name = 'OSD_PARAM_SHOW_CONFIG_REPLY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['request_id', 'result', 'param_id', 'config_type', 'min_value', 'max_value', 'increment'];
+
+}
+
+mavlink20.messages.osd_param_show_config_reply.prototype = new mavlink20.message;
+mavlink20.messages.osd_param_show_config_reply.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.min_value, this.max_value, this.increment, this.result, this.param_id, this.config_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Obstacle located as a 3D vector.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                sensor_type               : Class id of the distance sensor type. (uint8_t)
+                frame                     : Coordinate frame of reference. (uint8_t)
+                obstacle_id               : Unique ID given to each obstacle so that its movement can be tracked. Use UINT16_MAX if object ID is unknown or cannot be determined. (uint16_t)
+                x                         : X position of the obstacle. (float)
+                y                         : Y position of the obstacle. (float)
+                z                         : Z position of the obstacle. (float)
+                min_distance              : Minimum distance the sensor can measure. (float)
+                max_distance              : Maximum distance the sensor can measure. (float)
+
+*/
+    mavlink20.messages.obstacle_distance_3d = function( ...moreargs ) {
+    [ this.time_boot_ms , this.sensor_type , this.frame , this.obstacle_id , this.x , this.y , this.z , this.min_distance , this.max_distance ] = moreargs;
+
+    this._format = '<IfffffHBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OBSTACLE_DISTANCE_3D;
+    this.order_map = [0, 7, 8, 6, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 130;
+    this._name = 'OBSTACLE_DISTANCE_3D';
+
+    this._instance_field = 'obstacle_id';
+    this._instance_offset = 24;
+
+    this.fieldnames = ['time_boot_ms', 'sensor_type', 'frame', 'obstacle_id', 'x', 'y', 'z', 'min_distance', 'max_distance'];
+
+}
+
+mavlink20.messages.obstacle_distance_3d.prototype = new mavlink20.message;
+mavlink20.messages.obstacle_distance_3d.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.x, this.y, this.z, this.min_distance, this.max_distance, this.obstacle_id, this.sensor_type, this.frame];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Water depth
+
+                time_boot_ms              : Timestamp (time since system boot) (uint32_t)
+                id                        : Onboard ID of the sensor (uint8_t)
+                healthy                   : Sensor data healthy (0=unhealthy, 1=healthy) (uint8_t)
+                lat                       : Latitude (int32_t)
+                lng                       : Longitude (int32_t)
+                alt                       : Altitude (MSL) of vehicle (float)
+                roll                      : Roll angle (float)
+                pitch                     : Pitch angle (float)
+                yaw                       : Yaw angle (float)
+                distance                  : Distance (uncorrected) (float)
+                temperature               : Water temperature (float)
+
+*/
+    mavlink20.messages.water_depth = function( ...moreargs ) {
+    [ this.time_boot_ms , this.id , this.healthy , this.lat , this.lng , this.alt , this.roll , this.pitch , this.yaw , this.distance , this.temperature ] = moreargs;
+
+    this._format = '<IiiffffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_WATER_DEPTH;
+    this.order_map = [0, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 47;
+    this._name = 'WATER_DEPTH';
+
+    this._instance_field = 'id';
+    this._instance_offset = 36;
+
+    this.fieldnames = ['time_boot_ms', 'id', 'healthy', 'lat', 'lng', 'alt', 'roll', 'pitch', 'yaw', 'distance', 'temperature'];
+
+}
+
+mavlink20.messages.water_depth.prototype = new mavlink20.message;
+mavlink20.messages.water_depth.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.lat, this.lng, this.alt, this.roll, this.pitch, this.yaw, this.distance, this.temperature, this.id, this.healthy];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The MCU status, giving MCU temperature and voltage. The min and max
+voltages are to allow for detecting power supply instability.
+
+                id                        : MCU instance (uint8_t)
+                MCU_temperature           : MCU Internal temperature (int16_t)
+                MCU_voltage               : MCU voltage (uint16_t)
+                MCU_voltage_min           : MCU voltage minimum (uint16_t)
+                MCU_voltage_max           : MCU voltage maximum (uint16_t)
+
+*/
+    mavlink20.messages.mcu_status = function( ...moreargs ) {
+    [ this.id , this.MCU_temperature , this.MCU_voltage , this.MCU_voltage_min , this.MCU_voltage_max ] = moreargs;
+
+    this._format = '<hHHHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MCU_STATUS;
+    this.order_map = [4, 0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 142;
+    this._name = 'MCU_STATUS';
+
+    this._instance_field = 'id';
+    this._instance_offset = 8;
+
+    this.fieldnames = ['id', 'MCU_temperature', 'MCU_voltage', 'MCU_voltage_min', 'MCU_voltage_max'];
+
+}
+
+mavlink20.messages.mcu_status.prototype = new mavlink20.message;
+mavlink20.messages.mcu_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.MCU_temperature, this.MCU_voltage, this.MCU_voltage_min, this.MCU_voltage_max, this.id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ESC Telemetry Data for ESCs 13 to 16, matching data sent by BLHeli
+ESCs.
+
+                temperature               : Temperature. (uint8_t)
+                voltage                   : Voltage. (uint16_t)
+                current                   : Current. (uint16_t)
+                totalcurrent              : Total current. (uint16_t)
+                rpm                       : RPM (eRPM). (uint16_t)
+                count                     : count of telemetry packets received (wraps at 65535). (uint16_t)
+
+*/
+    mavlink20.messages.esc_telemetry_13_to_16 = function( ...moreargs ) {
+    [ this.temperature , this.voltage , this.current , this.totalcurrent , this.rpm , this.count ] = moreargs;
+
+    this._format = '<4H4H4H4H4H4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_13_TO_16;
+    this.order_map = [5, 0, 1, 2, 3, 4];
+    this.len_map = [4, 4, 4, 4, 4, 4];
+    this.array_len_map = [4, 4, 4, 4, 4, 4];
+    this.crc_extra = 132;
+    this._name = 'ESC_TELEMETRY_13_TO_16';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['temperature', 'voltage', 'current', 'totalcurrent', 'rpm', 'count'];
+
+}
+
+mavlink20.messages.esc_telemetry_13_to_16.prototype = new mavlink20.message;
+mavlink20.messages.esc_telemetry_13_to_16.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current, this.totalcurrent, this.rpm, this.count, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ESC Telemetry Data for ESCs 17 to 20, matching data sent by BLHeli
+ESCs.
+
+                temperature               : Temperature. (uint8_t)
+                voltage                   : Voltage. (uint16_t)
+                current                   : Current. (uint16_t)
+                totalcurrent              : Total current. (uint16_t)
+                rpm                       : RPM (eRPM). (uint16_t)
+                count                     : count of telemetry packets received (wraps at 65535). (uint16_t)
+
+*/
+    mavlink20.messages.esc_telemetry_17_to_20 = function( ...moreargs ) {
+    [ this.temperature , this.voltage , this.current , this.totalcurrent , this.rpm , this.count ] = moreargs;
+
+    this._format = '<4H4H4H4H4H4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_17_TO_20;
+    this.order_map = [5, 0, 1, 2, 3, 4];
+    this.len_map = [4, 4, 4, 4, 4, 4];
+    this.array_len_map = [4, 4, 4, 4, 4, 4];
+    this.crc_extra = 208;
+    this._name = 'ESC_TELEMETRY_17_TO_20';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['temperature', 'voltage', 'current', 'totalcurrent', 'rpm', 'count'];
+
+}
+
+mavlink20.messages.esc_telemetry_17_to_20.prototype = new mavlink20.message;
+mavlink20.messages.esc_telemetry_17_to_20.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current, this.totalcurrent, this.rpm, this.count, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ESC Telemetry Data for ESCs 21 to 24, matching data sent by BLHeli
+ESCs.
+
+                temperature               : Temperature. (uint8_t)
+                voltage                   : Voltage. (uint16_t)
+                current                   : Current. (uint16_t)
+                totalcurrent              : Total current. (uint16_t)
+                rpm                       : RPM (eRPM). (uint16_t)
+                count                     : count of telemetry packets received (wraps at 65535). (uint16_t)
+
+*/
+    mavlink20.messages.esc_telemetry_21_to_24 = function( ...moreargs ) {
+    [ this.temperature , this.voltage , this.current , this.totalcurrent , this.rpm , this.count ] = moreargs;
+
+    this._format = '<4H4H4H4H4H4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_21_TO_24;
+    this.order_map = [5, 0, 1, 2, 3, 4];
+    this.len_map = [4, 4, 4, 4, 4, 4];
+    this.array_len_map = [4, 4, 4, 4, 4, 4];
+    this.crc_extra = 201;
+    this._name = 'ESC_TELEMETRY_21_TO_24';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['temperature', 'voltage', 'current', 'totalcurrent', 'rpm', 'count'];
+
+}
+
+mavlink20.messages.esc_telemetry_21_to_24.prototype = new mavlink20.message;
+mavlink20.messages.esc_telemetry_21_to_24.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current, this.totalcurrent, this.rpm, this.count, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ESC Telemetry Data for ESCs 25 to 28, matching data sent by BLHeli
+ESCs.
+
+                temperature               : Temperature. (uint8_t)
+                voltage                   : Voltage. (uint16_t)
+                current                   : Current. (uint16_t)
+                totalcurrent              : Total current. (uint16_t)
+                rpm                       : RPM (eRPM). (uint16_t)
+                count                     : count of telemetry packets received (wraps at 65535). (uint16_t)
+
+*/
+    mavlink20.messages.esc_telemetry_25_to_28 = function( ...moreargs ) {
+    [ this.temperature , this.voltage , this.current , this.totalcurrent , this.rpm , this.count ] = moreargs;
+
+    this._format = '<4H4H4H4H4H4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_25_TO_28;
+    this.order_map = [5, 0, 1, 2, 3, 4];
+    this.len_map = [4, 4, 4, 4, 4, 4];
+    this.array_len_map = [4, 4, 4, 4, 4, 4];
+    this.crc_extra = 193;
+    this._name = 'ESC_TELEMETRY_25_TO_28';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['temperature', 'voltage', 'current', 'totalcurrent', 'rpm', 'count'];
+
+}
+
+mavlink20.messages.esc_telemetry_25_to_28.prototype = new mavlink20.message;
+mavlink20.messages.esc_telemetry_25_to_28.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current, this.totalcurrent, this.rpm, this.count, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ESC Telemetry Data for ESCs 29 to 32, matching data sent by BLHeli
+ESCs.
+
+                temperature               : Temperature. (uint8_t)
+                voltage                   : Voltage. (uint16_t)
+                current                   : Current. (uint16_t)
+                totalcurrent              : Total current. (uint16_t)
+                rpm                       : RPM (eRPM). (uint16_t)
+                count                     : count of telemetry packets received (wraps at 65535). (uint16_t)
+
+*/
+    mavlink20.messages.esc_telemetry_29_to_32 = function( ...moreargs ) {
+    [ this.temperature , this.voltage , this.current , this.totalcurrent , this.rpm , this.count ] = moreargs;
+
+    this._format = '<4H4H4H4H4H4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESC_TELEMETRY_29_TO_32;
+    this.order_map = [5, 0, 1, 2, 3, 4];
+    this.len_map = [4, 4, 4, 4, 4, 4];
+    this.array_len_map = [4, 4, 4, 4, 4, 4];
+    this.crc_extra = 189;
+    this._name = 'ESC_TELEMETRY_29_TO_32';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['temperature', 'voltage', 'current', 'totalcurrent', 'rpm', 'count'];
+
+}
+
+mavlink20.messages.esc_telemetry_29_to_32.prototype = new mavlink20.message;
+mavlink20.messages.esc_telemetry_29_to_32.prototype.pack = function(mav) {
+    var orderedfields = [ this.voltage, this.current, this.totalcurrent, this.rpm, this.count, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message encoding a command with parameters as scaled integers and
+additional metadata. Scaling depends on the actual command value.
+
+                utc_time                  : UTC time, seconds elapsed since 01.01.1970 (uint32_t)
+                vehicle_timestamp         : Microseconds elapsed since vehicle boot (uint64_t)
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                frame                     : The coordinate system of the COMMAND, as defined by MAV_FRAME enum (uint8_t)
+                command                   : The scheduled action for the mission item, as defined by MAV_CMD enum (uint16_t)
+                current                   : false:0, true:1 (uint8_t)
+                autocontinue              : autocontinue to next wp (uint8_t)
+                param1                    : PARAM1, see MAV_CMD enum (float)
+                param2                    : PARAM2, see MAV_CMD enum (float)
+                param3                    : PARAM3, see MAV_CMD enum (float)
+                param4                    : PARAM4, see MAV_CMD enum (float)
+                x                         : PARAM5 / local: x position in meters * 1e4, global: latitude in degrees * 10^7 (int32_t)
+                y                         : PARAM6 / local: y position in meters * 1e4, global: longitude in degrees * 10^7 (int32_t)
+                z                         : PARAM7 / z position: global: altitude in meters (MSL, WGS84, AGL or relative to home - depending on frame). (float)
+
+*/
+    mavlink20.messages.command_int_stamped = function( ...moreargs ) {
+    [ this.utc_time , this.vehicle_timestamp , this.target_system , this.target_component , this.frame , this.command , this.current , this.autocontinue , this.param1 , this.param2 , this.param3 , this.param4 , this.x , this.y , this.z ] = moreargs;
+
+    this._format = '<QIffffiifHBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_COMMAND_INT_STAMPED;
+    this.order_map = [1, 0, 10, 11, 12, 9, 13, 14, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 119;
+    this._name = 'COMMAND_INT_STAMPED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['utc_time', 'vehicle_timestamp', 'target_system', 'target_component', 'frame', 'command', 'current', 'autocontinue', 'param1', 'param2', 'param3', 'param4', 'x', 'y', 'z'];
+
+}
+
+mavlink20.messages.command_int_stamped.prototype = new mavlink20.message;
+mavlink20.messages.command_int_stamped.prototype.pack = function(mav) {
+    var orderedfields = [ this.vehicle_timestamp, this.utc_time, this.param1, this.param2, this.param3, this.param4, this.x, this.y, this.z, this.command, this.target_system, this.target_component, this.frame, this.current, this.autocontinue];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send a command with up to seven parameters to the MAV and additional
+metadata
+
+                utc_time                  : UTC time, seconds elapsed since 01.01.1970 (uint32_t)
+                vehicle_timestamp         : Microseconds elapsed since vehicle boot (uint64_t)
+                target_system             : System which should execute the command (uint8_t)
+                target_component          : Component which should execute the command, 0 for all components (uint8_t)
+                command                   : Command ID, as defined by MAV_CMD enum. (uint16_t)
+                confirmation              : 0: First transmission of this command. 1-255: Confirmation transmissions (e.g. for kill command) (uint8_t)
+                param1                    : Parameter 1, as defined by MAV_CMD enum. (float)
+                param2                    : Parameter 2, as defined by MAV_CMD enum. (float)
+                param3                    : Parameter 3, as defined by MAV_CMD enum. (float)
+                param4                    : Parameter 4, as defined by MAV_CMD enum. (float)
+                param5                    : Parameter 5, as defined by MAV_CMD enum. (float)
+                param6                    : Parameter 6, as defined by MAV_CMD enum. (float)
+                param7                    : Parameter 7, as defined by MAV_CMD enum. (float)
+
+*/
+    mavlink20.messages.command_long_stamped = function( ...moreargs ) {
+    [ this.utc_time , this.vehicle_timestamp , this.target_system , this.target_component , this.command , this.confirmation , this.param1 , this.param2 , this.param3 , this.param4 , this.param5 , this.param6 , this.param7 ] = moreargs;
+
+    this._format = '<QIfffffffHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_COMMAND_LONG_STAMPED;
+    this.order_map = [1, 0, 10, 11, 9, 12, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 102;
+    this._name = 'COMMAND_LONG_STAMPED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['utc_time', 'vehicle_timestamp', 'target_system', 'target_component', 'command', 'confirmation', 'param1', 'param2', 'param3', 'param4', 'param5', 'param6', 'param7'];
+
+}
+
+mavlink20.messages.command_long_stamped.prototype = new mavlink20.message;
+mavlink20.messages.command_long_stamped.prototype.pack = function(mav) {
+    var orderedfields = [ this.vehicle_timestamp, this.utc_time, this.param1, this.param2, this.param3, this.param4, this.param5, this.param6, this.param7, this.command, this.target_system, this.target_component, this.confirmation];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Voltage and current sensor data
+
+                adc121_vspb_volt          : Power board voltage sensor reading (float)
+                adc121_cspb_amp           : Power board current sensor reading (float)
+                adc121_cs1_amp            : Board current sensor 1 reading (float)
+                adc121_cs2_amp            : Board current sensor 2 reading (float)
+
+*/
+    mavlink20.messages.sens_power = function( ...moreargs ) {
+    [ this.adc121_vspb_volt , this.adc121_cspb_amp , this.adc121_cs1_amp , this.adc121_cs2_amp ] = moreargs;
+
+    this._format = '<ffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_SENS_POWER;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 218;
+    this._name = 'SENS_POWER';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['adc121_vspb_volt', 'adc121_cspb_amp', 'adc121_cs1_amp', 'adc121_cs2_amp'];
+
+}
+
+mavlink20.messages.sens_power.prototype = new mavlink20.message;
+mavlink20.messages.sens_power.prototype.pack = function(mav) {
+    var orderedfields = [ this.adc121_vspb_volt, this.adc121_cspb_amp, this.adc121_cs1_amp, this.adc121_cs2_amp];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Maximum Power Point Tracker (MPPT) sensor data for solar module power
+performance tracking
+
+                mppt_timestamp            : MPPT last timestamp (uint64_t)
+                mppt1_volt                : MPPT1 voltage (float)
+                mppt1_amp                 : MPPT1 current (float)
+                mppt1_pwm                 : MPPT1 pwm (uint16_t)
+                mppt1_status              : MPPT1 status (uint8_t)
+                mppt2_volt                : MPPT2 voltage (float)
+                mppt2_amp                 : MPPT2 current (float)
+                mppt2_pwm                 : MPPT2 pwm (uint16_t)
+                mppt2_status              : MPPT2 status (uint8_t)
+                mppt3_volt                : MPPT3 voltage (float)
+                mppt3_amp                 : MPPT3 current (float)
+                mppt3_pwm                 : MPPT3 pwm (uint16_t)
+                mppt3_status              : MPPT3 status (uint8_t)
+
+*/
+    mavlink20.messages.sens_mppt = function( ...moreargs ) {
+    [ this.mppt_timestamp , this.mppt1_volt , this.mppt1_amp , this.mppt1_pwm , this.mppt1_status , this.mppt2_volt , this.mppt2_amp , this.mppt2_pwm , this.mppt2_status , this.mppt3_volt , this.mppt3_amp , this.mppt3_pwm , this.mppt3_status ] = moreargs;
+
+    this._format = '<QffffffHHHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SENS_MPPT;
+    this.order_map = [0, 1, 2, 7, 10, 3, 4, 8, 11, 5, 6, 9, 12];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 231;
+    this._name = 'SENS_MPPT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['mppt_timestamp', 'mppt1_volt', 'mppt1_amp', 'mppt1_pwm', 'mppt1_status', 'mppt2_volt', 'mppt2_amp', 'mppt2_pwm', 'mppt2_status', 'mppt3_volt', 'mppt3_amp', 'mppt3_pwm', 'mppt3_status'];
+
+}
+
+mavlink20.messages.sens_mppt.prototype = new mavlink20.message;
+mavlink20.messages.sens_mppt.prototype.pack = function(mav) {
+    var orderedfields = [ this.mppt_timestamp, this.mppt1_volt, this.mppt1_amp, this.mppt2_volt, this.mppt2_amp, this.mppt3_volt, this.mppt3_amp, this.mppt1_pwm, this.mppt2_pwm, this.mppt3_pwm, this.mppt1_status, this.mppt2_status, this.mppt3_status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ASL-fixed-wing controller data
+
+                timestamp                 : Timestamp (uint64_t)
+                aslctrl_mode              : ASLCTRL control-mode (manual, stabilized, auto, etc...) (uint8_t)
+                h                         : See sourcecode for a description of these values... (float)
+                hRef                      :  (float)
+                hRef_t                    :  (float)
+                PitchAngle                : Pitch angle (float)
+                PitchAngleRef             : Pitch angle reference (float)
+                q                         :  (float)
+                qRef                      :  (float)
+                uElev                     :  (float)
+                uThrot                    :  (float)
+                uThrot2                   :  (float)
+                nZ                        :  (float)
+                AirspeedRef               : Airspeed reference (float)
+                SpoilersEngaged           :  (uint8_t)
+                YawAngle                  : Yaw angle (float)
+                YawAngleRef               : Yaw angle reference (float)
+                RollAngle                 : Roll angle (float)
+                RollAngleRef              : Roll angle reference (float)
+                p                         :  (float)
+                pRef                      :  (float)
+                r                         :  (float)
+                rRef                      :  (float)
+                uAil                      :  (float)
+                uRud                      :  (float)
+
+*/
+    mavlink20.messages.aslctrl_data = function( ...moreargs ) {
+    [ this.timestamp , this.aslctrl_mode , this.h , this.hRef , this.hRef_t , this.PitchAngle , this.PitchAngleRef , this.q , this.qRef , this.uElev , this.uThrot , this.uThrot2 , this.nZ , this.AirspeedRef , this.SpoilersEngaged , this.YawAngle , this.YawAngleRef , this.RollAngle , this.RollAngleRef , this.p , this.pRef , this.r , this.rRef , this.uAil , this.uRud ] = moreargs;
+
+    this._format = '<QffffffffffffffffffffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ASLCTRL_DATA;
+    this.order_map = [0, 23, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 24, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 172;
+    this._name = 'ASLCTRL_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'aslctrl_mode', 'h', 'hRef', 'hRef_t', 'PitchAngle', 'PitchAngleRef', 'q', 'qRef', 'uElev', 'uThrot', 'uThrot2', 'nZ', 'AirspeedRef', 'SpoilersEngaged', 'YawAngle', 'YawAngleRef', 'RollAngle', 'RollAngleRef', 'p', 'pRef', 'r', 'rRef', 'uAil', 'uRud'];
+
+}
+
+mavlink20.messages.aslctrl_data.prototype = new mavlink20.message;
+mavlink20.messages.aslctrl_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.h, this.hRef, this.hRef_t, this.PitchAngle, this.PitchAngleRef, this.q, this.qRef, this.uElev, this.uThrot, this.uThrot2, this.nZ, this.AirspeedRef, this.YawAngle, this.YawAngleRef, this.RollAngle, this.RollAngleRef, this.p, this.pRef, this.r, this.rRef, this.uAil, this.uRud, this.aslctrl_mode, this.SpoilersEngaged];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ASL-fixed-wing controller debug data
+
+                i32_1                     : Debug data (uint32_t)
+                i8_1                      : Debug data (uint8_t)
+                i8_2                      : Debug data (uint8_t)
+                f_1                       : Debug data (float)
+                f_2                       : Debug data (float)
+                f_3                       : Debug data (float)
+                f_4                       : Debug data (float)
+                f_5                       : Debug data (float)
+                f_6                       : Debug data (float)
+                f_7                       : Debug data (float)
+                f_8                       : Debug data (float)
+
+*/
+    mavlink20.messages.aslctrl_debug = function( ...moreargs ) {
+    [ this.i32_1 , this.i8_1 , this.i8_2 , this.f_1 , this.f_2 , this.f_3 , this.f_4 , this.f_5 , this.f_6 , this.f_7 , this.f_8 ] = moreargs;
+
+    this._format = '<IffffffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ASLCTRL_DEBUG;
+    this.order_map = [0, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 251;
+    this._name = 'ASLCTRL_DEBUG';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['i32_1', 'i8_1', 'i8_2', 'f_1', 'f_2', 'f_3', 'f_4', 'f_5', 'f_6', 'f_7', 'f_8'];
+
+}
+
+mavlink20.messages.aslctrl_debug.prototype = new mavlink20.message;
+mavlink20.messages.aslctrl_debug.prototype.pack = function(mav) {
+    var orderedfields = [ this.i32_1, this.f_1, this.f_2, this.f_3, this.f_4, this.f_5, this.f_6, this.f_7, this.f_8, this.i8_1, this.i8_2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Extended state information for ASLUAVs
+
+                LED_status                : Status of the position-indicator LEDs (uint8_t)
+                SATCOM_status             : Status of the IRIDIUM satellite communication system (uint8_t)
+                Servo_status              : Status vector for up to 8 servos (uint8_t)
+                Motor_rpm                 : Motor RPM (float)
+
+*/
+    mavlink20.messages.asluav_status = function( ...moreargs ) {
+    [ this.LED_status , this.SATCOM_status , this.Servo_status , this.Motor_rpm ] = moreargs;
+
+    this._format = '<fBB8s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ASLUAV_STATUS;
+    this.order_map = [1, 2, 3, 0];
+    this.len_map = [1, 1, 1, 8];
+    this.array_len_map = [0, 0, 0, 8];
+    this.crc_extra = 97;
+    this._name = 'ASLUAV_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['LED_status', 'SATCOM_status', 'Servo_status', 'Motor_rpm'];
+
+}
+
+mavlink20.messages.asluav_status.prototype = new mavlink20.message;
+mavlink20.messages.asluav_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.Motor_rpm, this.LED_status, this.SATCOM_status, this.Servo_status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Extended EKF state estimates for ASLUAVs
+
+                timestamp                 : Time since system start (uint64_t)
+                Windspeed                 : Magnitude of wind velocity (in lateral inertial plane) (float)
+                WindDir                   : Wind heading angle from North (float)
+                WindZ                     : Z (Down) component of inertial wind velocity (float)
+                Airspeed                  : Magnitude of air velocity (float)
+                beta                      : Sideslip angle (float)
+                alpha                     : Angle of attack (float)
+
+*/
+    mavlink20.messages.ekf_ext = function( ...moreargs ) {
+    [ this.timestamp , this.Windspeed , this.WindDir , this.WindZ , this.Airspeed , this.beta , this.alpha ] = moreargs;
+
+    this._format = '<Qffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_EKF_EXT;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 64;
+    this._name = 'EKF_EXT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'Windspeed', 'WindDir', 'WindZ', 'Airspeed', 'beta', 'alpha'];
+
+}
+
+mavlink20.messages.ekf_ext.prototype = new mavlink20.message;
+mavlink20.messages.ekf_ext.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.Windspeed, this.WindDir, this.WindZ, this.Airspeed, this.beta, this.alpha];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Off-board controls/commands for ASLUAVs
+
+                timestamp                 : Time since system start (uint64_t)
+                uElev                     : Elevator command [~] (float)
+                uThrot                    : Throttle command [~] (float)
+                uThrot2                   : Throttle 2 command [~] (float)
+                uAilL                     : Left aileron command [~] (float)
+                uAilR                     : Right aileron command [~] (float)
+                uRud                      : Rudder command [~] (float)
+                obctrl_status             : Off-board computer status (uint8_t)
+
+*/
+    mavlink20.messages.asl_obctrl = function( ...moreargs ) {
+    [ this.timestamp , this.uElev , this.uThrot , this.uThrot2 , this.uAilL , this.uAilR , this.uRud , this.obctrl_status ] = moreargs;
+
+    this._format = '<QffffffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ASL_OBCTRL;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 234;
+    this._name = 'ASL_OBCTRL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'uElev', 'uThrot', 'uThrot2', 'uAilL', 'uAilR', 'uRud', 'obctrl_status'];
+
+}
+
+mavlink20.messages.asl_obctrl.prototype = new mavlink20.message;
+mavlink20.messages.asl_obctrl.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.uElev, this.uThrot, this.uThrot2, this.uAilL, this.uAilR, this.uRud, this.obctrl_status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Atmospheric sensors (temperature, humidity, ...)
+
+                timestamp                 : Time since system boot (uint64_t)
+                TempAmbient               : Ambient temperature (float)
+                Humidity                  : Relative humidity (float)
+
+*/
+    mavlink20.messages.sens_atmos = function( ...moreargs ) {
+    [ this.timestamp , this.TempAmbient , this.Humidity ] = moreargs;
+
+    this._format = '<Qff';
+    this._id = mavlink20.MAVLINK_MSG_ID_SENS_ATMOS;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 144;
+    this._name = 'SENS_ATMOS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'TempAmbient', 'Humidity'];
+
+}
+
+mavlink20.messages.sens_atmos.prototype = new mavlink20.message;
+mavlink20.messages.sens_atmos.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.TempAmbient, this.Humidity];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Battery pack monitoring data for Li-Ion batteries
+
+                batmon_timestamp          : Time since system start (uint64_t)
+                temperature               : Battery pack temperature (float)
+                voltage                   : Battery pack voltage (uint16_t)
+                current                   : Battery pack current (int16_t)
+                SoC                       : Battery pack state-of-charge (uint8_t)
+                batterystatus             : Battery monitor status report bits in Hex (uint16_t)
+                serialnumber              : Battery monitor serial number in Hex (uint16_t)
+                safetystatus              : Battery monitor safetystatus report bits in Hex (uint32_t)
+                operationstatus           : Battery monitor operation status report bits in Hex (uint32_t)
+                cellvoltage1              : Battery pack cell 1 voltage (uint16_t)
+                cellvoltage2              : Battery pack cell 2 voltage (uint16_t)
+                cellvoltage3              : Battery pack cell 3 voltage (uint16_t)
+                cellvoltage4              : Battery pack cell 4 voltage (uint16_t)
+                cellvoltage5              : Battery pack cell 5 voltage (uint16_t)
+                cellvoltage6              : Battery pack cell 6 voltage (uint16_t)
+
+*/
+    mavlink20.messages.sens_batmon = function( ...moreargs ) {
+    [ this.batmon_timestamp , this.temperature , this.voltage , this.current , this.SoC , this.batterystatus , this.serialnumber , this.safetystatus , this.operationstatus , this.cellvoltage1 , this.cellvoltage2 , this.cellvoltage3 , this.cellvoltage4 , this.cellvoltage5 , this.cellvoltage6 ] = moreargs;
+
+    this._format = '<QfIIHhHHHHHHHHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SENS_BATMON;
+    this.order_map = [0, 1, 4, 5, 14, 6, 7, 2, 3, 8, 9, 10, 11, 12, 13];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 155;
+    this._name = 'SENS_BATMON';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['batmon_timestamp', 'temperature', 'voltage', 'current', 'SoC', 'batterystatus', 'serialnumber', 'safetystatus', 'operationstatus', 'cellvoltage1', 'cellvoltage2', 'cellvoltage3', 'cellvoltage4', 'cellvoltage5', 'cellvoltage6'];
+
+}
+
+mavlink20.messages.sens_batmon.prototype = new mavlink20.message;
+mavlink20.messages.sens_batmon.prototype.pack = function(mav) {
+    var orderedfields = [ this.batmon_timestamp, this.temperature, this.safetystatus, this.operationstatus, this.voltage, this.current, this.batterystatus, this.serialnumber, this.cellvoltage1, this.cellvoltage2, this.cellvoltage3, this.cellvoltage4, this.cellvoltage5, this.cellvoltage6, this.SoC];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Fixed-wing soaring (i.e. thermal seeking) data
+
+                timestamp                 : Timestamp (uint64_t)
+                timestampModeChanged        : Timestamp since last mode change (uint64_t)
+                xW                        : Thermal core updraft strength (float)
+                xR                        : Thermal radius (float)
+                xLat                      : Thermal center latitude (float)
+                xLon                      : Thermal center longitude (float)
+                VarW                      : Variance W (float)
+                VarR                      : Variance R (float)
+                VarLat                    : Variance Lat (float)
+                VarLon                    : Variance Lon (float)
+                LoiterRadius              : Suggested loiter radius (float)
+                LoiterDirection           : Suggested loiter direction (float)
+                DistToSoarPoint           : Distance to soar point (float)
+                vSinkExp                  : Expected sink rate at current airspeed, roll and throttle (float)
+                z1_LocalUpdraftSpeed        : Measurement / updraft speed at current/local airplane position (float)
+                z2_DeltaRoll              : Measurement / roll angle tracking error (float)
+                z1_exp                    : Expected measurement 1 (float)
+                z2_exp                    : Expected measurement 2 (float)
+                ThermalGSNorth            : Thermal drift (from estimator prediction step only) (float)
+                ThermalGSEast             : Thermal drift (from estimator prediction step only) (float)
+                TSE_dot                   : Total specific energy change (filtered) (float)
+                DebugVar1                 : Debug variable 1 (float)
+                DebugVar2                 : Debug variable 2 (float)
+                ControlMode               : Control Mode [-] (uint8_t)
+                valid                     : Data valid [-] (uint8_t)
+
+*/
+    mavlink20.messages.fw_soaring_data = function( ...moreargs ) {
+    [ this.timestamp , this.timestampModeChanged , this.xW , this.xR , this.xLat , this.xLon , this.VarW , this.VarR , this.VarLat , this.VarLon , this.LoiterRadius , this.LoiterDirection , this.DistToSoarPoint , this.vSinkExp , this.z1_LocalUpdraftSpeed , this.z2_DeltaRoll , this.z1_exp , this.z2_exp , this.ThermalGSNorth , this.ThermalGSEast , this.TSE_dot , this.DebugVar1 , this.DebugVar2 , this.ControlMode , this.valid ] = moreargs;
+
+    this._format = '<QQfffffffffffffffffffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_FW_SOARING_DATA;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 20;
+    this._name = 'FW_SOARING_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'timestampModeChanged', 'xW', 'xR', 'xLat', 'xLon', 'VarW', 'VarR', 'VarLat', 'VarLon', 'LoiterRadius', 'LoiterDirection', 'DistToSoarPoint', 'vSinkExp', 'z1_LocalUpdraftSpeed', 'z2_DeltaRoll', 'z1_exp', 'z2_exp', 'ThermalGSNorth', 'ThermalGSEast', 'TSE_dot', 'DebugVar1', 'DebugVar2', 'ControlMode', 'valid'];
+
+}
+
+mavlink20.messages.fw_soaring_data.prototype = new mavlink20.message;
+mavlink20.messages.fw_soaring_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.timestampModeChanged, this.xW, this.xR, this.xLat, this.xLon, this.VarW, this.VarR, this.VarLat, this.VarLon, this.LoiterRadius, this.LoiterDirection, this.DistToSoarPoint, this.vSinkExp, this.z1_LocalUpdraftSpeed, this.z2_DeltaRoll, this.z1_exp, this.z2_exp, this.ThermalGSNorth, this.ThermalGSEast, this.TSE_dot, this.DebugVar1, this.DebugVar2, this.ControlMode, this.valid];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Monitoring of sensorpod status
+
+                timestamp                 : Timestamp in linuxtime (since 1.1.1970) (uint64_t)
+                visensor_rate_1           : Rate of ROS topic 1 (uint8_t)
+                visensor_rate_2           : Rate of ROS topic 2 (uint8_t)
+                visensor_rate_3           : Rate of ROS topic 3 (uint8_t)
+                visensor_rate_4           : Rate of ROS topic 4 (uint8_t)
+                recording_nodes_count        : Number of recording nodes (uint8_t)
+                cpu_temp                  : Temperature of sensorpod CPU in (uint8_t)
+                free_space                : Free space available in recordings directory in [Gb] * 1e2 (uint16_t)
+
+*/
+    mavlink20.messages.sensorpod_status = function( ...moreargs ) {
+    [ this.timestamp , this.visensor_rate_1 , this.visensor_rate_2 , this.visensor_rate_3 , this.visensor_rate_4 , this.recording_nodes_count , this.cpu_temp , this.free_space ] = moreargs;
+
+    this._format = '<QHBBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SENSORPOD_STATUS;
+    this.order_map = [0, 2, 3, 4, 5, 6, 7, 1];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 54;
+    this._name = 'SENSORPOD_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'visensor_rate_1', 'visensor_rate_2', 'visensor_rate_3', 'visensor_rate_4', 'recording_nodes_count', 'cpu_temp', 'free_space'];
+
+}
+
+mavlink20.messages.sensorpod_status.prototype = new mavlink20.message;
+mavlink20.messages.sensorpod_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.free_space, this.visensor_rate_1, this.visensor_rate_2, this.visensor_rate_3, this.visensor_rate_4, this.recording_nodes_count, this.cpu_temp];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Monitoring of power board status
+
+                timestamp                 : Timestamp (uint64_t)
+                pwr_brd_status            : Power board status register (uint8_t)
+                pwr_brd_led_status        : Power board leds status (uint8_t)
+                pwr_brd_system_volt        : Power board system voltage (float)
+                pwr_brd_servo_volt        : Power board servo voltage (float)
+                pwr_brd_digital_volt        : Power board digital voltage (float)
+                pwr_brd_mot_l_amp         : Power board left motor current sensor (float)
+                pwr_brd_mot_r_amp         : Power board right motor current sensor (float)
+                pwr_brd_analog_amp        : Power board analog current sensor (float)
+                pwr_brd_digital_amp        : Power board digital current sensor (float)
+                pwr_brd_ext_amp           : Power board extension current sensor (float)
+                pwr_brd_aux_amp           : Power board aux current sensor (float)
+
+*/
+    mavlink20.messages.sens_power_board = function( ...moreargs ) {
+    [ this.timestamp , this.pwr_brd_status , this.pwr_brd_led_status , this.pwr_brd_system_volt , this.pwr_brd_servo_volt , this.pwr_brd_digital_volt , this.pwr_brd_mot_l_amp , this.pwr_brd_mot_r_amp , this.pwr_brd_analog_amp , this.pwr_brd_digital_amp , this.pwr_brd_ext_amp , this.pwr_brd_aux_amp ] = moreargs;
+
+    this._format = '<QfffffffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SENS_POWER_BOARD;
+    this.order_map = [0, 10, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 222;
+    this._name = 'SENS_POWER_BOARD';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'pwr_brd_status', 'pwr_brd_led_status', 'pwr_brd_system_volt', 'pwr_brd_servo_volt', 'pwr_brd_digital_volt', 'pwr_brd_mot_l_amp', 'pwr_brd_mot_r_amp', 'pwr_brd_analog_amp', 'pwr_brd_digital_amp', 'pwr_brd_ext_amp', 'pwr_brd_aux_amp'];
+
+}
+
+mavlink20.messages.sens_power_board.prototype = new mavlink20.message;
+mavlink20.messages.sens_power_board.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.pwr_brd_system_volt, this.pwr_brd_servo_volt, this.pwr_brd_digital_volt, this.pwr_brd_mot_l_amp, this.pwr_brd_mot_r_amp, this.pwr_brd_analog_amp, this.pwr_brd_digital_amp, this.pwr_brd_ext_amp, this.pwr_brd_aux_amp, this.pwr_brd_status, this.pwr_brd_led_status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of GSM modem (connected to onboard computer)
+
+                timestamp                 : Timestamp (of OBC) (uint64_t)
+                gsm_modem_type            : GSM modem used (uint8_t)
+                gsm_link_type             : GSM link type (uint8_t)
+                rssi                      : RSSI as reported by modem (unconverted) (uint8_t)
+                rsrp_rscp                 : RSRP (LTE) or RSCP (WCDMA) as reported by modem (unconverted) (uint8_t)
+                sinr_ecio                 : SINR (LTE) or ECIO (WCDMA) as reported by modem (unconverted) (uint8_t)
+                rsrq                      : RSRQ (LTE only) as reported by modem (unconverted) (uint8_t)
+
+*/
+    mavlink20.messages.gsm_link_status = function( ...moreargs ) {
+    [ this.timestamp , this.gsm_modem_type , this.gsm_link_type , this.rssi , this.rsrp_rscp , this.sinr_ecio , this.rsrq ] = moreargs;
+
+    this._format = '<QBBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GSM_LINK_STATUS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 200;
+    this._name = 'GSM_LINK_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'gsm_modem_type', 'gsm_link_type', 'rssi', 'rsrp_rscp', 'sinr_ecio', 'rsrq'];
+
+}
+
+mavlink20.messages.gsm_link_status.prototype = new mavlink20.message;
+mavlink20.messages.gsm_link_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.gsm_modem_type, this.gsm_link_type, this.rssi, this.rsrp_rscp, this.sinr_ecio, this.rsrq];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of the SatCom link
+
+                timestamp                 : Timestamp (uint64_t)
+                last_heartbeat            : Timestamp of the last successful sbd session (uint64_t)
+                failed_sessions           : Number of failed sessions (uint16_t)
+                successful_sessions        : Number of successful sessions (uint16_t)
+                signal_quality            : Signal quality (uint8_t)
+                ring_pending              : Ring call pending (uint8_t)
+                tx_session_pending        : Transmission session pending (uint8_t)
+                rx_session_pending        : Receiving session pending (uint8_t)
+
+*/
+    mavlink20.messages.satcom_link_status = function( ...moreargs ) {
+    [ this.timestamp , this.last_heartbeat , this.failed_sessions , this.successful_sessions , this.signal_quality , this.ring_pending , this.tx_session_pending , this.rx_session_pending ] = moreargs;
+
+    this._format = '<QQHHBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SATCOM_LINK_STATUS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 23;
+    this._name = 'SATCOM_LINK_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'last_heartbeat', 'failed_sessions', 'successful_sessions', 'signal_quality', 'ring_pending', 'tx_session_pending', 'rx_session_pending'];
+
+}
+
+mavlink20.messages.satcom_link_status.prototype = new mavlink20.message;
+mavlink20.messages.satcom_link_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.last_heartbeat, this.failed_sessions, this.successful_sessions, this.signal_quality, this.ring_pending, this.tx_session_pending, this.rx_session_pending];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Calibrated airflow angle measurements
+
+                timestamp                 : Timestamp (uint64_t)
+                angleofattack             : Angle of attack (float)
+                angleofattack_valid        : Angle of attack measurement valid (uint8_t)
+                sideslip                  : Sideslip angle (float)
+                sideslip_valid            : Sideslip angle measurement valid (uint8_t)
+
+*/
+    mavlink20.messages.sensor_airflow_angles = function( ...moreargs ) {
+    [ this.timestamp , this.angleofattack , this.angleofattack_valid , this.sideslip , this.sideslip_valid ] = moreargs;
+
+    this._format = '<QffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SENSOR_AIRFLOW_ANGLES;
+    this.order_map = [0, 1, 3, 2, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 149;
+    this._name = 'SENSOR_AIRFLOW_ANGLES';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'angleofattack', 'angleofattack_valid', 'sideslip', 'sideslip_valid'];
+
+}
+
+mavlink20.messages.sensor_airflow_angles.prototype = new mavlink20.message;
+mavlink20.messages.sensor_airflow_angles.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.angleofattack, this.sideslip, this.angleofattack_valid, this.sideslip_valid];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The general system state. If the system is following the MAVLink
+standard, the system state is mainly defined by three orthogonal
+states/modes: The system mode, which is either LOCKED (motors shut
+down and locked), MANUAL (system under RC control), GUIDED (system
+with autonomous position control, position setpoint controlled
+manually) or AUTO (system guided by path/waypoint planner). The
+NAV_MODE defined the current flight state: LIFTOFF (often an open-loop
+maneuver), LANDING, WAYPOINTS or VECTOR. This represents the internal
+navigation state machine. The system status shows whether the system
+is currently active or not and if an emergency occurred. During the
+CRITICAL and EMERGENCY states the MAV is still considered to be
+active, but should start emergency procedures autonomously. After a
+failure occurred it should first move from active to critical to allow
+manual intervention and then move to emergency after a certain
+timeout.
+
+                onboard_control_sensors_present        : Bitmap showing which onboard controllers and sensors are present. Value of 0: not present. Value of 1: present. (uint32_t)
+                onboard_control_sensors_enabled        : Bitmap showing which onboard controllers and sensors are enabled:  Value of 0: not enabled. Value of 1: enabled. (uint32_t)
+                onboard_control_sensors_health        : Bitmap showing which onboard controllers and sensors have an error (or are operational). Value of 0: error. Value of 1: healthy. (uint32_t)
+                load                      : Maximum usage in percent of the mainloop time. Values: [0-1000] - should always be below 1000 (uint16_t)
+                voltage_battery           : Battery voltage, UINT16_MAX: Voltage not sent by autopilot (uint16_t)
+                current_battery           : Battery current, -1: Current not sent by autopilot (int16_t)
+                battery_remaining         : Battery energy remaining, -1: Battery remaining energy not sent by autopilot (int8_t)
+                drop_rate_comm            : Communication drop rate, (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV) (uint16_t)
+                errors_comm               : Communication errors (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV) (uint16_t)
+                errors_count1             : Autopilot-specific errors (uint16_t)
+                errors_count2             : Autopilot-specific errors (uint16_t)
+                errors_count3             : Autopilot-specific errors (uint16_t)
+                errors_count4             : Autopilot-specific errors (uint16_t)
+
+*/
+    mavlink20.messages.sys_status = function( ...moreargs ) {
+    [ this.onboard_control_sensors_present , this.onboard_control_sensors_enabled , this.onboard_control_sensors_health , this.load , this.voltage_battery , this.current_battery , this.battery_remaining , this.drop_rate_comm , this.errors_comm , this.errors_count1 , this.errors_count2 , this.errors_count3 , this.errors_count4 ] = moreargs;
+
+    this._format = '<IIIHHhHHHHHHb';
+    this._id = mavlink20.MAVLINK_MSG_ID_SYS_STATUS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 12, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 124;
+    this._name = 'SYS_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['onboard_control_sensors_present', 'onboard_control_sensors_enabled', 'onboard_control_sensors_health', 'load', 'voltage_battery', 'current_battery', 'battery_remaining', 'drop_rate_comm', 'errors_comm', 'errors_count1', 'errors_count2', 'errors_count3', 'errors_count4'];
+
+}
+
+mavlink20.messages.sys_status.prototype = new mavlink20.message;
+mavlink20.messages.sys_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.onboard_control_sensors_present, this.onboard_control_sensors_enabled, this.onboard_control_sensors_health, this.load, this.voltage_battery, this.current_battery, this.drop_rate_comm, this.errors_comm, this.errors_count1, this.errors_count2, this.errors_count3, this.errors_count4, this.battery_remaining];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The system time is the time of the master clock, typically the
+computer clock of the main onboard computer.
+
+                time_unix_usec            : Timestamp (UNIX epoch time). (uint64_t)
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+
+*/
+    mavlink20.messages.system_time = function( ...moreargs ) {
+    [ this.time_unix_usec , this.time_boot_ms ] = moreargs;
+
+    this._format = '<QI';
+    this._id = mavlink20.MAVLINK_MSG_ID_SYSTEM_TIME;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 137;
+    this._name = 'SYSTEM_TIME';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_unix_usec', 'time_boot_ms'];
+
+}
+
+mavlink20.messages.system_time.prototype = new mavlink20.message;
+mavlink20.messages.system_time.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_unix_usec, this.time_boot_ms];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A ping message either requesting or responding to a ping. This allows
+to measure the system latencies, including serial port, radio modem
+and UDP connections. The ping microservice is documented at
+https://mavlink.io/en/services/ping.html
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                seq                       : PING sequence (uint32_t)
+                target_system             : 0: request ping from all receiving systems. If greater than 0: message is a ping response and number is the system id of the requesting system (uint8_t)
+                target_component          : 0: request ping from all receiving components. If greater than 0: message is a ping response and number is the component id of the requesting component. (uint8_t)
+
+*/
+    mavlink20.messages.ping = function( ...moreargs ) {
+    [ this.time_usec , this.seq , this.target_system , this.target_component ] = moreargs;
+
+    this._format = '<QIBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PING;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 237;
+    this._name = 'PING';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'seq', 'target_system', 'target_component'];
+
+}
+
+mavlink20.messages.ping.prototype = new mavlink20.message;
+mavlink20.messages.ping.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.seq, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request to control this MAV
+
+                target_system             : System the GCS requests control for (uint8_t)
+                control_request           : 0: request control of this MAV, 1: Release control of this MAV (uint8_t)
+                version                   : 0: key as plaintext, 1-255: future, different hashing/encryption variants. The GCS should in general use the safest mode possible initially and then gradually move down the encryption level if it gets a NACK message indicating an encryption mismatch. (uint8_t)
+                passkey                   : Password / Key, depending on version plaintext or encrypted. 25 or less characters, NULL terminated. The characters may involve A-Z, a-z, 0-9, and "!?,.-" (char)
+
+*/
+    mavlink20.messages.change_operator_control = function( ...moreargs ) {
+    [ this.target_system , this.control_request , this.version , this.passkey ] = moreargs;
+
+    this._format = '<BBB25s';
+    this._id = mavlink20.MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 25];
+    this.crc_extra = 217;
+    this._name = 'CHANGE_OPERATOR_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'control_request', 'version', 'passkey'];
+
+}
+
+mavlink20.messages.change_operator_control.prototype = new mavlink20.message;
+mavlink20.messages.change_operator_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.control_request, this.version, this.passkey];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Accept / deny control of this MAV
+
+                gcs_system_id             : ID of the GCS this message (uint8_t)
+                control_request           : 0: request control of this MAV, 1: Release control of this MAV (uint8_t)
+                ack                       : 0: ACK, 1: NACK: Wrong passkey, 2: NACK: Unsupported passkey encryption method, 3: NACK: Already under control (uint8_t)
+
+*/
+    mavlink20.messages.change_operator_control_ack = function( ...moreargs ) {
+    [ this.gcs_system_id , this.control_request , this.ack ] = moreargs;
+
+    this._format = '<BBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 104;
+    this._name = 'CHANGE_OPERATOR_CONTROL_ACK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['gcs_system_id', 'control_request', 'ack'];
+
+}
+
+mavlink20.messages.change_operator_control_ack.prototype = new mavlink20.message;
+mavlink20.messages.change_operator_control_ack.prototype.pack = function(mav) {
+    var orderedfields = [ this.gcs_system_id, this.control_request, this.ack];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Emit an encrypted signature / key identifying this system. PLEASE
+NOTE: This protocol has been kept simple, so transmitting the key
+requires an encrypted channel for true safety.
+
+                key                       : key (char)
+
+*/
+    mavlink20.messages.auth_key = function( ...moreargs ) {
+    [ this.key ] = moreargs;
+
+    this._format = '<32s';
+    this._id = mavlink20.MAVLINK_MSG_ID_AUTH_KEY;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [32];
+    this.crc_extra = 119;
+    this._name = 'AUTH_KEY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['key'];
+
+}
+
+mavlink20.messages.auth_key.prototype = new mavlink20.message;
+mavlink20.messages.auth_key.prototype.pack = function(mav) {
+    var orderedfields = [ this.key];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set the system mode, as defined by enum MAV_MODE. There is no target
+component id as the mode is by definition for the overall aircraft,
+not only for one component.
+
+                target_system             : The system setting the mode (uint8_t)
+                base_mode                 : The new base mode. (uint8_t)
+                custom_mode               : The new autopilot-specific mode. This field can be ignored by an autopilot. (uint32_t)
+
+*/
+    mavlink20.messages.set_mode = function( ...moreargs ) {
+    [ this.target_system , this.base_mode , this.custom_mode ] = moreargs;
+
+    this._format = '<IBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SET_MODE;
+    this.order_map = [1, 2, 0];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 89;
+    this._name = 'SET_MODE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'base_mode', 'custom_mode'];
+
+}
+
+mavlink20.messages.set_mode.prototype = new mavlink20.message;
+mavlink20.messages.set_mode.prototype.pack = function(mav) {
+    var orderedfields = [ this.custom_mode, this.target_system, this.base_mode];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request to read the onboard parameter with the param_id string id.
+Onboard parameters are stored as key[const char*] -> value[float].
+This allows to send a parameter to any other component (such as the
+GCS) without the need of previous knowledge of possible parameter
+names. Thus the same GCS can store different parameters for different
+autopilots. See also https://mavlink.io/en/services/parameter.html for
+a full documentation of QGroundControl and IMU code.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                param_id                  : Onboard parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                param_index               : Parameter index. Send -1 to use the param ID field as identifier (else the param id will be ignored) (int16_t)
+
+*/
+    mavlink20.messages.param_request_read = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.param_id , this.param_index ] = moreargs;
+
+    this._format = '<hBB16s';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_REQUEST_READ;
+    this.order_map = [1, 2, 3, 0];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 16];
+    this.crc_extra = 214;
+    this._name = 'PARAM_REQUEST_READ';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'param_id', 'param_index'];
+
+}
+
+mavlink20.messages.param_request_read.prototype = new mavlink20.message;
+mavlink20.messages.param_request_read.prototype.pack = function(mav) {
+    var orderedfields = [ this.param_index, this.target_system, this.target_component, this.param_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request all parameters of this component. After this request, all
+parameters are emitted. The parameter microservice is documented at
+https://mavlink.io/en/services/parameter.html
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+
+*/
+    mavlink20.messages.param_request_list = function( ...moreargs ) {
+    [ this.target_system , this.target_component ] = moreargs;
+
+    this._format = '<BB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_REQUEST_LIST;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 159;
+    this._name = 'PARAM_REQUEST_LIST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component'];
+
+}
+
+mavlink20.messages.param_request_list.prototype = new mavlink20.message;
+mavlink20.messages.param_request_list.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Emit the value of a onboard parameter. The inclusion of param_count
+and param_index in the message allows the recipient to keep track of
+received parameters and allows him to re-request missing parameters
+after a loss or timeout. The parameter microservice is documented at
+https://mavlink.io/en/services/parameter.html
+
+                param_id                  : Onboard parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                param_value               : Onboard parameter value (float)
+                param_type                : Onboard parameter type. (uint8_t)
+                param_count               : Total number of onboard parameters (uint16_t)
+                param_index               : Index of this onboard parameter (uint16_t)
+
+*/
+    mavlink20.messages.param_value = function( ...moreargs ) {
+    [ this.param_id , this.param_value , this.param_type , this.param_count , this.param_index ] = moreargs;
+
+    this._format = '<fHH16sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_VALUE;
+    this.order_map = [3, 0, 4, 1, 2];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 16, 0];
+    this.crc_extra = 220;
+    this._name = 'PARAM_VALUE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['param_id', 'param_value', 'param_type', 'param_count', 'param_index'];
+
+}
+
+mavlink20.messages.param_value.prototype = new mavlink20.message;
+mavlink20.messages.param_value.prototype.pack = function(mav) {
+    var orderedfields = [ this.param_value, this.param_count, this.param_index, this.param_id, this.param_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set a parameter value (write new value to permanent storage).
+The receiving component should acknowledge the new parameter value by
+broadcasting a PARAM_VALUE message (broadcasting ensures that multiple
+GCS all have an up-to-date list of all parameters). If the sending GCS
+did not receive a PARAM_VALUE within its timeout time, it should re-
+send the PARAM_SET message. The parameter microservice is documented
+at https://mavlink.io/en/services/parameter.html.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                param_id                  : Onboard parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                param_value               : Onboard parameter value (float)
+                param_type                : Onboard parameter type. (uint8_t)
+
+*/
+    mavlink20.messages.param_set = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.param_id , this.param_value , this.param_type ] = moreargs;
+
+    this._format = '<fBB16sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_SET;
+    this.order_map = [1, 2, 3, 0, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 16, 0];
+    this.crc_extra = 168;
+    this._name = 'PARAM_SET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'param_id', 'param_value', 'param_type'];
+
+}
+
+mavlink20.messages.param_set.prototype = new mavlink20.message;
+mavlink20.messages.param_set.prototype.pack = function(mav) {
+    var orderedfields = [ this.param_value, this.target_system, this.target_component, this.param_id, this.param_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The global position, as returned by the Global Positioning System
+(GPS). This is                 NOT the global position estimate of the
+system, but rather a RAW sensor value. See message GLOBAL_POSITION_INT
+for the global position estimate.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                fix_type                  : GPS fix type. (uint8_t)
+                lat                       : Latitude (WGS84, EGM96 ellipsoid) (int32_t)
+                lon                       : Longitude (WGS84, EGM96 ellipsoid) (int32_t)
+                alt                       : Altitude (MSL). Positive for up. Note that virtually all GPS modules provide the MSL altitude in addition to the WGS84 altitude. (int32_t)
+                eph                       : GPS HDOP horizontal dilution of position (unitless * 100). If unknown, set to: UINT16_MAX (uint16_t)
+                epv                       : GPS VDOP vertical dilution of position (unitless * 100). If unknown, set to: UINT16_MAX (uint16_t)
+                vel                       : GPS ground speed. If unknown, set to: UINT16_MAX (uint16_t)
+                cog                       : Course over ground (NOT heading, but direction of movement) in degrees * 100, 0.0..359.99 degrees. If unknown, set to: UINT16_MAX (uint16_t)
+                satellites_visible        : Number of satellites visible. If unknown, set to UINT8_MAX (uint8_t)
+                alt_ellipsoid             : Altitude (above WGS84, EGM96 ellipsoid). Positive for up. (int32_t)
+                h_acc                     : Position uncertainty. (uint32_t)
+                v_acc                     : Altitude uncertainty. (uint32_t)
+                vel_acc                   : Speed uncertainty. (uint32_t)
+                hdg_acc                   : Heading / track uncertainty (uint32_t)
+                yaw                       : Yaw in earth frame from north. Use 0 if this GPS does not provide yaw. Use UINT16_MAX if this GPS is configured to provide yaw and is currently unable to provide it. Use 36000 for north. (uint16_t)
+
+*/
+    mavlink20.messages.gps_raw_int = function( ...moreargs ) {
+    [ this.time_usec , this.fix_type , this.lat , this.lon , this.alt , this.eph , this.epv , this.vel , this.cog , this.satellites_visible , this.alt_ellipsoid , this.h_acc , this.v_acc , this.vel_acc , this.hdg_acc , this.yaw ] = moreargs;
+
+    this._format = '<QiiiHHHHBBiIIIIH';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS_RAW_INT;
+    this.order_map = [0, 8, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 24;
+    this._name = 'GPS_RAW_INT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'fix_type', 'lat', 'lon', 'alt', 'eph', 'epv', 'vel', 'cog', 'satellites_visible', 'alt_ellipsoid', 'h_acc', 'v_acc', 'vel_acc', 'hdg_acc', 'yaw'];
+
+}
+
+mavlink20.messages.gps_raw_int.prototype = new mavlink20.message;
+mavlink20.messages.gps_raw_int.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.lat, this.lon, this.alt, this.eph, this.epv, this.vel, this.cog, this.fix_type, this.satellites_visible, this.alt_ellipsoid, this.h_acc, this.v_acc, this.vel_acc, this.hdg_acc, this.yaw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The positioning status, as reported by GPS. This message is intended
+to display status information about each satellite visible to the
+receiver. See message GLOBAL_POSITION_INT for the global position
+estimate. This message can contain information for up to 20
+satellites.
+
+                satellites_visible        : Number of satellites visible (uint8_t)
+                satellite_prn             : Global satellite ID (uint8_t)
+                satellite_used            : 0: Satellite not used, 1: used for localization (uint8_t)
+                satellite_elevation        : Elevation (0: right on top of receiver, 90: on the horizon) of satellite (uint8_t)
+                satellite_azimuth         : Direction of satellite, 0: 0 deg, 255: 360 deg. (uint8_t)
+                satellite_snr             : Signal to noise ratio of satellite (uint8_t)
+
+*/
+    mavlink20.messages.gps_status = function( ...moreargs ) {
+    [ this.satellites_visible , this.satellite_prn , this.satellite_used , this.satellite_elevation , this.satellite_azimuth , this.satellite_snr ] = moreargs;
+
+    this._format = '<B20s20s20s20s20s';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS_STATUS;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 20, 20, 20, 20, 20];
+    this.array_len_map = [0, 20, 20, 20, 20, 20];
+    this.crc_extra = 23;
+    this._name = 'GPS_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['satellites_visible', 'satellite_prn', 'satellite_used', 'satellite_elevation', 'satellite_azimuth', 'satellite_snr'];
+
+}
+
+mavlink20.messages.gps_status.prototype = new mavlink20.message;
+mavlink20.messages.gps_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.satellites_visible, this.satellite_prn, this.satellite_used, this.satellite_elevation, this.satellite_azimuth, this.satellite_snr];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The RAW IMU readings for the usual 9DOF sensor setup. This message
+should contain the scaled values to the described units
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                xacc                      : X acceleration (int16_t)
+                yacc                      : Y acceleration (int16_t)
+                zacc                      : Z acceleration (int16_t)
+                xgyro                     : Angular speed around X axis (int16_t)
+                ygyro                     : Angular speed around Y axis (int16_t)
+                zgyro                     : Angular speed around Z axis (int16_t)
+                xmag                      : X Magnetic field (int16_t)
+                ymag                      : Y Magnetic field (int16_t)
+                zmag                      : Z Magnetic field (int16_t)
+                temperature               : Temperature, 0: IMU does not provide temperature values. If the IMU is at 0C it must send 1 (0.01C). (int16_t)
+
+*/
+    mavlink20.messages.scaled_imu = function( ...moreargs ) {
+    [ this.time_boot_ms , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro , this.xmag , this.ymag , this.zmag , this.temperature ] = moreargs;
+
+    this._format = '<Ihhhhhhhhhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_SCALED_IMU;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 170;
+    this._name = 'SCALED_IMU';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro', 'xmag', 'ymag', 'zmag', 'temperature'];
+
+}
+
+mavlink20.messages.scaled_imu.prototype = new mavlink20.message;
+mavlink20.messages.scaled_imu.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro, this.xmag, this.ymag, this.zmag, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The RAW IMU readings for a 9DOF sensor, which is identified by the id
+(default IMU1). This message should always contain the true raw values
+without any scaling to allow data capture and system debugging.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                xacc                      : X acceleration (raw) (int16_t)
+                yacc                      : Y acceleration (raw) (int16_t)
+                zacc                      : Z acceleration (raw) (int16_t)
+                xgyro                     : Angular speed around X axis (raw) (int16_t)
+                ygyro                     : Angular speed around Y axis (raw) (int16_t)
+                zgyro                     : Angular speed around Z axis (raw) (int16_t)
+                xmag                      : X Magnetic field (raw) (int16_t)
+                ymag                      : Y Magnetic field (raw) (int16_t)
+                zmag                      : Z Magnetic field (raw) (int16_t)
+                id                        : Id. Ids are numbered from 0 and map to IMUs numbered from 1 (e.g. IMU1 will have a message with id=0) (uint8_t)
+                temperature               : Temperature, 0: IMU does not provide temperature values. If the IMU is at 0C it must send 1 (0.01C). (int16_t)
+
+*/
+    mavlink20.messages.raw_imu = function( ...moreargs ) {
+    [ this.time_usec , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro , this.xmag , this.ymag , this.zmag , this.id , this.temperature ] = moreargs;
+
+    this._format = '<QhhhhhhhhhBh';
+    this._id = mavlink20.MAVLINK_MSG_ID_RAW_IMU;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 144;
+    this._name = 'RAW_IMU';
+
+    this._instance_field = 'id';
+    this._instance_offset = 26;
+
+    this.fieldnames = ['time_usec', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro', 'xmag', 'ymag', 'zmag', 'id', 'temperature'];
+
+}
+
+mavlink20.messages.raw_imu.prototype = new mavlink20.message;
+mavlink20.messages.raw_imu.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro, this.xmag, this.ymag, this.zmag, this.id, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The RAW pressure readings for the typical setup of one absolute
+pressure and one differential pressure sensor. The sensor values
+should be the raw, UNSCALED ADC values.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                press_abs                 : Absolute pressure (raw) (int16_t)
+                press_diff1               : Differential pressure 1 (raw, 0 if nonexistent) (int16_t)
+                press_diff2               : Differential pressure 2 (raw, 0 if nonexistent) (int16_t)
+                temperature               : Raw Temperature measurement (raw) (int16_t)
+
+*/
+    mavlink20.messages.raw_pressure = function( ...moreargs ) {
+    [ this.time_usec , this.press_abs , this.press_diff1 , this.press_diff2 , this.temperature ] = moreargs;
+
+    this._format = '<Qhhhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_RAW_PRESSURE;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 67;
+    this._name = 'RAW_PRESSURE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'press_abs', 'press_diff1', 'press_diff2', 'temperature'];
+
+}
+
+mavlink20.messages.raw_pressure.prototype = new mavlink20.message;
+mavlink20.messages.raw_pressure.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.press_abs, this.press_diff1, this.press_diff2, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The pressure readings for the typical setup of one absolute and
+differential pressure sensor. The units are as specified in each
+field.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                press_abs                 : Absolute pressure (float)
+                press_diff                : Differential pressure 1 (float)
+                temperature               : Absolute pressure temperature (int16_t)
+                temperature_press_diff        : Differential pressure temperature (0, if not available). Report values of 0 (or 1) as 1 cdegC. (int16_t)
+
+*/
+    mavlink20.messages.scaled_pressure = function( ...moreargs ) {
+    [ this.time_boot_ms , this.press_abs , this.press_diff , this.temperature , this.temperature_press_diff ] = moreargs;
+
+    this._format = '<Iffhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_SCALED_PRESSURE;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 115;
+    this._name = 'SCALED_PRESSURE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'press_abs', 'press_diff', 'temperature', 'temperature_press_diff'];
+
+}
+
+mavlink20.messages.scaled_pressure.prototype = new mavlink20.message;
+mavlink20.messages.scaled_pressure.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.press_abs, this.press_diff, this.temperature, this.temperature_press_diff];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The attitude in the aeronautical frame (right-handed, Z-down, X-front,
+Y-right).
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                roll                      : Roll angle (-pi..+pi) (float)
+                pitch                     : Pitch angle (-pi..+pi) (float)
+                yaw                       : Yaw angle (-pi..+pi) (float)
+                rollspeed                 : Roll angular speed (float)
+                pitchspeed                : Pitch angular speed (float)
+                yawspeed                  : Yaw angular speed (float)
+
+*/
+    mavlink20.messages.attitude = function( ...moreargs ) {
+    [ this.time_boot_ms , this.roll , this.pitch , this.yaw , this.rollspeed , this.pitchspeed , this.yawspeed ] = moreargs;
+
+    this._format = '<Iffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_ATTITUDE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 39;
+    this._name = 'ATTITUDE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'roll', 'pitch', 'yaw', 'rollspeed', 'pitchspeed', 'yawspeed'];
+
+}
+
+mavlink20.messages.attitude.prototype = new mavlink20.message;
+mavlink20.messages.attitude.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.roll, this.pitch, this.yaw, this.rollspeed, this.pitchspeed, this.yawspeed];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The attitude in the aeronautical frame (right-handed, Z-down, X-front,
+Y-right), expressed as quaternion. Quaternion order is w, x, y, z and
+a zero rotation would be expressed as (1 0 0 0).
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                q1                        : Quaternion component 1, w (1 in null-rotation) (float)
+                q2                        : Quaternion component 2, x (0 in null-rotation) (float)
+                q3                        : Quaternion component 3, y (0 in null-rotation) (float)
+                q4                        : Quaternion component 4, z (0 in null-rotation) (float)
+                rollspeed                 : Roll angular speed (float)
+                pitchspeed                : Pitch angular speed (float)
+                yawspeed                  : Yaw angular speed (float)
+                repr_offset_q             : Rotation offset by which the attitude quaternion and angular speed vector should be rotated for user display (quaternion with [w, x, y, z] order, zero-rotation is [1, 0, 0, 0], send [0, 0, 0, 0] if field not supported). This field is intended for systems in which the reference attitude may change during flight. For example, tailsitters VTOLs rotate their reference attitude by 90 degrees between hover mode and fixed wing mode, thus repr_offset_q is equal to [1, 0, 0, 0] in hover mode and equal to [0.7071, 0, 0.7071, 0] in fixed wing mode. (float)
+
+*/
+    mavlink20.messages.attitude_quaternion = function( ...moreargs ) {
+    [ this.time_boot_ms , this.q1 , this.q2 , this.q3 , this.q4 , this.rollspeed , this.pitchspeed , this.yawspeed , this.repr_offset_q ] = moreargs;
+
+    this._format = '<Ifffffff4f';
+    this._id = mavlink20.MAVLINK_MSG_ID_ATTITUDE_QUATERNION;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 4];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 4];
+    this.crc_extra = 246;
+    this._name = 'ATTITUDE_QUATERNION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'q1', 'q2', 'q3', 'q4', 'rollspeed', 'pitchspeed', 'yawspeed', 'repr_offset_q'];
+
+}
+
+mavlink20.messages.attitude_quaternion.prototype = new mavlink20.message;
+mavlink20.messages.attitude_quaternion.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.q1, this.q2, this.q3, this.q4, this.rollspeed, this.pitchspeed, this.yawspeed, this.repr_offset_q];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The filtered local position (e.g. fused computer vision and
+accelerometers). Coordinate frame is right-handed, Z-axis down
+(aeronautical frame, NED / north-east-down convention)
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                x                         : X Position (float)
+                y                         : Y Position (float)
+                z                         : Z Position (float)
+                vx                        : X Speed (float)
+                vy                        : Y Speed (float)
+                vz                        : Z Speed (float)
+
+*/
+    mavlink20.messages.local_position_ned = function( ...moreargs ) {
+    [ this.time_boot_ms , this.x , this.y , this.z , this.vx , this.vy , this.vz ] = moreargs;
+
+    this._format = '<Iffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOCAL_POSITION_NED;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 185;
+    this._name = 'LOCAL_POSITION_NED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'x', 'y', 'z', 'vx', 'vy', 'vz'];
+
+}
+
+mavlink20.messages.local_position_ned.prototype = new mavlink20.message;
+mavlink20.messages.local_position_ned.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.x, this.y, this.z, this.vx, this.vy, this.vz];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The filtered global position (e.g. fused GPS and accelerometers). The
+position is in GPS-frame (right-handed, Z-up). It                is
+designed as scaled integer message since the resolution of float is
+not sufficient.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                lat                       : Latitude, expressed (int32_t)
+                lon                       : Longitude, expressed (int32_t)
+                alt                       : Altitude (MSL). Note that virtually all GPS modules provide both WGS84 and MSL. (int32_t)
+                relative_alt              : Altitude above home (int32_t)
+                vx                        : Ground X Speed (Latitude, positive north) (int16_t)
+                vy                        : Ground Y Speed (Longitude, positive east) (int16_t)
+                vz                        : Ground Z Speed (Altitude, positive down) (int16_t)
+                hdg                       : Vehicle heading (yaw angle), 0.0..359.99 degrees. If unknown, set to: UINT16_MAX (uint16_t)
+
+*/
+    mavlink20.messages.global_position_int = function( ...moreargs ) {
+    [ this.time_boot_ms , this.lat , this.lon , this.alt , this.relative_alt , this.vx , this.vy , this.vz , this.hdg ] = moreargs;
+
+    this._format = '<IiiiihhhH';
+    this._id = mavlink20.MAVLINK_MSG_ID_GLOBAL_POSITION_INT;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 104;
+    this._name = 'GLOBAL_POSITION_INT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'lat', 'lon', 'alt', 'relative_alt', 'vx', 'vy', 'vz', 'hdg'];
+
+}
+
+mavlink20.messages.global_position_int.prototype = new mavlink20.message;
+mavlink20.messages.global_position_int.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.lat, this.lon, this.alt, this.relative_alt, this.vx, this.vy, this.vz, this.hdg];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The scaled values of the RC channels received: (-100%) -10000, (0%) 0,
+(100%) 10000. Channels that are inactive should be set to UINT16_MAX.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                port                      : Servo output port (set of 8 outputs = 1 port). Flight stacks running on Pixhawk should use: 0 = MAIN, 1 = AUX. (uint8_t)
+                chan1_scaled              : RC channel 1 value scaled. (int16_t)
+                chan2_scaled              : RC channel 2 value scaled. (int16_t)
+                chan3_scaled              : RC channel 3 value scaled. (int16_t)
+                chan4_scaled              : RC channel 4 value scaled. (int16_t)
+                chan5_scaled              : RC channel 5 value scaled. (int16_t)
+                chan6_scaled              : RC channel 6 value scaled. (int16_t)
+                chan7_scaled              : RC channel 7 value scaled. (int16_t)
+                chan8_scaled              : RC channel 8 value scaled. (int16_t)
+                rssi                      : Receive signal strength indicator in device-dependent units/scale. Values: [0-254], 255: invalid/unknown. (uint8_t)
+
+*/
+    mavlink20.messages.rc_channels_scaled = function( ...moreargs ) {
+    [ this.time_boot_ms , this.port , this.chan1_scaled , this.chan2_scaled , this.chan3_scaled , this.chan4_scaled , this.chan5_scaled , this.chan6_scaled , this.chan7_scaled , this.chan8_scaled , this.rssi ] = moreargs;
+
+    this._format = '<IhhhhhhhhBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_RC_CHANNELS_SCALED;
+    this.order_map = [0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 237;
+    this._name = 'RC_CHANNELS_SCALED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'port', 'chan1_scaled', 'chan2_scaled', 'chan3_scaled', 'chan4_scaled', 'chan5_scaled', 'chan6_scaled', 'chan7_scaled', 'chan8_scaled', 'rssi'];
+
+}
+
+mavlink20.messages.rc_channels_scaled.prototype = new mavlink20.message;
+mavlink20.messages.rc_channels_scaled.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.chan1_scaled, this.chan2_scaled, this.chan3_scaled, this.chan4_scaled, this.chan5_scaled, this.chan6_scaled, this.chan7_scaled, this.chan8_scaled, this.port, this.rssi];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The RAW values of the RC channels received. The standard PPM
+modulation is as follows: 1000 microseconds: 0%, 2000 microseconds:
+100%. A value of UINT16_MAX implies the channel is unused. Individual
+receivers/transmitters might violate this specification.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                port                      : Servo output port (set of 8 outputs = 1 port). Flight stacks running on Pixhawk should use: 0 = MAIN, 1 = AUX. (uint8_t)
+                chan1_raw                 : RC channel 1 value. (uint16_t)
+                chan2_raw                 : RC channel 2 value. (uint16_t)
+                chan3_raw                 : RC channel 3 value. (uint16_t)
+                chan4_raw                 : RC channel 4 value. (uint16_t)
+                chan5_raw                 : RC channel 5 value. (uint16_t)
+                chan6_raw                 : RC channel 6 value. (uint16_t)
+                chan7_raw                 : RC channel 7 value. (uint16_t)
+                chan8_raw                 : RC channel 8 value. (uint16_t)
+                rssi                      : Receive signal strength indicator in device-dependent units/scale. Values: [0-254], 255: invalid/unknown. (uint8_t)
+
+*/
+    mavlink20.messages.rc_channels_raw = function( ...moreargs ) {
+    [ this.time_boot_ms , this.port , this.chan1_raw , this.chan2_raw , this.chan3_raw , this.chan4_raw , this.chan5_raw , this.chan6_raw , this.chan7_raw , this.chan8_raw , this.rssi ] = moreargs;
+
+    this._format = '<IHHHHHHHHBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_RC_CHANNELS_RAW;
+    this.order_map = [0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 244;
+    this._name = 'RC_CHANNELS_RAW';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'port', 'chan1_raw', 'chan2_raw', 'chan3_raw', 'chan4_raw', 'chan5_raw', 'chan6_raw', 'chan7_raw', 'chan8_raw', 'rssi'];
+
+}
+
+mavlink20.messages.rc_channels_raw.prototype = new mavlink20.message;
+mavlink20.messages.rc_channels_raw.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.chan1_raw, this.chan2_raw, this.chan3_raw, this.chan4_raw, this.chan5_raw, this.chan6_raw, this.chan7_raw, this.chan8_raw, this.port, this.rssi];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Superseded by ACTUATOR_OUTPUT_STATUS. The RAW values of the servo
+outputs (for RC input from the remote, use the RC_CHANNELS messages).
+The standard PPM modulation is as follows: 1000 microseconds: 0%, 2000
+microseconds: 100%.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint32_t)
+                port                      : Servo output port (set of 8 outputs = 1 port). Flight stacks running on Pixhawk should use: 0 = MAIN, 1 = AUX. (uint8_t)
+                servo1_raw                : Servo output 1 value (uint16_t)
+                servo2_raw                : Servo output 2 value (uint16_t)
+                servo3_raw                : Servo output 3 value (uint16_t)
+                servo4_raw                : Servo output 4 value (uint16_t)
+                servo5_raw                : Servo output 5 value (uint16_t)
+                servo6_raw                : Servo output 6 value (uint16_t)
+                servo7_raw                : Servo output 7 value (uint16_t)
+                servo8_raw                : Servo output 8 value (uint16_t)
+                servo9_raw                : Servo output 9 value (uint16_t)
+                servo10_raw               : Servo output 10 value (uint16_t)
+                servo11_raw               : Servo output 11 value (uint16_t)
+                servo12_raw               : Servo output 12 value (uint16_t)
+                servo13_raw               : Servo output 13 value (uint16_t)
+                servo14_raw               : Servo output 14 value (uint16_t)
+                servo15_raw               : Servo output 15 value (uint16_t)
+                servo16_raw               : Servo output 16 value (uint16_t)
+
+*/
+    mavlink20.messages.servo_output_raw = function( ...moreargs ) {
+    [ this.time_usec , this.port , this.servo1_raw , this.servo2_raw , this.servo3_raw , this.servo4_raw , this.servo5_raw , this.servo6_raw , this.servo7_raw , this.servo8_raw , this.servo9_raw , this.servo10_raw , this.servo11_raw , this.servo12_raw , this.servo13_raw , this.servo14_raw , this.servo15_raw , this.servo16_raw ] = moreargs;
+
+    this._format = '<IHHHHHHHHBHHHHHHHH';
+    this._id = mavlink20.MAVLINK_MSG_ID_SERVO_OUTPUT_RAW;
+    this.order_map = [0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 222;
+    this._name = 'SERVO_OUTPUT_RAW';
+
+    this._instance_field = 'port';
+    this._instance_offset = 20;
+
+    this.fieldnames = ['time_usec', 'port', 'servo1_raw', 'servo2_raw', 'servo3_raw', 'servo4_raw', 'servo5_raw', 'servo6_raw', 'servo7_raw', 'servo8_raw', 'servo9_raw', 'servo10_raw', 'servo11_raw', 'servo12_raw', 'servo13_raw', 'servo14_raw', 'servo15_raw', 'servo16_raw'];
+
+}
+
+mavlink20.messages.servo_output_raw.prototype = new mavlink20.message;
+mavlink20.messages.servo_output_raw.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.servo1_raw, this.servo2_raw, this.servo3_raw, this.servo4_raw, this.servo5_raw, this.servo6_raw, this.servo7_raw, this.servo8_raw, this.port, this.servo9_raw, this.servo10_raw, this.servo11_raw, this.servo12_raw, this.servo13_raw, this.servo14_raw, this.servo15_raw, this.servo16_raw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request a partial list of mission items from the system/component.
+https://mavlink.io/en/services/mission.html. If start and end index
+are the same, just send one waypoint.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                start_index               : Start index (int16_t)
+                end_index                 : End index, -1 by default (-1: send list to end). Else a valid index of the list (int16_t)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_request_partial_list = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.start_index , this.end_index , this.mission_type ] = moreargs;
+
+    this._format = '<hhBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_REQUEST_PARTIAL_LIST;
+    this.order_map = [2, 3, 0, 1, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 212;
+    this._name = 'MISSION_REQUEST_PARTIAL_LIST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'start_index', 'end_index', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_request_partial_list.prototype = new mavlink20.message;
+mavlink20.messages.mission_request_partial_list.prototype.pack = function(mav) {
+    var orderedfields = [ this.start_index, this.end_index, this.target_system, this.target_component, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+This message is sent to the MAV to write a partial list. If start
+index == end index, only one item will be transmitted / updated. If
+the start index is NOT 0 and above the current list size, this request
+should be REJECTED!
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                start_index               : Start index. Must be smaller / equal to the largest index of the current onboard list. (int16_t)
+                end_index                 : End index, equal or greater than start index. (int16_t)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_write_partial_list = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.start_index , this.end_index , this.mission_type ] = moreargs;
+
+    this._format = '<hhBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_WRITE_PARTIAL_LIST;
+    this.order_map = [2, 3, 0, 1, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 9;
+    this._name = 'MISSION_WRITE_PARTIAL_LIST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'start_index', 'end_index', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_write_partial_list.prototype = new mavlink20.message;
+mavlink20.messages.mission_write_partial_list.prototype.pack = function(mav) {
+    var orderedfields = [ this.start_index, this.end_index, this.target_system, this.target_component, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message encoding a mission item. This message is emitted to announce
+the presence of a mission item and to set a mission item on the
+system. The mission item can be either in x, y, z meters (type: LOCAL)
+or x:lat, y:lon, z:altitude. Local frame is Z-down, right handed
+(NED), global frame is Z-up, right handed (ENU). NaN may be used to
+indicate an optional/default value (e.g. to use the system's current
+latitude or yaw rather than a specific value). See also
+https://mavlink.io/en/services/mission.html.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                seq                       : Sequence (uint16_t)
+                frame                     : The coordinate system of the waypoint. (uint8_t)
+                command                   : The scheduled action for the waypoint. (uint16_t)
+                current                   : false:0, true:1 (uint8_t)
+                autocontinue              : Autocontinue to next waypoint (uint8_t)
+                param1                    : PARAM1, see MAV_CMD enum (float)
+                param2                    : PARAM2, see MAV_CMD enum (float)
+                param3                    : PARAM3, see MAV_CMD enum (float)
+                param4                    : PARAM4, see MAV_CMD enum (float)
+                x                         : PARAM5 / local: X coordinate, global: latitude (float)
+                y                         : PARAM6 / local: Y coordinate, global: longitude (float)
+                z                         : PARAM7 / local: Z coordinate, global: altitude (relative or absolute, depending on frame). (float)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_item = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.seq , this.frame , this.command , this.current , this.autocontinue , this.param1 , this.param2 , this.param3 , this.param4 , this.x , this.y , this.z , this.mission_type ] = moreargs;
+
+    this._format = '<fffffffHHBBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_ITEM;
+    this.order_map = [9, 10, 7, 11, 8, 12, 13, 0, 1, 2, 3, 4, 5, 6, 14];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 254;
+    this._name = 'MISSION_ITEM';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'seq', 'frame', 'command', 'current', 'autocontinue', 'param1', 'param2', 'param3', 'param4', 'x', 'y', 'z', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_item.prototype = new mavlink20.message;
+mavlink20.messages.mission_item.prototype.pack = function(mav) {
+    var orderedfields = [ this.param1, this.param2, this.param3, this.param4, this.x, this.y, this.z, this.seq, this.command, this.target_system, this.target_component, this.frame, this.current, this.autocontinue, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request the information of the mission item with the sequence number
+seq. The response of the system to this message should be a
+MISSION_ITEM message. https://mavlink.io/en/services/mission.html
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                seq                       : Sequence (uint16_t)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_request = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.seq , this.mission_type ] = moreargs;
+
+    this._format = '<HBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_REQUEST;
+    this.order_map = [1, 2, 0, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 230;
+    this._name = 'MISSION_REQUEST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'seq', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_request.prototype = new mavlink20.message;
+mavlink20.messages.mission_request.prototype.pack = function(mav) {
+    var orderedfields = [ this.seq, this.target_system, this.target_component, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set the mission item with sequence number seq as current item. This
+means that the MAV will continue to this mission item on the shortest
+path (not following the mission items in-between).
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                seq                       : Sequence (uint16_t)
+
+*/
+    mavlink20.messages.mission_set_current = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.seq ] = moreargs;
+
+    this._format = '<HBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_SET_CURRENT;
+    this.order_map = [1, 2, 0];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 28;
+    this._name = 'MISSION_SET_CURRENT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'seq'];
+
+}
+
+mavlink20.messages.mission_set_current.prototype = new mavlink20.message;
+mavlink20.messages.mission_set_current.prototype.pack = function(mav) {
+    var orderedfields = [ this.seq, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message that announces the sequence number of the current active
+mission item. The MAV will fly towards this mission item.
+
+                seq                       : Sequence (uint16_t)
+                total                     : Total number of mission items on vehicle (on last item, sequence == total). If the autopilot stores its home location as part of the mission this will be excluded from the total. 0: Not supported, UINT16_MAX if no mission is present on the vehicle. (uint16_t)
+                mission_state             : Mission state machine state. MISSION_STATE_UNKNOWN if state reporting not supported. (uint8_t)
+                mission_mode              : Vehicle is in a mode that can execute mission items or suspended. 0: Unknown, 1: In mission mode, 2: Suspended (not in mission mode). (uint8_t)
+
+*/
+    mavlink20.messages.mission_current = function( ...moreargs ) {
+    [ this.seq , this.total , this.mission_state , this.mission_mode ] = moreargs;
+
+    this._format = '<HHBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_CURRENT;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 28;
+    this._name = 'MISSION_CURRENT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['seq', 'total', 'mission_state', 'mission_mode'];
+
+}
+
+mavlink20.messages.mission_current.prototype = new mavlink20.message;
+mavlink20.messages.mission_current.prototype.pack = function(mav) {
+    var orderedfields = [ this.seq, this.total, this.mission_state, this.mission_mode];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request the overall list of mission items from the system/component.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_request_list = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.mission_type ] = moreargs;
+
+    this._format = '<BBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_REQUEST_LIST;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 132;
+    this._name = 'MISSION_REQUEST_LIST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_request_list.prototype = new mavlink20.message;
+mavlink20.messages.mission_request_list.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+This message is emitted as response to MISSION_REQUEST_LIST by the MAV
+and to initiate a write transaction. The GCS can then request the
+individual mission item based on the knowledge of the total number of
+waypoints.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                count                     : Number of mission items in the sequence (uint16_t)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_count = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.count , this.mission_type ] = moreargs;
+
+    this._format = '<HBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_COUNT;
+    this.order_map = [1, 2, 0, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 221;
+    this._name = 'MISSION_COUNT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'count', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_count.prototype = new mavlink20.message;
+mavlink20.messages.mission_count.prototype.pack = function(mav) {
+    var orderedfields = [ this.count, this.target_system, this.target_component, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Delete all mission items at once.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_clear_all = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.mission_type ] = moreargs;
+
+    this._format = '<BBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_CLEAR_ALL;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 232;
+    this._name = 'MISSION_CLEAR_ALL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_clear_all.prototype = new mavlink20.message;
+mavlink20.messages.mission_clear_all.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A certain mission item has been reached. The system will either hold
+this position (or circle on the orbit) or (if the autocontinue on the
+WP was set) continue to the next waypoint.
+
+                seq                       : Sequence (uint16_t)
+
+*/
+    mavlink20.messages.mission_item_reached = function( ...moreargs ) {
+    [ this.seq ] = moreargs;
+
+    this._format = '<H';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_ITEM_REACHED;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [0];
+    this.crc_extra = 11;
+    this._name = 'MISSION_ITEM_REACHED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['seq'];
+
+}
+
+mavlink20.messages.mission_item_reached.prototype = new mavlink20.message;
+mavlink20.messages.mission_item_reached.prototype.pack = function(mav) {
+    var orderedfields = [ this.seq];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Acknowledgment message during waypoint handling. The type field states
+if this message is a positive ack (type=0) or if an error happened
+(type=non-zero).
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                type                      : Mission result. (uint8_t)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_ack = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.type , this.mission_type ] = moreargs;
+
+    this._format = '<BBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_ACK;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 153;
+    this._name = 'MISSION_ACK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'type', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_ack.prototype = new mavlink20.message;
+mavlink20.messages.mission_ack.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.type, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sets the GPS coordinates of the vehicle local origin (0,0,0) position.
+Vehicle should emit GPS_GLOBAL_ORIGIN irrespective of whether the
+origin is changed. This enables transform between the local coordinate
+frame and the global (GPS) coordinate frame, which may be necessary
+when (for example) indoor and outdoor settings are connected and the
+MAV should move from in- to outdoor.
+
+                target_system             : System ID (uint8_t)
+                latitude                  : Latitude (WGS84) (int32_t)
+                longitude                 : Longitude (WGS84) (int32_t)
+                altitude                  : Altitude (MSL). Positive for up. (int32_t)
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+
+*/
+    mavlink20.messages.set_gps_global_origin = function( ...moreargs ) {
+    [ this.target_system , this.latitude , this.longitude , this.altitude , this.time_usec ] = moreargs;
+
+    this._format = '<iiiBQ';
+    this._id = mavlink20.MAVLINK_MSG_ID_SET_GPS_GLOBAL_ORIGIN;
+    this.order_map = [3, 0, 1, 2, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 41;
+    this._name = 'SET_GPS_GLOBAL_ORIGIN';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'latitude', 'longitude', 'altitude', 'time_usec'];
+
+}
+
+mavlink20.messages.set_gps_global_origin.prototype = new mavlink20.message;
+mavlink20.messages.set_gps_global_origin.prototype.pack = function(mav) {
+    var orderedfields = [ this.latitude, this.longitude, this.altitude, this.target_system, this.time_usec];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Publishes the GPS coordinates of the vehicle local origin (0,0,0)
+position. Emitted whenever a new GPS-Local position mapping is
+requested or set - e.g. following SET_GPS_GLOBAL_ORIGIN message.
+
+                latitude                  : Latitude (WGS84) (int32_t)
+                longitude                 : Longitude (WGS84) (int32_t)
+                altitude                  : Altitude (MSL). Positive for up. (int32_t)
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+
+*/
+    mavlink20.messages.gps_global_origin = function( ...moreargs ) {
+    [ this.latitude , this.longitude , this.altitude , this.time_usec ] = moreargs;
+
+    this._format = '<iiiQ';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS_GLOBAL_ORIGIN;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 39;
+    this._name = 'GPS_GLOBAL_ORIGIN';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['latitude', 'longitude', 'altitude', 'time_usec'];
+
+}
+
+mavlink20.messages.gps_global_origin.prototype = new mavlink20.message;
+mavlink20.messages.gps_global_origin.prototype.pack = function(mav) {
+    var orderedfields = [ this.latitude, this.longitude, this.altitude, this.time_usec];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Bind a RC channel to a parameter. The parameter should change
+according to the RC channel value.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                param_id                  : Onboard parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                param_index               : Parameter index. Send -1 to use the param ID field as identifier (else the param id will be ignored), send -2 to disable any existing map for this rc_channel_index. (int16_t)
+                parameter_rc_channel_index        : Index of parameter RC channel. Not equal to the RC channel id. Typically corresponds to a potentiometer-knob on the RC. (uint8_t)
+                param_value0              : Initial parameter value (float)
+                scale                     : Scale, maps the RC range [-1, 1] to a parameter value (float)
+                param_value_min           : Minimum param value. The protocol does not define if this overwrites an onboard minimum value. (Depends on implementation) (float)
+                param_value_max           : Maximum param value. The protocol does not define if this overwrites an onboard maximum value. (Depends on implementation) (float)
+
+*/
+    mavlink20.messages.param_map_rc = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.param_id , this.param_index , this.parameter_rc_channel_index , this.param_value0 , this.scale , this.param_value_min , this.param_value_max ] = moreargs;
+
+    this._format = '<ffffhBB16sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_MAP_RC;
+    this.order_map = [5, 6, 7, 4, 8, 0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 16, 0];
+    this.crc_extra = 78;
+    this._name = 'PARAM_MAP_RC';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'param_id', 'param_index', 'parameter_rc_channel_index', 'param_value0', 'scale', 'param_value_min', 'param_value_max'];
+
+}
+
+mavlink20.messages.param_map_rc.prototype = new mavlink20.message;
+mavlink20.messages.param_map_rc.prototype.pack = function(mav) {
+    var orderedfields = [ this.param_value0, this.scale, this.param_value_min, this.param_value_max, this.param_index, this.target_system, this.target_component, this.param_id, this.parameter_rc_channel_index];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request the information of the mission item with the sequence number
+seq. The response of the system to this message should be a
+MISSION_ITEM_INT message. https://mavlink.io/en/services/mission.html
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                seq                       : Sequence (uint16_t)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_request_int = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.seq , this.mission_type ] = moreargs;
+
+    this._format = '<HBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_REQUEST_INT;
+    this.order_map = [1, 2, 0, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 196;
+    this._name = 'MISSION_REQUEST_INT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'seq', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_request_int.prototype = new mavlink20.message;
+mavlink20.messages.mission_request_int.prototype.pack = function(mav) {
+    var orderedfields = [ this.seq, this.target_system, this.target_component, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set a safety zone (volume), which is defined by two corners of a cube.
+This message can be used to tell the MAV which setpoints/waypoints to
+accept and which to reject. Safety areas are often enforced by
+national or competition regulations.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                frame                     : Coordinate frame. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down. (uint8_t)
+                p1x                       : x position 1 / Latitude 1 (float)
+                p1y                       : y position 1 / Longitude 1 (float)
+                p1z                       : z position 1 / Altitude 1 (float)
+                p2x                       : x position 2 / Latitude 2 (float)
+                p2y                       : y position 2 / Longitude 2 (float)
+                p2z                       : z position 2 / Altitude 2 (float)
+
+*/
+    mavlink20.messages.safety_set_allowed_area = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.frame , this.p1x , this.p1y , this.p1z , this.p2x , this.p2y , this.p2z ] = moreargs;
+
+    this._format = '<ffffffBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA;
+    this.order_map = [6, 7, 8, 0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 15;
+    this._name = 'SAFETY_SET_ALLOWED_AREA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'frame', 'p1x', 'p1y', 'p1z', 'p2x', 'p2y', 'p2z'];
+
+}
+
+mavlink20.messages.safety_set_allowed_area.prototype = new mavlink20.message;
+mavlink20.messages.safety_set_allowed_area.prototype.pack = function(mav) {
+    var orderedfields = [ this.p1x, this.p1y, this.p1z, this.p2x, this.p2y, this.p2z, this.target_system, this.target_component, this.frame];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Read out the safety zone the MAV currently assumes.
+
+                frame                     : Coordinate frame. Can be either global, GPS, right-handed with Z axis up or local, right handed, Z axis down. (uint8_t)
+                p1x                       : x position 1 / Latitude 1 (float)
+                p1y                       : y position 1 / Longitude 1 (float)
+                p1z                       : z position 1 / Altitude 1 (float)
+                p2x                       : x position 2 / Latitude 2 (float)
+                p2y                       : y position 2 / Longitude 2 (float)
+                p2z                       : z position 2 / Altitude 2 (float)
+
+*/
+    mavlink20.messages.safety_allowed_area = function( ...moreargs ) {
+    [ this.frame , this.p1x , this.p1y , this.p1z , this.p2x , this.p2y , this.p2z ] = moreargs;
+
+    this._format = '<ffffffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA;
+    this.order_map = [6, 0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 3;
+    this._name = 'SAFETY_ALLOWED_AREA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['frame', 'p1x', 'p1y', 'p1z', 'p2x', 'p2y', 'p2z'];
+
+}
+
+mavlink20.messages.safety_allowed_area.prototype = new mavlink20.message;
+mavlink20.messages.safety_allowed_area.prototype.pack = function(mav) {
+    var orderedfields = [ this.p1x, this.p1y, this.p1z, this.p2x, this.p2y, this.p2z, this.frame];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The attitude in the aeronautical frame (right-handed, Z-down, X-front,
+Y-right), expressed as quaternion. Quaternion order is w, x, y, z and
+a zero rotation would be expressed as (1 0 0 0).
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                q                         : Quaternion components, w, x, y, z (1 0 0 0 is the null-rotation) (float)
+                rollspeed                 : Roll angular speed (float)
+                pitchspeed                : Pitch angular speed (float)
+                yawspeed                  : Yaw angular speed (float)
+                covariance                : Row-major representation of a 3x3 attitude covariance matrix (states: roll, pitch, yaw; first three entries are the first ROW, next three entries are the second row, etc.). If unknown, assign NaN value to first element in the array. (float)
+
+*/
+    mavlink20.messages.attitude_quaternion_cov = function( ...moreargs ) {
+    [ this.time_usec , this.q , this.rollspeed , this.pitchspeed , this.yawspeed , this.covariance ] = moreargs;
+
+    this._format = '<Q4ffff9f';
+    this._id = mavlink20.MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 4, 1, 1, 1, 9];
+    this.array_len_map = [0, 4, 0, 0, 0, 9];
+    this.crc_extra = 167;
+    this._name = 'ATTITUDE_QUATERNION_COV';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'q', 'rollspeed', 'pitchspeed', 'yawspeed', 'covariance'];
+
+}
+
+mavlink20.messages.attitude_quaternion_cov.prototype = new mavlink20.message;
+mavlink20.messages.attitude_quaternion_cov.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.q, this.rollspeed, this.pitchspeed, this.yawspeed, this.covariance];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The state of the navigation and position controller.
+
+                nav_roll                  : Current desired roll (float)
+                nav_pitch                 : Current desired pitch (float)
+                nav_bearing               : Current desired heading (int16_t)
+                target_bearing            : Bearing to current waypoint/target (int16_t)
+                wp_dist                   : Distance to active waypoint (uint16_t)
+                alt_error                 : Current altitude error (float)
+                aspd_error                : Current airspeed error (float)
+                xtrack_error              : Current crosstrack error on x-y plane (float)
+
+*/
+    mavlink20.messages.nav_controller_output = function( ...moreargs ) {
+    [ this.nav_roll , this.nav_pitch , this.nav_bearing , this.target_bearing , this.wp_dist , this.alt_error , this.aspd_error , this.xtrack_error ] = moreargs;
+
+    this._format = '<fffffhhH';
+    this._id = mavlink20.MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT;
+    this.order_map = [0, 1, 5, 6, 7, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 183;
+    this._name = 'NAV_CONTROLLER_OUTPUT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['nav_roll', 'nav_pitch', 'nav_bearing', 'target_bearing', 'wp_dist', 'alt_error', 'aspd_error', 'xtrack_error'];
+
+}
+
+mavlink20.messages.nav_controller_output.prototype = new mavlink20.message;
+mavlink20.messages.nav_controller_output.prototype.pack = function(mav) {
+    var orderedfields = [ this.nav_roll, this.nav_pitch, this.alt_error, this.aspd_error, this.xtrack_error, this.nav_bearing, this.target_bearing, this.wp_dist];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The filtered global position (e.g. fused GPS and accelerometers). The
+position is in GPS-frame (right-handed, Z-up). It  is designed as
+scaled integer message since the resolution of float is not
+sufficient. NOTE: This message is intended for onboard networks /
+companion computers and higher-bandwidth links and optimized for
+accuracy and completeness. Please use the GLOBAL_POSITION_INT message
+for a minimal subset.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                estimator_type            : Class id of the estimator this estimate originated from. (uint8_t)
+                lat                       : Latitude (int32_t)
+                lon                       : Longitude (int32_t)
+                alt                       : Altitude in meters above MSL (int32_t)
+                relative_alt              : Altitude above ground (int32_t)
+                vx                        : Ground X Speed (Latitude) (float)
+                vy                        : Ground Y Speed (Longitude) (float)
+                vz                        : Ground Z Speed (Altitude) (float)
+                covariance                : Row-major representation of a 6x6 position and velocity 6x6 cross-covariance matrix (states: lat, lon, alt, vx, vy, vz; first six entries are the first ROW, next six entries are the second row, etc.). If unknown, assign NaN value to first element in the array. (float)
+
+*/
+    mavlink20.messages.global_position_int_cov = function( ...moreargs ) {
+    [ this.time_usec , this.estimator_type , this.lat , this.lon , this.alt , this.relative_alt , this.vx , this.vy , this.vz , this.covariance ] = moreargs;
+
+    this._format = '<Qiiiifff36fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV;
+    this.order_map = [0, 9, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 36, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 36, 0];
+    this.crc_extra = 119;
+    this._name = 'GLOBAL_POSITION_INT_COV';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'estimator_type', 'lat', 'lon', 'alt', 'relative_alt', 'vx', 'vy', 'vz', 'covariance'];
+
+}
+
+mavlink20.messages.global_position_int_cov.prototype = new mavlink20.message;
+mavlink20.messages.global_position_int_cov.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.lat, this.lon, this.alt, this.relative_alt, this.vx, this.vy, this.vz, this.covariance, this.estimator_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The filtered local position (e.g. fused computer vision and
+accelerometers). Coordinate frame is right-handed, Z-axis down
+(aeronautical frame, NED / north-east-down convention)
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                estimator_type            : Class id of the estimator this estimate originated from. (uint8_t)
+                x                         : X Position (float)
+                y                         : Y Position (float)
+                z                         : Z Position (float)
+                vx                        : X Speed (float)
+                vy                        : Y Speed (float)
+                vz                        : Z Speed (float)
+                ax                        : X Acceleration (float)
+                ay                        : Y Acceleration (float)
+                az                        : Z Acceleration (float)
+                covariance                : Row-major representation of position, velocity and acceleration 9x9 cross-covariance matrix upper right triangle (states: x, y, z, vx, vy, vz, ax, ay, az; first nine entries are the first ROW, next eight entries are the second row, etc.). If unknown, assign NaN value to first element in the array. (float)
+
+*/
+    mavlink20.messages.local_position_ned_cov = function( ...moreargs ) {
+    [ this.time_usec , this.estimator_type , this.x , this.y , this.z , this.vx , this.vy , this.vz , this.ax , this.ay , this.az , this.covariance ] = moreargs;
+
+    this._format = '<Qfffffffff45fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOCAL_POSITION_NED_COV;
+    this.order_map = [0, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 45, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0];
+    this.crc_extra = 191;
+    this._name = 'LOCAL_POSITION_NED_COV';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'estimator_type', 'x', 'y', 'z', 'vx', 'vy', 'vz', 'ax', 'ay', 'az', 'covariance'];
+
+}
+
+mavlink20.messages.local_position_ned_cov.prototype = new mavlink20.message;
+mavlink20.messages.local_position_ned_cov.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.x, this.y, this.z, this.vx, this.vy, this.vz, this.ax, this.ay, this.az, this.covariance, this.estimator_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The PPM values of the RC channels received. The standard PPM
+modulation is as follows: 1000 microseconds: 0%, 2000 microseconds:
+100%.  A value of UINT16_MAX implies the channel is unused. Individual
+receivers/transmitters might violate this specification.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                chancount                 : Total number of RC channels being received. This can be larger than 18, indicating that more channels are available but not given in this message. This value should be 0 when no RC channels are available. (uint8_t)
+                chan1_raw                 : RC channel 1 value. (uint16_t)
+                chan2_raw                 : RC channel 2 value. (uint16_t)
+                chan3_raw                 : RC channel 3 value. (uint16_t)
+                chan4_raw                 : RC channel 4 value. (uint16_t)
+                chan5_raw                 : RC channel 5 value. (uint16_t)
+                chan6_raw                 : RC channel 6 value. (uint16_t)
+                chan7_raw                 : RC channel 7 value. (uint16_t)
+                chan8_raw                 : RC channel 8 value. (uint16_t)
+                chan9_raw                 : RC channel 9 value. (uint16_t)
+                chan10_raw                : RC channel 10 value. (uint16_t)
+                chan11_raw                : RC channel 11 value. (uint16_t)
+                chan12_raw                : RC channel 12 value. (uint16_t)
+                chan13_raw                : RC channel 13 value. (uint16_t)
+                chan14_raw                : RC channel 14 value. (uint16_t)
+                chan15_raw                : RC channel 15 value. (uint16_t)
+                chan16_raw                : RC channel 16 value. (uint16_t)
+                chan17_raw                : RC channel 17 value. (uint16_t)
+                chan18_raw                : RC channel 18 value. (uint16_t)
+                rssi                      : Receive signal strength indicator in device-dependent units/scale. Values: [0-254], 255: invalid/unknown. (uint8_t)
+
+*/
+    mavlink20.messages.rc_channels = function( ...moreargs ) {
+    [ this.time_boot_ms , this.chancount , this.chan1_raw , this.chan2_raw , this.chan3_raw , this.chan4_raw , this.chan5_raw , this.chan6_raw , this.chan7_raw , this.chan8_raw , this.chan9_raw , this.chan10_raw , this.chan11_raw , this.chan12_raw , this.chan13_raw , this.chan14_raw , this.chan15_raw , this.chan16_raw , this.chan17_raw , this.chan18_raw , this.rssi ] = moreargs;
+
+    this._format = '<IHHHHHHHHHHHHHHHHHHBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_RC_CHANNELS;
+    this.order_map = [0, 19, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 118;
+    this._name = 'RC_CHANNELS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'chancount', 'chan1_raw', 'chan2_raw', 'chan3_raw', 'chan4_raw', 'chan5_raw', 'chan6_raw', 'chan7_raw', 'chan8_raw', 'chan9_raw', 'chan10_raw', 'chan11_raw', 'chan12_raw', 'chan13_raw', 'chan14_raw', 'chan15_raw', 'chan16_raw', 'chan17_raw', 'chan18_raw', 'rssi'];
+
+}
+
+mavlink20.messages.rc_channels.prototype = new mavlink20.message;
+mavlink20.messages.rc_channels.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.chan1_raw, this.chan2_raw, this.chan3_raw, this.chan4_raw, this.chan5_raw, this.chan6_raw, this.chan7_raw, this.chan8_raw, this.chan9_raw, this.chan10_raw, this.chan11_raw, this.chan12_raw, this.chan13_raw, this.chan14_raw, this.chan15_raw, this.chan16_raw, this.chan17_raw, this.chan18_raw, this.chancount, this.rssi];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request a data stream.
+
+                target_system             : The target requested to send the message stream. (uint8_t)
+                target_component          : The target requested to send the message stream. (uint8_t)
+                req_stream_id             : The ID of the requested data stream (uint8_t)
+                req_message_rate          : The requested message rate (uint16_t)
+                start_stop                : 1 to start sending, 0 to stop sending. (uint8_t)
+
+*/
+    mavlink20.messages.request_data_stream = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.req_stream_id , this.req_message_rate , this.start_stop ] = moreargs;
+
+    this._format = '<HBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_REQUEST_DATA_STREAM;
+    this.order_map = [1, 2, 3, 0, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 148;
+    this._name = 'REQUEST_DATA_STREAM';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'req_stream_id', 'req_message_rate', 'start_stop'];
+
+}
+
+mavlink20.messages.request_data_stream.prototype = new mavlink20.message;
+mavlink20.messages.request_data_stream.prototype.pack = function(mav) {
+    var orderedfields = [ this.req_message_rate, this.target_system, this.target_component, this.req_stream_id, this.start_stop];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data stream status information.
+
+                stream_id                 : The ID of the requested data stream (uint8_t)
+                message_rate              : The message rate (uint16_t)
+                on_off                    : 1 stream is enabled, 0 stream is stopped. (uint8_t)
+
+*/
+    mavlink20.messages.data_stream = function( ...moreargs ) {
+    [ this.stream_id , this.message_rate , this.on_off ] = moreargs;
+
+    this._format = '<HBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DATA_STREAM;
+    this.order_map = [1, 0, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 21;
+    this._name = 'DATA_STREAM';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['stream_id', 'message_rate', 'on_off'];
+
+}
+
+mavlink20.messages.data_stream.prototype = new mavlink20.message;
+mavlink20.messages.data_stream.prototype.pack = function(mav) {
+    var orderedfields = [ this.message_rate, this.stream_id, this.on_off];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+This message provides an API for manually controlling the vehicle
+using standard joystick axes nomenclature, along with a joystick-like
+input device. Unused axes can be disabled and buttons states are
+transmitted as individual on/off bits of a bitmask
+
+                target                    : The system to be controlled. (uint8_t)
+                x                         : X-axis, normalized to the range [-1000,1000]. A value of INT16_MAX indicates that this axis is invalid. Generally corresponds to forward(1000)-backward(-1000) movement on a joystick and the pitch of a vehicle. (int16_t)
+                y                         : Y-axis, normalized to the range [-1000,1000]. A value of INT16_MAX indicates that this axis is invalid. Generally corresponds to left(-1000)-right(1000) movement on a joystick and the roll of a vehicle. (int16_t)
+                z                         : Z-axis, normalized to the range [-1000,1000]. A value of INT16_MAX indicates that this axis is invalid. Generally corresponds to a separate slider movement with maximum being 1000 and minimum being -1000 on a joystick and the thrust of a vehicle. Positive values are positive thrust, negative values are negative thrust. (int16_t)
+                r                         : R-axis, normalized to the range [-1000,1000]. A value of INT16_MAX indicates that this axis is invalid. Generally corresponds to a twisting of the joystick, with counter-clockwise being 1000 and clockwise being -1000, and the yaw of a vehicle. (int16_t)
+                buttons                   : A bitfield corresponding to the joystick buttons' current state, 1 for pressed, 0 for released. The lowest bit corresponds to Button 1. (uint16_t)
+                buttons2                  : A bitfield corresponding to the joystick buttons' 16-31 current state, 1 for pressed, 0 for released. The lowest bit corresponds to Button 16. (uint16_t)
+                enabled_extensions        : Set bits to 1 to indicate which of the following extension fields contain valid data: bit 0: pitch, bit 1: roll, bit 2: aux1, bit 3: aux2, bit 4: aux3, bit 5: aux4, bit 6: aux5, bit 7: aux6 (uint8_t)
+                s                         : Pitch-only-axis, normalized to the range [-1000,1000]. Generally corresponds to pitch on vehicles with additional degrees of freedom. Valid if bit 0 of enabled_extensions field is set. Set to 0 if invalid. (int16_t)
+                t                         : Roll-only-axis, normalized to the range [-1000,1000]. Generally corresponds to roll on vehicles with additional degrees of freedom. Valid if bit 1 of enabled_extensions field is set. Set to 0 if invalid. (int16_t)
+                aux1                      : Aux continuous input field 1. Normalized in the range [-1000,1000]. Purpose defined by recipient. Valid data if bit 2 of enabled_extensions field is set. 0 if bit 2 is unset. (int16_t)
+                aux2                      : Aux continuous input field 2. Normalized in the range [-1000,1000]. Purpose defined by recipient. Valid data if bit 3 of enabled_extensions field is set. 0 if bit 3 is unset. (int16_t)
+                aux3                      : Aux continuous input field 3. Normalized in the range [-1000,1000]. Purpose defined by recipient. Valid data if bit 4 of enabled_extensions field is set. 0 if bit 4 is unset. (int16_t)
+                aux4                      : Aux continuous input field 4. Normalized in the range [-1000,1000]. Purpose defined by recipient. Valid data if bit 5 of enabled_extensions field is set. 0 if bit 5 is unset. (int16_t)
+                aux5                      : Aux continuous input field 5. Normalized in the range [-1000,1000]. Purpose defined by recipient. Valid data if bit 6 of enabled_extensions field is set. 0 if bit 6 is unset. (int16_t)
+                aux6                      : Aux continuous input field 6. Normalized in the range [-1000,1000]. Purpose defined by recipient. Valid data if bit 7 of enabled_extensions field is set. 0 if bit 7 is unset. (int16_t)
+
+*/
+    mavlink20.messages.manual_control = function( ...moreargs ) {
+    [ this.target , this.x , this.y , this.z , this.r , this.buttons , this.buttons2 , this.enabled_extensions , this.s , this.t , this.aux1 , this.aux2 , this.aux3 , this.aux4 , this.aux5 , this.aux6 ] = moreargs;
+
+    this._format = '<hhhhHBHBhhhhhhhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_MANUAL_CONTROL;
+    this.order_map = [5, 0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 243;
+    this._name = 'MANUAL_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target', 'x', 'y', 'z', 'r', 'buttons', 'buttons2', 'enabled_extensions', 's', 't', 'aux1', 'aux2', 'aux3', 'aux4', 'aux5', 'aux6'];
+
+}
+
+mavlink20.messages.manual_control.prototype = new mavlink20.message;
+mavlink20.messages.manual_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.x, this.y, this.z, this.r, this.buttons, this.target, this.buttons2, this.enabled_extensions, this.s, this.t, this.aux1, this.aux2, this.aux3, this.aux4, this.aux5, this.aux6];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The RAW values of the RC channels sent to the MAV to override info
+received from the RC radio. The standard PPM modulation is as follows:
+1000 microseconds: 0%, 2000 microseconds: 100%. Individual
+receivers/transmitters might violate this specification.  Note
+carefully the semantic differences between the first 8 channels and
+the subsequent channels
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                chan1_raw                 : RC channel 1 value. A value of UINT16_MAX means to ignore this field. A value of 0 means to release this channel back to the RC radio. (uint16_t)
+                chan2_raw                 : RC channel 2 value. A value of UINT16_MAX means to ignore this field. A value of 0 means to release this channel back to the RC radio. (uint16_t)
+                chan3_raw                 : RC channel 3 value. A value of UINT16_MAX means to ignore this field. A value of 0 means to release this channel back to the RC radio. (uint16_t)
+                chan4_raw                 : RC channel 4 value. A value of UINT16_MAX means to ignore this field. A value of 0 means to release this channel back to the RC radio. (uint16_t)
+                chan5_raw                 : RC channel 5 value. A value of UINT16_MAX means to ignore this field. A value of 0 means to release this channel back to the RC radio. (uint16_t)
+                chan6_raw                 : RC channel 6 value. A value of UINT16_MAX means to ignore this field. A value of 0 means to release this channel back to the RC radio. (uint16_t)
+                chan7_raw                 : RC channel 7 value. A value of UINT16_MAX means to ignore this field. A value of 0 means to release this channel back to the RC radio. (uint16_t)
+                chan8_raw                 : RC channel 8 value. A value of UINT16_MAX means to ignore this field. A value of 0 means to release this channel back to the RC radio. (uint16_t)
+                chan9_raw                 : RC channel 9 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan10_raw                : RC channel 10 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan11_raw                : RC channel 11 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan12_raw                : RC channel 12 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan13_raw                : RC channel 13 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan14_raw                : RC channel 14 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan15_raw                : RC channel 15 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan16_raw                : RC channel 16 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan17_raw                : RC channel 17 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+                chan18_raw                : RC channel 18 value. A value of 0 or UINT16_MAX means to ignore this field. A value of UINT16_MAX-1 means to release this channel back to the RC radio. (uint16_t)
+
+*/
+    mavlink20.messages.rc_channels_override = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.chan1_raw , this.chan2_raw , this.chan3_raw , this.chan4_raw , this.chan5_raw , this.chan6_raw , this.chan7_raw , this.chan8_raw , this.chan9_raw , this.chan10_raw , this.chan11_raw , this.chan12_raw , this.chan13_raw , this.chan14_raw , this.chan15_raw , this.chan16_raw , this.chan17_raw , this.chan18_raw ] = moreargs;
+
+    this._format = '<HHHHHHHHBBHHHHHHHHHH';
+    this._id = mavlink20.MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE;
+    this.order_map = [8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 124;
+    this._name = 'RC_CHANNELS_OVERRIDE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'chan1_raw', 'chan2_raw', 'chan3_raw', 'chan4_raw', 'chan5_raw', 'chan6_raw', 'chan7_raw', 'chan8_raw', 'chan9_raw', 'chan10_raw', 'chan11_raw', 'chan12_raw', 'chan13_raw', 'chan14_raw', 'chan15_raw', 'chan16_raw', 'chan17_raw', 'chan18_raw'];
+
+}
+
+mavlink20.messages.rc_channels_override.prototype = new mavlink20.message;
+mavlink20.messages.rc_channels_override.prototype.pack = function(mav) {
+    var orderedfields = [ this.chan1_raw, this.chan2_raw, this.chan3_raw, this.chan4_raw, this.chan5_raw, this.chan6_raw, this.chan7_raw, this.chan8_raw, this.target_system, this.target_component, this.chan9_raw, this.chan10_raw, this.chan11_raw, this.chan12_raw, this.chan13_raw, this.chan14_raw, this.chan15_raw, this.chan16_raw, this.chan17_raw, this.chan18_raw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message encoding a mission item. This message is emitted to announce
+the presence of a mission item and to set a mission item on the
+system. The mission item can be either in x, y, z meters (type: LOCAL)
+or x:lat, y:lon, z:altitude. Local frame is Z-down, right handed
+(NED), global frame is Z-up, right handed (ENU). NaN or INT32_MAX may
+be used in float/integer params (respectively) to indicate
+optional/default values (e.g. to use the component's current latitude,
+yaw rather than a specific value). See also
+https://mavlink.io/en/services/mission.html.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                seq                       : Waypoint ID (sequence number). Starts at zero. Increases monotonically for each waypoint, no gaps in the sequence (0,1,2,3,4). (uint16_t)
+                frame                     : The coordinate system of the waypoint. (uint8_t)
+                command                   : The scheduled action for the waypoint. (uint16_t)
+                current                   : false:0, true:1 (uint8_t)
+                autocontinue              : Autocontinue to next waypoint (uint8_t)
+                param1                    : PARAM1, see MAV_CMD enum (float)
+                param2                    : PARAM2, see MAV_CMD enum (float)
+                param3                    : PARAM3, see MAV_CMD enum (float)
+                param4                    : PARAM4, see MAV_CMD enum (float)
+                x                         : PARAM5 / local: x position in meters * 1e4, global: latitude in degrees * 10^7 (int32_t)
+                y                         : PARAM6 / y position: local: x position in meters * 1e4, global: longitude in degrees *10^7 (int32_t)
+                z                         : PARAM7 / z position: global: altitude in meters (relative or absolute, depending on frame. (float)
+                mission_type              : Mission type. (uint8_t)
+
+*/
+    mavlink20.messages.mission_item_int = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.seq , this.frame , this.command , this.current , this.autocontinue , this.param1 , this.param2 , this.param3 , this.param4 , this.x , this.y , this.z , this.mission_type ] = moreargs;
+
+    this._format = '<ffffiifHHBBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_ITEM_INT;
+    this.order_map = [9, 10, 7, 11, 8, 12, 13, 0, 1, 2, 3, 4, 5, 6, 14];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 38;
+    this._name = 'MISSION_ITEM_INT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'seq', 'frame', 'command', 'current', 'autocontinue', 'param1', 'param2', 'param3', 'param4', 'x', 'y', 'z', 'mission_type'];
+
+}
+
+mavlink20.messages.mission_item_int.prototype = new mavlink20.message;
+mavlink20.messages.mission_item_int.prototype.pack = function(mav) {
+    var orderedfields = [ this.param1, this.param2, this.param3, this.param4, this.x, this.y, this.z, this.seq, this.command, this.target_system, this.target_component, this.frame, this.current, this.autocontinue, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Metrics typically displayed on a HUD for fixed wing aircraft.
+
+                airspeed                  : Vehicle speed in form appropriate for vehicle type. For standard aircraft this is typically calibrated airspeed (CAS) or indicated airspeed (IAS) - either of which can be used by a pilot to estimate stall speed. (float)
+                groundspeed               : Current ground speed. (float)
+                heading                   : Current heading in compass units (0-360, 0=north). (int16_t)
+                throttle                  : Current throttle setting (0 to 100). (uint16_t)
+                alt                       : Current altitude (MSL). (float)
+                climb                     : Current climb rate. (float)
+
+*/
+    mavlink20.messages.vfr_hud = function( ...moreargs ) {
+    [ this.airspeed , this.groundspeed , this.heading , this.throttle , this.alt , this.climb ] = moreargs;
+
+    this._format = '<ffffhH';
+    this._id = mavlink20.MAVLINK_MSG_ID_VFR_HUD;
+    this.order_map = [0, 1, 4, 5, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 20;
+    this._name = 'VFR_HUD';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['airspeed', 'groundspeed', 'heading', 'throttle', 'alt', 'climb'];
+
+}
+
+mavlink20.messages.vfr_hud.prototype = new mavlink20.message;
+mavlink20.messages.vfr_hud.prototype.pack = function(mav) {
+    var orderedfields = [ this.airspeed, this.groundspeed, this.alt, this.climb, this.heading, this.throttle];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message encoding a command with parameters as scaled integers. Scaling
+depends on the actual command value. The command microservice is
+documented at https://mavlink.io/en/services/command.html
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                frame                     : The coordinate system of the COMMAND. (uint8_t)
+                command                   : The scheduled action for the mission item. (uint16_t)
+                current                   : Not used. (uint8_t)
+                autocontinue              : Not used (set 0). (uint8_t)
+                param1                    : PARAM1, see MAV_CMD enum (float)
+                param2                    : PARAM2, see MAV_CMD enum (float)
+                param3                    : PARAM3, see MAV_CMD enum (float)
+                param4                    : PARAM4, see MAV_CMD enum (float)
+                x                         : PARAM5 / local: x position in meters * 1e4, global: latitude in degrees * 10^7 (int32_t)
+                y                         : PARAM6 / local: y position in meters * 1e4, global: longitude in degrees * 10^7 (int32_t)
+                z                         : PARAM7 / z position: global: altitude in meters (relative or absolute, depending on frame). (float)
+
+*/
+    mavlink20.messages.command_int = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.frame , this.command , this.current , this.autocontinue , this.param1 , this.param2 , this.param3 , this.param4 , this.x , this.y , this.z ] = moreargs;
+
+    this._format = '<ffffiifHBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_COMMAND_INT;
+    this.order_map = [8, 9, 10, 7, 11, 12, 0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 158;
+    this._name = 'COMMAND_INT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'frame', 'command', 'current', 'autocontinue', 'param1', 'param2', 'param3', 'param4', 'x', 'y', 'z'];
+
+}
+
+mavlink20.messages.command_int.prototype = new mavlink20.message;
+mavlink20.messages.command_int.prototype.pack = function(mav) {
+    var orderedfields = [ this.param1, this.param2, this.param3, this.param4, this.x, this.y, this.z, this.command, this.target_system, this.target_component, this.frame, this.current, this.autocontinue];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send a command with up to seven parameters to the MAV. The command
+microservice is documented at
+https://mavlink.io/en/services/command.html
+
+                target_system             : System which should execute the command (uint8_t)
+                target_component          : Component which should execute the command, 0 for all components (uint8_t)
+                command                   : Command ID (of command to send). (uint16_t)
+                confirmation              : 0: First transmission of this command. 1-255: Confirmation transmissions (e.g. for kill command) (uint8_t)
+                param1                    : Parameter 1 (for the specific command). (float)
+                param2                    : Parameter 2 (for the specific command). (float)
+                param3                    : Parameter 3 (for the specific command). (float)
+                param4                    : Parameter 4 (for the specific command). (float)
+                param5                    : Parameter 5 (for the specific command). (float)
+                param6                    : Parameter 6 (for the specific command). (float)
+                param7                    : Parameter 7 (for the specific command). (float)
+
+*/
+    mavlink20.messages.command_long = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.command , this.confirmation , this.param1 , this.param2 , this.param3 , this.param4 , this.param5 , this.param6 , this.param7 ] = moreargs;
+
+    this._format = '<fffffffHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_COMMAND_LONG;
+    this.order_map = [8, 9, 7, 10, 0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 152;
+    this._name = 'COMMAND_LONG';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'command', 'confirmation', 'param1', 'param2', 'param3', 'param4', 'param5', 'param6', 'param7'];
+
+}
+
+mavlink20.messages.command_long.prototype = new mavlink20.message;
+mavlink20.messages.command_long.prototype.pack = function(mav) {
+    var orderedfields = [ this.param1, this.param2, this.param3, this.param4, this.param5, this.param6, this.param7, this.command, this.target_system, this.target_component, this.confirmation];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Report status of a command. Includes feedback whether the command was
+executed. The command microservice is documented at
+https://mavlink.io/en/services/command.html
+
+                command                   : Command ID (of acknowledged command). (uint16_t)
+                result                    : Result of command. (uint8_t)
+                progress                  : Also used as result_param1, it can be set with a enum containing the errors reasons of why the command was denied or the progress percentage or 255 if unknown the progress when result is MAV_RESULT_IN_PROGRESS. (uint8_t)
+                result_param2             : Additional parameter of the result, example: which parameter of MAV_CMD_NAV_WAYPOINT caused it to be denied. (int32_t)
+                target_system             : System which requested the command to be executed (uint8_t)
+                target_component          : Component which requested the command to be executed (uint8_t)
+
+*/
+    mavlink20.messages.command_ack = function( ...moreargs ) {
+    [ this.command , this.result , this.progress , this.result_param2 , this.target_system , this.target_component ] = moreargs;
+
+    this._format = '<HBBiBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_COMMAND_ACK;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 143;
+    this._name = 'COMMAND_ACK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['command', 'result', 'progress', 'result_param2', 'target_system', 'target_component'];
+
+}
+
+mavlink20.messages.command_ack.prototype = new mavlink20.message;
+mavlink20.messages.command_ack.prototype.pack = function(mav) {
+    var orderedfields = [ this.command, this.result, this.progress, this.result_param2, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Setpoint in roll, pitch, yaw and thrust from the operator
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                roll                      : Desired roll rate (float)
+                pitch                     : Desired pitch rate (float)
+                yaw                       : Desired yaw rate (float)
+                thrust                    : Collective thrust, normalized to 0 .. 1 (float)
+                mode_switch               : Flight mode switch position, 0.. 255 (uint8_t)
+                manual_override_switch        : Override mode switch position, 0.. 255 (uint8_t)
+
+*/
+    mavlink20.messages.manual_setpoint = function( ...moreargs ) {
+    [ this.time_boot_ms , this.roll , this.pitch , this.yaw , this.thrust , this.mode_switch , this.manual_override_switch ] = moreargs;
+
+    this._format = '<IffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MANUAL_SETPOINT;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 106;
+    this._name = 'MANUAL_SETPOINT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'roll', 'pitch', 'yaw', 'thrust', 'mode_switch', 'manual_override_switch'];
+
+}
+
+mavlink20.messages.manual_setpoint.prototype = new mavlink20.message;
+mavlink20.messages.manual_setpoint.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.roll, this.pitch, this.yaw, this.thrust, this.mode_switch, this.manual_override_switch];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sets a desired vehicle attitude. Used by an external controller to
+command the vehicle (manual controller or other system).
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                type_mask                 : Bitmap to indicate which dimensions should be ignored by the vehicle. (uint8_t)
+                q                         : Attitude quaternion (w, x, y, z order, zero-rotation is 1, 0, 0, 0) (float)
+                body_roll_rate            : Body roll rate (float)
+                body_pitch_rate           : Body pitch rate (float)
+                body_yaw_rate             : Body yaw rate (float)
+                thrust                    : Collective thrust, normalized to 0 .. 1 (-1 .. 1 for vehicles capable of reverse trust) (float)
+
+*/
+    mavlink20.messages.set_attitude_target = function( ...moreargs ) {
+    [ this.time_boot_ms , this.target_system , this.target_component , this.type_mask , this.q , this.body_roll_rate , this.body_pitch_rate , this.body_yaw_rate , this.thrust ] = moreargs;
+
+    this._format = '<I4fffffBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SET_ATTITUDE_TARGET;
+    this.order_map = [0, 6, 7, 8, 1, 2, 3, 4, 5];
+    this.len_map = [1, 4, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 4, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 49;
+    this._name = 'SET_ATTITUDE_TARGET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'target_system', 'target_component', 'type_mask', 'q', 'body_roll_rate', 'body_pitch_rate', 'body_yaw_rate', 'thrust'];
+
+}
+
+mavlink20.messages.set_attitude_target.prototype = new mavlink20.message;
+mavlink20.messages.set_attitude_target.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.q, this.body_roll_rate, this.body_pitch_rate, this.body_yaw_rate, this.thrust, this.target_system, this.target_component, this.type_mask];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reports the current commanded attitude of the vehicle as specified by
+the autopilot. This should match the commands sent in a
+SET_ATTITUDE_TARGET message if the vehicle is being controlled this
+way.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                type_mask                 : Bitmap to indicate which dimensions should be ignored by the vehicle. (uint8_t)
+                q                         : Attitude quaternion (w, x, y, z order, zero-rotation is 1, 0, 0, 0) (float)
+                body_roll_rate            : Body roll rate (float)
+                body_pitch_rate           : Body pitch rate (float)
+                body_yaw_rate             : Body yaw rate (float)
+                thrust                    : Collective thrust, normalized to 0 .. 1 (-1 .. 1 for vehicles capable of reverse trust) (float)
+
+*/
+    mavlink20.messages.attitude_target = function( ...moreargs ) {
+    [ this.time_boot_ms , this.type_mask , this.q , this.body_roll_rate , this.body_pitch_rate , this.body_yaw_rate , this.thrust ] = moreargs;
+
+    this._format = '<I4fffffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ATTITUDE_TARGET;
+    this.order_map = [0, 6, 1, 2, 3, 4, 5];
+    this.len_map = [1, 4, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 4, 0, 0, 0, 0, 0];
+    this.crc_extra = 22;
+    this._name = 'ATTITUDE_TARGET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'type_mask', 'q', 'body_roll_rate', 'body_pitch_rate', 'body_yaw_rate', 'thrust'];
+
+}
+
+mavlink20.messages.attitude_target.prototype = new mavlink20.message;
+mavlink20.messages.attitude_target.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.q, this.body_roll_rate, this.body_pitch_rate, this.body_yaw_rate, this.thrust, this.type_mask];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sets a desired vehicle position in a local north-east-down coordinate
+frame. Used by an external controller to command the vehicle (manual
+controller or other system).
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                coordinate_frame          : Valid options are: MAV_FRAME_LOCAL_NED = 1, MAV_FRAME_LOCAL_OFFSET_NED = 7, MAV_FRAME_BODY_NED = 8, MAV_FRAME_BODY_OFFSET_NED = 9 (uint8_t)
+                type_mask                 : Bitmap to indicate which dimensions should be ignored by the vehicle. (uint16_t)
+                x                         : X Position in NED frame (float)
+                y                         : Y Position in NED frame (float)
+                z                         : Z Position in NED frame (note, altitude is negative in NED) (float)
+                vx                        : X velocity in NED frame (float)
+                vy                        : Y velocity in NED frame (float)
+                vz                        : Z velocity in NED frame (float)
+                afx                       : X acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                afy                       : Y acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                afz                       : Z acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                yaw                       : yaw setpoint (float)
+                yaw_rate                  : yaw rate setpoint (float)
+
+*/
+    mavlink20.messages.set_position_target_local_ned = function( ...moreargs ) {
+    [ this.time_boot_ms , this.target_system , this.target_component , this.coordinate_frame , this.type_mask , this.x , this.y , this.z , this.vx , this.vy , this.vz , this.afx , this.afy , this.afz , this.yaw , this.yaw_rate ] = moreargs;
+
+    this._format = '<IfffffffffffHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SET_POSITION_TARGET_LOCAL_NED;
+    this.order_map = [0, 13, 14, 15, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 143;
+    this._name = 'SET_POSITION_TARGET_LOCAL_NED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'target_system', 'target_component', 'coordinate_frame', 'type_mask', 'x', 'y', 'z', 'vx', 'vy', 'vz', 'afx', 'afy', 'afz', 'yaw', 'yaw_rate'];
+
+}
+
+mavlink20.messages.set_position_target_local_ned.prototype = new mavlink20.message;
+mavlink20.messages.set_position_target_local_ned.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.x, this.y, this.z, this.vx, this.vy, this.vz, this.afx, this.afy, this.afz, this.yaw, this.yaw_rate, this.type_mask, this.target_system, this.target_component, this.coordinate_frame];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reports the current commanded vehicle position, velocity, and
+acceleration as specified by the autopilot. This should match the
+commands sent in SET_POSITION_TARGET_LOCAL_NED if the vehicle is being
+controlled this way.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                coordinate_frame          : Valid options are: MAV_FRAME_LOCAL_NED = 1, MAV_FRAME_LOCAL_OFFSET_NED = 7, MAV_FRAME_BODY_NED = 8, MAV_FRAME_BODY_OFFSET_NED = 9 (uint8_t)
+                type_mask                 : Bitmap to indicate which dimensions should be ignored by the vehicle. (uint16_t)
+                x                         : X Position in NED frame (float)
+                y                         : Y Position in NED frame (float)
+                z                         : Z Position in NED frame (note, altitude is negative in NED) (float)
+                vx                        : X velocity in NED frame (float)
+                vy                        : Y velocity in NED frame (float)
+                vz                        : Z velocity in NED frame (float)
+                afx                       : X acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                afy                       : Y acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                afz                       : Z acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                yaw                       : yaw setpoint (float)
+                yaw_rate                  : yaw rate setpoint (float)
+
+*/
+    mavlink20.messages.position_target_local_ned = function( ...moreargs ) {
+    [ this.time_boot_ms , this.coordinate_frame , this.type_mask , this.x , this.y , this.z , this.vx , this.vy , this.vz , this.afx , this.afy , this.afz , this.yaw , this.yaw_rate ] = moreargs;
+
+    this._format = '<IfffffffffffHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_POSITION_TARGET_LOCAL_NED;
+    this.order_map = [0, 13, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 140;
+    this._name = 'POSITION_TARGET_LOCAL_NED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'coordinate_frame', 'type_mask', 'x', 'y', 'z', 'vx', 'vy', 'vz', 'afx', 'afy', 'afz', 'yaw', 'yaw_rate'];
+
+}
+
+mavlink20.messages.position_target_local_ned.prototype = new mavlink20.message;
+mavlink20.messages.position_target_local_ned.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.x, this.y, this.z, this.vx, this.vy, this.vz, this.afx, this.afy, this.afz, this.yaw, this.yaw_rate, this.type_mask, this.coordinate_frame];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sets a desired vehicle position, velocity, and/or acceleration in a
+global coordinate system (WGS84). Used by an external controller to
+command the vehicle (manual controller or other system).
+
+                time_boot_ms              : Timestamp (time since system boot). The rationale for the timestamp in the setpoint is to allow the system to compensate for the transport delay of the setpoint. This allows the system to compensate processing latency. (uint32_t)
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                coordinate_frame          : Valid options are: MAV_FRAME_GLOBAL = 0, MAV_FRAME_GLOBAL_RELATIVE_ALT = 3, MAV_FRAME_GLOBAL_TERRAIN_ALT = 10 (MAV_FRAME_GLOBAL_INT, MAV_FRAME_GLOBAL_RELATIVE_ALT_INT, MAV_FRAME_GLOBAL_TERRAIN_ALT_INT are allowed synonyms, but have been deprecated) (uint8_t)
+                type_mask                 : Bitmap to indicate which dimensions should be ignored by the vehicle. (uint16_t)
+                lat_int                   : Latitude in WGS84 frame (int32_t)
+                lon_int                   : Longitude in WGS84 frame (int32_t)
+                alt                       : Altitude (MSL, Relative to home, or AGL - depending on frame) (float)
+                vx                        : X velocity in NED frame (float)
+                vy                        : Y velocity in NED frame (float)
+                vz                        : Z velocity in NED frame (float)
+                afx                       : X acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                afy                       : Y acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                afz                       : Z acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                yaw                       : yaw setpoint (float)
+                yaw_rate                  : yaw rate setpoint (float)
+
+*/
+    mavlink20.messages.set_position_target_global_int = function( ...moreargs ) {
+    [ this.time_boot_ms , this.target_system , this.target_component , this.coordinate_frame , this.type_mask , this.lat_int , this.lon_int , this.alt , this.vx , this.vy , this.vz , this.afx , this.afy , this.afz , this.yaw , this.yaw_rate ] = moreargs;
+
+    this._format = '<IiifffffffffHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SET_POSITION_TARGET_GLOBAL_INT;
+    this.order_map = [0, 13, 14, 15, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 5;
+    this._name = 'SET_POSITION_TARGET_GLOBAL_INT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'target_system', 'target_component', 'coordinate_frame', 'type_mask', 'lat_int', 'lon_int', 'alt', 'vx', 'vy', 'vz', 'afx', 'afy', 'afz', 'yaw', 'yaw_rate'];
+
+}
+
+mavlink20.messages.set_position_target_global_int.prototype = new mavlink20.message;
+mavlink20.messages.set_position_target_global_int.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.lat_int, this.lon_int, this.alt, this.vx, this.vy, this.vz, this.afx, this.afy, this.afz, this.yaw, this.yaw_rate, this.type_mask, this.target_system, this.target_component, this.coordinate_frame];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reports the current commanded vehicle position, velocity, and
+acceleration as specified by the autopilot. This should match the
+commands sent in SET_POSITION_TARGET_GLOBAL_INT if the vehicle is
+being controlled this way.
+
+                time_boot_ms              : Timestamp (time since system boot). The rationale for the timestamp in the setpoint is to allow the system to compensate for the transport delay of the setpoint. This allows the system to compensate processing latency. (uint32_t)
+                coordinate_frame          : Valid options are: MAV_FRAME_GLOBAL = 0, MAV_FRAME_GLOBAL_RELATIVE_ALT = 3, MAV_FRAME_GLOBAL_TERRAIN_ALT = 10 (MAV_FRAME_GLOBAL_INT, MAV_FRAME_GLOBAL_RELATIVE_ALT_INT, MAV_FRAME_GLOBAL_TERRAIN_ALT_INT are allowed synonyms, but have been deprecated) (uint8_t)
+                type_mask                 : Bitmap to indicate which dimensions should be ignored by the vehicle. (uint16_t)
+                lat_int                   : Latitude in WGS84 frame (int32_t)
+                lon_int                   : Longitude in WGS84 frame (int32_t)
+                alt                       : Altitude (MSL, AGL or relative to home altitude, depending on frame) (float)
+                vx                        : X velocity in NED frame (float)
+                vy                        : Y velocity in NED frame (float)
+                vz                        : Z velocity in NED frame (float)
+                afx                       : X acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                afy                       : Y acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                afz                       : Z acceleration or force (if bit 10 of type_mask is set) in NED frame in meter / s^2 or N (float)
+                yaw                       : yaw setpoint (float)
+                yaw_rate                  : yaw rate setpoint (float)
+
+*/
+    mavlink20.messages.position_target_global_int = function( ...moreargs ) {
+    [ this.time_boot_ms , this.coordinate_frame , this.type_mask , this.lat_int , this.lon_int , this.alt , this.vx , this.vy , this.vz , this.afx , this.afy , this.afz , this.yaw , this.yaw_rate ] = moreargs;
+
+    this._format = '<IiifffffffffHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_POSITION_TARGET_GLOBAL_INT;
+    this.order_map = [0, 13, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 150;
+    this._name = 'POSITION_TARGET_GLOBAL_INT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'coordinate_frame', 'type_mask', 'lat_int', 'lon_int', 'alt', 'vx', 'vy', 'vz', 'afx', 'afy', 'afz', 'yaw', 'yaw_rate'];
+
+}
+
+mavlink20.messages.position_target_global_int.prototype = new mavlink20.message;
+mavlink20.messages.position_target_global_int.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.lat_int, this.lon_int, this.alt, this.vx, this.vy, this.vz, this.afx, this.afy, this.afz, this.yaw, this.yaw_rate, this.type_mask, this.coordinate_frame];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The offset in X, Y, Z and yaw between the LOCAL_POSITION_NED messages
+of MAV X and the global coordinate frame in NED coordinates.
+Coordinate frame is right-handed, Z-axis down (aeronautical frame, NED
+/ north-east-down convention)
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                x                         : X Position (float)
+                y                         : Y Position (float)
+                z                         : Z Position (float)
+                roll                      : Roll (float)
+                pitch                     : Pitch (float)
+                yaw                       : Yaw (float)
+
+*/
+    mavlink20.messages.local_position_ned_system_global_offset = function( ...moreargs ) {
+    [ this.time_boot_ms , this.x , this.y , this.z , this.roll , this.pitch , this.yaw ] = moreargs;
+
+    this._format = '<Iffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOCAL_POSITION_NED_SYSTEM_GLOBAL_OFFSET;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 231;
+    this._name = 'LOCAL_POSITION_NED_SYSTEM_GLOBAL_OFFSET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'x', 'y', 'z', 'roll', 'pitch', 'yaw'];
+
+}
+
+mavlink20.messages.local_position_ned_system_global_offset.prototype = new mavlink20.message;
+mavlink20.messages.local_position_ned_system_global_offset.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.x, this.y, this.z, this.roll, this.pitch, this.yaw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sent from simulation to autopilot. This packet is useful for high
+throughput applications such as hardware in the loop simulations.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                roll                      : Roll angle (float)
+                pitch                     : Pitch angle (float)
+                yaw                       : Yaw angle (float)
+                rollspeed                 : Body frame roll / phi angular speed (float)
+                pitchspeed                : Body frame pitch / theta angular speed (float)
+                yawspeed                  : Body frame yaw / psi angular speed (float)
+                lat                       : Latitude (int32_t)
+                lon                       : Longitude (int32_t)
+                alt                       : Altitude (int32_t)
+                vx                        : Ground X Speed (Latitude) (int16_t)
+                vy                        : Ground Y Speed (Longitude) (int16_t)
+                vz                        : Ground Z Speed (Altitude) (int16_t)
+                xacc                      : X acceleration (int16_t)
+                yacc                      : Y acceleration (int16_t)
+                zacc                      : Z acceleration (int16_t)
+
+*/
+    mavlink20.messages.hil_state = function( ...moreargs ) {
+    [ this.time_usec , this.roll , this.pitch , this.yaw , this.rollspeed , this.pitchspeed , this.yawspeed , this.lat , this.lon , this.alt , this.vx , this.vy , this.vz , this.xacc , this.yacc , this.zacc ] = moreargs;
+
+    this._format = '<Qffffffiiihhhhhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIL_STATE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 183;
+    this._name = 'HIL_STATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'roll', 'pitch', 'yaw', 'rollspeed', 'pitchspeed', 'yawspeed', 'lat', 'lon', 'alt', 'vx', 'vy', 'vz', 'xacc', 'yacc', 'zacc'];
+
+}
+
+mavlink20.messages.hil_state.prototype = new mavlink20.message;
+mavlink20.messages.hil_state.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.roll, this.pitch, this.yaw, this.rollspeed, this.pitchspeed, this.yawspeed, this.lat, this.lon, this.alt, this.vx, this.vy, this.vz, this.xacc, this.yacc, this.zacc];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sent from autopilot to simulation. Hardware in the loop control
+outputs
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                roll_ailerons             : Control output -1 .. 1 (float)
+                pitch_elevator            : Control output -1 .. 1 (float)
+                yaw_rudder                : Control output -1 .. 1 (float)
+                throttle                  : Throttle 0 .. 1 (float)
+                aux1                      : Aux 1, -1 .. 1 (float)
+                aux2                      : Aux 2, -1 .. 1 (float)
+                aux3                      : Aux 3, -1 .. 1 (float)
+                aux4                      : Aux 4, -1 .. 1 (float)
+                mode                      : System mode. (uint8_t)
+                nav_mode                  : Navigation mode (MAV_NAV_MODE) (uint8_t)
+
+*/
+    mavlink20.messages.hil_controls = function( ...moreargs ) {
+    [ this.time_usec , this.roll_ailerons , this.pitch_elevator , this.yaw_rudder , this.throttle , this.aux1 , this.aux2 , this.aux3 , this.aux4 , this.mode , this.nav_mode ] = moreargs;
+
+    this._format = '<QffffffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIL_CONTROLS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 63;
+    this._name = 'HIL_CONTROLS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'roll_ailerons', 'pitch_elevator', 'yaw_rudder', 'throttle', 'aux1', 'aux2', 'aux3', 'aux4', 'mode', 'nav_mode'];
+
+}
+
+mavlink20.messages.hil_controls.prototype = new mavlink20.message;
+mavlink20.messages.hil_controls.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.roll_ailerons, this.pitch_elevator, this.yaw_rudder, this.throttle, this.aux1, this.aux2, this.aux3, this.aux4, this.mode, this.nav_mode];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sent from simulation to autopilot. The RAW values of the RC channels
+received. The standard PPM modulation is as follows: 1000
+microseconds: 0%, 2000 microseconds: 100%. Individual
+receivers/transmitters might violate this specification.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                chan1_raw                 : RC channel 1 value (uint16_t)
+                chan2_raw                 : RC channel 2 value (uint16_t)
+                chan3_raw                 : RC channel 3 value (uint16_t)
+                chan4_raw                 : RC channel 4 value (uint16_t)
+                chan5_raw                 : RC channel 5 value (uint16_t)
+                chan6_raw                 : RC channel 6 value (uint16_t)
+                chan7_raw                 : RC channel 7 value (uint16_t)
+                chan8_raw                 : RC channel 8 value (uint16_t)
+                chan9_raw                 : RC channel 9 value (uint16_t)
+                chan10_raw                : RC channel 10 value (uint16_t)
+                chan11_raw                : RC channel 11 value (uint16_t)
+                chan12_raw                : RC channel 12 value (uint16_t)
+                rssi                      : Receive signal strength indicator in device-dependent units/scale. Values: [0-254], UINT8_MAX: invalid/unknown. (uint8_t)
+
+*/
+    mavlink20.messages.hil_rc_inputs_raw = function( ...moreargs ) {
+    [ this.time_usec , this.chan1_raw , this.chan2_raw , this.chan3_raw , this.chan4_raw , this.chan5_raw , this.chan6_raw , this.chan7_raw , this.chan8_raw , this.chan9_raw , this.chan10_raw , this.chan11_raw , this.chan12_raw , this.rssi ] = moreargs;
+
+    this._format = '<QHHHHHHHHHHHHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIL_RC_INPUTS_RAW;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 54;
+    this._name = 'HIL_RC_INPUTS_RAW';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'chan1_raw', 'chan2_raw', 'chan3_raw', 'chan4_raw', 'chan5_raw', 'chan6_raw', 'chan7_raw', 'chan8_raw', 'chan9_raw', 'chan10_raw', 'chan11_raw', 'chan12_raw', 'rssi'];
+
+}
+
+mavlink20.messages.hil_rc_inputs_raw.prototype = new mavlink20.message;
+mavlink20.messages.hil_rc_inputs_raw.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.chan1_raw, this.chan2_raw, this.chan3_raw, this.chan4_raw, this.chan5_raw, this.chan6_raw, this.chan7_raw, this.chan8_raw, this.chan9_raw, this.chan10_raw, this.chan11_raw, this.chan12_raw, this.rssi];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sent from autopilot to simulation. Hardware in the loop control
+outputs (replacement for HIL_CONTROLS)
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                controls                  : Control outputs -1 .. 1. Channel assignment depends on the simulated hardware. (float)
+                mode                      : System mode. Includes arming state. (uint8_t)
+                flags                     : Flags as bitfield, 1: indicate simulation using lockstep. (uint64_t)
+
+*/
+    mavlink20.messages.hil_actuator_controls = function( ...moreargs ) {
+    [ this.time_usec , this.controls , this.mode , this.flags ] = moreargs;
+
+    this._format = '<QQ16fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIL_ACTUATOR_CONTROLS;
+    this.order_map = [0, 2, 3, 1];
+    this.len_map = [1, 1, 16, 1];
+    this.array_len_map = [0, 0, 16, 0];
+    this.crc_extra = 47;
+    this._name = 'HIL_ACTUATOR_CONTROLS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'controls', 'mode', 'flags'];
+
+}
+
+mavlink20.messages.hil_actuator_controls.prototype = new mavlink20.message;
+mavlink20.messages.hil_actuator_controls.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.flags, this.controls, this.mode];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Optical flow from a flow sensor (e.g. optical mouse sensor)
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                sensor_id                 : Sensor ID (uint8_t)
+                flow_x                    : Flow rate around X-axis (deprecated; use flow_rate_x) (int16_t)
+                flow_y                    : Flow rate around Y-axis (deprecated; use flow_rate_y) (int16_t)
+                flow_comp_m_x             : Flow in x-sensor direction, angular-speed compensated (float)
+                flow_comp_m_y             : Flow in y-sensor direction, angular-speed compensated (float)
+                quality                   : Optical flow quality / confidence. 0: bad, 255: maximum quality (uint8_t)
+                ground_distance           : Ground distance. Positive value: distance known. Negative value: Unknown distance (float)
+                flow_rate_x               : Flow rate about X axis (float)
+                flow_rate_y               : Flow rate about Y axis (float)
+
+*/
+    mavlink20.messages.optical_flow = function( ...moreargs ) {
+    [ this.time_usec , this.sensor_id , this.flow_x , this.flow_y , this.flow_comp_m_x , this.flow_comp_m_y , this.quality , this.ground_distance , this.flow_rate_x , this.flow_rate_y ] = moreargs;
+
+    this._format = '<QfffhhBBff';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPTICAL_FLOW;
+    this.order_map = [0, 6, 4, 5, 1, 2, 7, 3, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 175;
+    this._name = 'OPTICAL_FLOW';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'sensor_id', 'flow_x', 'flow_y', 'flow_comp_m_x', 'flow_comp_m_y', 'quality', 'ground_distance', 'flow_rate_x', 'flow_rate_y'];
+
+}
+
+mavlink20.messages.optical_flow.prototype = new mavlink20.message;
+mavlink20.messages.optical_flow.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.flow_comp_m_x, this.flow_comp_m_y, this.ground_distance, this.flow_x, this.flow_y, this.sensor_id, this.quality, this.flow_rate_x, this.flow_rate_y];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Global position/attitude estimate from a vision source.
+
+                usec                      : Timestamp (UNIX time or since system boot) (uint64_t)
+                x                         : Global X position (float)
+                y                         : Global Y position (float)
+                z                         : Global Z position (float)
+                roll                      : Roll angle (float)
+                pitch                     : Pitch angle (float)
+                yaw                       : Yaw angle (float)
+                covariance                : Row-major representation of pose 6x6 cross-covariance matrix upper right triangle (states: x_global, y_global, z_global, roll, pitch, yaw; first six entries are the first ROW, next five entries are the second ROW, etc.). If unknown, assign NaN value to first element in the array. (float)
+                reset_counter             : Estimate reset counter. This should be incremented when the estimate resets in any of the dimensions (position, velocity, attitude, angular speed). This is designed to be used when e.g an external SLAM system detects a loop-closure and the estimate jumps. (uint8_t)
+
+*/
+    mavlink20.messages.global_vision_position_estimate = function( ...moreargs ) {
+    [ this.usec , this.x , this.y , this.z , this.roll , this.pitch , this.yaw , this.covariance , this.reset_counter ] = moreargs;
+
+    this._format = '<Qffffff21fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GLOBAL_VISION_POSITION_ESTIMATE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 21, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 21, 0];
+    this.crc_extra = 102;
+    this._name = 'GLOBAL_VISION_POSITION_ESTIMATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['usec', 'x', 'y', 'z', 'roll', 'pitch', 'yaw', 'covariance', 'reset_counter'];
+
+}
+
+mavlink20.messages.global_vision_position_estimate.prototype = new mavlink20.message;
+mavlink20.messages.global_vision_position_estimate.prototype.pack = function(mav) {
+    var orderedfields = [ this.usec, this.x, this.y, this.z, this.roll, this.pitch, this.yaw, this.covariance, this.reset_counter];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Local position/attitude estimate from a vision source.
+
+                usec                      : Timestamp (UNIX time or time since system boot) (uint64_t)
+                x                         : Local X position (float)
+                y                         : Local Y position (float)
+                z                         : Local Z position (float)
+                roll                      : Roll angle (float)
+                pitch                     : Pitch angle (float)
+                yaw                       : Yaw angle (float)
+                covariance                : Row-major representation of pose 6x6 cross-covariance matrix upper right triangle (states: x, y, z, roll, pitch, yaw; first six entries are the first ROW, next five entries are the second ROW, etc.). If unknown, assign NaN value to first element in the array. (float)
+                reset_counter             : Estimate reset counter. This should be incremented when the estimate resets in any of the dimensions (position, velocity, attitude, angular speed). This is designed to be used when e.g an external SLAM system detects a loop-closure and the estimate jumps. (uint8_t)
+
+*/
+    mavlink20.messages.vision_position_estimate = function( ...moreargs ) {
+    [ this.usec , this.x , this.y , this.z , this.roll , this.pitch , this.yaw , this.covariance , this.reset_counter ] = moreargs;
+
+    this._format = '<Qffffff21fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_VISION_POSITION_ESTIMATE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 21, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 21, 0];
+    this.crc_extra = 158;
+    this._name = 'VISION_POSITION_ESTIMATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['usec', 'x', 'y', 'z', 'roll', 'pitch', 'yaw', 'covariance', 'reset_counter'];
+
+}
+
+mavlink20.messages.vision_position_estimate.prototype = new mavlink20.message;
+mavlink20.messages.vision_position_estimate.prototype.pack = function(mav) {
+    var orderedfields = [ this.usec, this.x, this.y, this.z, this.roll, this.pitch, this.yaw, this.covariance, this.reset_counter];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Speed estimate from a vision source.
+
+                usec                      : Timestamp (UNIX time or time since system boot) (uint64_t)
+                x                         : Global X speed (float)
+                y                         : Global Y speed (float)
+                z                         : Global Z speed (float)
+                covariance                : Row-major representation of 3x3 linear velocity covariance matrix (states: vx, vy, vz; 1st three entries - 1st row, etc.). If unknown, assign NaN value to first element in the array. (float)
+                reset_counter             : Estimate reset counter. This should be incremented when the estimate resets in any of the dimensions (position, velocity, attitude, angular speed). This is designed to be used when e.g an external SLAM system detects a loop-closure and the estimate jumps. (uint8_t)
+
+*/
+    mavlink20.messages.vision_speed_estimate = function( ...moreargs ) {
+    [ this.usec , this.x , this.y , this.z , this.covariance , this.reset_counter ] = moreargs;
+
+    this._format = '<Qfff9fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_VISION_SPEED_ESTIMATE;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 9, 1];
+    this.array_len_map = [0, 0, 0, 0, 9, 0];
+    this.crc_extra = 208;
+    this._name = 'VISION_SPEED_ESTIMATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['usec', 'x', 'y', 'z', 'covariance', 'reset_counter'];
+
+}
+
+mavlink20.messages.vision_speed_estimate.prototype = new mavlink20.message;
+mavlink20.messages.vision_speed_estimate.prototype.pack = function(mav) {
+    var orderedfields = [ this.usec, this.x, this.y, this.z, this.covariance, this.reset_counter];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Global position estimate from a Vicon motion system source.
+
+                usec                      : Timestamp (UNIX time or time since system boot) (uint64_t)
+                x                         : Global X position (float)
+                y                         : Global Y position (float)
+                z                         : Global Z position (float)
+                roll                      : Roll angle (float)
+                pitch                     : Pitch angle (float)
+                yaw                       : Yaw angle (float)
+                covariance                : Row-major representation of 6x6 pose cross-covariance matrix upper right triangle (states: x, y, z, roll, pitch, yaw; first six entries are the first ROW, next five entries are the second ROW, etc.). If unknown, assign NaN value to first element in the array. (float)
+
+*/
+    mavlink20.messages.vicon_position_estimate = function( ...moreargs ) {
+    [ this.usec , this.x , this.y , this.z , this.roll , this.pitch , this.yaw , this.covariance ] = moreargs;
+
+    this._format = '<Qffffff21f';
+    this._id = mavlink20.MAVLINK_MSG_ID_VICON_POSITION_ESTIMATE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 21];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 21];
+    this.crc_extra = 56;
+    this._name = 'VICON_POSITION_ESTIMATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['usec', 'x', 'y', 'z', 'roll', 'pitch', 'yaw', 'covariance'];
+
+}
+
+mavlink20.messages.vicon_position_estimate.prototype = new mavlink20.message;
+mavlink20.messages.vicon_position_estimate.prototype.pack = function(mav) {
+    var orderedfields = [ this.usec, this.x, this.y, this.z, this.roll, this.pitch, this.yaw, this.covariance];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The IMU readings in SI units in NED body frame
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                xacc                      : X acceleration (float)
+                yacc                      : Y acceleration (float)
+                zacc                      : Z acceleration (float)
+                xgyro                     : Angular speed around X axis (float)
+                ygyro                     : Angular speed around Y axis (float)
+                zgyro                     : Angular speed around Z axis (float)
+                xmag                      : X Magnetic field (float)
+                ymag                      : Y Magnetic field (float)
+                zmag                      : Z Magnetic field (float)
+                abs_pressure              : Absolute pressure (float)
+                diff_pressure             : Differential pressure (float)
+                pressure_alt              : Altitude calculated from pressure (float)
+                temperature               : Temperature (float)
+                fields_updated            : Bitmap for fields that have updated since last message, bit 0 = xacc, bit 12: temperature (uint16_t)
+                id                        : Id. Ids are numbered from 0 and map to IMUs numbered from 1 (e.g. IMU1 will have a message with id=0) (uint8_t)
+
+*/
+    mavlink20.messages.highres_imu = function( ...moreargs ) {
+    [ this.time_usec , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro , this.xmag , this.ymag , this.zmag , this.abs_pressure , this.diff_pressure , this.pressure_alt , this.temperature , this.fields_updated , this.id ] = moreargs;
+
+    this._format = '<QfffffffffffffHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIGHRES_IMU;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 93;
+    this._name = 'HIGHRES_IMU';
+
+    this._instance_field = 'id';
+    this._instance_offset = 62;
+
+    this.fieldnames = ['time_usec', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro', 'xmag', 'ymag', 'zmag', 'abs_pressure', 'diff_pressure', 'pressure_alt', 'temperature', 'fields_updated', 'id'];
+
+}
+
+mavlink20.messages.highres_imu.prototype = new mavlink20.message;
+mavlink20.messages.highres_imu.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro, this.xmag, this.ymag, this.zmag, this.abs_pressure, this.diff_pressure, this.pressure_alt, this.temperature, this.fields_updated, this.id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Optical flow from an angular rate flow sensor (e.g. PX4FLOW or mouse
+sensor)
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                sensor_id                 : Sensor ID (uint8_t)
+                integration_time_us        : Integration time. Divide integrated_x and integrated_y by the integration time to obtain average flow. The integration time also indicates the. (uint32_t)
+                integrated_x              : Flow around X axis (Sensor RH rotation about the X axis induces a positive flow. Sensor linear motion along the positive Y axis induces a negative flow.) (float)
+                integrated_y              : Flow around Y axis (Sensor RH rotation about the Y axis induces a positive flow. Sensor linear motion along the positive X axis induces a positive flow.) (float)
+                integrated_xgyro          : RH rotation around X axis (float)
+                integrated_ygyro          : RH rotation around Y axis (float)
+                integrated_zgyro          : RH rotation around Z axis (float)
+                temperature               : Temperature (int16_t)
+                quality                   : Optical flow quality / confidence. 0: no valid flow, 255: maximum quality (uint8_t)
+                time_delta_distance_us        : Time since the distance was sampled. (uint32_t)
+                distance                  : Distance to the center of the flow field. Positive value (including zero): distance known. Negative value: Unknown distance. (float)
+
+*/
+    mavlink20.messages.optical_flow_rad = function( ...moreargs ) {
+    [ this.time_usec , this.sensor_id , this.integration_time_us , this.integrated_x , this.integrated_y , this.integrated_xgyro , this.integrated_ygyro , this.integrated_zgyro , this.temperature , this.quality , this.time_delta_distance_us , this.distance ] = moreargs;
+
+    this._format = '<QIfffffIfhBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPTICAL_FLOW_RAD;
+    this.order_map = [0, 10, 1, 2, 3, 4, 5, 6, 9, 11, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 138;
+    this._name = 'OPTICAL_FLOW_RAD';
+
+    this._instance_field = 'sensor_id';
+    this._instance_offset = 42;
+
+    this.fieldnames = ['time_usec', 'sensor_id', 'integration_time_us', 'integrated_x', 'integrated_y', 'integrated_xgyro', 'integrated_ygyro', 'integrated_zgyro', 'temperature', 'quality', 'time_delta_distance_us', 'distance'];
+
+}
+
+mavlink20.messages.optical_flow_rad.prototype = new mavlink20.message;
+mavlink20.messages.optical_flow_rad.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.integration_time_us, this.integrated_x, this.integrated_y, this.integrated_xgyro, this.integrated_ygyro, this.integrated_zgyro, this.time_delta_distance_us, this.distance, this.temperature, this.sensor_id, this.quality];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The IMU readings in SI units in NED body frame
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                xacc                      : X acceleration (float)
+                yacc                      : Y acceleration (float)
+                zacc                      : Z acceleration (float)
+                xgyro                     : Angular speed around X axis in body frame (float)
+                ygyro                     : Angular speed around Y axis in body frame (float)
+                zgyro                     : Angular speed around Z axis in body frame (float)
+                xmag                      : X Magnetic field (float)
+                ymag                      : Y Magnetic field (float)
+                zmag                      : Z Magnetic field (float)
+                abs_pressure              : Absolute pressure (float)
+                diff_pressure             : Differential pressure (airspeed) (float)
+                pressure_alt              : Altitude calculated from pressure (float)
+                temperature               : Temperature (float)
+                fields_updated            : Bitmap for fields that have updated since last message, bit 0 = xacc, bit 12: temperature, bit 31: full reset of attitude/position/velocities/etc was performed in sim. (uint32_t)
+                id                        : Sensor ID (zero indexed). Used for multiple sensor inputs (uint8_t)
+
+*/
+    mavlink20.messages.hil_sensor = function( ...moreargs ) {
+    [ this.time_usec , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro , this.xmag , this.ymag , this.zmag , this.abs_pressure , this.diff_pressure , this.pressure_alt , this.temperature , this.fields_updated , this.id ] = moreargs;
+
+    this._format = '<QfffffffffffffIB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIL_SENSOR;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 108;
+    this._name = 'HIL_SENSOR';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro', 'xmag', 'ymag', 'zmag', 'abs_pressure', 'diff_pressure', 'pressure_alt', 'temperature', 'fields_updated', 'id'];
+
+}
+
+mavlink20.messages.hil_sensor.prototype = new mavlink20.message;
+mavlink20.messages.hil_sensor.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro, this.xmag, this.ymag, this.zmag, this.abs_pressure, this.diff_pressure, this.pressure_alt, this.temperature, this.fields_updated, this.id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of simulation environment, if used
+
+                q1                        : True attitude quaternion component 1, w (1 in null-rotation) (float)
+                q2                        : True attitude quaternion component 2, x (0 in null-rotation) (float)
+                q3                        : True attitude quaternion component 3, y (0 in null-rotation) (float)
+                q4                        : True attitude quaternion component 4, z (0 in null-rotation) (float)
+                roll                      : Attitude roll expressed as Euler angles, not recommended except for human-readable outputs (float)
+                pitch                     : Attitude pitch expressed as Euler angles, not recommended except for human-readable outputs (float)
+                yaw                       : Attitude yaw expressed as Euler angles, not recommended except for human-readable outputs (float)
+                xacc                      : X acceleration (float)
+                yacc                      : Y acceleration (float)
+                zacc                      : Z acceleration (float)
+                xgyro                     : Angular speed around X axis (float)
+                ygyro                     : Angular speed around Y axis (float)
+                zgyro                     : Angular speed around Z axis (float)
+                lat                       : Latitude (float)
+                lon                       : Longitude (float)
+                alt                       : Altitude (float)
+                std_dev_horz              : Horizontal position standard deviation (float)
+                std_dev_vert              : Vertical position standard deviation (float)
+                vn                        : True velocity in north direction in earth-fixed NED frame (float)
+                ve                        : True velocity in east direction in earth-fixed NED frame (float)
+                vd                        : True velocity in down direction in earth-fixed NED frame (float)
+                lat_int                   : Latitude (higher precision). If 0, recipients should use the lat field value (otherwise this field is preferred). (int32_t)
+                lon_int                   : Longitude (higher precision). If 0, recipients should use the lon field value (otherwise this field is preferred). (int32_t)
+
+*/
+    mavlink20.messages.sim_state = function( ...moreargs ) {
+    [ this.q1 , this.q2 , this.q3 , this.q4 , this.roll , this.pitch , this.yaw , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro , this.lat , this.lon , this.alt , this.std_dev_horz , this.std_dev_vert , this.vn , this.ve , this.vd , this.lat_int , this.lon_int ] = moreargs;
+
+    this._format = '<fffffffffffffffffffffii';
+    this._id = mavlink20.MAVLINK_MSG_ID_SIM_STATE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 32;
+    this._name = 'SIM_STATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['q1', 'q2', 'q3', 'q4', 'roll', 'pitch', 'yaw', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro', 'lat', 'lon', 'alt', 'std_dev_horz', 'std_dev_vert', 'vn', 've', 'vd', 'lat_int', 'lon_int'];
+
+}
+
+mavlink20.messages.sim_state.prototype = new mavlink20.message;
+mavlink20.messages.sim_state.prototype.pack = function(mav) {
+    var orderedfields = [ this.q1, this.q2, this.q3, this.q4, this.roll, this.pitch, this.yaw, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro, this.lat, this.lon, this.alt, this.std_dev_horz, this.std_dev_vert, this.vn, this.ve, this.vd, this.lat_int, this.lon_int];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status generated by radio and injected into MAVLink stream.
+
+                rssi                      : Local (message sender) received signal strength indication in device-dependent units/scale. Values: [0-254], 255: invalid/unknown. (uint8_t)
+                remrssi                   : Remote (message receiver) signal strength indication in device-dependent units/scale. Values: [0-254], 255: invalid/unknown. (uint8_t)
+                txbuf                     : Remaining free transmitter buffer space. (uint8_t)
+                noise                     : Local background noise level. These are device dependent RSSI values (scale as approx 2x dB on SiK radios). Values: [0-254], 255: invalid/unknown. (uint8_t)
+                remnoise                  : Remote background noise level. These are device dependent RSSI values (scale as approx 2x dB on SiK radios). Values: [0-254], 255: invalid/unknown. (uint8_t)
+                rxerrors                  : Count of radio packet receive errors (since boot). (uint16_t)
+                fixed                     : Count of error corrected radio packets (since boot). (uint16_t)
+
+*/
+    mavlink20.messages.radio_status = function( ...moreargs ) {
+    [ this.rssi , this.remrssi , this.txbuf , this.noise , this.remnoise , this.rxerrors , this.fixed ] = moreargs;
+
+    this._format = '<HHBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_RADIO_STATUS;
+    this.order_map = [2, 3, 4, 5, 6, 0, 1];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 185;
+    this._name = 'RADIO_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['rssi', 'remrssi', 'txbuf', 'noise', 'remnoise', 'rxerrors', 'fixed'];
+
+}
+
+mavlink20.messages.radio_status.prototype = new mavlink20.message;
+mavlink20.messages.radio_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.rxerrors, this.fixed, this.rssi, this.remrssi, this.txbuf, this.noise, this.remnoise];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+File transfer protocol message:
+https://mavlink.io/en/services/ftp.html.
+
+                target_network            : Network ID (0 for broadcast) (uint8_t)
+                target_system             : System ID (0 for broadcast) (uint8_t)
+                target_component          : Component ID (0 for broadcast) (uint8_t)
+                payload                   : Variable length payload. The length is defined by the remaining message length when subtracting the header and other fields.  The entire content of this block is opaque unless you understand any the encoding message_type.  The particular encoding used can be extension specific and might not always be documented as part of the mavlink specification. (uint8_t)
+
+*/
+    mavlink20.messages.file_transfer_protocol = function( ...moreargs ) {
+    [ this.target_network , this.target_system , this.target_component , this.payload ] = moreargs;
+
+    this._format = '<BBB251s';
+    this._id = mavlink20.MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 251];
+    this.array_len_map = [0, 0, 0, 251];
+    this.crc_extra = 84;
+    this._name = 'FILE_TRANSFER_PROTOCOL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_network', 'target_system', 'target_component', 'payload'];
+
+}
+
+mavlink20.messages.file_transfer_protocol.prototype = new mavlink20.message;
+mavlink20.messages.file_transfer_protocol.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_network, this.target_system, this.target_component, this.payload];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Time synchronization message.
+
+                tc1                       : Time sync timestamp 1 (int64_t)
+                ts1                       : Time sync timestamp 2 (int64_t)
+
+*/
+    mavlink20.messages.timesync = function( ...moreargs ) {
+    [ this.tc1 , this.ts1 ] = moreargs;
+
+    this._format = '<qq';
+    this._id = mavlink20.MAVLINK_MSG_ID_TIMESYNC;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 34;
+    this._name = 'TIMESYNC';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['tc1', 'ts1'];
+
+}
+
+mavlink20.messages.timesync.prototype = new mavlink20.message;
+mavlink20.messages.timesync.prototype.pack = function(mav) {
+    var orderedfields = [ this.tc1, this.ts1];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Camera-IMU triggering and synchronisation message.
+
+                time_usec                 : Timestamp for image frame (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                seq                       : Image frame sequence (uint32_t)
+
+*/
+    mavlink20.messages.camera_trigger = function( ...moreargs ) {
+    [ this.time_usec , this.seq ] = moreargs;
+
+    this._format = '<QI';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_TRIGGER;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 174;
+    this._name = 'CAMERA_TRIGGER';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'seq'];
+
+}
+
+mavlink20.messages.camera_trigger.prototype = new mavlink20.message;
+mavlink20.messages.camera_trigger.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.seq];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The global position, as returned by the Global Positioning System
+(GPS). This is                  NOT the global position estimate of
+the system, but rather a RAW sensor value. See message
+GLOBAL_POSITION_INT for the global position estimate.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                fix_type                  : 0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix. (uint8_t)
+                lat                       : Latitude (WGS84) (int32_t)
+                lon                       : Longitude (WGS84) (int32_t)
+                alt                       : Altitude (MSL). Positive for up. (int32_t)
+                eph                       : GPS HDOP horizontal dilution of position (unitless * 100). If unknown, set to: UINT16_MAX (uint16_t)
+                epv                       : GPS VDOP vertical dilution of position (unitless * 100). If unknown, set to: UINT16_MAX (uint16_t)
+                vel                       : GPS ground speed. If unknown, set to: UINT16_MAX (uint16_t)
+                vn                        : GPS velocity in north direction in earth-fixed NED frame (int16_t)
+                ve                        : GPS velocity in east direction in earth-fixed NED frame (int16_t)
+                vd                        : GPS velocity in down direction in earth-fixed NED frame (int16_t)
+                cog                       : Course over ground (NOT heading, but direction of movement), 0.0..359.99 degrees. If unknown, set to: UINT16_MAX (uint16_t)
+                satellites_visible        : Number of satellites visible. If unknown, set to UINT8_MAX (uint8_t)
+                id                        : GPS ID (zero indexed). Used for multiple GPS inputs (uint8_t)
+                yaw                       : Yaw of vehicle relative to Earth's North, zero means not available, use 36000 for north (uint16_t)
+
+*/
+    mavlink20.messages.hil_gps = function( ...moreargs ) {
+    [ this.time_usec , this.fix_type , this.lat , this.lon , this.alt , this.eph , this.epv , this.vel , this.vn , this.ve , this.vd , this.cog , this.satellites_visible , this.id , this.yaw ] = moreargs;
+
+    this._format = '<QiiiHHHhhhHBBBH';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIL_GPS;
+    this.order_map = [0, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 124;
+    this._name = 'HIL_GPS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'fix_type', 'lat', 'lon', 'alt', 'eph', 'epv', 'vel', 'vn', 've', 'vd', 'cog', 'satellites_visible', 'id', 'yaw'];
+
+}
+
+mavlink20.messages.hil_gps.prototype = new mavlink20.message;
+mavlink20.messages.hil_gps.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.lat, this.lon, this.alt, this.eph, this.epv, this.vel, this.vn, this.ve, this.vd, this.cog, this.fix_type, this.satellites_visible, this.id, this.yaw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Simulated optical flow from a flow sensor (e.g. PX4FLOW or optical
+mouse sensor)
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                sensor_id                 : Sensor ID (uint8_t)
+                integration_time_us        : Integration time. Divide integrated_x and integrated_y by the integration time to obtain average flow. The integration time also indicates the. (uint32_t)
+                integrated_x              : Flow in radians around X axis (Sensor RH rotation about the X axis induces a positive flow. Sensor linear motion along the positive Y axis induces a negative flow.) (float)
+                integrated_y              : Flow in radians around Y axis (Sensor RH rotation about the Y axis induces a positive flow. Sensor linear motion along the positive X axis induces a positive flow.) (float)
+                integrated_xgyro          : RH rotation around X axis (float)
+                integrated_ygyro          : RH rotation around Y axis (float)
+                integrated_zgyro          : RH rotation around Z axis (float)
+                temperature               : Temperature (int16_t)
+                quality                   : Optical flow quality / confidence. 0: no valid flow, 255: maximum quality (uint8_t)
+                time_delta_distance_us        : Time since the distance was sampled. (uint32_t)
+                distance                  : Distance to the center of the flow field. Positive value (including zero): distance known. Negative value: Unknown distance. (float)
+
+*/
+    mavlink20.messages.hil_optical_flow = function( ...moreargs ) {
+    [ this.time_usec , this.sensor_id , this.integration_time_us , this.integrated_x , this.integrated_y , this.integrated_xgyro , this.integrated_ygyro , this.integrated_zgyro , this.temperature , this.quality , this.time_delta_distance_us , this.distance ] = moreargs;
+
+    this._format = '<QIfffffIfhBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIL_OPTICAL_FLOW;
+    this.order_map = [0, 10, 1, 2, 3, 4, 5, 6, 9, 11, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 237;
+    this._name = 'HIL_OPTICAL_FLOW';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'sensor_id', 'integration_time_us', 'integrated_x', 'integrated_y', 'integrated_xgyro', 'integrated_ygyro', 'integrated_zgyro', 'temperature', 'quality', 'time_delta_distance_us', 'distance'];
+
+}
+
+mavlink20.messages.hil_optical_flow.prototype = new mavlink20.message;
+mavlink20.messages.hil_optical_flow.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.integration_time_us, this.integrated_x, this.integrated_y, this.integrated_xgyro, this.integrated_ygyro, this.integrated_zgyro, this.time_delta_distance_us, this.distance, this.temperature, this.sensor_id, this.quality];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Sent from simulation to autopilot, avoids in contrast to HIL_STATE
+singularities. This packet is useful for high throughput applications
+such as hardware in the loop simulations.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                attitude_quaternion        : Vehicle attitude expressed as normalized quaternion in w, x, y, z order (with 1 0 0 0 being the null-rotation) (float)
+                rollspeed                 : Body frame roll / phi angular speed (float)
+                pitchspeed                : Body frame pitch / theta angular speed (float)
+                yawspeed                  : Body frame yaw / psi angular speed (float)
+                lat                       : Latitude (int32_t)
+                lon                       : Longitude (int32_t)
+                alt                       : Altitude (int32_t)
+                vx                        : Ground X Speed (Latitude) (int16_t)
+                vy                        : Ground Y Speed (Longitude) (int16_t)
+                vz                        : Ground Z Speed (Altitude) (int16_t)
+                ind_airspeed              : Indicated airspeed (uint16_t)
+                true_airspeed             : True airspeed (uint16_t)
+                xacc                      : X acceleration (int16_t)
+                yacc                      : Y acceleration (int16_t)
+                zacc                      : Z acceleration (int16_t)
+
+*/
+    mavlink20.messages.hil_state_quaternion = function( ...moreargs ) {
+    [ this.time_usec , this.attitude_quaternion , this.rollspeed , this.pitchspeed , this.yawspeed , this.lat , this.lon , this.alt , this.vx , this.vy , this.vz , this.ind_airspeed , this.true_airspeed , this.xacc , this.yacc , this.zacc ] = moreargs;
+
+    this._format = '<Q4ffffiiihhhHHhhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIL_STATE_QUATERNION;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    this.len_map = [1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 4;
+    this._name = 'HIL_STATE_QUATERNION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'attitude_quaternion', 'rollspeed', 'pitchspeed', 'yawspeed', 'lat', 'lon', 'alt', 'vx', 'vy', 'vz', 'ind_airspeed', 'true_airspeed', 'xacc', 'yacc', 'zacc'];
+
+}
+
+mavlink20.messages.hil_state_quaternion.prototype = new mavlink20.message;
+mavlink20.messages.hil_state_quaternion.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.attitude_quaternion, this.rollspeed, this.pitchspeed, this.yawspeed, this.lat, this.lon, this.alt, this.vx, this.vy, this.vz, this.ind_airspeed, this.true_airspeed, this.xacc, this.yacc, this.zacc];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The RAW IMU readings for secondary 9DOF sensor setup. This message
+should contain the scaled values to the described units
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                xacc                      : X acceleration (int16_t)
+                yacc                      : Y acceleration (int16_t)
+                zacc                      : Z acceleration (int16_t)
+                xgyro                     : Angular speed around X axis (int16_t)
+                ygyro                     : Angular speed around Y axis (int16_t)
+                zgyro                     : Angular speed around Z axis (int16_t)
+                xmag                      : X Magnetic field (int16_t)
+                ymag                      : Y Magnetic field (int16_t)
+                zmag                      : Z Magnetic field (int16_t)
+                temperature               : Temperature, 0: IMU does not provide temperature values. If the IMU is at 0C it must send 1 (0.01C). (int16_t)
+
+*/
+    mavlink20.messages.scaled_imu2 = function( ...moreargs ) {
+    [ this.time_boot_ms , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro , this.xmag , this.ymag , this.zmag , this.temperature ] = moreargs;
+
+    this._format = '<Ihhhhhhhhhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_SCALED_IMU2;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 76;
+    this._name = 'SCALED_IMU2';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro', 'xmag', 'ymag', 'zmag', 'temperature'];
+
+}
+
+mavlink20.messages.scaled_imu2.prototype = new mavlink20.message;
+mavlink20.messages.scaled_imu2.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro, this.xmag, this.ymag, this.zmag, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request a list of available logs. On some systems calling this may
+stop on-board logging until LOG_REQUEST_END is called. If there are no
+log files available this request shall be answered with one LOG_ENTRY
+message with id = 0 and num_logs = 0.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                start                     : First log id (0 for first available) (uint16_t)
+                end                       : Last log id (0xffff for last available) (uint16_t)
+
+*/
+    mavlink20.messages.log_request_list = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.start , this.end ] = moreargs;
+
+    this._format = '<HHBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOG_REQUEST_LIST;
+    this.order_map = [2, 3, 0, 1];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 128;
+    this._name = 'LOG_REQUEST_LIST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'start', 'end'];
+
+}
+
+mavlink20.messages.log_request_list.prototype = new mavlink20.message;
+mavlink20.messages.log_request_list.prototype.pack = function(mav) {
+    var orderedfields = [ this.start, this.end, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reply to LOG_REQUEST_LIST
+
+                id                        : Log id (uint16_t)
+                num_logs                  : Total number of logs (uint16_t)
+                last_log_num              : High log number (uint16_t)
+                time_utc                  : UTC timestamp of log since 1970, or 0 if not available (uint32_t)
+                size                      : Size of the log (may be approximate) (uint32_t)
+
+*/
+    mavlink20.messages.log_entry = function( ...moreargs ) {
+    [ this.id , this.num_logs , this.last_log_num , this.time_utc , this.size ] = moreargs;
+
+    this._format = '<IIHHH';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOG_ENTRY;
+    this.order_map = [2, 3, 4, 0, 1];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 56;
+    this._name = 'LOG_ENTRY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['id', 'num_logs', 'last_log_num', 'time_utc', 'size'];
+
+}
+
+mavlink20.messages.log_entry.prototype = new mavlink20.message;
+mavlink20.messages.log_entry.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_utc, this.size, this.id, this.num_logs, this.last_log_num];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request a chunk of a log
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                id                        : Log id (from LOG_ENTRY reply) (uint16_t)
+                ofs                       : Offset into the log (uint32_t)
+                count                     : Number of bytes (uint32_t)
+
+*/
+    mavlink20.messages.log_request_data = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.id , this.ofs , this.count ] = moreargs;
+
+    this._format = '<IIHBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOG_REQUEST_DATA;
+    this.order_map = [3, 4, 2, 0, 1];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 116;
+    this._name = 'LOG_REQUEST_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'id', 'ofs', 'count'];
+
+}
+
+mavlink20.messages.log_request_data.prototype = new mavlink20.message;
+mavlink20.messages.log_request_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.ofs, this.count, this.id, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reply to LOG_REQUEST_DATA
+
+                id                        : Log id (from LOG_ENTRY reply) (uint16_t)
+                ofs                       : Offset into the log (uint32_t)
+                count                     : Number of bytes (zero for end of log) (uint8_t)
+                data                      : log data (uint8_t)
+
+*/
+    mavlink20.messages.log_data = function( ...moreargs ) {
+    [ this.id , this.ofs , this.count , this.data ] = moreargs;
+
+    this._format = '<IHB90s';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOG_DATA;
+    this.order_map = [1, 0, 2, 3];
+    this.len_map = [1, 1, 1, 90];
+    this.array_len_map = [0, 0, 0, 90];
+    this.crc_extra = 134;
+    this._name = 'LOG_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['id', 'ofs', 'count', 'data'];
+
+}
+
+mavlink20.messages.log_data.prototype = new mavlink20.message;
+mavlink20.messages.log_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.ofs, this.id, this.count, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Erase all logs
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+
+*/
+    mavlink20.messages.log_erase = function( ...moreargs ) {
+    [ this.target_system , this.target_component ] = moreargs;
+
+    this._format = '<BB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOG_ERASE;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 237;
+    this._name = 'LOG_ERASE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component'];
+
+}
+
+mavlink20.messages.log_erase.prototype = new mavlink20.message;
+mavlink20.messages.log_erase.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Stop log transfer and resume normal logging
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+
+*/
+    mavlink20.messages.log_request_end = function( ...moreargs ) {
+    [ this.target_system , this.target_component ] = moreargs;
+
+    this._format = '<BB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOG_REQUEST_END;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 203;
+    this._name = 'LOG_REQUEST_END';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component'];
+
+}
+
+mavlink20.messages.log_request_end.prototype = new mavlink20.message;
+mavlink20.messages.log_request_end.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data for injecting into the onboard GPS (used for DGPS)
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                len                       : Data length (uint8_t)
+                data                      : Raw data (110 is enough for 12 satellites of RTCMv2) (uint8_t)
+
+*/
+    mavlink20.messages.gps_inject_data = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.len , this.data ] = moreargs;
+
+    this._format = '<BBB110s';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS_INJECT_DATA;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 110];
+    this.array_len_map = [0, 0, 0, 110];
+    this.crc_extra = 250;
+    this._name = 'GPS_INJECT_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'len', 'data'];
+
+}
+
+mavlink20.messages.gps_inject_data.prototype = new mavlink20.message;
+mavlink20.messages.gps_inject_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.len, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Second GPS data.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                fix_type                  : GPS fix type. (uint8_t)
+                lat                       : Latitude (WGS84) (int32_t)
+                lon                       : Longitude (WGS84) (int32_t)
+                alt                       : Altitude (MSL). Positive for up. (int32_t)
+                eph                       : GPS HDOP horizontal dilution of position (unitless). If unknown, set to: UINT16_MAX (uint16_t)
+                epv                       : GPS VDOP vertical dilution of position (unitless). If unknown, set to: UINT16_MAX (uint16_t)
+                vel                       : GPS ground speed. If unknown, set to: UINT16_MAX (uint16_t)
+                cog                       : Course over ground (NOT heading, but direction of movement): 0.0..359.99 degrees. If unknown, set to: UINT16_MAX (uint16_t)
+                satellites_visible        : Number of satellites visible. If unknown, set to 255 (uint8_t)
+                dgps_numch                : Number of DGPS satellites (uint8_t)
+                dgps_age                  : Age of DGPS info (uint32_t)
+                yaw                       : Yaw in earth frame from north. Use 0 if this GPS does not provide yaw. Use UINT16_MAX if this GPS is configured to provide yaw and is currently unable to provide it. Use 36000 for north. (uint16_t)
+                alt_ellipsoid             : Altitude (above WGS84, EGM96 ellipsoid). Positive for up. (int32_t)
+                h_acc                     : Position uncertainty. (uint32_t)
+                v_acc                     : Altitude uncertainty. (uint32_t)
+                vel_acc                   : Speed uncertainty. (uint32_t)
+                hdg_acc                   : Heading / track uncertainty (uint32_t)
+
+*/
+    mavlink20.messages.gps2_raw = function( ...moreargs ) {
+    [ this.time_usec , this.fix_type , this.lat , this.lon , this.alt , this.eph , this.epv , this.vel , this.cog , this.satellites_visible , this.dgps_numch , this.dgps_age , this.yaw , this.alt_ellipsoid , this.h_acc , this.v_acc , this.vel_acc , this.hdg_acc ] = moreargs;
+
+    this._format = '<QiiiIHHHHBBBHiIIII';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS2_RAW;
+    this.order_map = [0, 9, 1, 2, 3, 5, 6, 7, 8, 10, 11, 4, 12, 13, 14, 15, 16, 17];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 87;
+    this._name = 'GPS2_RAW';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'fix_type', 'lat', 'lon', 'alt', 'eph', 'epv', 'vel', 'cog', 'satellites_visible', 'dgps_numch', 'dgps_age', 'yaw', 'alt_ellipsoid', 'h_acc', 'v_acc', 'vel_acc', 'hdg_acc'];
+
+}
+
+mavlink20.messages.gps2_raw.prototype = new mavlink20.message;
+mavlink20.messages.gps2_raw.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.lat, this.lon, this.alt, this.dgps_age, this.eph, this.epv, this.vel, this.cog, this.fix_type, this.satellites_visible, this.dgps_numch, this.yaw, this.alt_ellipsoid, this.h_acc, this.v_acc, this.vel_acc, this.hdg_acc];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Power supply status
+
+                Vcc                       : 5V rail voltage. (uint16_t)
+                Vservo                    : Servo rail voltage. (uint16_t)
+                flags                     : Bitmap of power supply status flags. (uint16_t)
+
+*/
+    mavlink20.messages.power_status = function( ...moreargs ) {
+    [ this.Vcc , this.Vservo , this.flags ] = moreargs;
+
+    this._format = '<HHH';
+    this._id = mavlink20.MAVLINK_MSG_ID_POWER_STATUS;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 203;
+    this._name = 'POWER_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['Vcc', 'Vservo', 'flags'];
+
+}
+
+mavlink20.messages.power_status.prototype = new mavlink20.message;
+mavlink20.messages.power_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.Vcc, this.Vservo, this.flags];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Control a serial port. This can be used for raw access to an onboard
+serial peripheral such as a GPS or telemetry radio. It is designed to
+make it possible to update the devices firmware via MAVLink messages
+or change the devices settings. A message with zero bytes can be used
+to change just the baudrate.
+
+                device                    : Serial control device type. (uint8_t)
+                flags                     : Bitmap of serial control flags. (uint8_t)
+                timeout                   : Timeout for reply data (uint16_t)
+                baudrate                  : Baudrate of transfer. Zero means no change. (uint32_t)
+                count                     : how many bytes in this transfer (uint8_t)
+                data                      : serial data (uint8_t)
+
+*/
+    mavlink20.messages.serial_control = function( ...moreargs ) {
+    [ this.device , this.flags , this.timeout , this.baudrate , this.count , this.data ] = moreargs;
+
+    this._format = '<IHBBB70s';
+    this._id = mavlink20.MAVLINK_MSG_ID_SERIAL_CONTROL;
+    this.order_map = [2, 3, 1, 0, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 70];
+    this.array_len_map = [0, 0, 0, 0, 0, 70];
+    this.crc_extra = 220;
+    this._name = 'SERIAL_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['device', 'flags', 'timeout', 'baudrate', 'count', 'data'];
+
+}
+
+mavlink20.messages.serial_control.prototype = new mavlink20.message;
+mavlink20.messages.serial_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.baudrate, this.timeout, this.device, this.flags, this.count, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+RTK GPS data. Gives information on the relative baseline calculation
+the GPS is reporting
+
+                time_last_baseline_ms        : Time since boot of last baseline message received. (uint32_t)
+                rtk_receiver_id           : Identification of connected RTK receiver. (uint8_t)
+                wn                        : GPS Week Number of last baseline (uint16_t)
+                tow                       : GPS Time of Week of last baseline (uint32_t)
+                rtk_health                : GPS-specific health report for RTK data. (uint8_t)
+                rtk_rate                  : Rate of baseline messages being received by GPS (uint8_t)
+                nsats                     : Current number of sats used for RTK calculation. (uint8_t)
+                baseline_coords_type        : Coordinate system of baseline (uint8_t)
+                baseline_a_mm             : Current baseline in ECEF x or NED north component. (int32_t)
+                baseline_b_mm             : Current baseline in ECEF y or NED east component. (int32_t)
+                baseline_c_mm             : Current baseline in ECEF z or NED down component. (int32_t)
+                accuracy                  : Current estimate of baseline accuracy. (uint32_t)
+                iar_num_hypotheses        : Current number of integer ambiguity hypotheses. (int32_t)
+
+*/
+    mavlink20.messages.gps_rtk = function( ...moreargs ) {
+    [ this.time_last_baseline_ms , this.rtk_receiver_id , this.wn , this.tow , this.rtk_health , this.rtk_rate , this.nsats , this.baseline_coords_type , this.baseline_a_mm , this.baseline_b_mm , this.baseline_c_mm , this.accuracy , this.iar_num_hypotheses ] = moreargs;
+
+    this._format = '<IIiiiIiHBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS_RTK;
+    this.order_map = [0, 8, 7, 1, 9, 10, 11, 12, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 25;
+    this._name = 'GPS_RTK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_last_baseline_ms', 'rtk_receiver_id', 'wn', 'tow', 'rtk_health', 'rtk_rate', 'nsats', 'baseline_coords_type', 'baseline_a_mm', 'baseline_b_mm', 'baseline_c_mm', 'accuracy', 'iar_num_hypotheses'];
+
+}
+
+mavlink20.messages.gps_rtk.prototype = new mavlink20.message;
+mavlink20.messages.gps_rtk.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_last_baseline_ms, this.tow, this.baseline_a_mm, this.baseline_b_mm, this.baseline_c_mm, this.accuracy, this.iar_num_hypotheses, this.wn, this.rtk_receiver_id, this.rtk_health, this.rtk_rate, this.nsats, this.baseline_coords_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+RTK GPS data. Gives information on the relative baseline calculation
+the GPS is reporting
+
+                time_last_baseline_ms        : Time since boot of last baseline message received. (uint32_t)
+                rtk_receiver_id           : Identification of connected RTK receiver. (uint8_t)
+                wn                        : GPS Week Number of last baseline (uint16_t)
+                tow                       : GPS Time of Week of last baseline (uint32_t)
+                rtk_health                : GPS-specific health report for RTK data. (uint8_t)
+                rtk_rate                  : Rate of baseline messages being received by GPS (uint8_t)
+                nsats                     : Current number of sats used for RTK calculation. (uint8_t)
+                baseline_coords_type        : Coordinate system of baseline (uint8_t)
+                baseline_a_mm             : Current baseline in ECEF x or NED north component. (int32_t)
+                baseline_b_mm             : Current baseline in ECEF y or NED east component. (int32_t)
+                baseline_c_mm             : Current baseline in ECEF z or NED down component. (int32_t)
+                accuracy                  : Current estimate of baseline accuracy. (uint32_t)
+                iar_num_hypotheses        : Current number of integer ambiguity hypotheses. (int32_t)
+
+*/
+    mavlink20.messages.gps2_rtk = function( ...moreargs ) {
+    [ this.time_last_baseline_ms , this.rtk_receiver_id , this.wn , this.tow , this.rtk_health , this.rtk_rate , this.nsats , this.baseline_coords_type , this.baseline_a_mm , this.baseline_b_mm , this.baseline_c_mm , this.accuracy , this.iar_num_hypotheses ] = moreargs;
+
+    this._format = '<IIiiiIiHBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS2_RTK;
+    this.order_map = [0, 8, 7, 1, 9, 10, 11, 12, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 226;
+    this._name = 'GPS2_RTK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_last_baseline_ms', 'rtk_receiver_id', 'wn', 'tow', 'rtk_health', 'rtk_rate', 'nsats', 'baseline_coords_type', 'baseline_a_mm', 'baseline_b_mm', 'baseline_c_mm', 'accuracy', 'iar_num_hypotheses'];
+
+}
+
+mavlink20.messages.gps2_rtk.prototype = new mavlink20.message;
+mavlink20.messages.gps2_rtk.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_last_baseline_ms, this.tow, this.baseline_a_mm, this.baseline_b_mm, this.baseline_c_mm, this.accuracy, this.iar_num_hypotheses, this.wn, this.rtk_receiver_id, this.rtk_health, this.rtk_rate, this.nsats, this.baseline_coords_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The RAW IMU readings for 3rd 9DOF sensor setup. This message should
+contain the scaled values to the described units
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                xacc                      : X acceleration (int16_t)
+                yacc                      : Y acceleration (int16_t)
+                zacc                      : Z acceleration (int16_t)
+                xgyro                     : Angular speed around X axis (int16_t)
+                ygyro                     : Angular speed around Y axis (int16_t)
+                zgyro                     : Angular speed around Z axis (int16_t)
+                xmag                      : X Magnetic field (int16_t)
+                ymag                      : Y Magnetic field (int16_t)
+                zmag                      : Z Magnetic field (int16_t)
+                temperature               : Temperature, 0: IMU does not provide temperature values. If the IMU is at 0C it must send 1 (0.01C). (int16_t)
+
+*/
+    mavlink20.messages.scaled_imu3 = function( ...moreargs ) {
+    [ this.time_boot_ms , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro , this.xmag , this.ymag , this.zmag , this.temperature ] = moreargs;
+
+    this._format = '<Ihhhhhhhhhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_SCALED_IMU3;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 46;
+    this._name = 'SCALED_IMU3';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro', 'xmag', 'ymag', 'zmag', 'temperature'];
+
+}
+
+mavlink20.messages.scaled_imu3.prototype = new mavlink20.message;
+mavlink20.messages.scaled_imu3.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro, this.xmag, this.ymag, this.zmag, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Handshake message to initiate, control and stop image streaming when
+using the Image Transmission Protocol:
+https://mavlink.io/en/services/image_transmission.html.
+
+                type                      : Type of requested/acknowledged data. (uint8_t)
+                size                      : total data size (set on ACK only). (uint32_t)
+                width                     : Width of a matrix or image. (uint16_t)
+                height                    : Height of a matrix or image. (uint16_t)
+                packets                   : Number of packets being sent (set on ACK only). (uint16_t)
+                payload                   : Payload size per packet (normally 253 byte, see DATA field size in message ENCAPSULATED_DATA) (set on ACK only). (uint8_t)
+                jpg_quality               : JPEG quality. Values: [1-100]. (uint8_t)
+
+*/
+    mavlink20.messages.data_transmission_handshake = function( ...moreargs ) {
+    [ this.type , this.size , this.width , this.height , this.packets , this.payload , this.jpg_quality ] = moreargs;
+
+    this._format = '<IHHHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DATA_TRANSMISSION_HANDSHAKE;
+    this.order_map = [4, 0, 1, 2, 3, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 29;
+    this._name = 'DATA_TRANSMISSION_HANDSHAKE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['type', 'size', 'width', 'height', 'packets', 'payload', 'jpg_quality'];
+
+}
+
+mavlink20.messages.data_transmission_handshake.prototype = new mavlink20.message;
+mavlink20.messages.data_transmission_handshake.prototype.pack = function(mav) {
+    var orderedfields = [ this.size, this.width, this.height, this.packets, this.type, this.payload, this.jpg_quality];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data packet for images sent using the Image Transmission Protocol:
+https://mavlink.io/en/services/image_transmission.html.
+
+                seqnr                     : sequence number (starting with 0 on every transmission) (uint16_t)
+                data                      : image data bytes (uint8_t)
+
+*/
+    mavlink20.messages.encapsulated_data = function( ...moreargs ) {
+    [ this.seqnr , this.data ] = moreargs;
+
+    this._format = '<H253s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ENCAPSULATED_DATA;
+    this.order_map = [0, 1];
+    this.len_map = [1, 253];
+    this.array_len_map = [0, 253];
+    this.crc_extra = 223;
+    this._name = 'ENCAPSULATED_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['seqnr', 'data'];
+
+}
+
+mavlink20.messages.encapsulated_data.prototype = new mavlink20.message;
+mavlink20.messages.encapsulated_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.seqnr, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Distance sensor information for an onboard rangefinder.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                min_distance              : Minimum distance the sensor can measure (uint16_t)
+                max_distance              : Maximum distance the sensor can measure (uint16_t)
+                current_distance          : Current distance reading (uint16_t)
+                type                      : Type of distance sensor. (uint8_t)
+                id                        : Onboard ID of the sensor (uint8_t)
+                orientation               : Direction the sensor faces. downward-facing: ROTATION_PITCH_270, upward-facing: ROTATION_PITCH_90, backward-facing: ROTATION_PITCH_180, forward-facing: ROTATION_NONE, left-facing: ROTATION_YAW_90, right-facing: ROTATION_YAW_270 (uint8_t)
+                covariance                : Measurement variance. Max standard deviation is 6cm. UINT8_MAX if unknown. (uint8_t)
+                horizontal_fov            : Horizontal Field of View (angle) where the distance measurement is valid and the field of view is known. Otherwise this is set to 0. (float)
+                vertical_fov              : Vertical Field of View (angle) where the distance measurement is valid and the field of view is known. Otherwise this is set to 0. (float)
+                quaternion                : Quaternion of the sensor orientation in vehicle body frame (w, x, y, z order, zero-rotation is 1, 0, 0, 0). Zero-rotation is along the vehicle body x-axis. This field is required if the orientation is set to MAV_SENSOR_ROTATION_CUSTOM. Set it to 0 if invalid." (float)
+                signal_quality            : Signal quality of the sensor. Specific to each sensor type, representing the relation of the signal strength with the target reflectivity, distance, size or aspect, but normalised as a percentage. 0 = unknown/unset signal quality, 1 = invalid signal, 100 = perfect signal. (uint8_t)
+
+*/
+    mavlink20.messages.distance_sensor = function( ...moreargs ) {
+    [ this.time_boot_ms , this.min_distance , this.max_distance , this.current_distance , this.type , this.id , this.orientation , this.covariance , this.horizontal_fov , this.vertical_fov , this.quaternion , this.signal_quality ] = moreargs;
+
+    this._format = '<IHHHBBBBff4fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DISTANCE_SENSOR;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0];
+    this.crc_extra = 85;
+    this._name = 'DISTANCE_SENSOR';
+
+    this._instance_field = 'id';
+    this._instance_offset = 11;
+
+    this.fieldnames = ['time_boot_ms', 'min_distance', 'max_distance', 'current_distance', 'type', 'id', 'orientation', 'covariance', 'horizontal_fov', 'vertical_fov', 'quaternion', 'signal_quality'];
+
+}
+
+mavlink20.messages.distance_sensor.prototype = new mavlink20.message;
+mavlink20.messages.distance_sensor.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.min_distance, this.max_distance, this.current_distance, this.type, this.id, this.orientation, this.covariance, this.horizontal_fov, this.vertical_fov, this.quaternion, this.signal_quality];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request for terrain data and terrain status. See terrain protocol
+docs: https://mavlink.io/en/services/terrain.html
+
+                lat                       : Latitude of SW corner of first grid (int32_t)
+                lon                       : Longitude of SW corner of first grid (int32_t)
+                grid_spacing              : Grid spacing (uint16_t)
+                mask                      : Bitmask of requested 4x4 grids (row major 8x7 array of grids, 56 bits) (uint64_t)
+
+*/
+    mavlink20.messages.terrain_request = function( ...moreargs ) {
+    [ this.lat , this.lon , this.grid_spacing , this.mask ] = moreargs;
+
+    this._format = '<QiiH';
+    this._id = mavlink20.MAVLINK_MSG_ID_TERRAIN_REQUEST;
+    this.order_map = [1, 2, 3, 0];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 6;
+    this._name = 'TERRAIN_REQUEST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['lat', 'lon', 'grid_spacing', 'mask'];
+
+}
+
+mavlink20.messages.terrain_request.prototype = new mavlink20.message;
+mavlink20.messages.terrain_request.prototype.pack = function(mav) {
+    var orderedfields = [ this.mask, this.lat, this.lon, this.grid_spacing];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Terrain data sent from GCS. The lat/lon and grid_spacing must be the
+same as a lat/lon from a TERRAIN_REQUEST. See terrain protocol docs:
+https://mavlink.io/en/services/terrain.html
+
+                lat                       : Latitude of SW corner of first grid (int32_t)
+                lon                       : Longitude of SW corner of first grid (int32_t)
+                grid_spacing              : Grid spacing (uint16_t)
+                gridbit                   : bit within the terrain request mask (uint8_t)
+                data                      : Terrain data MSL (int16_t)
+
+*/
+    mavlink20.messages.terrain_data = function( ...moreargs ) {
+    [ this.lat , this.lon , this.grid_spacing , this.gridbit , this.data ] = moreargs;
+
+    this._format = '<iiH16hB';
+    this._id = mavlink20.MAVLINK_MSG_ID_TERRAIN_DATA;
+    this.order_map = [0, 1, 2, 4, 3];
+    this.len_map = [1, 1, 1, 16, 1];
+    this.array_len_map = [0, 0, 0, 16, 0];
+    this.crc_extra = 229;
+    this._name = 'TERRAIN_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['lat', 'lon', 'grid_spacing', 'gridbit', 'data'];
+
+}
+
+mavlink20.messages.terrain_data.prototype = new mavlink20.message;
+mavlink20.messages.terrain_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.lat, this.lon, this.grid_spacing, this.data, this.gridbit];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request that the vehicle report terrain height at the given location
+(expected response is a TERRAIN_REPORT). Used by GCS to check if
+vehicle has all terrain data needed for a mission.
+
+                lat                       : Latitude (int32_t)
+                lon                       : Longitude (int32_t)
+
+*/
+    mavlink20.messages.terrain_check = function( ...moreargs ) {
+    [ this.lat , this.lon ] = moreargs;
+
+    this._format = '<ii';
+    this._id = mavlink20.MAVLINK_MSG_ID_TERRAIN_CHECK;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 203;
+    this._name = 'TERRAIN_CHECK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['lat', 'lon'];
+
+}
+
+mavlink20.messages.terrain_check.prototype = new mavlink20.message;
+mavlink20.messages.terrain_check.prototype.pack = function(mav) {
+    var orderedfields = [ this.lat, this.lon];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Streamed from drone to report progress of terrain map download
+(initiated by TERRAIN_REQUEST), or sent as a response to a
+TERRAIN_CHECK request. See terrain protocol docs:
+https://mavlink.io/en/services/terrain.html
+
+                lat                       : Latitude (int32_t)
+                lon                       : Longitude (int32_t)
+                spacing                   : grid spacing (zero if terrain at this location unavailable) (uint16_t)
+                terrain_height            : Terrain height MSL (float)
+                current_height            : Current vehicle height above lat/lon terrain height (float)
+                pending                   : Number of 4x4 terrain blocks waiting to be received or read from disk (uint16_t)
+                loaded                    : Number of 4x4 terrain blocks in memory (uint16_t)
+
+*/
+    mavlink20.messages.terrain_report = function( ...moreargs ) {
+    [ this.lat , this.lon , this.spacing , this.terrain_height , this.current_height , this.pending , this.loaded ] = moreargs;
+
+    this._format = '<iiffHHH';
+    this._id = mavlink20.MAVLINK_MSG_ID_TERRAIN_REPORT;
+    this.order_map = [0, 1, 4, 2, 3, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 1;
+    this._name = 'TERRAIN_REPORT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['lat', 'lon', 'spacing', 'terrain_height', 'current_height', 'pending', 'loaded'];
+
+}
+
+mavlink20.messages.terrain_report.prototype = new mavlink20.message;
+mavlink20.messages.terrain_report.prototype.pack = function(mav) {
+    var orderedfields = [ this.lat, this.lon, this.terrain_height, this.current_height, this.spacing, this.pending, this.loaded];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Barometer readings for 2nd barometer
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                press_abs                 : Absolute pressure (float)
+                press_diff                : Differential pressure (float)
+                temperature               : Absolute pressure temperature (int16_t)
+                temperature_press_diff        : Differential pressure temperature (0, if not available). Report values of 0 (or 1) as 1 cdegC. (int16_t)
+
+*/
+    mavlink20.messages.scaled_pressure2 = function( ...moreargs ) {
+    [ this.time_boot_ms , this.press_abs , this.press_diff , this.temperature , this.temperature_press_diff ] = moreargs;
+
+    this._format = '<Iffhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_SCALED_PRESSURE2;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 195;
+    this._name = 'SCALED_PRESSURE2';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'press_abs', 'press_diff', 'temperature', 'temperature_press_diff'];
+
+}
+
+mavlink20.messages.scaled_pressure2.prototype = new mavlink20.message;
+mavlink20.messages.scaled_pressure2.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.press_abs, this.press_diff, this.temperature, this.temperature_press_diff];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Motion capture attitude and position
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                q                         : Attitude quaternion (w, x, y, z order, zero-rotation is 1, 0, 0, 0) (float)
+                x                         : X position (NED) (float)
+                y                         : Y position (NED) (float)
+                z                         : Z position (NED) (float)
+                covariance                : Row-major representation of a pose 6x6 cross-covariance matrix upper right triangle (states: x, y, z, roll, pitch, yaw; first six entries are the first ROW, next five entries are the second ROW, etc.). If unknown, assign NaN value to first element in the array. (float)
+
+*/
+    mavlink20.messages.att_pos_mocap = function( ...moreargs ) {
+    [ this.time_usec , this.q , this.x , this.y , this.z , this.covariance ] = moreargs;
+
+    this._format = '<Q4ffff21f';
+    this._id = mavlink20.MAVLINK_MSG_ID_ATT_POS_MOCAP;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 4, 1, 1, 1, 21];
+    this.array_len_map = [0, 4, 0, 0, 0, 21];
+    this.crc_extra = 109;
+    this._name = 'ATT_POS_MOCAP';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'q', 'x', 'y', 'z', 'covariance'];
+
+}
+
+mavlink20.messages.att_pos_mocap.prototype = new mavlink20.message;
+mavlink20.messages.att_pos_mocap.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.q, this.x, this.y, this.z, this.covariance];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set the vehicle attitude and body angular rates.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                group_mlx                 : Actuator group. The "_mlx" indicates this is a multi-instance message and a MAVLink parser should use this field to difference between instances. (uint8_t)
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                controls                  : Actuator controls. Normed to -1..+1 where 0 is neutral position. Throttle for single rotation direction motors is 0..1, negative range for reverse direction. Standard mapping for attitude controls (group 0): (index 0-7): roll, pitch, yaw, throttle, flaps, spoilers, airbrakes, landing gear. Load a pass-through mixer to repurpose them as generic outputs. (float)
+
+*/
+    mavlink20.messages.set_actuator_control_target = function( ...moreargs ) {
+    [ this.time_usec , this.group_mlx , this.target_system , this.target_component , this.controls ] = moreargs;
+
+    this._format = '<Q8fBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET;
+    this.order_map = [0, 2, 3, 4, 1];
+    this.len_map = [1, 8, 1, 1, 1];
+    this.array_len_map = [0, 8, 0, 0, 0];
+    this.crc_extra = 168;
+    this._name = 'SET_ACTUATOR_CONTROL_TARGET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'group_mlx', 'target_system', 'target_component', 'controls'];
+
+}
+
+mavlink20.messages.set_actuator_control_target.prototype = new mavlink20.message;
+mavlink20.messages.set_actuator_control_target.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.controls, this.group_mlx, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set the vehicle attitude and body angular rates.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                group_mlx                 : Actuator group. The "_mlx" indicates this is a multi-instance message and a MAVLink parser should use this field to difference between instances. (uint8_t)
+                controls                  : Actuator controls. Normed to -1..+1 where 0 is neutral position. Throttle for single rotation direction motors is 0..1, negative range for reverse direction. Standard mapping for attitude controls (group 0): (index 0-7): roll, pitch, yaw, throttle, flaps, spoilers, airbrakes, landing gear. Load a pass-through mixer to repurpose them as generic outputs. (float)
+
+*/
+    mavlink20.messages.actuator_control_target = function( ...moreargs ) {
+    [ this.time_usec , this.group_mlx , this.controls ] = moreargs;
+
+    this._format = '<Q8fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET;
+    this.order_map = [0, 2, 1];
+    this.len_map = [1, 8, 1];
+    this.array_len_map = [0, 8, 0];
+    this.crc_extra = 181;
+    this._name = 'ACTUATOR_CONTROL_TARGET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'group_mlx', 'controls'];
+
+}
+
+mavlink20.messages.actuator_control_target.prototype = new mavlink20.message;
+mavlink20.messages.actuator_control_target.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.controls, this.group_mlx];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The current system altitude.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                altitude_monotonic        : This altitude measure is initialized on system boot and monotonic (it is never reset, but represents the local altitude change). The only guarantee on this field is that it will never be reset and is consistent within a flight. The recommended value for this field is the uncorrected barometric altitude at boot time. This altitude will also drift and vary between flights. (float)
+                altitude_amsl             : This altitude measure is strictly above mean sea level and might be non-monotonic (it might reset on events like GPS lock or when a new QNH value is set). It should be the altitude to which global altitude waypoints are compared to. Note that it is *not* the GPS altitude, however, most GPS modules already output MSL by default and not the WGS84 altitude. (float)
+                altitude_local            : This is the local altitude in the local coordinate frame. It is not the altitude above home, but in reference to the coordinate origin (0, 0, 0). It is up-positive. (float)
+                altitude_relative         : This is the altitude above the home position. It resets on each change of the current home position. (float)
+                altitude_terrain          : This is the altitude above terrain. It might be fed by a terrain database or an altimeter. Values smaller than -1000 should be interpreted as unknown. (float)
+                bottom_clearance          : This is not the altitude, but the clear space below the system according to the fused clearance estimate. It generally should max out at the maximum range of e.g. the laser altimeter. It is generally a moving target. A negative value indicates no measurement available. (float)
+
+*/
+    mavlink20.messages.altitude = function( ...moreargs ) {
+    [ this.time_usec , this.altitude_monotonic , this.altitude_amsl , this.altitude_local , this.altitude_relative , this.altitude_terrain , this.bottom_clearance ] = moreargs;
+
+    this._format = '<Qffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_ALTITUDE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 47;
+    this._name = 'ALTITUDE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'altitude_monotonic', 'altitude_amsl', 'altitude_local', 'altitude_relative', 'altitude_terrain', 'bottom_clearance'];
+
+}
+
+mavlink20.messages.altitude.prototype = new mavlink20.message;
+mavlink20.messages.altitude.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.altitude_monotonic, this.altitude_amsl, this.altitude_local, this.altitude_relative, this.altitude_terrain, this.bottom_clearance];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The autopilot is requesting a resource (file, binary, other type of
+data)
+
+                request_id                : Request ID. This ID should be reused when sending back URI contents (uint8_t)
+                uri_type                  : The type of requested URI. 0 = a file via URL. 1 = a UAVCAN binary (uint8_t)
+                uri                       : The requested unique resource identifier (URI). It is not necessarily a straight domain name (depends on the URI type enum) (uint8_t)
+                transfer_type             : The way the autopilot wants to receive the URI. 0 = MAVLink FTP. 1 = binary stream. (uint8_t)
+                storage                   : The storage path the autopilot wants the URI to be stored in. Will only be valid if the transfer_type has a storage associated (e.g. MAVLink FTP). (uint8_t)
+
+*/
+    mavlink20.messages.resource_request = function( ...moreargs ) {
+    [ this.request_id , this.uri_type , this.uri , this.transfer_type , this.storage ] = moreargs;
+
+    this._format = '<BB120sB120s';
+    this._id = mavlink20.MAVLINK_MSG_ID_RESOURCE_REQUEST;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 120, 1, 120];
+    this.array_len_map = [0, 0, 120, 0, 120];
+    this.crc_extra = 72;
+    this._name = 'RESOURCE_REQUEST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['request_id', 'uri_type', 'uri', 'transfer_type', 'storage'];
+
+}
+
+mavlink20.messages.resource_request.prototype = new mavlink20.message;
+mavlink20.messages.resource_request.prototype.pack = function(mav) {
+    var orderedfields = [ this.request_id, this.uri_type, this.uri, this.transfer_type, this.storage];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Barometer readings for 3rd barometer
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                press_abs                 : Absolute pressure (float)
+                press_diff                : Differential pressure (float)
+                temperature               : Absolute pressure temperature (int16_t)
+                temperature_press_diff        : Differential pressure temperature (0, if not available). Report values of 0 (or 1) as 1 cdegC. (int16_t)
+
+*/
+    mavlink20.messages.scaled_pressure3 = function( ...moreargs ) {
+    [ this.time_boot_ms , this.press_abs , this.press_diff , this.temperature , this.temperature_press_diff ] = moreargs;
+
+    this._format = '<Iffhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_SCALED_PRESSURE3;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 131;
+    this._name = 'SCALED_PRESSURE3';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'press_abs', 'press_diff', 'temperature', 'temperature_press_diff'];
+
+}
+
+mavlink20.messages.scaled_pressure3.prototype = new mavlink20.message;
+mavlink20.messages.scaled_pressure3.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.press_abs, this.press_diff, this.temperature, this.temperature_press_diff];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Current motion information from a designated system
+
+                timestamp                 : Timestamp (time since system boot). (uint64_t)
+                est_capabilities          : bit positions for tracker reporting capabilities (POS = 0, VEL = 1, ACCEL = 2, ATT + RATES = 3) (uint8_t)
+                lat                       : Latitude (WGS84) (int32_t)
+                lon                       : Longitude (WGS84) (int32_t)
+                alt                       : Altitude (MSL) (float)
+                vel                       : target velocity (0,0,0) for unknown (float)
+                acc                       : linear target acceleration (0,0,0) for unknown (float)
+                attitude_q                : (1 0 0 0 for unknown) (float)
+                rates                     : (0 0 0 for unknown) (float)
+                position_cov              : eph epv (float)
+                custom_state              : button states or switches of a tracker device (uint64_t)
+
+*/
+    mavlink20.messages.follow_target = function( ...moreargs ) {
+    [ this.timestamp , this.est_capabilities , this.lat , this.lon , this.alt , this.vel , this.acc , this.attitude_q , this.rates , this.position_cov , this.custom_state ] = moreargs;
+
+    this._format = '<QQiif3f3f4f3f3fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_FOLLOW_TARGET;
+    this.order_map = [0, 10, 2, 3, 4, 5, 6, 7, 8, 9, 1];
+    this.len_map = [1, 1, 1, 1, 1, 3, 3, 4, 3, 3, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 3, 3, 4, 3, 3, 0];
+    this.crc_extra = 127;
+    this._name = 'FOLLOW_TARGET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'est_capabilities', 'lat', 'lon', 'alt', 'vel', 'acc', 'attitude_q', 'rates', 'position_cov', 'custom_state'];
+
+}
+
+mavlink20.messages.follow_target.prototype = new mavlink20.message;
+mavlink20.messages.follow_target.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.custom_state, this.lat, this.lon, this.alt, this.vel, this.acc, this.attitude_q, this.rates, this.position_cov, this.est_capabilities];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The smoothed, monotonic system state used to feed the control loops of
+the system.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                x_acc                     : X acceleration in body frame (float)
+                y_acc                     : Y acceleration in body frame (float)
+                z_acc                     : Z acceleration in body frame (float)
+                x_vel                     : X velocity in body frame (float)
+                y_vel                     : Y velocity in body frame (float)
+                z_vel                     : Z velocity in body frame (float)
+                x_pos                     : X position in local frame (float)
+                y_pos                     : Y position in local frame (float)
+                z_pos                     : Z position in local frame (float)
+                airspeed                  : Airspeed, set to -1 if unknown (float)
+                vel_variance              : Variance of body velocity estimate (float)
+                pos_variance              : Variance in local position (float)
+                q                         : The attitude, represented as Quaternion (float)
+                roll_rate                 : Angular rate in roll axis (float)
+                pitch_rate                : Angular rate in pitch axis (float)
+                yaw_rate                  : Angular rate in yaw axis (float)
+
+*/
+    mavlink20.messages.control_system_state = function( ...moreargs ) {
+    [ this.time_usec , this.x_acc , this.y_acc , this.z_acc , this.x_vel , this.y_vel , this.z_vel , this.x_pos , this.y_pos , this.z_pos , this.airspeed , this.vel_variance , this.pos_variance , this.q , this.roll_rate , this.pitch_rate , this.yaw_rate ] = moreargs;
+
+    this._format = '<Qffffffffff3f3f4ffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 4, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 4, 0, 0, 0];
+    this.crc_extra = 103;
+    this._name = 'CONTROL_SYSTEM_STATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'x_acc', 'y_acc', 'z_acc', 'x_vel', 'y_vel', 'z_vel', 'x_pos', 'y_pos', 'z_pos', 'airspeed', 'vel_variance', 'pos_variance', 'q', 'roll_rate', 'pitch_rate', 'yaw_rate'];
+
+}
+
+mavlink20.messages.control_system_state.prototype = new mavlink20.message;
+mavlink20.messages.control_system_state.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.x_acc, this.y_acc, this.z_acc, this.x_vel, this.y_vel, this.z_vel, this.x_pos, this.y_pos, this.z_pos, this.airspeed, this.vel_variance, this.pos_variance, this.q, this.roll_rate, this.pitch_rate, this.yaw_rate];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Battery information
+
+                id                        : Battery ID (uint8_t)
+                battery_function          : Function of the battery (uint8_t)
+                type                      : Type (chemistry) of the battery (uint8_t)
+                temperature               : Temperature of the battery. INT16_MAX for unknown temperature. (int16_t)
+                voltages                  : Battery voltage of cells 1 to 10 (see voltages_ext for cells 11-14). Cells in this field above the valid cell count for this battery should have the UINT16_MAX value. If individual cell voltages are unknown or not measured for this battery, then the overall battery voltage should be filled in cell 0, with all others set to UINT16_MAX. If the voltage of the battery is greater than (UINT16_MAX - 1), then cell 0 should be set to (UINT16_MAX - 1), and cell 1 to the remaining voltage. This can be extended to multiple cells if the total voltage is greater than 2 * (UINT16_MAX - 1). (uint16_t)
+                current_battery           : Battery current, -1: autopilot does not measure the current (int16_t)
+                current_consumed          : Consumed charge, -1: autopilot does not provide consumption estimate (int32_t)
+                energy_consumed           : Consumed energy, -1: autopilot does not provide energy consumption estimate (int32_t)
+                battery_remaining         : Remaining battery energy. Values: [0-100], -1: autopilot does not estimate the remaining battery. (int8_t)
+                time_remaining            : Remaining battery time, 0: autopilot does not provide remaining battery time estimate (int32_t)
+                charge_state              : State for extent of discharge, provided by autopilot for warning or external reactions (uint8_t)
+                voltages_ext              : Battery voltages for cells 11 to 14. Cells above the valid cell count for this battery should have a value of 0, where zero indicates not supported (note, this is different than for the voltages field and allows empty byte truncation). If the measured value is 0 then 1 should be sent instead. (uint16_t)
+                mode                      : Battery mode. Default (0) is that battery mode reporting is not supported or battery is in normal-use mode. (uint8_t)
+                fault_bitmask             : Fault/health indications. These should be set when charge_state is MAV_BATTERY_CHARGE_STATE_FAILED or MAV_BATTERY_CHARGE_STATE_UNHEALTHY (if not, fault reporting is not supported). (uint32_t)
+
+*/
+    mavlink20.messages.battery_status = function( ...moreargs ) {
+    [ this.id , this.battery_function , this.type , this.temperature , this.voltages , this.current_battery , this.current_consumed , this.energy_consumed , this.battery_remaining , this.time_remaining , this.charge_state , this.voltages_ext , this.mode , this.fault_bitmask ] = moreargs;
+
+    this._format = '<iih10HhBBBbiB4HBI';
+    this._id = mavlink20.MAVLINK_MSG_ID_BATTERY_STATUS;
+    this.order_map = [5, 6, 7, 2, 3, 4, 0, 1, 8, 9, 10, 11, 12, 13];
+    this.len_map = [1, 1, 1, 10, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1];
+    this.array_len_map = [0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0];
+    this.crc_extra = 154;
+    this._name = 'BATTERY_STATUS';
+
+    this._instance_field = 'id';
+    this._instance_offset = 32;
+
+    this.fieldnames = ['id', 'battery_function', 'type', 'temperature', 'voltages', 'current_battery', 'current_consumed', 'energy_consumed', 'battery_remaining', 'time_remaining', 'charge_state', 'voltages_ext', 'mode', 'fault_bitmask'];
+
+}
+
+mavlink20.messages.battery_status.prototype = new mavlink20.message;
+mavlink20.messages.battery_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.current_consumed, this.energy_consumed, this.temperature, this.voltages, this.current_battery, this.id, this.battery_function, this.type, this.battery_remaining, this.time_remaining, this.charge_state, this.voltages_ext, this.mode, this.fault_bitmask];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Version and capability of autopilot software. This should be emitted
+in response to a request with MAV_CMD_REQUEST_MESSAGE.
+
+                capabilities              : Bitmap of capabilities (uint64_t)
+                flight_sw_version         : Firmware version number (uint32_t)
+                middleware_sw_version        : Middleware version number (uint32_t)
+                os_sw_version             : Operating system version number (uint32_t)
+                board_version             : HW / board version (last 8 bits should be silicon ID, if any). The first 16 bits of this field specify https://github.com/ardupilot/ardupilot/blob/master/Tools/AP_Bootloader/board_types.txt (uint32_t)
+                flight_custom_version        : Custom version field, commonly the first 8 bytes of the git hash. This is not an unique identifier, but should allow to identify the commit using the main version number even for very large code bases. (uint8_t)
+                middleware_custom_version        : Custom version field, commonly the first 8 bytes of the git hash. This is not an unique identifier, but should allow to identify the commit using the main version number even for very large code bases. (uint8_t)
+                os_custom_version         : Custom version field, commonly the first 8 bytes of the git hash. This is not an unique identifier, but should allow to identify the commit using the main version number even for very large code bases. (uint8_t)
+                vendor_id                 : ID of the board vendor (uint16_t)
+                product_id                : ID of the product (uint16_t)
+                uid                       : UID if provided by hardware (see uid2) (uint64_t)
+                uid2                      : UID if provided by hardware (supersedes the uid field. If this is non-zero, use this field, otherwise use uid) (uint8_t)
+
+*/
+    mavlink20.messages.autopilot_version = function( ...moreargs ) {
+    [ this.capabilities , this.flight_sw_version , this.middleware_sw_version , this.os_sw_version , this.board_version , this.flight_custom_version , this.middleware_custom_version , this.os_custom_version , this.vendor_id , this.product_id , this.uid , this.uid2 ] = moreargs;
+
+    this._format = '<QQIIIIHH8s8s8s18s';
+    this._id = mavlink20.MAVLINK_MSG_ID_AUTOPILOT_VERSION;
+    this.order_map = [0, 2, 3, 4, 5, 8, 9, 10, 6, 7, 1, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 8, 8, 8, 18];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 18];
+    this.crc_extra = 178;
+    this._name = 'AUTOPILOT_VERSION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['capabilities', 'flight_sw_version', 'middleware_sw_version', 'os_sw_version', 'board_version', 'flight_custom_version', 'middleware_custom_version', 'os_custom_version', 'vendor_id', 'product_id', 'uid', 'uid2'];
+
+}
+
+mavlink20.messages.autopilot_version.prototype = new mavlink20.message;
+mavlink20.messages.autopilot_version.prototype.pack = function(mav) {
+    var orderedfields = [ this.capabilities, this.uid, this.flight_sw_version, this.middleware_sw_version, this.os_sw_version, this.board_version, this.vendor_id, this.product_id, this.flight_custom_version, this.middleware_custom_version, this.os_custom_version, this.uid2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The location of a landing target. See:
+https://mavlink.io/en/services/landing_target.html
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                target_num                : The ID of the target if multiple targets are present (uint8_t)
+                frame                     : Coordinate frame used for following fields. (uint8_t)
+                angle_x                   : X-axis angular offset of the target from the center of the image (float)
+                angle_y                   : Y-axis angular offset of the target from the center of the image (float)
+                distance                  : Distance to the target from the vehicle (float)
+                size_x                    : Size of target along x-axis (float)
+                size_y                    : Size of target along y-axis (float)
+                x                         : X Position of the landing target in MAV_FRAME (float)
+                y                         : Y Position of the landing target in MAV_FRAME (float)
+                z                         : Z Position of the landing target in MAV_FRAME (float)
+                q                         : Quaternion of landing target orientation (w, x, y, z order, zero-rotation is 1, 0, 0, 0) (float)
+                type                      : Type of landing target (uint8_t)
+                position_valid            : Position fields (x, y, z, q, type) contain valid target position information (MAV_BOOL_FALSE: invalid values). Values not equal to 0 or 1 are invalid. (uint8_t)
+
+*/
+    mavlink20.messages.landing_target = function( ...moreargs ) {
+    [ this.time_usec , this.target_num , this.frame , this.angle_x , this.angle_y , this.distance , this.size_x , this.size_y , this.x , this.y , this.z , this.q , this.type , this.position_valid ] = moreargs;
+
+    this._format = '<QfffffBBfff4fBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LANDING_TARGET;
+    this.order_map = [0, 6, 7, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0];
+    this.crc_extra = 200;
+    this._name = 'LANDING_TARGET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'target_num', 'frame', 'angle_x', 'angle_y', 'distance', 'size_x', 'size_y', 'x', 'y', 'z', 'q', 'type', 'position_valid'];
+
+}
+
+mavlink20.messages.landing_target.prototype = new mavlink20.message;
+mavlink20.messages.landing_target.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.angle_x, this.angle_y, this.distance, this.size_x, this.size_y, this.target_num, this.frame, this.x, this.y, this.z, this.q, this.type, this.position_valid];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of geo-fencing. Sent in extended status stream when fencing
+enabled.
+
+                breach_status             : Breach status (0 if currently inside fence, 1 if outside). (uint8_t)
+                breach_count              : Number of fence breaches. (uint16_t)
+                breach_type               : Last breach type. (uint8_t)
+                breach_time               : Time (since boot) of last breach. (uint32_t)
+                breach_mitigation         : Active action to prevent fence breach (uint8_t)
+
+*/
+    mavlink20.messages.fence_status = function( ...moreargs ) {
+    [ this.breach_status , this.breach_count , this.breach_type , this.breach_time , this.breach_mitigation ] = moreargs;
+
+    this._format = '<IHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_FENCE_STATUS;
+    this.order_map = [2, 1, 3, 0, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 189;
+    this._name = 'FENCE_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['breach_status', 'breach_count', 'breach_type', 'breach_time', 'breach_mitigation'];
+
+}
+
+mavlink20.messages.fence_status.prototype = new mavlink20.message;
+mavlink20.messages.fence_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.breach_time, this.breach_count, this.breach_status, this.breach_type, this.breach_mitigation];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reports results of completed compass calibration. Sent until
+MAG_CAL_ACK received.
+
+                compass_id                : Compass being calibrated. (uint8_t)
+                cal_mask                  : Bitmask of compasses being calibrated. (uint8_t)
+                cal_status                : Calibration Status. (uint8_t)
+                autosaved                 : 0=requires a MAV_CMD_DO_ACCEPT_MAG_CAL, 1=saved to parameters. (uint8_t)
+                fitness                   : RMS milligauss residuals. (float)
+                ofs_x                     : X offset. (float)
+                ofs_y                     : Y offset. (float)
+                ofs_z                     : Z offset. (float)
+                diag_x                    : X diagonal (matrix 11). (float)
+                diag_y                    : Y diagonal (matrix 22). (float)
+                diag_z                    : Z diagonal (matrix 33). (float)
+                offdiag_x                 : X off-diagonal (matrix 12 and 21). (float)
+                offdiag_y                 : Y off-diagonal (matrix 13 and 31). (float)
+                offdiag_z                 : Z off-diagonal (matrix 32 and 23). (float)
+                orientation_confidence        : Confidence in orientation (higher is better). (float)
+                old_orientation           : orientation before calibration. (uint8_t)
+                new_orientation           : orientation after calibration. (uint8_t)
+                scale_factor              : field radius correction factor (float)
+
+*/
+    mavlink20.messages.mag_cal_report = function( ...moreargs ) {
+    [ this.compass_id , this.cal_mask , this.cal_status , this.autosaved , this.fitness , this.ofs_x , this.ofs_y , this.ofs_z , this.diag_x , this.diag_y , this.diag_z , this.offdiag_x , this.offdiag_y , this.offdiag_z , this.orientation_confidence , this.old_orientation , this.new_orientation , this.scale_factor ] = moreargs;
+
+    this._format = '<ffffffffffBBBBfBBf';
+    this._id = mavlink20.MAVLINK_MSG_ID_MAG_CAL_REPORT;
+    this.order_map = [10, 11, 12, 13, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 14, 15, 16, 17];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 36;
+    this._name = 'MAG_CAL_REPORT';
+
+    this._instance_field = 'compass_id';
+    this._instance_offset = 40;
+
+    this.fieldnames = ['compass_id', 'cal_mask', 'cal_status', 'autosaved', 'fitness', 'ofs_x', 'ofs_y', 'ofs_z', 'diag_x', 'diag_y', 'diag_z', 'offdiag_x', 'offdiag_y', 'offdiag_z', 'orientation_confidence', 'old_orientation', 'new_orientation', 'scale_factor'];
+
+}
+
+mavlink20.messages.mag_cal_report.prototype = new mavlink20.message;
+mavlink20.messages.mag_cal_report.prototype.pack = function(mav) {
+    var orderedfields = [ this.fitness, this.ofs_x, this.ofs_y, this.ofs_z, this.diag_x, this.diag_y, this.diag_z, this.offdiag_x, this.offdiag_y, this.offdiag_z, this.compass_id, this.cal_mask, this.cal_status, this.autosaved, this.orientation_confidence, this.old_orientation, this.new_orientation, this.scale_factor];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+EFI status output
+
+                health                    : EFI health status (uint8_t)
+                ecu_index                 : ECU index (float)
+                rpm                       : RPM (float)
+                fuel_consumed             : Fuel consumed (float)
+                fuel_flow                 : Fuel flow rate (float)
+                engine_load               : Engine load (float)
+                throttle_position         : Throttle position (float)
+                spark_dwell_time          : Spark dwell time (float)
+                barometric_pressure        : Barometric pressure (float)
+                intake_manifold_pressure        : Intake manifold pressure( (float)
+                intake_manifold_temperature        : Intake manifold temperature (float)
+                cylinder_head_temperature        : Cylinder head temperature (float)
+                ignition_timing           : Ignition timing (Crank angle degrees) (float)
+                injection_time            : Injection time (float)
+                exhaust_gas_temperature        : Exhaust gas temperature (float)
+                throttle_out              : Output throttle (float)
+                pt_compensation           : Pressure/temperature compensation (float)
+                ignition_voltage          : Supply voltage to EFI sparking system.  Zero in this value means "unknown", so if the supply voltage really is zero volts use 0.0001 instead. (float)
+                fuel_pressure             : Fuel pressure. Zero in this value means "unknown", so if the fuel pressure really is zero kPa use 0.0001 instead. (float)
+
+*/
+    mavlink20.messages.efi_status = function( ...moreargs ) {
+    [ this.health , this.ecu_index , this.rpm , this.fuel_consumed , this.fuel_flow , this.engine_load , this.throttle_position , this.spark_dwell_time , this.barometric_pressure , this.intake_manifold_pressure , this.intake_manifold_temperature , this.cylinder_head_temperature , this.ignition_timing , this.injection_time , this.exhaust_gas_temperature , this.throttle_out , this.pt_compensation , this.ignition_voltage , this.fuel_pressure ] = moreargs;
+
+    this._format = '<ffffffffffffffffBff';
+    this._id = mavlink20.MAVLINK_MSG_ID_EFI_STATUS;
+    this.order_map = [16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 208;
+    this._name = 'EFI_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['health', 'ecu_index', 'rpm', 'fuel_consumed', 'fuel_flow', 'engine_load', 'throttle_position', 'spark_dwell_time', 'barometric_pressure', 'intake_manifold_pressure', 'intake_manifold_temperature', 'cylinder_head_temperature', 'ignition_timing', 'injection_time', 'exhaust_gas_temperature', 'throttle_out', 'pt_compensation', 'ignition_voltage', 'fuel_pressure'];
+
+}
+
+mavlink20.messages.efi_status.prototype = new mavlink20.message;
+mavlink20.messages.efi_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.ecu_index, this.rpm, this.fuel_consumed, this.fuel_flow, this.engine_load, this.throttle_position, this.spark_dwell_time, this.barometric_pressure, this.intake_manifold_pressure, this.intake_manifold_temperature, this.cylinder_head_temperature, this.ignition_timing, this.injection_time, this.exhaust_gas_temperature, this.throttle_out, this.pt_compensation, this.health, this.ignition_voltage, this.fuel_pressure];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Estimator status message including flags, innovation test ratios and
+estimated accuracies. The flags message is an integer bitmask
+containing information on which EKF outputs are valid. See the
+ESTIMATOR_STATUS_FLAGS enum definition for further information. The
+innovation test ratios show the magnitude of the sensor innovation
+divided by the innovation check threshold. Under normal operation the
+innovation test ratios should be below 0.5 with occasional values up
+to 1.0. Values greater than 1.0 should be rare under normal operation
+and indicate that a measurement has been rejected by the filter. The
+user should be notified if an innovation test ratio greater than 1.0
+is recorded. Notifications for values in the range between 0.5 and 1.0
+should be optional and controllable by the user.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                flags                     : Bitmap indicating which EKF outputs are valid. (uint16_t)
+                vel_ratio                 : Velocity innovation test ratio (float)
+                pos_horiz_ratio           : Horizontal position innovation test ratio (float)
+                pos_vert_ratio            : Vertical position innovation test ratio (float)
+                mag_ratio                 : Magnetometer innovation test ratio (float)
+                hagl_ratio                : Height above terrain innovation test ratio (float)
+                tas_ratio                 : True airspeed innovation test ratio (float)
+                pos_horiz_accuracy        : Horizontal position 1-STD accuracy relative to the EKF local origin (float)
+                pos_vert_accuracy         : Vertical position 1-STD accuracy relative to the EKF local origin (float)
+
+*/
+    mavlink20.messages.estimator_status = function( ...moreargs ) {
+    [ this.time_usec , this.flags , this.vel_ratio , this.pos_horiz_ratio , this.pos_vert_ratio , this.mag_ratio , this.hagl_ratio , this.tas_ratio , this.pos_horiz_accuracy , this.pos_vert_accuracy ] = moreargs;
+
+    this._format = '<QffffffffH';
+    this._id = mavlink20.MAVLINK_MSG_ID_ESTIMATOR_STATUS;
+    this.order_map = [0, 9, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 163;
+    this._name = 'ESTIMATOR_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'flags', 'vel_ratio', 'pos_horiz_ratio', 'pos_vert_ratio', 'mag_ratio', 'hagl_ratio', 'tas_ratio', 'pos_horiz_accuracy', 'pos_vert_accuracy'];
+
+}
+
+mavlink20.messages.estimator_status.prototype = new mavlink20.message;
+mavlink20.messages.estimator_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.vel_ratio, this.pos_horiz_ratio, this.pos_vert_ratio, this.mag_ratio, this.hagl_ratio, this.tas_ratio, this.pos_horiz_accuracy, this.pos_vert_accuracy, this.flags];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Wind covariance estimate from vehicle.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                wind_x                    : Wind in X (NED) direction (float)
+                wind_y                    : Wind in Y (NED) direction (float)
+                wind_z                    : Wind in Z (NED) direction (float)
+                var_horiz                 : Variability of the wind in XY. RMS of a 1 Hz lowpassed wind estimate. (float)
+                var_vert                  : Variability of the wind in Z. RMS of a 1 Hz lowpassed wind estimate. (float)
+                wind_alt                  : Altitude (MSL) that this measurement was taken at (float)
+                horiz_accuracy            : Horizontal speed 1-STD accuracy (float)
+                vert_accuracy             : Vertical speed 1-STD accuracy (float)
+
+*/
+    mavlink20.messages.wind_cov = function( ...moreargs ) {
+    [ this.time_usec , this.wind_x , this.wind_y , this.wind_z , this.var_horiz , this.var_vert , this.wind_alt , this.horiz_accuracy , this.vert_accuracy ] = moreargs;
+
+    this._format = '<Qffffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_WIND_COV;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 105;
+    this._name = 'WIND_COV';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'wind_x', 'wind_y', 'wind_z', 'var_horiz', 'var_vert', 'wind_alt', 'horiz_accuracy', 'vert_accuracy'];
+
+}
+
+mavlink20.messages.wind_cov.prototype = new mavlink20.message;
+mavlink20.messages.wind_cov.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.wind_x, this.wind_y, this.wind_z, this.var_horiz, this.var_vert, this.wind_alt, this.horiz_accuracy, this.vert_accuracy];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+GPS sensor input message.  This is a raw sensor value sent by the GPS.
+This is NOT the global position estimate of the system.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                gps_id                    : ID of the GPS for multiple GPS inputs (uint8_t)
+                ignore_flags              : Bitmap indicating which GPS input flags fields to ignore.  All other fields must be provided. (uint16_t)
+                time_week_ms              : GPS time (from start of GPS week) (uint32_t)
+                time_week                 : GPS week number (uint16_t)
+                fix_type                  : 0-1: no fix, 2: 2D fix, 3: 3D fix. 4: 3D with DGPS. 5: 3D with RTK (uint8_t)
+                lat                       : Latitude (WGS84) (int32_t)
+                lon                       : Longitude (WGS84) (int32_t)
+                alt                       : Altitude (MSL). Positive for up. (float)
+                hdop                      : GPS HDOP horizontal dilution of position (unitless). If unknown, set to: UINT16_MAX (float)
+                vdop                      : GPS VDOP vertical dilution of position (unitless). If unknown, set to: UINT16_MAX (float)
+                vn                        : GPS velocity in north direction in earth-fixed NED frame (float)
+                ve                        : GPS velocity in east direction in earth-fixed NED frame (float)
+                vd                        : GPS velocity in down direction in earth-fixed NED frame (float)
+                speed_accuracy            : GPS speed accuracy (float)
+                horiz_accuracy            : GPS horizontal accuracy (float)
+                vert_accuracy             : GPS vertical accuracy (float)
+                satellites_visible        : Number of satellites visible. (uint8_t)
+                yaw                       : Yaw of vehicle relative to Earth's North, zero means not available, use 36000 for north (uint16_t)
+
+*/
+    mavlink20.messages.gps_input = function( ...moreargs ) {
+    [ this.time_usec , this.gps_id , this.ignore_flags , this.time_week_ms , this.time_week , this.fix_type , this.lat , this.lon , this.alt , this.hdop , this.vdop , this.vn , this.ve , this.vd , this.speed_accuracy , this.horiz_accuracy , this.vert_accuracy , this.satellites_visible , this.yaw ] = moreargs;
+
+    this._format = '<QIiifffffffffHHBBBH';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS_INPUT;
+    this.order_map = [0, 15, 13, 1, 14, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 17, 18];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 151;
+    this._name = 'GPS_INPUT';
+
+    this._instance_field = 'gps_id';
+    this._instance_offset = 60;
+
+    this.fieldnames = ['time_usec', 'gps_id', 'ignore_flags', 'time_week_ms', 'time_week', 'fix_type', 'lat', 'lon', 'alt', 'hdop', 'vdop', 'vn', 've', 'vd', 'speed_accuracy', 'horiz_accuracy', 'vert_accuracy', 'satellites_visible', 'yaw'];
+
+}
+
+mavlink20.messages.gps_input.prototype = new mavlink20.message;
+mavlink20.messages.gps_input.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.time_week_ms, this.lat, this.lon, this.alt, this.hdop, this.vdop, this.vn, this.ve, this.vd, this.speed_accuracy, this.horiz_accuracy, this.vert_accuracy, this.ignore_flags, this.time_week, this.gps_id, this.fix_type, this.satellites_visible, this.yaw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+RTCM message for injecting into the onboard GPS (used for DGPS)
+
+                flags                     : LSB: 1 means message is fragmented, next 2 bits are the fragment ID, the remaining 5 bits are used for the sequence ID. Messages are only to be flushed to the GPS when the entire message has been reconstructed on the autopilot. The fragment ID specifies which order the fragments should be assembled into a buffer, while the sequence ID is used to detect a mismatch between different buffers. The buffer is considered fully reconstructed when either all 4 fragments are present, or all the fragments before the first fragment with a non full payload is received. This management is used to ensure that normal GPS operation doesn't corrupt RTCM data, and to recover from a unreliable transport delivery order. (uint8_t)
+                len                       : data length (uint8_t)
+                data                      : RTCM message (may be fragmented) (uint8_t)
+
+*/
+    mavlink20.messages.gps_rtcm_data = function( ...moreargs ) {
+    [ this.flags , this.len , this.data ] = moreargs;
+
+    this._format = '<BB180s';
+    this._id = mavlink20.MAVLINK_MSG_ID_GPS_RTCM_DATA;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 180];
+    this.array_len_map = [0, 0, 180];
+    this.crc_extra = 35;
+    this._name = 'GPS_RTCM_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['flags', 'len', 'data'];
+
+}
+
+mavlink20.messages.gps_rtcm_data.prototype = new mavlink20.message;
+mavlink20.messages.gps_rtcm_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.flags, this.len, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message appropriate for high latency connections like Iridium
+
+                base_mode                 : Bitmap of enabled system modes. (uint8_t)
+                custom_mode               : A bitfield for use for autopilot-specific flags. (uint32_t)
+                landed_state              : The landed state. Is set to MAV_LANDED_STATE_UNDEFINED if landed state is unknown. (uint8_t)
+                roll                      : roll (int16_t)
+                pitch                     : pitch (int16_t)
+                heading                   : heading (uint16_t)
+                throttle                  : throttle (percentage) (int8_t)
+                heading_sp                : heading setpoint (int16_t)
+                latitude                  : Latitude (int32_t)
+                longitude                 : Longitude (int32_t)
+                altitude_amsl             : Altitude above mean sea level (int16_t)
+                altitude_sp               : Altitude setpoint relative to the home position (int16_t)
+                airspeed                  : airspeed (uint8_t)
+                airspeed_sp               : airspeed setpoint (uint8_t)
+                groundspeed               : groundspeed (uint8_t)
+                climb_rate                : climb rate (int8_t)
+                gps_nsat                  : Number of satellites visible. If unknown, set to UINT8_MAX (uint8_t)
+                gps_fix_type              : GPS Fix type. (uint8_t)
+                battery_remaining         : Remaining battery (percentage) (uint8_t)
+                temperature               : Autopilot temperature (degrees C) (int8_t)
+                temperature_air           : Air temperature (degrees C) from airspeed sensor (int8_t)
+                failsafe                  : failsafe (each bit represents a failsafe where 0=ok, 1=failsafe active (bit0:RC, bit1:batt, bit2:GPS, bit3:GCS, bit4:fence) (uint8_t)
+                wp_num                    : current waypoint number (uint8_t)
+                wp_distance               : distance to target (uint16_t)
+
+*/
+    mavlink20.messages.high_latency = function( ...moreargs ) {
+    [ this.base_mode , this.custom_mode , this.landed_state , this.roll , this.pitch , this.heading , this.throttle , this.heading_sp , this.latitude , this.longitude , this.altitude_amsl , this.altitude_sp , this.airspeed , this.airspeed_sp , this.groundspeed , this.climb_rate , this.gps_nsat , this.gps_fix_type , this.battery_remaining , this.temperature , this.temperature_air , this.failsafe , this.wp_num , this.wp_distance ] = moreargs;
+
+    this._format = '<IiihhHhhhHBBbBBBbBBBbbBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIGH_LATENCY;
+    this.order_map = [10, 0, 11, 3, 4, 5, 12, 6, 1, 2, 7, 8, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 150;
+    this._name = 'HIGH_LATENCY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['base_mode', 'custom_mode', 'landed_state', 'roll', 'pitch', 'heading', 'throttle', 'heading_sp', 'latitude', 'longitude', 'altitude_amsl', 'altitude_sp', 'airspeed', 'airspeed_sp', 'groundspeed', 'climb_rate', 'gps_nsat', 'gps_fix_type', 'battery_remaining', 'temperature', 'temperature_air', 'failsafe', 'wp_num', 'wp_distance'];
+
+}
+
+mavlink20.messages.high_latency.prototype = new mavlink20.message;
+mavlink20.messages.high_latency.prototype.pack = function(mav) {
+    var orderedfields = [ this.custom_mode, this.latitude, this.longitude, this.roll, this.pitch, this.heading, this.heading_sp, this.altitude_amsl, this.altitude_sp, this.wp_distance, this.base_mode, this.landed_state, this.throttle, this.airspeed, this.airspeed_sp, this.groundspeed, this.climb_rate, this.gps_nsat, this.gps_fix_type, this.battery_remaining, this.temperature, this.temperature_air, this.failsafe, this.wp_num];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message appropriate for high latency connections like Iridium (version
+2)
+
+                timestamp                 : Timestamp (milliseconds since boot or Unix epoch) (uint32_t)
+                type                      : Type of the MAV (quadrotor, helicopter, etc.) (uint8_t)
+                autopilot                 : Autopilot type / class. Use MAV_AUTOPILOT_INVALID for components that are not flight controllers. (uint8_t)
+                custom_mode               : A bitfield for use for autopilot-specific flags (2 byte version). (uint16_t)
+                latitude                  : Latitude (int32_t)
+                longitude                 : Longitude (int32_t)
+                altitude                  : Altitude above mean sea level (int16_t)
+                target_altitude           : Altitude setpoint (int16_t)
+                heading                   : Heading (uint8_t)
+                target_heading            : Heading setpoint (uint8_t)
+                target_distance           : Distance to target waypoint or position (uint16_t)
+                throttle                  : Throttle (uint8_t)
+                airspeed                  : Airspeed (uint8_t)
+                airspeed_sp               : Airspeed setpoint (uint8_t)
+                groundspeed               : Groundspeed (uint8_t)
+                windspeed                 : Windspeed (uint8_t)
+                wind_heading              : Wind heading (uint8_t)
+                eph                       : Maximum error horizontal position since last message (uint8_t)
+                epv                       : Maximum error vertical position since last message (uint8_t)
+                temperature_air           : Air temperature from airspeed sensor (int8_t)
+                climb_rate                : Maximum climb rate magnitude since last message (int8_t)
+                battery                   : Battery level (-1 if field not provided). (int8_t)
+                wp_num                    : Current waypoint number (uint16_t)
+                failure_flags             : Bitmap of failure flags. (uint16_t)
+                custom0                   : Field for custom payload. (int8_t)
+                custom1                   : Field for custom payload. (int8_t)
+                custom2                   : Field for custom payload. (int8_t)
+
+*/
+    mavlink20.messages.high_latency2 = function( ...moreargs ) {
+    [ this.timestamp , this.type , this.autopilot , this.custom_mode , this.latitude , this.longitude , this.altitude , this.target_altitude , this.heading , this.target_heading , this.target_distance , this.throttle , this.airspeed , this.airspeed_sp , this.groundspeed , this.windspeed , this.wind_heading , this.eph , this.epv , this.temperature_air , this.climb_rate , this.battery , this.wp_num , this.failure_flags , this.custom0 , this.custom1 , this.custom2 ] = moreargs;
+
+    this._format = '<IiiHhhHHHBBBBBBBBBBBBbbbbbb';
+    this._id = mavlink20.MAVLINK_MSG_ID_HIGH_LATENCY2;
+    this.order_map = [0, 9, 10, 3, 1, 2, 4, 5, 11, 12, 6, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 7, 8, 24, 25, 26];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 179;
+    this._name = 'HIGH_LATENCY2';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'type', 'autopilot', 'custom_mode', 'latitude', 'longitude', 'altitude', 'target_altitude', 'heading', 'target_heading', 'target_distance', 'throttle', 'airspeed', 'airspeed_sp', 'groundspeed', 'windspeed', 'wind_heading', 'eph', 'epv', 'temperature_air', 'climb_rate', 'battery', 'wp_num', 'failure_flags', 'custom0', 'custom1', 'custom2'];
+
+}
+
+mavlink20.messages.high_latency2.prototype = new mavlink20.message;
+mavlink20.messages.high_latency2.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.latitude, this.longitude, this.custom_mode, this.altitude, this.target_altitude, this.target_distance, this.wp_num, this.failure_flags, this.type, this.autopilot, this.heading, this.target_heading, this.throttle, this.airspeed, this.airspeed_sp, this.groundspeed, this.windspeed, this.wind_heading, this.eph, this.epv, this.temperature_air, this.climb_rate, this.battery, this.custom0, this.custom1, this.custom2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Vibration levels and accelerometer clipping
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                vibration_x               : Vibration levels on X-axis (float)
+                vibration_y               : Vibration levels on Y-axis (float)
+                vibration_z               : Vibration levels on Z-axis (float)
+                clipping_0                : first accelerometer clipping count (uint32_t)
+                clipping_1                : second accelerometer clipping count (uint32_t)
+                clipping_2                : third accelerometer clipping count (uint32_t)
+
+*/
+    mavlink20.messages.vibration = function( ...moreargs ) {
+    [ this.time_usec , this.vibration_x , this.vibration_y , this.vibration_z , this.clipping_0 , this.clipping_1 , this.clipping_2 ] = moreargs;
+
+    this._format = '<QfffIII';
+    this._id = mavlink20.MAVLINK_MSG_ID_VIBRATION;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 90;
+    this._name = 'VIBRATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'vibration_x', 'vibration_y', 'vibration_z', 'clipping_0', 'clipping_1', 'clipping_2'];
+
+}
+
+mavlink20.messages.vibration.prototype = new mavlink20.message;
+mavlink20.messages.vibration.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.vibration_x, this.vibration_y, this.vibration_z, this.clipping_0, this.clipping_1, this.clipping_2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+This message can be requested by sending the MAV_CMD_GET_HOME_POSITION
+command. The position the system will return to and land on. The
+position is set automatically by the system during the takeoff in case
+it was not explicitly set by the operator before or after. The global
+and local positions encode the position in the respective coordinate
+frames, while the q parameter encodes the orientation of the surface.
+Under normal conditions it describes the heading and terrain slope,
+which can be used by the aircraft to adjust the approach. The approach
+3D vector describes the point to which the system should fly in normal
+flight mode and then perform a landing sequence along the vector.
+
+                latitude                  : Latitude (WGS84) (int32_t)
+                longitude                 : Longitude (WGS84) (int32_t)
+                altitude                  : Altitude (MSL). Positive for up. (int32_t)
+                x                         : Local X position of this position in the local coordinate frame (float)
+                y                         : Local Y position of this position in the local coordinate frame (float)
+                z                         : Local Z position of this position in the local coordinate frame (float)
+                q                         : World to surface normal and heading transformation of the takeoff position. Used to indicate the heading and slope of the ground (float)
+                approach_x                : Local X position of the end of the approach vector. Multicopters should set this position based on their takeoff path. Grass-landing fixed wing aircraft should set it the same way as multicopters. Runway-landing fixed wing aircraft should set it to the opposite direction of the takeoff, assuming the takeoff happened from the threshold / touchdown zone. (float)
+                approach_y                : Local Y position of the end of the approach vector. Multicopters should set this position based on their takeoff path. Grass-landing fixed wing aircraft should set it the same way as multicopters. Runway-landing fixed wing aircraft should set it to the opposite direction of the takeoff, assuming the takeoff happened from the threshold / touchdown zone. (float)
+                approach_z                : Local Z position of the end of the approach vector. Multicopters should set this position based on their takeoff path. Grass-landing fixed wing aircraft should set it the same way as multicopters. Runway-landing fixed wing aircraft should set it to the opposite direction of the takeoff, assuming the takeoff happened from the threshold / touchdown zone. (float)
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+
+*/
+    mavlink20.messages.home_position = function( ...moreargs ) {
+    [ this.latitude , this.longitude , this.altitude , this.x , this.y , this.z , this.q , this.approach_x , this.approach_y , this.approach_z , this.time_usec ] = moreargs;
+
+    this._format = '<iiifff4ffffQ';
+    this._id = mavlink20.MAVLINK_MSG_ID_HOME_POSITION;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0];
+    this.crc_extra = 104;
+    this._name = 'HOME_POSITION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['latitude', 'longitude', 'altitude', 'x', 'y', 'z', 'q', 'approach_x', 'approach_y', 'approach_z', 'time_usec'];
+
+}
+
+mavlink20.messages.home_position.prototype = new mavlink20.message;
+mavlink20.messages.home_position.prototype.pack = function(mav) {
+    var orderedfields = [ this.latitude, this.longitude, this.altitude, this.x, this.y, this.z, this.q, this.approach_x, this.approach_y, this.approach_z, this.time_usec];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The position the system will return to and land on. The position is
+set automatically by the system during the takeoff in case it was not
+explicitly set by the operator before or after. The global and local
+positions encode the position in the respective coordinate frames,
+while the q parameter encodes the orientation of the surface. Under
+normal conditions it describes the heading and terrain slope, which
+can be used by the aircraft to adjust the approach. The approach 3D
+vector describes the point to which the system should fly in normal
+flight mode and then perform a landing sequence along the vector.
+
+                target_system             : System ID. (uint8_t)
+                latitude                  : Latitude (WGS84) (int32_t)
+                longitude                 : Longitude (WGS84) (int32_t)
+                altitude                  : Altitude (MSL). Positive for up. (int32_t)
+                x                         : Local X position of this position in the local coordinate frame (float)
+                y                         : Local Y position of this position in the local coordinate frame (float)
+                z                         : Local Z position of this position in the local coordinate frame (float)
+                q                         : World to surface normal and heading transformation of the takeoff position. Used to indicate the heading and slope of the ground (float)
+                approach_x                : Local X position of the end of the approach vector. Multicopters should set this position based on their takeoff path. Grass-landing fixed wing aircraft should set it the same way as multicopters. Runway-landing fixed wing aircraft should set it to the opposite direction of the takeoff, assuming the takeoff happened from the threshold / touchdown zone. (float)
+                approach_y                : Local Y position of the end of the approach vector. Multicopters should set this position based on their takeoff path. Grass-landing fixed wing aircraft should set it the same way as multicopters. Runway-landing fixed wing aircraft should set it to the opposite direction of the takeoff, assuming the takeoff happened from the threshold / touchdown zone. (float)
+                approach_z                : Local Z position of the end of the approach vector. Multicopters should set this position based on their takeoff path. Grass-landing fixed wing aircraft should set it the same way as multicopters. Runway-landing fixed wing aircraft should set it to the opposite direction of the takeoff, assuming the takeoff happened from the threshold / touchdown zone. (float)
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+
+*/
+    mavlink20.messages.set_home_position = function( ...moreargs ) {
+    [ this.target_system , this.latitude , this.longitude , this.altitude , this.x , this.y , this.z , this.q , this.approach_x , this.approach_y , this.approach_z , this.time_usec ] = moreargs;
+
+    this._format = '<iiifff4ffffBQ';
+    this._id = mavlink20.MAVLINK_MSG_ID_SET_HOME_POSITION;
+    this.order_map = [10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0];
+    this.crc_extra = 85;
+    this._name = 'SET_HOME_POSITION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'latitude', 'longitude', 'altitude', 'x', 'y', 'z', 'q', 'approach_x', 'approach_y', 'approach_z', 'time_usec'];
+
+}
+
+mavlink20.messages.set_home_position.prototype = new mavlink20.message;
+mavlink20.messages.set_home_position.prototype.pack = function(mav) {
+    var orderedfields = [ this.latitude, this.longitude, this.altitude, this.x, this.y, this.z, this.q, this.approach_x, this.approach_y, this.approach_z, this.target_system, this.time_usec];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The interval between messages for a particular MAVLink message ID.
+This message is sent in response to the MAV_CMD_REQUEST_MESSAGE
+command with param1=244 (this message) and param2=message_id (the id
+of the message for which the interval is required).         It may
+also be sent in response to MAV_CMD_GET_MESSAGE_INTERVAL.         This
+interface replaces DATA_STREAM.
+
+                message_id                : The ID of the requested MAVLink message. v1.0 is limited to 254 messages. (uint16_t)
+                interval_us               : The interval between two messages. A value of -1 indicates this stream is disabled, 0 indicates it is not available, > 0 indicates the interval at which it is sent. (int32_t)
+
+*/
+    mavlink20.messages.message_interval = function( ...moreargs ) {
+    [ this.message_id , this.interval_us ] = moreargs;
+
+    this._format = '<iH';
+    this._id = mavlink20.MAVLINK_MSG_ID_MESSAGE_INTERVAL;
+    this.order_map = [1, 0];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 95;
+    this._name = 'MESSAGE_INTERVAL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['message_id', 'interval_us'];
+
+}
+
+mavlink20.messages.message_interval.prototype = new mavlink20.message;
+mavlink20.messages.message_interval.prototype.pack = function(mav) {
+    var orderedfields = [ this.interval_us, this.message_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Provides state for additional features
+
+                vtol_state                : The VTOL state if applicable. Is set to MAV_VTOL_STATE_UNDEFINED if UAV is not in VTOL configuration. (uint8_t)
+                landed_state              : The landed state. Is set to MAV_LANDED_STATE_UNDEFINED if landed state is unknown. (uint8_t)
+
+*/
+    mavlink20.messages.extended_sys_state = function( ...moreargs ) {
+    [ this.vtol_state , this.landed_state ] = moreargs;
+
+    this._format = '<BB';
+    this._id = mavlink20.MAVLINK_MSG_ID_EXTENDED_SYS_STATE;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 130;
+    this._name = 'EXTENDED_SYS_STATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['vtol_state', 'landed_state'];
+
+}
+
+mavlink20.messages.extended_sys_state.prototype = new mavlink20.message;
+mavlink20.messages.extended_sys_state.prototype.pack = function(mav) {
+    var orderedfields = [ this.vtol_state, this.landed_state];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The location and information of an ADSB vehicle
+
+                ICAO_address              : ICAO address (uint32_t)
+                lat                       : Latitude (int32_t)
+                lon                       : Longitude (int32_t)
+                altitude_type             : ADSB altitude type. (uint8_t)
+                altitude                  : Altitude(ASL) (int32_t)
+                heading                   : Course over ground (uint16_t)
+                hor_velocity              : The horizontal velocity (uint16_t)
+                ver_velocity              : The vertical velocity. Positive is up (int16_t)
+                callsign                  : The callsign, 8+null (char)
+                emitter_type              : ADSB emitter type. (uint8_t)
+                tslc                      : Time since last communication in seconds (uint8_t)
+                flags                     : Bitmap to indicate various statuses including valid data fields (uint16_t)
+                squawk                    : Squawk code (uint16_t)
+
+*/
+    mavlink20.messages.adsb_vehicle = function( ...moreargs ) {
+    [ this.ICAO_address , this.lat , this.lon , this.altitude_type , this.altitude , this.heading , this.hor_velocity , this.ver_velocity , this.callsign , this.emitter_type , this.tslc , this.flags , this.squawk ] = moreargs;
+
+    this._format = '<IiiiHHhHHB9sBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ADSB_VEHICLE;
+    this.order_map = [0, 1, 2, 9, 3, 4, 5, 6, 10, 11, 12, 7, 8];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0];
+    this.crc_extra = 184;
+    this._name = 'ADSB_VEHICLE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['ICAO_address', 'lat', 'lon', 'altitude_type', 'altitude', 'heading', 'hor_velocity', 'ver_velocity', 'callsign', 'emitter_type', 'tslc', 'flags', 'squawk'];
+
+}
+
+mavlink20.messages.adsb_vehicle.prototype = new mavlink20.message;
+mavlink20.messages.adsb_vehicle.prototype.pack = function(mav) {
+    var orderedfields = [ this.ICAO_address, this.lat, this.lon, this.altitude, this.heading, this.hor_velocity, this.ver_velocity, this.flags, this.squawk, this.altitude_type, this.callsign, this.emitter_type, this.tslc];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about a potential collision
+
+                src                       : Collision data source (uint8_t)
+                id                        : Unique identifier, domain based on src field (uint32_t)
+                action                    : Action that is being taken to avoid this collision (uint8_t)
+                threat_level              : How concerned the aircraft is about this collision (uint8_t)
+                time_to_minimum_delta        : Estimated time until collision occurs (float)
+                altitude_minimum_delta        : Closest vertical distance between vehicle and object (float)
+                horizontal_minimum_delta        : Closest horizontal distance between vehicle and object (float)
+
+*/
+    mavlink20.messages.collision = function( ...moreargs ) {
+    [ this.src , this.id , this.action , this.threat_level , this.time_to_minimum_delta , this.altitude_minimum_delta , this.horizontal_minimum_delta ] = moreargs;
+
+    this._format = '<IfffBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_COLLISION;
+    this.order_map = [4, 0, 5, 6, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 81;
+    this._name = 'COLLISION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['src', 'id', 'action', 'threat_level', 'time_to_minimum_delta', 'altitude_minimum_delta', 'horizontal_minimum_delta'];
+
+}
+
+mavlink20.messages.collision.prototype = new mavlink20.message;
+mavlink20.messages.collision.prototype.pack = function(mav) {
+    var orderedfields = [ this.id, this.time_to_minimum_delta, this.altitude_minimum_delta, this.horizontal_minimum_delta, this.src, this.action, this.threat_level];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message implementing parts of the V2 payload specs in V1 frames for
+transitional support.
+
+                target_network            : Network ID (0 for broadcast) (uint8_t)
+                target_system             : System ID (0 for broadcast) (uint8_t)
+                target_component          : Component ID (0 for broadcast) (uint8_t)
+                message_type              : A code that identifies the software component that understands this message (analogous to USB device classes or mime type strings). If this code is less than 32768, it is considered a 'registered' protocol extension and the corresponding entry should be added to https://github.com/mavlink/mavlink/definition_files/extension_message_ids.xml. Software creators can register blocks of message IDs as needed (useful for GCS specific metadata, etc...). Message_types greater than 32767 are considered local experiments and should not be checked in to any widely distributed codebase. (uint16_t)
+                payload                   : Variable length payload. The length must be encoded in the payload as part of the message_type protocol, e.g. by including the length as payload data, or by terminating the payload data with a non-zero marker. This is required in order to reconstruct zero-terminated payloads that are (or otherwise would be) trimmed by MAVLink 2 empty-byte truncation. The entire content of the payload block is opaque unless you understand the encoding message_type. The particular encoding used can be extension specific and might not always be documented as part of the MAVLink specification. (uint8_t)
+
+*/
+    mavlink20.messages.v2_extension = function( ...moreargs ) {
+    [ this.target_network , this.target_system , this.target_component , this.message_type , this.payload ] = moreargs;
+
+    this._format = '<HBBB249s';
+    this._id = mavlink20.MAVLINK_MSG_ID_V2_EXTENSION;
+    this.order_map = [1, 2, 3, 0, 4];
+    this.len_map = [1, 1, 1, 1, 249];
+    this.array_len_map = [0, 0, 0, 0, 249];
+    this.crc_extra = 8;
+    this._name = 'V2_EXTENSION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_network', 'target_system', 'target_component', 'message_type', 'payload'];
+
+}
+
+mavlink20.messages.v2_extension.prototype = new mavlink20.message;
+mavlink20.messages.v2_extension.prototype.pack = function(mav) {
+    var orderedfields = [ this.message_type, this.target_network, this.target_system, this.target_component, this.payload];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send raw controller memory. The use of this message is discouraged for
+normal packets, but a quite efficient way for testing new messages and
+getting experimental debug output.
+
+                address                   : Starting address of the debug variables (uint16_t)
+                ver                       : Version code of the type variable. 0=unknown, type ignored and assumed int16_t. 1=as below (uint8_t)
+                type                      : Type code of the memory variables. for ver = 1: 0=16 x int16_t, 1=16 x uint16_t, 2=16 x Q15, 3=16 x 1Q14 (uint8_t)
+                value                     : Memory contents at specified address (int8_t)
+
+*/
+    mavlink20.messages.memory_vect = function( ...moreargs ) {
+    [ this.address , this.ver , this.type , this.value ] = moreargs;
+
+    this._format = '<HBB32s';
+    this._id = mavlink20.MAVLINK_MSG_ID_MEMORY_VECT;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 32];
+    this.array_len_map = [0, 0, 0, 32];
+    this.crc_extra = 204;
+    this._name = 'MEMORY_VECT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['address', 'ver', 'type', 'value'];
+
+}
+
+mavlink20.messages.memory_vect.prototype = new mavlink20.message;
+mavlink20.messages.memory_vect.prototype.pack = function(mav) {
+    var orderedfields = [ this.address, this.ver, this.type, this.value];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+To debug something using a named 3D vector.
+
+                name                      : Name (char)
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                x                         : x (float)
+                y                         : y (float)
+                z                         : z (float)
+
+*/
+    mavlink20.messages.debug_vect = function( ...moreargs ) {
+    [ this.name , this.time_usec , this.x , this.y , this.z ] = moreargs;
+
+    this._format = '<Qfff10s';
+    this._id = mavlink20.MAVLINK_MSG_ID_DEBUG_VECT;
+    this.order_map = [4, 0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 10];
+    this.crc_extra = 49;
+    this._name = 'DEBUG_VECT';
+
+    this._instance_field = 'name';
+    this._instance_offset = 20;
+
+    this.fieldnames = ['name', 'time_usec', 'x', 'y', 'z'];
+
+}
+
+mavlink20.messages.debug_vect.prototype = new mavlink20.message;
+mavlink20.messages.debug_vect.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.x, this.y, this.z, this.name];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send a key-value pair as float. The use of this message is discouraged
+for normal packets, but a quite efficient way for testing new messages
+and getting experimental debug output.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                name                      : Name of the debug variable (char)
+                value                     : Floating point value (float)
+
+*/
+    mavlink20.messages.named_value_float = function( ...moreargs ) {
+    [ this.time_boot_ms , this.name , this.value ] = moreargs;
+
+    this._format = '<If10s';
+    this._id = mavlink20.MAVLINK_MSG_ID_NAMED_VALUE_FLOAT;
+    this.order_map = [0, 2, 1];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 10];
+    this.crc_extra = 170;
+    this._name = 'NAMED_VALUE_FLOAT';
+
+    this._instance_field = 'name';
+    this._instance_offset = 8;
+
+    this.fieldnames = ['time_boot_ms', 'name', 'value'];
+
+}
+
+mavlink20.messages.named_value_float.prototype = new mavlink20.message;
+mavlink20.messages.named_value_float.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.value, this.name];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send a key-value pair as integer. The use of this message is
+discouraged for normal packets, but a quite efficient way for testing
+new messages and getting experimental debug output.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                name                      : Name of the debug variable (char)
+                value                     : Signed integer value (int32_t)
+
+*/
+    mavlink20.messages.named_value_int = function( ...moreargs ) {
+    [ this.time_boot_ms , this.name , this.value ] = moreargs;
+
+    this._format = '<Ii10s';
+    this._id = mavlink20.MAVLINK_MSG_ID_NAMED_VALUE_INT;
+    this.order_map = [0, 2, 1];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 10];
+    this.crc_extra = 44;
+    this._name = 'NAMED_VALUE_INT';
+
+    this._instance_field = 'name';
+    this._instance_offset = 8;
+
+    this.fieldnames = ['time_boot_ms', 'name', 'value'];
+
+}
+
+mavlink20.messages.named_value_int.prototype = new mavlink20.message;
+mavlink20.messages.named_value_int.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.value, this.name];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status text message. These messages are printed in yellow in the COMM
+console of QGroundControl. WARNING: They consume quite some bandwidth,
+so use only for important status and error messages. If implemented
+wisely, these messages are buffered on the MCU and sent only at a
+limited rate (e.g. 10 Hz).
+
+                severity                  : Severity of status. Relies on the definitions within RFC-5424. (uint8_t)
+                text                      : Status text message, without null termination character (char)
+                id                        : Unique (opaque) identifier for this statustext message.  May be used to reassemble a logical long-statustext message from a sequence of chunks.  A value of zero indicates this is the only chunk in the sequence and the message can be emitted immediately. (uint16_t)
+                chunk_seq                 : This chunk's sequence number; indexing is from zero.  Any null character in the text field is taken to mean this was the last chunk. (uint8_t)
+
+*/
+    mavlink20.messages.statustext = function( ...moreargs ) {
+    [ this.severity , this.text , this.id , this.chunk_seq ] = moreargs;
+
+    this._format = '<B50sHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_STATUSTEXT;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 50, 0, 0];
+    this.crc_extra = 83;
+    this._name = 'STATUSTEXT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['severity', 'text', 'id', 'chunk_seq'];
+
+}
+
+mavlink20.messages.statustext.prototype = new mavlink20.message;
+mavlink20.messages.statustext.prototype.pack = function(mav) {
+    var orderedfields = [ this.severity, this.text, this.id, this.chunk_seq];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Send a debug value. The index is used to discriminate between values.
+These values show up in the plot of QGroundControl as DEBUG N.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                ind                       : index of debug variable (uint8_t)
+                value                     : DEBUG value (float)
+
+*/
+    mavlink20.messages.debug = function( ...moreargs ) {
+    [ this.time_boot_ms , this.ind , this.value ] = moreargs;
+
+    this._format = '<IfB';
+    this._id = mavlink20.MAVLINK_MSG_ID_DEBUG;
+    this.order_map = [0, 2, 1];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 46;
+    this._name = 'DEBUG';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'ind', 'value'];
+
+}
+
+mavlink20.messages.debug.prototype = new mavlink20.message;
+mavlink20.messages.debug.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.value, this.ind];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Setup a MAVLink2 signing key. If called with secret_key of all zero
+and zero initial_timestamp will disable signing
+
+                target_system             : system id of the target (uint8_t)
+                target_component          : component ID of the target (uint8_t)
+                secret_key                : signing key (uint8_t)
+                initial_timestamp         : initial timestamp (uint64_t)
+
+*/
+    mavlink20.messages.setup_signing = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.secret_key , this.initial_timestamp ] = moreargs;
+
+    this._format = '<QBB32s';
+    this._id = mavlink20.MAVLINK_MSG_ID_SETUP_SIGNING;
+    this.order_map = [1, 2, 3, 0];
+    this.len_map = [1, 1, 1, 32];
+    this.array_len_map = [0, 0, 0, 32];
+    this.crc_extra = 71;
+    this._name = 'SETUP_SIGNING';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'secret_key', 'initial_timestamp'];
+
+}
+
+mavlink20.messages.setup_signing.prototype = new mavlink20.message;
+mavlink20.messages.setup_signing.prototype.pack = function(mav) {
+    var orderedfields = [ this.initial_timestamp, this.target_system, this.target_component, this.secret_key];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Report button state change.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                last_change_ms            : Time of last change of button state. (uint32_t)
+                state                     : Bitmap for state of buttons. (uint8_t)
+
+*/
+    mavlink20.messages.button_change = function( ...moreargs ) {
+    [ this.time_boot_ms , this.last_change_ms , this.state ] = moreargs;
+
+    this._format = '<IIB';
+    this._id = mavlink20.MAVLINK_MSG_ID_BUTTON_CHANGE;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 131;
+    this._name = 'BUTTON_CHANGE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'last_change_ms', 'state'];
+
+}
+
+mavlink20.messages.button_change.prototype = new mavlink20.message;
+mavlink20.messages.button_change.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.last_change_ms, this.state];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Control vehicle tone generation (buzzer).
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                tune                      : tune in board specific format (char)
+                tune2                     : tune extension (appended to tune) (char)
+
+*/
+    mavlink20.messages.play_tune = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.tune , this.tune2 ] = moreargs;
+
+    this._format = '<BB30s200s';
+    this._id = mavlink20.MAVLINK_MSG_ID_PLAY_TUNE;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 30, 200];
+    this.crc_extra = 187;
+    this._name = 'PLAY_TUNE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'tune', 'tune2'];
+
+}
+
+mavlink20.messages.play_tune.prototype = new mavlink20.message;
+mavlink20.messages.play_tune.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.tune, this.tune2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about a camera. Can be requested with a
+MAV_CMD_REQUEST_MESSAGE command.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                vendor_name               : Name of the camera vendor (uint8_t)
+                model_name                : Name of the camera model (uint8_t)
+                firmware_version          : Version of the camera firmware, encoded as: (Dev & 0xff) << 24 | (Patch & 0xff) << 16 | (Minor & 0xff) << 8 | (Major & 0xff). Use 0 if not known. (uint32_t)
+                focal_length              : Focal length. Use NaN if not known. (float)
+                sensor_size_h             : Image sensor size horizontal. Use NaN if not known. (float)
+                sensor_size_v             : Image sensor size vertical. Use NaN if not known. (float)
+                resolution_h              : Horizontal image resolution. Use 0 if not known. (uint16_t)
+                resolution_v              : Vertical image resolution. Use 0 if not known. (uint16_t)
+                lens_id                   : Reserved for a lens ID.  Use 0 if not known. (uint8_t)
+                flags                     : Bitmap of camera capability flags. (uint32_t)
+                cam_definition_version        : Camera definition version (iteration).  Use 0 if not known. (uint16_t)
+                cam_definition_uri        : Camera definition URI (if any, otherwise only basic functions will be available). HTTP- (http://) and MAVLink FTP- (mavlinkftp://) formatted URIs are allowed (and both must be supported by any GCS that implements the Camera Protocol). The definition file may be xz compressed, which will be indicated by the file extension .xml.xz (a GCS that implements the protocol must support decompressing the file). The string needs to be zero terminated.  Use a zero-length string if not known. (char)
+                gimbal_device_id          : Gimbal id of a gimbal associated with this camera. This is the component id of the gimbal device, or 1-6 for non mavlink gimbals. Use 0 if no gimbal is associated with the camera. (uint8_t)
+
+*/
+    mavlink20.messages.camera_information = function( ...moreargs ) {
+    [ this.time_boot_ms , this.vendor_name , this.model_name , this.firmware_version , this.focal_length , this.sensor_size_h , this.sensor_size_v , this.resolution_h , this.resolution_v , this.lens_id , this.flags , this.cam_definition_version , this.cam_definition_uri , this.gimbal_device_id ] = moreargs;
+
+    this._format = '<IIfffIHHH32s32sB140sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_INFORMATION;
+    this.order_map = [0, 9, 10, 1, 2, 3, 4, 6, 7, 11, 5, 8, 12, 13];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 32, 32, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 32, 0, 140, 0];
+    this.crc_extra = 92;
+    this._name = 'CAMERA_INFORMATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'vendor_name', 'model_name', 'firmware_version', 'focal_length', 'sensor_size_h', 'sensor_size_v', 'resolution_h', 'resolution_v', 'lens_id', 'flags', 'cam_definition_version', 'cam_definition_uri', 'gimbal_device_id'];
+
+}
+
+mavlink20.messages.camera_information.prototype = new mavlink20.message;
+mavlink20.messages.camera_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.firmware_version, this.focal_length, this.sensor_size_h, this.sensor_size_v, this.flags, this.resolution_h, this.resolution_v, this.cam_definition_version, this.vendor_name, this.model_name, this.lens_id, this.cam_definition_uri, this.gimbal_device_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Settings of a camera. Can be requested with a MAV_CMD_REQUEST_MESSAGE
+command.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                mode_id                   : Camera mode (uint8_t)
+                zoomLevel                 : Current zoom level as a percentage of the full range (0.0 to 100.0, NaN if not known) (float)
+                focusLevel                : Current focus level as a percentage of the full range (0.0 to 100.0, NaN if not known) (float)
+
+*/
+    mavlink20.messages.camera_settings = function( ...moreargs ) {
+    [ this.time_boot_ms , this.mode_id , this.zoomLevel , this.focusLevel ] = moreargs;
+
+    this._format = '<IBff';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_SETTINGS;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 146;
+    this._name = 'CAMERA_SETTINGS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'mode_id', 'zoomLevel', 'focusLevel'];
+
+}
+
+mavlink20.messages.camera_settings.prototype = new mavlink20.message;
+mavlink20.messages.camera_settings.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.mode_id, this.zoomLevel, this.focusLevel];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about a storage medium. This message is sent in response
+to a request with MAV_CMD_REQUEST_MESSAGE and whenever the status of
+the storage changes (STORAGE_STATUS). Use
+MAV_CMD_REQUEST_MESSAGE.param2 to indicate the index/id of requested
+storage: 0 for all, 1 for first, 2 for second, etc.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                storage_id                : Storage ID (1 for first, 2 for second, etc.) (uint8_t)
+                storage_count             : Number of storage devices (uint8_t)
+                status                    : Status of storage (uint8_t)
+                total_capacity            : Total capacity. If storage is not ready (STORAGE_STATUS_READY) value will be ignored. (float)
+                used_capacity             : Used capacity. If storage is not ready (STORAGE_STATUS_READY) value will be ignored. (float)
+                available_capacity        : Available storage capacity. If storage is not ready (STORAGE_STATUS_READY) value will be ignored. (float)
+                read_speed                : Read speed. (float)
+                write_speed               : Write speed. (float)
+                type                      : Type of storage (uint8_t)
+                name                      : Textual storage name to be used in UI (microSD 1, Internal Memory, etc.) This is a NULL terminated string. If it is exactly 32 characters long, add a terminating NULL. If this string is empty, the generic type is shown to the user. (char)
+
+*/
+    mavlink20.messages.storage_information = function( ...moreargs ) {
+    [ this.time_boot_ms , this.storage_id , this.storage_count , this.status , this.total_capacity , this.used_capacity , this.available_capacity , this.read_speed , this.write_speed , this.type , this.name ] = moreargs;
+
+    this._format = '<IfffffBBBB32s';
+    this._id = mavlink20.MAVLINK_MSG_ID_STORAGE_INFORMATION;
+    this.order_map = [0, 6, 7, 8, 1, 2, 3, 4, 5, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32];
+    this.crc_extra = 179;
+    this._name = 'STORAGE_INFORMATION';
+
+    this._instance_field = 'storage_id';
+    this._instance_offset = 24;
+
+    this.fieldnames = ['time_boot_ms', 'storage_id', 'storage_count', 'status', 'total_capacity', 'used_capacity', 'available_capacity', 'read_speed', 'write_speed', 'type', 'name'];
+
+}
+
+mavlink20.messages.storage_information.prototype = new mavlink20.message;
+mavlink20.messages.storage_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.total_capacity, this.used_capacity, this.available_capacity, this.read_speed, this.write_speed, this.storage_id, this.storage_count, this.status, this.type, this.name];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about the status of a capture. Can be requested with a
+MAV_CMD_REQUEST_MESSAGE command.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                image_status              : Current status of image capturing (0: idle, 1: capture in progress, 2: interval set but idle, 3: interval set and capture in progress) (uint8_t)
+                video_status              : Current status of video capturing (0: idle, 1: capture in progress) (uint8_t)
+                image_interval            : Image capture interval (float)
+                recording_time_ms         : Time since recording started (uint32_t)
+                available_capacity        : Available storage capacity. (float)
+                image_count               : Total number of images captured ('forever', or until reset using MAV_CMD_STORAGE_FORMAT). (int32_t)
+
+*/
+    mavlink20.messages.camera_capture_status = function( ...moreargs ) {
+    [ this.time_boot_ms , this.image_status , this.video_status , this.image_interval , this.recording_time_ms , this.available_capacity , this.image_count ] = moreargs;
+
+    this._format = '<IfIfBBi';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_CAPTURE_STATUS;
+    this.order_map = [0, 4, 5, 1, 2, 3, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 12;
+    this._name = 'CAMERA_CAPTURE_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'image_status', 'video_status', 'image_interval', 'recording_time_ms', 'available_capacity', 'image_count'];
+
+}
+
+mavlink20.messages.camera_capture_status.prototype = new mavlink20.message;
+mavlink20.messages.camera_capture_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.image_interval, this.recording_time_ms, this.available_capacity, this.image_status, this.video_status, this.image_count];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about a captured image. This is emitted every time a
+message is captured. It may be re-requested using
+MAV_CMD_REQUEST_MESSAGE, using param2 to indicate the sequence number
+for the missing image.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                time_utc                  : Timestamp (time since UNIX epoch) in UTC. 0 for unknown. (uint64_t)
+                camera_id                 : Deprecated/unused. Component IDs are used to differentiate multiple cameras. (uint8_t)
+                lat                       : Latitude where image was taken (int32_t)
+                lon                       : Longitude where capture was taken (int32_t)
+                alt                       : Altitude (MSL) where image was taken (int32_t)
+                relative_alt              : Altitude above ground (int32_t)
+                q                         : Quaternion of camera orientation (w, x, y, z order, zero-rotation is 1, 0, 0, 0) (float)
+                image_index               : Zero based index of this image (i.e. a new image will have index CAMERA_CAPTURE_STATUS.image count -1) (int32_t)
+                capture_result            : Image was captured successfully (MAV_BOOL_TRUE). Values not equal to 0 or 1 are invalid. (int8_t)
+                file_url                  : URL of image taken. Either local storage or http://foo.jpg if camera provides an HTTP interface. (char)
+
+*/
+    mavlink20.messages.camera_image_captured = function( ...moreargs ) {
+    [ this.time_boot_ms , this.time_utc , this.camera_id , this.lat , this.lon , this.alt , this.relative_alt , this.q , this.image_index , this.capture_result , this.file_url ] = moreargs;
+
+    this._format = '<QIiiii4fiBb205s';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED;
+    this.order_map = [1, 0, 8, 2, 3, 4, 5, 6, 7, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 205];
+    this.crc_extra = 133;
+    this._name = 'CAMERA_IMAGE_CAPTURED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'time_utc', 'camera_id', 'lat', 'lon', 'alt', 'relative_alt', 'q', 'image_index', 'capture_result', 'file_url'];
+
+}
+
+mavlink20.messages.camera_image_captured.prototype = new mavlink20.message;
+mavlink20.messages.camera_image_captured.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_utc, this.time_boot_ms, this.lat, this.lon, this.alt, this.relative_alt, this.q, this.image_index, this.camera_id, this.capture_result, this.file_url];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about flight since last arming.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                arming_time_utc           : Timestamp at arming (time since UNIX epoch) in UTC, 0 for unknown (uint64_t)
+                takeoff_time_utc          : Timestamp at takeoff (time since UNIX epoch) in UTC, 0 for unknown (uint64_t)
+                flight_uuid               : Universally unique identifier (UUID) of flight, should correspond to name of log files (uint64_t)
+
+*/
+    mavlink20.messages.flight_information = function( ...moreargs ) {
+    [ this.time_boot_ms , this.arming_time_utc , this.takeoff_time_utc , this.flight_uuid ] = moreargs;
+
+    this._format = '<QQQI';
+    this._id = mavlink20.MAVLINK_MSG_ID_FLIGHT_INFORMATION;
+    this.order_map = [3, 0, 1, 2];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 49;
+    this._name = 'FLIGHT_INFORMATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'arming_time_utc', 'takeoff_time_utc', 'flight_uuid'];
+
+}
+
+mavlink20.messages.flight_information.prototype = new mavlink20.message;
+mavlink20.messages.flight_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.arming_time_utc, this.takeoff_time_utc, this.flight_uuid, this.time_boot_ms];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Orientation of a mount
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                roll                      : Roll in global frame (set to NaN for invalid). (float)
+                pitch                     : Pitch in global frame (set to NaN for invalid). (float)
+                yaw                       : Yaw relative to vehicle (set to NaN for invalid). (float)
+                yaw_absolute              : Yaw in absolute frame relative to Earth's North, north is 0 (set to NaN for invalid). (float)
+
+*/
+    mavlink20.messages.mount_orientation = function( ...moreargs ) {
+    [ this.time_boot_ms , this.roll , this.pitch , this.yaw , this.yaw_absolute ] = moreargs;
+
+    this._format = '<Iffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_MOUNT_ORIENTATION;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 26;
+    this._name = 'MOUNT_ORIENTATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'roll', 'pitch', 'yaw', 'yaw_absolute'];
+
+}
+
+mavlink20.messages.mount_orientation.prototype = new mavlink20.message;
+mavlink20.messages.mount_orientation.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.roll, this.pitch, this.yaw, this.yaw_absolute];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A message containing logged data (see also MAV_CMD_LOGGING_START)
+
+                target_system             : system ID of the target (uint8_t)
+                target_component          : component ID of the target (uint8_t)
+                sequence                  : sequence number (can wrap) (uint16_t)
+                length                    : data length (uint8_t)
+                first_message_offset        : offset into data where first message starts. This can be used for recovery, when a previous message got lost (set to UINT8_MAX if no start exists). (uint8_t)
+                data                      : logged data (uint8_t)
+
+*/
+    mavlink20.messages.logging_data = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.sequence , this.length , this.first_message_offset , this.data ] = moreargs;
+
+    this._format = '<HBBBB249s';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOGGING_DATA;
+    this.order_map = [1, 2, 0, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 249];
+    this.array_len_map = [0, 0, 0, 0, 0, 249];
+    this.crc_extra = 193;
+    this._name = 'LOGGING_DATA';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'sequence', 'length', 'first_message_offset', 'data'];
+
+}
+
+mavlink20.messages.logging_data.prototype = new mavlink20.message;
+mavlink20.messages.logging_data.prototype.pack = function(mav) {
+    var orderedfields = [ this.sequence, this.target_system, this.target_component, this.length, this.first_message_offset, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A message containing logged data which requires a LOGGING_ACK to be
+sent back
+
+                target_system             : system ID of the target (uint8_t)
+                target_component          : component ID of the target (uint8_t)
+                sequence                  : sequence number (can wrap) (uint16_t)
+                length                    : data length (uint8_t)
+                first_message_offset        : offset into data where first message starts. This can be used for recovery, when a previous message got lost (set to UINT8_MAX if no start exists). (uint8_t)
+                data                      : logged data (uint8_t)
+
+*/
+    mavlink20.messages.logging_data_acked = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.sequence , this.length , this.first_message_offset , this.data ] = moreargs;
+
+    this._format = '<HBBBB249s';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOGGING_DATA_ACKED;
+    this.order_map = [1, 2, 0, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 249];
+    this.array_len_map = [0, 0, 0, 0, 0, 249];
+    this.crc_extra = 35;
+    this._name = 'LOGGING_DATA_ACKED';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'sequence', 'length', 'first_message_offset', 'data'];
+
+}
+
+mavlink20.messages.logging_data_acked.prototype = new mavlink20.message;
+mavlink20.messages.logging_data_acked.prototype.pack = function(mav) {
+    var orderedfields = [ this.sequence, this.target_system, this.target_component, this.length, this.first_message_offset, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+An ack for a LOGGING_DATA_ACKED message
+
+                target_system             : system ID of the target (uint8_t)
+                target_component          : component ID of the target (uint8_t)
+                sequence                  : sequence number (must match the one in LOGGING_DATA_ACKED) (uint16_t)
+
+*/
+    mavlink20.messages.logging_ack = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.sequence ] = moreargs;
+
+    this._format = '<HBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOGGING_ACK;
+    this.order_map = [1, 2, 0];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 14;
+    this._name = 'LOGGING_ACK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'sequence'];
+
+}
+
+mavlink20.messages.logging_ack.prototype = new mavlink20.message;
+mavlink20.messages.logging_ack.prototype.pack = function(mav) {
+    var orderedfields = [ this.sequence, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about video stream. It may be requested using
+MAV_CMD_REQUEST_MESSAGE, where param2 indicates the video stream id: 0
+for all streams, 1 for first, 2 for second, etc.
+
+                stream_id                 : Video Stream ID (1 for first, 2 for second, etc.) (uint8_t)
+                count                     : Number of streams available. (uint8_t)
+                type                      : Type of stream. (uint8_t)
+                flags                     : Bitmap of stream status flags. (uint16_t)
+                framerate                 : Frame rate. (float)
+                resolution_h              : Horizontal resolution. (uint16_t)
+                resolution_v              : Vertical resolution. (uint16_t)
+                bitrate                   : Bit rate. (uint32_t)
+                rotation                  : Video image rotation clockwise. (uint16_t)
+                hfov                      : Horizontal Field of view. (uint16_t)
+                name                      : Stream name. (char)
+                uri                       : Video stream URI (TCP or RTSP URI ground station should connect to) or port number (UDP port ground station should listen to). (char)
+                encoding                  : Encoding of stream. (uint8_t)
+
+*/
+    mavlink20.messages.video_stream_information = function( ...moreargs ) {
+    [ this.stream_id , this.count , this.type , this.flags , this.framerate , this.resolution_h , this.resolution_v , this.bitrate , this.rotation , this.hfov , this.name , this.uri , this.encoding ] = moreargs;
+
+    this._format = '<fIHHHHHBBB32s160sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_VIDEO_STREAM_INFORMATION;
+    this.order_map = [7, 8, 9, 2, 0, 3, 4, 1, 5, 6, 10, 11, 12];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 160, 0];
+    this.crc_extra = 109;
+    this._name = 'VIDEO_STREAM_INFORMATION';
+
+    this._instance_field = 'stream_id';
+    this._instance_offset = 18;
+
+    this.fieldnames = ['stream_id', 'count', 'type', 'flags', 'framerate', 'resolution_h', 'resolution_v', 'bitrate', 'rotation', 'hfov', 'name', 'uri', 'encoding'];
+
+}
+
+mavlink20.messages.video_stream_information.prototype = new mavlink20.message;
+mavlink20.messages.video_stream_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.framerate, this.bitrate, this.flags, this.resolution_h, this.resolution_v, this.rotation, this.hfov, this.stream_id, this.count, this.type, this.name, this.uri, this.encoding];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about the status of a video stream. It may be requested
+using MAV_CMD_REQUEST_MESSAGE.
+
+                stream_id                 : Video Stream ID (1 for first, 2 for second, etc.) (uint8_t)
+                flags                     : Bitmap of stream status flags (uint16_t)
+                framerate                 : Frame rate (float)
+                resolution_h              : Horizontal resolution (uint16_t)
+                resolution_v              : Vertical resolution (uint16_t)
+                bitrate                   : Bit rate (uint32_t)
+                rotation                  : Video image rotation clockwise (uint16_t)
+                hfov                      : Horizontal Field of view (uint16_t)
+
+*/
+    mavlink20.messages.video_stream_status = function( ...moreargs ) {
+    [ this.stream_id , this.flags , this.framerate , this.resolution_h , this.resolution_v , this.bitrate , this.rotation , this.hfov ] = moreargs;
+
+    this._format = '<fIHHHHHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_VIDEO_STREAM_STATUS;
+    this.order_map = [7, 2, 0, 3, 4, 1, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 59;
+    this._name = 'VIDEO_STREAM_STATUS';
+
+    this._instance_field = 'stream_id';
+    this._instance_offset = 18;
+
+    this.fieldnames = ['stream_id', 'flags', 'framerate', 'resolution_h', 'resolution_v', 'bitrate', 'rotation', 'hfov'];
+
+}
+
+mavlink20.messages.video_stream_status.prototype = new mavlink20.message;
+mavlink20.messages.video_stream_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.framerate, this.bitrate, this.flags, this.resolution_h, this.resolution_v, this.rotation, this.hfov, this.stream_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about the field of view of a camera. Can be requested with
+a MAV_CMD_REQUEST_MESSAGE command.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                lat_camera                : Latitude of camera (INT32_MAX if unknown). (int32_t)
+                lon_camera                : Longitude of camera (INT32_MAX if unknown). (int32_t)
+                alt_camera                : Altitude (MSL) of camera (INT32_MAX if unknown). (int32_t)
+                lat_image                 : Latitude of center of image (INT32_MAX if unknown, INT32_MIN if at infinity, not intersecting with horizon). (int32_t)
+                lon_image                 : Longitude of center of image (INT32_MAX if unknown, INT32_MIN if at infinity, not intersecting with horizon). (int32_t)
+                alt_image                 : Altitude (MSL) of center of image (INT32_MAX if unknown, INT32_MIN if at infinity, not intersecting with horizon). (int32_t)
+                q                         : Quaternion of camera orientation (w, x, y, z order, zero-rotation is 1, 0, 0, 0) (float)
+                hfov                      : Horizontal field of view (NaN if unknown). (float)
+                vfov                      : Vertical field of view (NaN if unknown). (float)
+
+*/
+    mavlink20.messages.camera_fov_status = function( ...moreargs ) {
+    [ this.time_boot_ms , this.lat_camera , this.lon_camera , this.alt_camera , this.lat_image , this.lon_image , this.alt_image , this.q , this.hfov , this.vfov ] = moreargs;
+
+    this._format = '<Iiiiiii4fff';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_FOV_STATUS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 4, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 4, 0, 0];
+    this.crc_extra = 22;
+    this._name = 'CAMERA_FOV_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'lat_camera', 'lon_camera', 'alt_camera', 'lat_image', 'lon_image', 'alt_image', 'q', 'hfov', 'vfov'];
+
+}
+
+mavlink20.messages.camera_fov_status.prototype = new mavlink20.message;
+mavlink20.messages.camera_fov_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.lat_camera, this.lon_camera, this.alt_camera, this.lat_image, this.lon_image, this.alt_image, this.q, this.hfov, this.vfov];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Camera tracking status, sent while in active tracking. Use
+MAV_CMD_SET_MESSAGE_INTERVAL to define message interval.
+
+                tracking_status           : Current tracking status (uint8_t)
+                tracking_mode             : Current tracking mode (uint8_t)
+                target_data               : Defines location of target data (uint8_t)
+                point_x                   : Current tracked point x value if CAMERA_TRACKING_MODE_POINT (normalized 0..1, 0 is left, 1 is right), NAN if unknown (float)
+                point_y                   : Current tracked point y value if CAMERA_TRACKING_MODE_POINT (normalized 0..1, 0 is top, 1 is bottom), NAN if unknown (float)
+                radius                    : Current tracked radius if CAMERA_TRACKING_MODE_POINT (normalized 0..1, 0 is image left, 1 is image right), NAN if unknown (float)
+                rec_top_x                 : Current tracked rectangle top x value if CAMERA_TRACKING_MODE_RECTANGLE (normalized 0..1, 0 is left, 1 is right), NAN if unknown (float)
+                rec_top_y                 : Current tracked rectangle top y value if CAMERA_TRACKING_MODE_RECTANGLE (normalized 0..1, 0 is top, 1 is bottom), NAN if unknown (float)
+                rec_bottom_x              : Current tracked rectangle bottom x value if CAMERA_TRACKING_MODE_RECTANGLE (normalized 0..1, 0 is left, 1 is right), NAN if unknown (float)
+                rec_bottom_y              : Current tracked rectangle bottom y value if CAMERA_TRACKING_MODE_RECTANGLE (normalized 0..1, 0 is top, 1 is bottom), NAN if unknown (float)
+
+*/
+    mavlink20.messages.camera_tracking_image_status = function( ...moreargs ) {
+    [ this.tracking_status , this.tracking_mode , this.target_data , this.point_x , this.point_y , this.radius , this.rec_top_x , this.rec_top_y , this.rec_bottom_x , this.rec_bottom_y ] = moreargs;
+
+    this._format = '<fffffffBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_TRACKING_IMAGE_STATUS;
+    this.order_map = [7, 8, 9, 0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 126;
+    this._name = 'CAMERA_TRACKING_IMAGE_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['tracking_status', 'tracking_mode', 'target_data', 'point_x', 'point_y', 'radius', 'rec_top_x', 'rec_top_y', 'rec_bottom_x', 'rec_bottom_y'];
+
+}
+
+mavlink20.messages.camera_tracking_image_status.prototype = new mavlink20.message;
+mavlink20.messages.camera_tracking_image_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.point_x, this.point_y, this.radius, this.rec_top_x, this.rec_top_y, this.rec_bottom_x, this.rec_bottom_y, this.tracking_status, this.tracking_mode, this.target_data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Camera tracking status, sent while in active tracking. Use
+MAV_CMD_SET_MESSAGE_INTERVAL to define message interval.
+
+                tracking_status           : Current tracking status (uint8_t)
+                lat                       : Latitude of tracked object (int32_t)
+                lon                       : Longitude of tracked object (int32_t)
+                alt                       : Altitude of tracked object(AMSL, WGS84) (float)
+                h_acc                     : Horizontal accuracy. NAN if unknown (float)
+                v_acc                     : Vertical accuracy. NAN if unknown (float)
+                vel_n                     : North velocity of tracked object. NAN if unknown (float)
+                vel_e                     : East velocity of tracked object. NAN if unknown (float)
+                vel_d                     : Down velocity of tracked object. NAN if unknown (float)
+                vel_acc                   : Velocity accuracy. NAN if unknown (float)
+                dist                      : Distance between camera and tracked object. NAN if unknown (float)
+                hdg                       : Heading in radians, in NED. NAN if unknown (float)
+                hdg_acc                   : Accuracy of heading, in NED. NAN if unknown (float)
+
+*/
+    mavlink20.messages.camera_tracking_geo_status = function( ...moreargs ) {
+    [ this.tracking_status , this.lat , this.lon , this.alt , this.h_acc , this.v_acc , this.vel_n , this.vel_e , this.vel_d , this.vel_acc , this.dist , this.hdg , this.hdg_acc ] = moreargs;
+
+    this._format = '<iiffffffffffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_TRACKING_GEO_STATUS;
+    this.order_map = [12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 18;
+    this._name = 'CAMERA_TRACKING_GEO_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['tracking_status', 'lat', 'lon', 'alt', 'h_acc', 'v_acc', 'vel_n', 'vel_e', 'vel_d', 'vel_acc', 'dist', 'hdg', 'hdg_acc'];
+
+}
+
+mavlink20.messages.camera_tracking_geo_status.prototype = new mavlink20.message;
+mavlink20.messages.camera_tracking_geo_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.lat, this.lon, this.alt, this.h_acc, this.v_acc, this.vel_n, this.vel_e, this.vel_d, this.vel_acc, this.dist, this.hdg, this.hdg_acc, this.tracking_status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Camera absolute thermal range. This can be streamed when the
+associated `VIDEO_STREAM_STATUS.flag` bit
+`VIDEO_STREAM_STATUS_FLAGS_THERMAL_RANGE_ENABLED` is set, but a GCS
+may choose to only request it for the current active stream. Use
+MAV_CMD_SET_MESSAGE_INTERVAL to define message interval (param3
+indicates the stream id of the current camera, or 0 for all streams,
+param4 indicates the target camera_device_id for autopilot-attached
+cameras or 0 for MAVLink cameras).
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                stream_id                 : Video Stream ID (1 for first, 2 for second, etc.) (uint8_t)
+                camera_device_id          : Camera id of a non-MAVLink camera attached to an autopilot (1-6).  0 if the component is a MAVLink camera (with its own component id). (uint8_t)
+                max                       : Temperature max. (float)
+                max_point_x               : Temperature max point x value (normalized 0..1, 0 is left, 1 is right), NAN if unknown. (float)
+                max_point_y               : Temperature max point y value (normalized 0..1, 0 is top, 1 is bottom), NAN if unknown. (float)
+                min                       : Temperature min. (float)
+                min_point_x               : Temperature min point x value (normalized 0..1, 0 is left, 1 is right), NAN if unknown. (float)
+                min_point_y               : Temperature min point y value (normalized 0..1, 0 is top, 1 is bottom), NAN if unknown. (float)
+
+*/
+    mavlink20.messages.camera_thermal_range = function( ...moreargs ) {
+    [ this.time_boot_ms , this.stream_id , this.camera_device_id , this.max , this.max_point_x , this.max_point_y , this.min , this.min_point_x , this.min_point_y ] = moreargs;
+
+    this._format = '<IffffffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAMERA_THERMAL_RANGE;
+    this.order_map = [0, 7, 8, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 62;
+    this._name = 'CAMERA_THERMAL_RANGE';
+
+    this._instance_field = 'stream_id';
+    this._instance_offset = 28;
+
+    this.fieldnames = ['time_boot_ms', 'stream_id', 'camera_device_id', 'max', 'max_point_x', 'max_point_y', 'min', 'min_point_x', 'min_point_y'];
+
+}
+
+mavlink20.messages.camera_thermal_range.prototype = new mavlink20.message;
+mavlink20.messages.camera_thermal_range.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.max, this.max_point_x, this.max_point_y, this.min, this.min_point_x, this.min_point_y, this.stream_id, this.camera_device_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about a high level gimbal manager. This message should be
+requested by a ground station using MAV_CMD_REQUEST_MESSAGE.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                cap_flags                 : Bitmap of gimbal capability flags. (uint32_t)
+                gimbal_device_id          : Gimbal device ID that this gimbal manager is responsible for. Component ID of gimbal device (or 1-6 for non-MAVLink gimbal). (uint8_t)
+                roll_min                  : Minimum hardware roll angle (positive: rolling to the right, negative: rolling to the left) (float)
+                roll_max                  : Maximum hardware roll angle (positive: rolling to the right, negative: rolling to the left) (float)
+                pitch_min                 : Minimum pitch angle (positive: up, negative: down) (float)
+                pitch_max                 : Maximum pitch angle (positive: up, negative: down) (float)
+                yaw_min                   : Minimum yaw angle (positive: to the right, negative: to the left) (float)
+                yaw_max                   : Maximum yaw angle (positive: to the right, negative: to the left) (float)
+
+*/
+    mavlink20.messages.gimbal_manager_information = function( ...moreargs ) {
+    [ this.time_boot_ms , this.cap_flags , this.gimbal_device_id , this.roll_min , this.roll_max , this.pitch_min , this.pitch_max , this.yaw_min , this.yaw_max ] = moreargs;
+
+    this._format = '<IIffffffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_INFORMATION;
+    this.order_map = [0, 1, 8, 2, 3, 4, 5, 6, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 70;
+    this._name = 'GIMBAL_MANAGER_INFORMATION';
+
+    this._instance_field = 'gimbal_device_id';
+    this._instance_offset = 32;
+
+    this.fieldnames = ['time_boot_ms', 'cap_flags', 'gimbal_device_id', 'roll_min', 'roll_max', 'pitch_min', 'pitch_max', 'yaw_min', 'yaw_max'];
+
+}
+
+mavlink20.messages.gimbal_manager_information.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_manager_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.cap_flags, this.roll_min, this.roll_max, this.pitch_min, this.pitch_max, this.yaw_min, this.yaw_max, this.gimbal_device_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Current status about a high level gimbal manager. This message should
+be broadcast at a low regular rate (e.g. 5Hz).
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                flags                     : High level gimbal manager flags currently applied. (uint32_t)
+                gimbal_device_id          : Gimbal device ID that this gimbal manager is responsible for. Component ID of gimbal device (or 1-6 for non-MAVLink gimbal). (uint8_t)
+                primary_control_sysid        : System ID of MAVLink component with primary control, 0 for none. (uint8_t)
+                primary_control_compid        : Component ID of MAVLink component with primary control, 0 for none. (uint8_t)
+                secondary_control_sysid        : System ID of MAVLink component with secondary control, 0 for none. (uint8_t)
+                secondary_control_compid        : Component ID of MAVLink component with secondary control, 0 for none. (uint8_t)
+
+*/
+    mavlink20.messages.gimbal_manager_status = function( ...moreargs ) {
+    [ this.time_boot_ms , this.flags , this.gimbal_device_id , this.primary_control_sysid , this.primary_control_compid , this.secondary_control_sysid , this.secondary_control_compid ] = moreargs;
+
+    this._format = '<IIBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_STATUS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 48;
+    this._name = 'GIMBAL_MANAGER_STATUS';
+
+    this._instance_field = 'gimbal_device_id';
+    this._instance_offset = 8;
+
+    this.fieldnames = ['time_boot_ms', 'flags', 'gimbal_device_id', 'primary_control_sysid', 'primary_control_compid', 'secondary_control_sysid', 'secondary_control_compid'];
+
+}
+
+mavlink20.messages.gimbal_manager_status.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_manager_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.flags, this.gimbal_device_id, this.primary_control_sysid, this.primary_control_compid, this.secondary_control_sysid, this.secondary_control_compid];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+High level message to control a gimbal's attitude. This message is to
+be sent to the gimbal manager (e.g. from a ground station). Angles and
+rates can be set to NaN according to use case.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                flags                     : High level gimbal manager flags to use. (uint32_t)
+                gimbal_device_id          : Component ID of gimbal device to address (or 1-6 for non-MAVLink gimbal), 0 for all gimbal device components. Send command multiple times for more than one gimbal (but not all gimbals). (uint8_t)
+                q                         : Quaternion components, w, x, y, z (1 0 0 0 is the null-rotation, the frame is depends on whether the flag GIMBAL_MANAGER_FLAGS_YAW_LOCK is set) (float)
+                angular_velocity_x        : X component of angular velocity, positive is rolling to the right, NaN to be ignored. (float)
+                angular_velocity_y        : Y component of angular velocity, positive is pitching up, NaN to be ignored. (float)
+                angular_velocity_z        : Z component of angular velocity, positive is yawing to the right, NaN to be ignored. (float)
+
+*/
+    mavlink20.messages.gimbal_manager_set_attitude = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.flags , this.gimbal_device_id , this.q , this.angular_velocity_x , this.angular_velocity_y , this.angular_velocity_z ] = moreargs;
+
+    this._format = '<I4ffffBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE;
+    this.order_map = [5, 6, 0, 7, 1, 2, 3, 4];
+    this.len_map = [1, 4, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 4, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 123;
+    this._name = 'GIMBAL_MANAGER_SET_ATTITUDE';
+
+    this._instance_field = 'gimbal_device_id';
+    this._instance_offset = 34;
+
+    this.fieldnames = ['target_system', 'target_component', 'flags', 'gimbal_device_id', 'q', 'angular_velocity_x', 'angular_velocity_y', 'angular_velocity_z'];
+
+}
+
+mavlink20.messages.gimbal_manager_set_attitude.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_manager_set_attitude.prototype.pack = function(mav) {
+    var orderedfields = [ this.flags, this.q, this.angular_velocity_x, this.angular_velocity_y, this.angular_velocity_z, this.target_system, this.target_component, this.gimbal_device_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about a low level gimbal. This message should be requested
+by the gimbal manager or a ground station using
+MAV_CMD_REQUEST_MESSAGE. The maximum angles and rates are the limits
+by hardware. However, the limits by software used are likely
+different/smaller and dependent on mode/settings/etc..
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                vendor_name               : Name of the gimbal vendor. (char)
+                model_name                : Name of the gimbal model. (char)
+                custom_name               : Custom name of the gimbal given to it by the user. (char)
+                firmware_version          : Version of the gimbal firmware, encoded as: (Dev & 0xff) << 24 | (Patch & 0xff) << 16 | (Minor & 0xff) << 8 | (Major & 0xff). (uint32_t)
+                hardware_version          : Version of the gimbal hardware, encoded as: (Dev & 0xff) << 24 | (Patch & 0xff) << 16 | (Minor & 0xff) << 8 | (Major & 0xff). (uint32_t)
+                uid                       : UID of gimbal hardware (0 if unknown). (uint64_t)
+                cap_flags                 : Bitmap of gimbal capability flags. (uint16_t)
+                custom_cap_flags          : Bitmap for use for gimbal-specific capability flags. (uint16_t)
+                roll_min                  : Minimum hardware roll angle (positive: rolling to the right, negative: rolling to the left). NAN if unknown. (float)
+                roll_max                  : Maximum hardware roll angle (positive: rolling to the right, negative: rolling to the left). NAN if unknown. (float)
+                pitch_min                 : Minimum hardware pitch angle (positive: up, negative: down). NAN if unknown. (float)
+                pitch_max                 : Maximum hardware pitch angle (positive: up, negative: down). NAN if unknown. (float)
+                yaw_min                   : Minimum hardware yaw angle (positive: to the right, negative: to the left). NAN if unknown. (float)
+                yaw_max                   : Maximum hardware yaw angle (positive: to the right, negative: to the left). NAN if unknown. (float)
+                gimbal_device_id          : This field is to be used if the gimbal manager and the gimbal device are the same component and hence have the same component ID. This field is then set to a number between 1-6. If the component ID is separate, this field is not required and must be set to 0. (uint8_t)
+
+*/
+    mavlink20.messages.gimbal_device_information = function( ...moreargs ) {
+    [ this.time_boot_ms , this.vendor_name , this.model_name , this.custom_name , this.firmware_version , this.hardware_version , this.uid , this.cap_flags , this.custom_cap_flags , this.roll_min , this.roll_max , this.pitch_min , this.pitch_max , this.yaw_min , this.yaw_max , this.gimbal_device_id ] = moreargs;
+
+    this._format = '<QIIIffffffHH32s32s32sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION;
+    this.order_map = [1, 12, 13, 14, 2, 3, 0, 10, 11, 4, 5, 6, 7, 8, 9, 15];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 32, 32, 0];
+    this.crc_extra = 74;
+    this._name = 'GIMBAL_DEVICE_INFORMATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'vendor_name', 'model_name', 'custom_name', 'firmware_version', 'hardware_version', 'uid', 'cap_flags', 'custom_cap_flags', 'roll_min', 'roll_max', 'pitch_min', 'pitch_max', 'yaw_min', 'yaw_max', 'gimbal_device_id'];
+
+}
+
+mavlink20.messages.gimbal_device_information.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_device_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.uid, this.time_boot_ms, this.firmware_version, this.hardware_version, this.roll_min, this.roll_max, this.pitch_min, this.pitch_max, this.yaw_min, this.yaw_max, this.cap_flags, this.custom_cap_flags, this.vendor_name, this.model_name, this.custom_name, this.gimbal_device_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Low level message to control a gimbal device's attitude.
+This message is to be sent from the gimbal manager to the gimbal
+device component.           The quaternion and angular velocities can
+be set to NaN according to use case.           For the angles encoded
+in the quaternion and the angular velocities holds:           If the
+flag GIMBAL_DEVICE_FLAGS_YAW_IN_VEHICLE_FRAME is set, then they are
+relative to the vehicle heading (vehicle frame).           If the flag
+GIMBAL_DEVICE_FLAGS_YAW_IN_EARTH_FRAME is set, then they are relative
+to absolute North (earth frame).           If neither of these flags
+are set, then (for backwards compatibility) it holds:           If the
+flag GIMBAL_DEVICE_FLAGS_YAW_LOCK is set, then they are relative to
+absolute North (earth frame),           else they are relative to the
+vehicle heading (vehicle frame).           Setting both
+GIMBAL_DEVICE_FLAGS_YAW_IN_VEHICLE_FRAME and
+GIMBAL_DEVICE_FLAGS_YAW_IN_EARTH_FRAME is not allowed.           These
+rules are to ensure backwards compatibility.           New
+implementations should always set either
+GIMBAL_DEVICE_FLAGS_YAW_IN_VEHICLE_FRAME or
+GIMBAL_DEVICE_FLAGS_YAW_IN_EARTH_FRAME.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                flags                     : Low level gimbal flags. (uint16_t)
+                q                         : Quaternion components, w, x, y, z (1 0 0 0 is the null-rotation). The frame is described in the message description. Set fields to NaN to be ignored. (float)
+                angular_velocity_x        : X component of angular velocity (positive: rolling to the right). The frame is described in the message description. NaN to be ignored. (float)
+                angular_velocity_y        : Y component of angular velocity (positive: pitching up). The frame is described in the message description. NaN to be ignored. (float)
+                angular_velocity_z        : Z component of angular velocity (positive: yawing to the right). The frame is described in the message description. NaN to be ignored. (float)
+
+*/
+    mavlink20.messages.gimbal_device_set_attitude = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.flags , this.q , this.angular_velocity_x , this.angular_velocity_y , this.angular_velocity_z ] = moreargs;
+
+    this._format = '<4ffffHBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE;
+    this.order_map = [5, 6, 4, 0, 1, 2, 3];
+    this.len_map = [4, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [4, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 99;
+    this._name = 'GIMBAL_DEVICE_SET_ATTITUDE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'flags', 'q', 'angular_velocity_x', 'angular_velocity_y', 'angular_velocity_z'];
+
+}
+
+mavlink20.messages.gimbal_device_set_attitude.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_device_set_attitude.prototype.pack = function(mav) {
+    var orderedfields = [ this.q, this.angular_velocity_x, this.angular_velocity_y, this.angular_velocity_z, this.flags, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message reporting the status of a gimbal device.           This
+message should be broadcast by a gimbal device component at a low
+regular rate (e.g. 5 Hz).           For the angles encoded in the
+quaternion and the angular velocities holds:           If the flag
+GIMBAL_DEVICE_FLAGS_YAW_IN_VEHICLE_FRAME is set, then they are
+relative to the vehicle heading (vehicle frame).           If the flag
+GIMBAL_DEVICE_FLAGS_YAW_IN_EARTH_FRAME is set, then they are relative
+to absolute North (earth frame).           If neither of these flags
+are set, then (for backwards compatibility) it holds:           If the
+flag GIMBAL_DEVICE_FLAGS_YAW_LOCK is set, then they are relative to
+absolute North (earth frame),           else they are relative to the
+vehicle heading (vehicle frame).           Other conditions of the
+flags are not allowed.           The quaternion and angular velocities
+in the other frame can be calculated from delta_yaw and
+delta_yaw_velocity as           q_earth = q_delta_yaw * q_vehicle and
+w_earth = w_delta_yaw_velocity + w_vehicle (if not NaN).           If
+neither the GIMBAL_DEVICE_FLAGS_YAW_IN_VEHICLE_FRAME nor the
+GIMBAL_DEVICE_FLAGS_YAW_IN_EARTH_FRAME flag is set,           then
+(for backwards compatibility) the data in the delta_yaw and
+delta_yaw_velocity fields are to be ignored.           New
+implementations should always set either
+GIMBAL_DEVICE_FLAGS_YAW_IN_VEHICLE_FRAME or
+GIMBAL_DEVICE_FLAGS_YAW_IN_EARTH_FRAME,           and always should
+set delta_yaw and delta_yaw_velocity either to the proper value or
+NaN.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                flags                     : Current gimbal flags set. (uint16_t)
+                q                         : Quaternion components, w, x, y, z (1 0 0 0 is the null-rotation). The frame is described in the message description. (float)
+                angular_velocity_x        : X component of angular velocity (positive: rolling to the right). The frame is described in the message description. NaN if unknown. (float)
+                angular_velocity_y        : Y component of angular velocity (positive: pitching up). The frame is described in the message description. NaN if unknown. (float)
+                angular_velocity_z        : Z component of angular velocity (positive: yawing to the right). The frame is described in the message description. NaN if unknown. (float)
+                failure_flags             : Failure flags (0 for no failure) (uint32_t)
+                delta_yaw                 : Yaw angle relating the quaternions in earth and body frames (see message description). NaN if unknown. (float)
+                delta_yaw_velocity        : Yaw angular velocity relating the angular velocities in earth and body frames (see message description). NaN if unknown. (float)
+                gimbal_device_id          : This field is to be used if the gimbal manager and the gimbal device are the same component and hence have the same component ID. This field is then set a number between 1-6. If the component ID is separate, this field is not required and must be set to 0. (uint8_t)
+
+*/
+    mavlink20.messages.gimbal_device_attitude_status = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.time_boot_ms , this.flags , this.q , this.angular_velocity_x , this.angular_velocity_y , this.angular_velocity_z , this.failure_flags , this.delta_yaw , this.delta_yaw_velocity , this.gimbal_device_id ] = moreargs;
+
+    this._format = '<I4ffffIHBBffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS;
+    this.order_map = [7, 8, 0, 6, 1, 2, 3, 4, 5, 9, 10, 11];
+    this.len_map = [1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 137;
+    this._name = 'GIMBAL_DEVICE_ATTITUDE_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'time_boot_ms', 'flags', 'q', 'angular_velocity_x', 'angular_velocity_y', 'angular_velocity_z', 'failure_flags', 'delta_yaw', 'delta_yaw_velocity', 'gimbal_device_id'];
+
+}
+
+mavlink20.messages.gimbal_device_attitude_status.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_device_attitude_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.q, this.angular_velocity_x, this.angular_velocity_y, this.angular_velocity_z, this.failure_flags, this.flags, this.target_system, this.target_component, this.delta_yaw, this.delta_yaw_velocity, this.gimbal_device_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Low level message containing autopilot state relevant for a gimbal
+device. This message is to be sent from the autopilot to the gimbal
+device component. The data of this message are for the gimbal device's
+estimator corrections, in particular horizon compensation, as well as
+indicates autopilot control intentions, e.g. feed forward angular
+control in the z-axis.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                time_boot_us              : Timestamp (time since system boot). (uint64_t)
+                q                         : Quaternion components of autopilot attitude: w, x, y, z (1 0 0 0 is the null-rotation, Hamilton convention). (float)
+                q_estimated_delay_us        : Estimated delay of the attitude data. 0 if unknown. (uint32_t)
+                vx                        : X Speed in NED (North, East, Down). NAN if unknown. (float)
+                vy                        : Y Speed in NED (North, East, Down). NAN if unknown. (float)
+                vz                        : Z Speed in NED (North, East, Down). NAN if unknown. (float)
+                v_estimated_delay_us        : Estimated delay of the speed data. 0 if unknown. (uint32_t)
+                feed_forward_angular_velocity_z        : Feed forward Z component of angular velocity (positive: yawing to the right). NaN to be ignored. This is to indicate if the autopilot is actively yawing. (float)
+                estimator_status          : Bitmap indicating which estimator outputs are valid. (uint16_t)
+                landed_state              : The landed state. Is set to MAV_LANDED_STATE_UNDEFINED if landed state is unknown. (uint8_t)
+                angular_velocity_z        : Z component of angular velocity in NED (North, East, Down). NaN if unknown. (float)
+
+*/
+    mavlink20.messages.autopilot_state_for_gimbal_device = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.time_boot_us , this.q , this.q_estimated_delay_us , this.vx , this.vy , this.vz , this.v_estimated_delay_us , this.feed_forward_angular_velocity_z , this.estimator_status , this.landed_state , this.angular_velocity_z ] = moreargs;
+
+    this._format = '<Q4fIfffIfHBBBf';
+    this._id = mavlink20.MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE;
+    this.order_map = [9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 12];
+    this.len_map = [1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 210;
+    this._name = 'AUTOPILOT_STATE_FOR_GIMBAL_DEVICE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'time_boot_us', 'q', 'q_estimated_delay_us', 'vx', 'vy', 'vz', 'v_estimated_delay_us', 'feed_forward_angular_velocity_z', 'estimator_status', 'landed_state', 'angular_velocity_z'];
+
+}
+
+mavlink20.messages.autopilot_state_for_gimbal_device.prototype = new mavlink20.message;
+mavlink20.messages.autopilot_state_for_gimbal_device.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_us, this.q, this.q_estimated_delay_us, this.vx, this.vy, this.vz, this.v_estimated_delay_us, this.feed_forward_angular_velocity_z, this.estimator_status, this.target_system, this.target_component, this.landed_state, this.angular_velocity_z];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set gimbal manager pitch and yaw angles (high rate message). This
+message is to be sent to the gimbal manager (e.g. from a ground
+station) and will be ignored by gimbal devices. Angles and rates can
+be set to NaN according to use case. Use
+MAV_CMD_DO_GIMBAL_MANAGER_PITCHYAW for low-rate adjustments that
+require confirmation.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                flags                     : High level gimbal manager flags to use. (uint32_t)
+                gimbal_device_id          : Component ID of gimbal device to address (or 1-6 for non-MAVLink gimbal), 0 for all gimbal device components. Send command multiple times for more than one gimbal (but not all gimbals). (uint8_t)
+                pitch                     : Pitch angle (positive: up, negative: down, NaN to be ignored). (float)
+                yaw                       : Yaw angle (positive: to the right, negative: to the left, NaN to be ignored). (float)
+                pitch_rate                : Pitch angular rate (positive: up, negative: down, NaN to be ignored). (float)
+                yaw_rate                  : Yaw angular rate (positive: to the right, negative: to the left, NaN to be ignored). (float)
+
+*/
+    mavlink20.messages.gimbal_manager_set_pitchyaw = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.flags , this.gimbal_device_id , this.pitch , this.yaw , this.pitch_rate , this.yaw_rate ] = moreargs;
+
+    this._format = '<IffffBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_PITCHYAW;
+    this.order_map = [5, 6, 0, 7, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 1;
+    this._name = 'GIMBAL_MANAGER_SET_PITCHYAW';
+
+    this._instance_field = 'gimbal_device_id';
+    this._instance_offset = 22;
+
+    this.fieldnames = ['target_system', 'target_component', 'flags', 'gimbal_device_id', 'pitch', 'yaw', 'pitch_rate', 'yaw_rate'];
+
+}
+
+mavlink20.messages.gimbal_manager_set_pitchyaw.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_manager_set_pitchyaw.prototype.pack = function(mav) {
+    var orderedfields = [ this.flags, this.pitch, this.yaw, this.pitch_rate, this.yaw_rate, this.target_system, this.target_component, this.gimbal_device_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+High level message to control a gimbal manually. The angles or angular
+rates are unitless; the actual rates will depend on internal gimbal
+manager settings/configuration (e.g. set by parameters). This message
+is to be sent to the gimbal manager (e.g. from a ground station).
+Angles and rates can be set to NaN according to use case.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                flags                     : High level gimbal manager flags. (uint32_t)
+                gimbal_device_id          : Component ID of gimbal device to address (or 1-6 for non-MAVLink gimbal), 0 for all gimbal device components. Send command multiple times for more than one gimbal (but not all gimbals). (uint8_t)
+                pitch                     : Pitch angle unitless (-1..1, positive: up, negative: down, NaN to be ignored). (float)
+                yaw                       : Yaw angle unitless (-1..1, positive: to the right, negative: to the left, NaN to be ignored). (float)
+                pitch_rate                : Pitch angular rate unitless (-1..1, positive: up, negative: down, NaN to be ignored). (float)
+                yaw_rate                  : Yaw angular rate unitless (-1..1, positive: to the right, negative: to the left, NaN to be ignored). (float)
+
+*/
+    mavlink20.messages.gimbal_manager_set_manual_control = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.flags , this.gimbal_device_id , this.pitch , this.yaw , this.pitch_rate , this.yaw_rate ] = moreargs;
+
+    this._format = '<IffffBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_MANUAL_CONTROL;
+    this.order_map = [5, 6, 0, 7, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 20;
+    this._name = 'GIMBAL_MANAGER_SET_MANUAL_CONTROL';
+
+    this._instance_field = 'gimbal_device_id';
+    this._instance_offset = 22;
+
+    this.fieldnames = ['target_system', 'target_component', 'flags', 'gimbal_device_id', 'pitch', 'yaw', 'pitch_rate', 'yaw_rate'];
+
+}
+
+mavlink20.messages.gimbal_manager_set_manual_control.prototype = new mavlink20.message;
+mavlink20.messages.gimbal_manager_set_manual_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.flags, this.pitch, this.yaw, this.pitch_rate, this.yaw_rate, this.target_system, this.target_component, this.gimbal_device_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Configure WiFi AP SSID, password, and mode. This message is re-emitted
+as an acknowledgement by the AP. The message may also be explicitly
+requested using MAV_CMD_REQUEST_MESSAGE
+
+                ssid                      : Name of Wi-Fi network (SSID). Blank to leave it unchanged when setting. Current SSID when sent back as a response. (char)
+                password                  : Password. Blank for an open AP. MD5 hash when message is sent back as a response. (char)
+
+*/
+    mavlink20.messages.wifi_config_ap = function( ...moreargs ) {
+    [ this.ssid , this.password ] = moreargs;
+
+    this._format = '<32s64s';
+    this._id = mavlink20.MAVLINK_MSG_ID_WIFI_CONFIG_AP;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [32, 64];
+    this.crc_extra = 19;
+    this._name = 'WIFI_CONFIG_AP';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['ssid', 'password'];
+
+}
+
+mavlink20.messages.wifi_config_ap.prototype = new mavlink20.message;
+mavlink20.messages.wifi_config_ap.prototype.pack = function(mav) {
+    var orderedfields = [ this.ssid, this.password];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The location and information of an AIS vessel
+
+                MMSI                      : Mobile Marine Service Identifier, 9 decimal digits (uint32_t)
+                lat                       : Latitude (int32_t)
+                lon                       : Longitude (int32_t)
+                COG                       : Course over ground (uint16_t)
+                heading                   : True heading (uint16_t)
+                velocity                  : Speed over ground (uint16_t)
+                turn_rate                 : Turn rate (int8_t)
+                navigational_status        : Navigational status (uint8_t)
+                type                      : Type of vessels (uint8_t)
+                dimension_bow             : Distance from lat/lon location to bow (uint16_t)
+                dimension_stern           : Distance from lat/lon location to stern (uint16_t)
+                dimension_port            : Distance from lat/lon location to port side (uint8_t)
+                dimension_starboard        : Distance from lat/lon location to starboard side (uint8_t)
+                callsign                  : The vessel callsign (char)
+                name                      : The vessel name (char)
+                tslc                      : Time since last communication in seconds (uint16_t)
+                flags                     : Bitmask to indicate various statuses including valid data fields (uint16_t)
+
+*/
+    mavlink20.messages.ais_vessel = function( ...moreargs ) {
+    [ this.MMSI , this.lat , this.lon , this.COG , this.heading , this.velocity , this.turn_rate , this.navigational_status , this.type , this.dimension_bow , this.dimension_stern , this.dimension_port , this.dimension_starboard , this.callsign , this.name , this.tslc , this.flags ] = moreargs;
+
+    this._format = '<IiiHHHHHHHbBBBB7s20s';
+    this._id = mavlink20.MAVLINK_MSG_ID_AIS_VESSEL;
+    this.order_map = [0, 1, 2, 3, 4, 5, 10, 11, 12, 6, 7, 13, 14, 15, 16, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 20];
+    this.crc_extra = 243;
+    this._name = 'AIS_VESSEL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['MMSI', 'lat', 'lon', 'COG', 'heading', 'velocity', 'turn_rate', 'navigational_status', 'type', 'dimension_bow', 'dimension_stern', 'dimension_port', 'dimension_starboard', 'callsign', 'name', 'tslc', 'flags'];
+
+}
+
+mavlink20.messages.ais_vessel.prototype = new mavlink20.message;
+mavlink20.messages.ais_vessel.prototype.pack = function(mav) {
+    var orderedfields = [ this.MMSI, this.lat, this.lon, this.COG, this.heading, this.velocity, this.dimension_bow, this.dimension_stern, this.tslc, this.flags, this.turn_rate, this.navigational_status, this.type, this.dimension_port, this.dimension_starboard, this.callsign, this.name];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+General status information of an UAVCAN node. Please refer to the
+definition of the UAVCAN message "uavcan.protocol.NodeStatus" for the
+background information. The UAVCAN specification is available at
+http://uavcan.org.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                uptime_sec                : Time since the start-up of the node. (uint32_t)
+                health                    : Generalized node health status. (uint8_t)
+                mode                      : Generalized operating mode. (uint8_t)
+                sub_mode                  : Not used currently. (uint8_t)
+                vendor_specific_status_code        : Vendor-specific status information. (uint16_t)
+
+*/
+    mavlink20.messages.uavcan_node_status = function( ...moreargs ) {
+    [ this.time_usec , this.uptime_sec , this.health , this.mode , this.sub_mode , this.vendor_specific_status_code ] = moreargs;
+
+    this._format = '<QIHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVCAN_NODE_STATUS;
+    this.order_map = [0, 1, 3, 4, 5, 2];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 28;
+    this._name = 'UAVCAN_NODE_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'uptime_sec', 'health', 'mode', 'sub_mode', 'vendor_specific_status_code'];
+
+}
+
+mavlink20.messages.uavcan_node_status.prototype = new mavlink20.message;
+mavlink20.messages.uavcan_node_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.uptime_sec, this.vendor_specific_status_code, this.health, this.mode, this.sub_mode];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+General information describing a particular UAVCAN node. Please refer
+to the definition of the UAVCAN service "uavcan.protocol.GetNodeInfo"
+for the background information. This message should be emitted by the
+system whenever a new node appears online, or an existing node
+reboots. Additionally, it can be emitted upon request from the other
+end of the MAVLink channel (see MAV_CMD_UAVCAN_GET_NODE_INFO). It is
+also not prohibited to emit this message unconditionally at a low
+frequency. The UAVCAN specification is available at http://uavcan.org.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                uptime_sec                : Time since the start-up of the node. (uint32_t)
+                name                      : Node name string. For example, "sapog.px4.io". (char)
+                hw_version_major          : Hardware major version number. (uint8_t)
+                hw_version_minor          : Hardware minor version number. (uint8_t)
+                hw_unique_id              : Hardware unique 128-bit ID. (uint8_t)
+                sw_version_major          : Software major version number. (uint8_t)
+                sw_version_minor          : Software minor version number. (uint8_t)
+                sw_vcs_commit             : Version control system (VCS) revision identifier (e.g. git short commit hash). 0 if unknown. (uint32_t)
+
+*/
+    mavlink20.messages.uavcan_node_info = function( ...moreargs ) {
+    [ this.time_usec , this.uptime_sec , this.name , this.hw_version_major , this.hw_version_minor , this.hw_unique_id , this.sw_version_major , this.sw_version_minor , this.sw_vcs_commit ] = moreargs;
+
+    this._format = '<QII80sBB16sBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVCAN_NODE_INFO;
+    this.order_map = [0, 1, 3, 4, 5, 6, 7, 8, 2];
+    this.len_map = [1, 1, 1, 1, 1, 1, 16, 1, 1];
+    this.array_len_map = [0, 0, 0, 80, 0, 0, 16, 0, 0];
+    this.crc_extra = 95;
+    this._name = 'UAVCAN_NODE_INFO';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'uptime_sec', 'name', 'hw_version_major', 'hw_version_minor', 'hw_unique_id', 'sw_version_major', 'sw_version_minor', 'sw_vcs_commit'];
+
+}
+
+mavlink20.messages.uavcan_node_info.prototype = new mavlink20.message;
+mavlink20.messages.uavcan_node_info.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.uptime_sec, this.sw_vcs_commit, this.name, this.hw_version_major, this.hw_version_minor, this.hw_unique_id, this.sw_version_major, this.sw_version_minor];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request to read the value of a parameter with either the param_id
+string id or param_index. PARAM_EXT_VALUE should be emitted in
+response.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                param_id                  : Parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                param_index               : Parameter index. Set to -1 to use the Parameter ID field as identifier (else param_id will be ignored) (int16_t)
+
+*/
+    mavlink20.messages.param_ext_request_read = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.param_id , this.param_index ] = moreargs;
+
+    this._format = '<hBB16s';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_EXT_REQUEST_READ;
+    this.order_map = [1, 2, 3, 0];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 16];
+    this.crc_extra = 243;
+    this._name = 'PARAM_EXT_REQUEST_READ';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'param_id', 'param_index'];
+
+}
+
+mavlink20.messages.param_ext_request_read.prototype = new mavlink20.message;
+mavlink20.messages.param_ext_request_read.prototype.pack = function(mav) {
+    var orderedfields = [ this.param_index, this.target_system, this.target_component, this.param_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request all parameters of this component. All parameters should be
+emitted in response as PARAM_EXT_VALUE.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+
+*/
+    mavlink20.messages.param_ext_request_list = function( ...moreargs ) {
+    [ this.target_system , this.target_component ] = moreargs;
+
+    this._format = '<BB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_EXT_REQUEST_LIST;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 88;
+    this._name = 'PARAM_EXT_REQUEST_LIST';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component'];
+
+}
+
+mavlink20.messages.param_ext_request_list.prototype = new mavlink20.message;
+mavlink20.messages.param_ext_request_list.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Emit the value of a parameter. The inclusion of param_count and
+param_index in the message allows the recipient to keep track of
+received parameters and allows them to re-request missing parameters
+after a loss or timeout.
+
+                param_id                  : Parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                param_value               : Parameter value (char)
+                param_type                : Parameter type. (uint8_t)
+                param_count               : Total number of parameters (uint16_t)
+                param_index               : Index of this parameter (uint16_t)
+
+*/
+    mavlink20.messages.param_ext_value = function( ...moreargs ) {
+    [ this.param_id , this.param_value , this.param_type , this.param_count , this.param_index ] = moreargs;
+
+    this._format = '<HH16s128sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_EXT_VALUE;
+    this.order_map = [2, 3, 4, 0, 1];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 16, 128, 0];
+    this.crc_extra = 243;
+    this._name = 'PARAM_EXT_VALUE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['param_id', 'param_value', 'param_type', 'param_count', 'param_index'];
+
+}
+
+mavlink20.messages.param_ext_value.prototype = new mavlink20.message;
+mavlink20.messages.param_ext_value.prototype.pack = function(mav) {
+    var orderedfields = [ this.param_count, this.param_index, this.param_id, this.param_value, this.param_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Set a parameter value. In order to deal with message loss (and
+retransmission of PARAM_EXT_SET), when setting a parameter value and
+the new value is the same as the current value, you will immediately
+get a PARAM_ACK_ACCEPTED response. If the current state is
+PARAM_ACK_IN_PROGRESS, you will accordingly receive a
+PARAM_ACK_IN_PROGRESS in response.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                param_id                  : Parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                param_value               : Parameter value (char)
+                param_type                : Parameter type. (uint8_t)
+
+*/
+    mavlink20.messages.param_ext_set = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.param_id , this.param_value , this.param_type ] = moreargs;
+
+    this._format = '<BB16s128sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_EXT_SET;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 16, 128, 0];
+    this.crc_extra = 78;
+    this._name = 'PARAM_EXT_SET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'param_id', 'param_value', 'param_type'];
+
+}
+
+mavlink20.messages.param_ext_set.prototype = new mavlink20.message;
+mavlink20.messages.param_ext_set.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.param_id, this.param_value, this.param_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Response from a PARAM_EXT_SET message.
+
+                param_id                  : Parameter id, terminated by NULL if the length is less than 16 human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to provide 16+1 bytes storage if the ID is stored as string (char)
+                param_value               : Parameter value (new value if PARAM_ACK_ACCEPTED, current value otherwise) (char)
+                param_type                : Parameter type. (uint8_t)
+                param_result              : Result code. (uint8_t)
+
+*/
+    mavlink20.messages.param_ext_ack = function( ...moreargs ) {
+    [ this.param_id , this.param_value , this.param_type , this.param_result ] = moreargs;
+
+    this._format = '<16s128sBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_EXT_ACK;
+    this.order_map = [0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [16, 128, 0, 0];
+    this.crc_extra = 132;
+    this._name = 'PARAM_EXT_ACK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['param_id', 'param_value', 'param_type', 'param_result'];
+
+}
+
+mavlink20.messages.param_ext_ack.prototype = new mavlink20.message;
+mavlink20.messages.param_ext_ack.prototype.pack = function(mav) {
+    var orderedfields = [ this.param_id, this.param_value, this.param_type, this.param_result];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Obstacle distances in front of the sensor, starting from the left in
+increment degrees to the right
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                sensor_type               : Class id of the distance sensor type. (uint8_t)
+                distances                 : Distance of obstacles around the vehicle with index 0 corresponding to north + angle_offset, unless otherwise specified in the frame. A value of 0 is valid and means that the obstacle is practically touching the sensor. A value of max_distance +1 means no obstacle is present. A value of UINT16_MAX for unknown/not used. In a array element, one unit corresponds to 1cm. (uint16_t)
+                increment                 : Angular width in degrees of each array element. Increment direction is clockwise. This field is ignored if increment_f is non-zero. (uint8_t)
+                min_distance              : Minimum distance the sensor can measure. (uint16_t)
+                max_distance              : Maximum distance the sensor can measure. (uint16_t)
+                increment_f               : Angular width in degrees of each array element as a float. If non-zero then this value is used instead of the uint8_t increment field. Positive is clockwise direction, negative is counter-clockwise. (float)
+                angle_offset              : Relative angle offset of the 0-index element in the distances array. Value of 0 corresponds to forward. Positive is clockwise direction, negative is counter-clockwise. (float)
+                frame                     : Coordinate frame of reference for the yaw rotation and offset of the sensor data. Defaults to MAV_FRAME_GLOBAL, which is north aligned. For body-mounted sensors use MAV_FRAME_BODY_FRD, which is vehicle front aligned. (uint8_t)
+
+*/
+    mavlink20.messages.obstacle_distance = function( ...moreargs ) {
+    [ this.time_usec , this.sensor_type , this.distances , this.increment , this.min_distance , this.max_distance , this.increment_f , this.angle_offset , this.frame ] = moreargs;
+
+    this._format = '<Q72HHHBBffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OBSTACLE_DISTANCE;
+    this.order_map = [0, 4, 1, 5, 2, 3, 6, 7, 8];
+    this.len_map = [1, 72, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 72, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 23;
+    this._name = 'OBSTACLE_DISTANCE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'sensor_type', 'distances', 'increment', 'min_distance', 'max_distance', 'increment_f', 'angle_offset', 'frame'];
+
+}
+
+mavlink20.messages.obstacle_distance.prototype = new mavlink20.message;
+mavlink20.messages.obstacle_distance.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.distances, this.min_distance, this.max_distance, this.sensor_type, this.increment, this.increment_f, this.angle_offset, this.frame];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Odometry message to communicate odometry information with an external
+interface. Fits ROS REP 147 standard for aerial vehicles
+(http://www.ros.org/reps/rep-0147.html).
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                frame_id                  : Coordinate frame of reference for the pose data. (uint8_t)
+                child_frame_id            : Coordinate frame of reference for the velocity in free space (twist) data. (uint8_t)
+                x                         : X Position (float)
+                y                         : Y Position (float)
+                z                         : Z Position (float)
+                q                         : Quaternion components, w, x, y, z (1 0 0 0 is the null-rotation) (float)
+                vx                        : X linear speed (float)
+                vy                        : Y linear speed (float)
+                vz                        : Z linear speed (float)
+                rollspeed                 : Roll angular speed (float)
+                pitchspeed                : Pitch angular speed (float)
+                yawspeed                  : Yaw angular speed (float)
+                pose_covariance           : Row-major representation of a 6x6 pose cross-covariance matrix upper right triangle (states: x, y, z, roll, pitch, yaw; first six entries are the first ROW, next five entries are the second ROW, etc.). If unknown, assign NaN value to first element in the array. (float)
+                velocity_covariance        : Row-major representation of a 6x6 velocity cross-covariance matrix upper right triangle (states: vx, vy, vz, rollspeed, pitchspeed, yawspeed; first six entries are the first ROW, next five entries are the second ROW, etc.). If unknown, assign NaN value to first element in the array. (float)
+                reset_counter             : Estimate reset counter. This should be incremented when the estimate resets in any of the dimensions (position, velocity, attitude, angular speed). This is designed to be used when e.g an external SLAM system detects a loop-closure and the estimate jumps. (uint8_t)
+                estimator_type            : Type of estimator that is providing the odometry. (uint8_t)
+                quality                   : Optional odometry quality metric as a percentage. -1 = odometry has failed, 0 = unknown/unset quality, 1 = worst quality, 100 = best quality (int8_t)
+
+*/
+    mavlink20.messages.odometry = function( ...moreargs ) {
+    [ this.time_usec , this.frame_id , this.child_frame_id , this.x , this.y , this.z , this.q , this.vx , this.vy , this.vz , this.rollspeed , this.pitchspeed , this.yawspeed , this.pose_covariance , this.velocity_covariance , this.reset_counter , this.estimator_type , this.quality ] = moreargs;
+
+    this._format = '<Qfff4fffffff21f21fBBBBb';
+    this._id = mavlink20.MAVLINK_MSG_ID_ODOMETRY;
+    this.order_map = [0, 13, 14, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 17];
+    this.len_map = [1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 21, 21, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 21, 21, 0, 0, 0, 0, 0];
+    this.crc_extra = 91;
+    this._name = 'ODOMETRY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'frame_id', 'child_frame_id', 'x', 'y', 'z', 'q', 'vx', 'vy', 'vz', 'rollspeed', 'pitchspeed', 'yawspeed', 'pose_covariance', 'velocity_covariance', 'reset_counter', 'estimator_type', 'quality'];
+
+}
+
+mavlink20.messages.odometry.prototype = new mavlink20.message;
+mavlink20.messages.odometry.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.x, this.y, this.z, this.q, this.vx, this.vy, this.vz, this.rollspeed, this.pitchspeed, this.yawspeed, this.pose_covariance, this.velocity_covariance, this.frame_id, this.child_frame_id, this.reset_counter, this.estimator_type, this.quality];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Describe a trajectory using an array of up-to 5 waypoints in the local
+frame (MAV_FRAME_LOCAL_NED).
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                valid_points              : Number of valid points (up-to 5 waypoints are possible) (uint8_t)
+                pos_x                     : X-coordinate of waypoint, set to NaN if not being used (float)
+                pos_y                     : Y-coordinate of waypoint, set to NaN if not being used (float)
+                pos_z                     : Z-coordinate of waypoint, set to NaN if not being used (float)
+                vel_x                     : X-velocity of waypoint, set to NaN if not being used (float)
+                vel_y                     : Y-velocity of waypoint, set to NaN if not being used (float)
+                vel_z                     : Z-velocity of waypoint, set to NaN if not being used (float)
+                acc_x                     : X-acceleration of waypoint, set to NaN if not being used (float)
+                acc_y                     : Y-acceleration of waypoint, set to NaN if not being used (float)
+                acc_z                     : Z-acceleration of waypoint, set to NaN if not being used (float)
+                pos_yaw                   : Yaw angle, set to NaN if not being used (float)
+                vel_yaw                   : Yaw rate, set to NaN if not being used (float)
+                command                   : MAV_CMD command id of waypoint, set to UINT16_MAX if not being used. (uint16_t)
+
+*/
+    mavlink20.messages.trajectory_representation_waypoints = function( ...moreargs ) {
+    [ this.time_usec , this.valid_points , this.pos_x , this.pos_y , this.pos_z , this.vel_x , this.vel_y , this.vel_z , this.acc_x , this.acc_y , this.acc_z , this.pos_yaw , this.vel_yaw , this.command ] = moreargs;
+
+    this._format = '<Q5f5f5f5f5f5f5f5f5f5f5f5HB';
+    this._id = mavlink20.MAVLINK_MSG_ID_TRAJECTORY_REPRESENTATION_WAYPOINTS;
+    this.order_map = [0, 13, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+    this.len_map = [1, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1];
+    this.array_len_map = [0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0];
+    this.crc_extra = 236;
+    this._name = 'TRAJECTORY_REPRESENTATION_WAYPOINTS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'valid_points', 'pos_x', 'pos_y', 'pos_z', 'vel_x', 'vel_y', 'vel_z', 'acc_x', 'acc_y', 'acc_z', 'pos_yaw', 'vel_yaw', 'command'];
+
+}
+
+mavlink20.messages.trajectory_representation_waypoints.prototype = new mavlink20.message;
+mavlink20.messages.trajectory_representation_waypoints.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.pos_x, this.pos_y, this.pos_z, this.vel_x, this.vel_y, this.vel_z, this.acc_x, this.acc_y, this.acc_z, this.pos_yaw, this.vel_yaw, this.command, this.valid_points];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Describe a trajectory using an array of up-to 5 bezier control points
+in the local frame (MAV_FRAME_LOCAL_NED).
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                valid_points              : Number of valid control points (up-to 5 points are possible) (uint8_t)
+                pos_x                     : X-coordinate of bezier control points. Set to NaN if not being used (float)
+                pos_y                     : Y-coordinate of bezier control points. Set to NaN if not being used (float)
+                pos_z                     : Z-coordinate of bezier control points. Set to NaN if not being used (float)
+                delta                     : Bezier time horizon. Set to NaN if velocity/acceleration should not be incorporated (float)
+                pos_yaw                   : Yaw. Set to NaN for unchanged (float)
+
+*/
+    mavlink20.messages.trajectory_representation_bezier = function( ...moreargs ) {
+    [ this.time_usec , this.valid_points , this.pos_x , this.pos_y , this.pos_z , this.delta , this.pos_yaw ] = moreargs;
+
+    this._format = '<Q5f5f5f5f5fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_TRAJECTORY_REPRESENTATION_BEZIER;
+    this.order_map = [0, 6, 1, 2, 3, 4, 5];
+    this.len_map = [1, 5, 5, 5, 5, 5, 1];
+    this.array_len_map = [0, 5, 5, 5, 5, 5, 0];
+    this.crc_extra = 231;
+    this._name = 'TRAJECTORY_REPRESENTATION_BEZIER';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'valid_points', 'pos_x', 'pos_y', 'pos_z', 'delta', 'pos_yaw'];
+
+}
+
+mavlink20.messages.trajectory_representation_bezier.prototype = new mavlink20.message;
+mavlink20.messages.trajectory_representation_bezier.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.pos_x, this.pos_y, this.pos_z, this.delta, this.pos_yaw, this.valid_points];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status of the Iridium SBD link.
+
+                timestamp                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                last_heartbeat            : Timestamp of the last successful sbd session. The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                failed_sessions           : Number of failed SBD sessions. (uint16_t)
+                successful_sessions        : Number of successful SBD sessions. (uint16_t)
+                signal_quality            : Signal quality equal to the number of bars displayed on the ISU signal strength indicator. Range is 0 to 5, where 0 indicates no signal and 5 indicates maximum signal strength. (uint8_t)
+                ring_pending              : 1: Ring call pending, 0: No call pending. (uint8_t)
+                tx_session_pending        : 1: Transmission session pending, 0: No transmission session pending. (uint8_t)
+                rx_session_pending        : 1: Receiving session pending, 0: No receiving session pending. (uint8_t)
+
+*/
+    mavlink20.messages.isbd_link_status = function( ...moreargs ) {
+    [ this.timestamp , this.last_heartbeat , this.failed_sessions , this.successful_sessions , this.signal_quality , this.ring_pending , this.tx_session_pending , this.rx_session_pending ] = moreargs;
+
+    this._format = '<QQHHBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ISBD_LINK_STATUS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 225;
+    this._name = 'ISBD_LINK_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['timestamp', 'last_heartbeat', 'failed_sessions', 'successful_sessions', 'signal_quality', 'ring_pending', 'tx_session_pending', 'rx_session_pending'];
+
+}
+
+mavlink20.messages.isbd_link_status.prototype = new mavlink20.message;
+mavlink20.messages.isbd_link_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.last_heartbeat, this.failed_sessions, this.successful_sessions, this.signal_quality, this.ring_pending, this.tx_session_pending, this.rx_session_pending];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+RPM sensor data message.
+
+                index                     : Index of this RPM sensor (0-indexed) (uint8_t)
+                frequency                 : Indicated rate (float)
+
+*/
+    mavlink20.messages.raw_rpm = function( ...moreargs ) {
+    [ this.index , this.frequency ] = moreargs;
+
+    this._format = '<fB';
+    this._id = mavlink20.MAVLINK_MSG_ID_RAW_RPM;
+    this.order_map = [1, 0];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 199;
+    this._name = 'RAW_RPM';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['index', 'frequency'];
+
+}
+
+mavlink20.messages.raw_rpm.prototype = new mavlink20.message;
+mavlink20.messages.raw_rpm.prototype.pack = function(mav) {
+    var orderedfields = [ this.frequency, this.index];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The global position resulting from GPS and sensor fusion.
+
+                time                      : Time of applicability of position (microseconds since UNIX epoch). (uint64_t)
+                uas_id                    : Unique UAS ID. (uint8_t)
+                lat                       : Latitude (WGS84) (int32_t)
+                lon                       : Longitude (WGS84) (int32_t)
+                alt                       : Altitude (WGS84) (int32_t)
+                relative_alt              : Altitude above ground (int32_t)
+                vx                        : Ground X speed (latitude, positive north) (int16_t)
+                vy                        : Ground Y speed (longitude, positive east) (int16_t)
+                vz                        : Ground Z speed (altitude, positive down) (int16_t)
+                h_acc                     : Horizontal position uncertainty (standard deviation) (uint16_t)
+                v_acc                     : Altitude uncertainty (standard deviation) (uint16_t)
+                vel_acc                   : Speed uncertainty (standard deviation) (uint16_t)
+                next_lat                  : Next waypoint, latitude (WGS84) (int32_t)
+                next_lon                  : Next waypoint, longitude (WGS84) (int32_t)
+                next_alt                  : Next waypoint, altitude (WGS84) (int32_t)
+                update_rate               : Time until next update. Set to 0 if unknown or in data driven mode. (uint16_t)
+                flight_state              : Flight state (uint8_t)
+                flags                     : Bitwise OR combination of the data available flags. (uint8_t)
+
+*/
+    mavlink20.messages.utm_global_position = function( ...moreargs ) {
+    [ this.time , this.uas_id , this.lat , this.lon , this.alt , this.relative_alt , this.vx , this.vy , this.vz , this.h_acc , this.v_acc , this.vel_acc , this.next_lat , this.next_lon , this.next_alt , this.update_rate , this.flight_state , this.flags ] = moreargs;
+
+    this._format = '<QiiiiiiihhhHHHH18sBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_UTM_GLOBAL_POSITION;
+    this.order_map = [0, 15, 1, 2, 3, 4, 8, 9, 10, 11, 12, 13, 5, 6, 7, 14, 16, 17];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 18, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0];
+    this.crc_extra = 99;
+    this._name = 'UTM_GLOBAL_POSITION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time', 'uas_id', 'lat', 'lon', 'alt', 'relative_alt', 'vx', 'vy', 'vz', 'h_acc', 'v_acc', 'vel_acc', 'next_lat', 'next_lon', 'next_alt', 'update_rate', 'flight_state', 'flags'];
+
+}
+
+mavlink20.messages.utm_global_position.prototype = new mavlink20.message;
+mavlink20.messages.utm_global_position.prototype.pack = function(mav) {
+    var orderedfields = [ this.time, this.lat, this.lon, this.alt, this.relative_alt, this.next_lat, this.next_lon, this.next_alt, this.vx, this.vy, this.vz, this.h_acc, this.v_acc, this.vel_acc, this.update_rate, this.uas_id, this.flight_state, this.flags];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Large debug/prototyping array. The message uses the maximum available
+payload for data. The array_id and name fields are used to
+discriminate between messages in code and in user interfaces
+(respectively). Do not use in production code.
+
+                time_usec                 : Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number. (uint64_t)
+                name                      : Name, for human-friendly display in a Ground Control Station (char)
+                array_id                  : Unique ID used to discriminate between arrays (uint16_t)
+                data                      : data (float)
+
+*/
+    mavlink20.messages.debug_float_array = function( ...moreargs ) {
+    [ this.time_usec , this.name , this.array_id , this.data ] = moreargs;
+
+    this._format = '<QH10s58f';
+    this._id = mavlink20.MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY;
+    this.order_map = [0, 2, 1, 3];
+    this.len_map = [1, 1, 1, 58];
+    this.array_len_map = [0, 0, 10, 58];
+    this.crc_extra = 232;
+    this._name = 'DEBUG_FLOAT_ARRAY';
+
+    this._instance_field = 'array_id';
+    this._instance_offset = 8;
+
+    this.fieldnames = ['time_usec', 'name', 'array_id', 'data'];
+
+}
+
+mavlink20.messages.debug_float_array.prototype = new mavlink20.message;
+mavlink20.messages.debug_float_array.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.array_id, this.name, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Smart Battery information (static/infrequent update). Use for updates
+from: smart battery to flight stack, flight stack to GCS. Use
+BATTERY_STATUS for smart battery frequent updates.
+
+                id                        : Battery ID (uint8_t)
+                battery_function          : Function of the battery (uint8_t)
+                type                      : Type (chemistry) of the battery (uint8_t)
+                capacity_full_specification        : Capacity when full according to manufacturer, -1: field not provided. (int32_t)
+                capacity_full             : Capacity when full (accounting for battery degradation), -1: field not provided. (int32_t)
+                cycle_count               : Charge/discharge cycle count. UINT16_MAX: field not provided. (uint16_t)
+                serial_number             : Serial number in ASCII characters, 0 terminated. All 0: field not provided. (char)
+                device_name               : Static device name in ASCII characters, 0 terminated. All 0: field not provided. Encode as manufacturer name then product name separated using an underscore. (char)
+                weight                    : Battery weight. 0: field not provided. (uint16_t)
+                discharge_minimum_voltage        : Minimum per-cell voltage when discharging. If not supplied set to UINT16_MAX value. (uint16_t)
+                charging_minimum_voltage        : Minimum per-cell voltage when charging. If not supplied set to UINT16_MAX value. (uint16_t)
+                resting_minimum_voltage        : Minimum per-cell voltage when resting. If not supplied set to UINT16_MAX value. (uint16_t)
+                charging_maximum_voltage        : Maximum per-cell voltage when charged. 0: field not provided. (uint16_t)
+                cells_in_series           : Number of battery cells in series. 0: field not provided. (uint8_t)
+                discharge_maximum_current        : Maximum pack discharge current. 0: field not provided. (uint32_t)
+                discharge_maximum_burst_current        : Maximum pack discharge burst current. 0: field not provided. (uint32_t)
+                manufacture_date          : Manufacture date (DD/MM/YYYY) in ASCII characters, 0 terminated. All 0: field not provided. (char)
+
+*/
+    mavlink20.messages.smart_battery_info = function( ...moreargs ) {
+    [ this.id , this.battery_function , this.type , this.capacity_full_specification , this.capacity_full , this.cycle_count , this.serial_number , this.device_name , this.weight , this.discharge_minimum_voltage , this.charging_minimum_voltage , this.resting_minimum_voltage , this.charging_maximum_voltage , this.cells_in_series , this.discharge_maximum_current , this.discharge_maximum_burst_current , this.manufacture_date ] = moreargs;
+
+    this._format = '<iiHHHHHBBB16s50sHBII11s';
+    this._id = mavlink20.MAVLINK_MSG_ID_SMART_BATTERY_INFO;
+    this.order_map = [7, 8, 9, 0, 1, 2, 10, 11, 3, 4, 5, 6, 12, 13, 14, 15, 16];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 50, 0, 0, 0, 0, 11];
+    this.crc_extra = 75;
+    this._name = 'SMART_BATTERY_INFO';
+
+    this._instance_field = 'id';
+    this._instance_offset = 18;
+
+    this.fieldnames = ['id', 'battery_function', 'type', 'capacity_full_specification', 'capacity_full', 'cycle_count', 'serial_number', 'device_name', 'weight', 'discharge_minimum_voltage', 'charging_minimum_voltage', 'resting_minimum_voltage', 'charging_maximum_voltage', 'cells_in_series', 'discharge_maximum_current', 'discharge_maximum_burst_current', 'manufacture_date'];
+
+}
+
+mavlink20.messages.smart_battery_info.prototype = new mavlink20.message;
+mavlink20.messages.smart_battery_info.prototype.pack = function(mav) {
+    var orderedfields = [ this.capacity_full_specification, this.capacity_full, this.cycle_count, this.weight, this.discharge_minimum_voltage, this.charging_minimum_voltage, this.resting_minimum_voltage, this.id, this.battery_function, this.type, this.serial_number, this.device_name, this.charging_maximum_voltage, this.cells_in_series, this.discharge_maximum_current, this.discharge_maximum_burst_current, this.manufacture_date];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Telemetry of power generation system. Alternator or mechanical
+generator.
+
+                status                    : Status flags. (uint64_t)
+                generator_speed           : Speed of electrical generator or alternator. UINT16_MAX: field not provided. (uint16_t)
+                battery_current           : Current into/out of battery. Positive for out. Negative for in. NaN: field not provided. (float)
+                load_current              : Current going to the UAV. If battery current not available this is the DC current from the generator. Positive for out. Negative for in. NaN: field not provided (float)
+                power_generated           : The power being generated. NaN: field not provided (float)
+                bus_voltage               : Voltage of the bus seen at the generator, or battery bus if battery bus is controlled by generator and at a different voltage to main bus. (float)
+                rectifier_temperature        : The temperature of the rectifier or power converter. INT16_MAX: field not provided. (int16_t)
+                bat_current_setpoint        : The target battery current. Positive for out. Negative for in. NaN: field not provided (float)
+                generator_temperature        : The temperature of the mechanical motor, fuel cell core or generator. INT16_MAX: field not provided. (int16_t)
+                runtime                   : Seconds this generator has run since it was rebooted. UINT32_MAX: field not provided. (uint32_t)
+                time_until_maintenance        : Seconds until this generator requires maintenance.  A negative value indicates maintenance is past-due. INT32_MAX: field not provided. (int32_t)
+
+*/
+    mavlink20.messages.generator_status = function( ...moreargs ) {
+    [ this.status , this.generator_speed , this.battery_current , this.load_current , this.power_generated , this.bus_voltage , this.rectifier_temperature , this.bat_current_setpoint , this.generator_temperature , this.runtime , this.time_until_maintenance ] = moreargs;
+
+    this._format = '<QfffffIiHhh';
+    this._id = mavlink20.MAVLINK_MSG_ID_GENERATOR_STATUS;
+    this.order_map = [0, 8, 1, 2, 3, 4, 9, 5, 10, 6, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 117;
+    this._name = 'GENERATOR_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['status', 'generator_speed', 'battery_current', 'load_current', 'power_generated', 'bus_voltage', 'rectifier_temperature', 'bat_current_setpoint', 'generator_temperature', 'runtime', 'time_until_maintenance'];
+
+}
+
+mavlink20.messages.generator_status.prototype = new mavlink20.message;
+mavlink20.messages.generator_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.status, this.battery_current, this.load_current, this.power_generated, this.bus_voltage, this.bat_current_setpoint, this.runtime, this.time_until_maintenance, this.generator_speed, this.rectifier_temperature, this.generator_temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The raw values of the actuator outputs (e.g. on Pixhawk, from MAIN,
+AUX ports). This message supersedes SERVO_OUTPUT_RAW.
+
+                time_usec                 : Timestamp (since system boot). (uint64_t)
+                active                    : Active outputs (uint32_t)
+                actuator                  : Servo / motor output array values. Zero values indicate unused channels. (float)
+
+*/
+    mavlink20.messages.actuator_output_status = function( ...moreargs ) {
+    [ this.time_usec , this.active , this.actuator ] = moreargs;
+
+    this._format = '<QI32f';
+    this._id = mavlink20.MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 32];
+    this.array_len_map = [0, 0, 32];
+    this.crc_extra = 251;
+    this._name = 'ACTUATOR_OUTPUT_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'active', 'actuator'];
+
+}
+
+mavlink20.messages.actuator_output_status.prototype = new mavlink20.message;
+mavlink20.messages.actuator_output_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.active, this.actuator];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Reports the on/off state of relays, as controlled by
+MAV_CMD_DO_SET_RELAY.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                on                        : Relay states.  Relay instance numbers are represented as individual bits in this mask by offset. (uint16_t)
+                present                   : Relay present.  Relay instance numbers are represented as individual bits in this mask by offset.  Bits will be true if a relay instance is configured. (uint16_t)
+
+*/
+    mavlink20.messages.relay_status = function( ...moreargs ) {
+    [ this.time_boot_ms , this.on , this.present ] = moreargs;
+
+    this._format = '<IHH';
+    this._id = mavlink20.MAVLINK_MSG_ID_RELAY_STATUS;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 199;
+    this._name = 'RELAY_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'on', 'present'];
+
+}
+
+mavlink20.messages.relay_status.prototype = new mavlink20.message;
+mavlink20.messages.relay_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.on, this.present];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message for transporting "arbitrary" variable-length data from one
+component to another (broadcast is not forbidden, but discouraged).
+The encoding of the data is usually extension specific, i.e.
+determined by the source, and is usually not documented as part of the
+MAVLink specification.
+
+                target_system             : System ID (can be 0 for broadcast, but this is discouraged) (uint8_t)
+                target_component          : Component ID (can be 0 for broadcast, but this is discouraged) (uint8_t)
+                payload_type              : A code that identifies the content of the payload (0 for unknown, which is the default). If this code is less than 32768, it is a 'registered' payload type and the corresponding code should be added to the MAV_TUNNEL_PAYLOAD_TYPE enum. Software creators can register blocks of types as needed. Codes greater than 32767 are considered local experiments and should not be checked in to any widely distributed codebase. (uint16_t)
+                payload_length            : Length of the data transported in payload (uint8_t)
+                payload                   : Variable length payload. The payload length is defined by payload_length. The entire content of this block is opaque unless you understand the encoding specified by payload_type. (uint8_t)
+
+*/
+    mavlink20.messages.tunnel = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.payload_type , this.payload_length , this.payload ] = moreargs;
+
+    this._format = '<HBBB128s';
+    this._id = mavlink20.MAVLINK_MSG_ID_TUNNEL;
+    this.order_map = [1, 2, 0, 3, 4];
+    this.len_map = [1, 1, 1, 1, 128];
+    this.array_len_map = [0, 0, 0, 0, 128];
+    this.crc_extra = 147;
+    this._name = 'TUNNEL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'payload_type', 'payload_length', 'payload'];
+
+}
+
+mavlink20.messages.tunnel.prototype = new mavlink20.message;
+mavlink20.messages.tunnel.prototype.pack = function(mav) {
+    var orderedfields = [ this.payload_type, this.target_system, this.target_component, this.payload_length, this.payload];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A forwarded CAN frame as requested by MAV_CMD_CAN_FORWARD.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                bus                       : Bus number (uint8_t)
+                len                       : Frame length (uint8_t)
+                id                        : Frame ID (uint32_t)
+                data                      : Frame data (uint8_t)
+
+*/
+    mavlink20.messages.can_frame = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.bus , this.len , this.id , this.data ] = moreargs;
+
+    this._format = '<IBBBB8s';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAN_FRAME;
+    this.order_map = [1, 2, 3, 4, 0, 5];
+    this.len_map = [1, 1, 1, 1, 1, 8];
+    this.array_len_map = [0, 0, 0, 0, 0, 8];
+    this.crc_extra = 132;
+    this._name = 'CAN_FRAME';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'bus', 'len', 'id', 'data'];
+
+}
+
+mavlink20.messages.can_frame.prototype = new mavlink20.message;
+mavlink20.messages.can_frame.prototype.pack = function(mav) {
+    var orderedfields = [ this.id, this.target_system, this.target_component, this.bus, this.len, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A forwarded CANFD frame as requested by MAV_CMD_CAN_FORWARD. These are
+separated from CAN_FRAME as they need different handling (eg. TAO
+handling)
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                bus                       : bus number (uint8_t)
+                len                       : Frame length (uint8_t)
+                id                        : Frame ID (uint32_t)
+                data                      : Frame data (uint8_t)
+
+*/
+    mavlink20.messages.canfd_frame = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.bus , this.len , this.id , this.data ] = moreargs;
+
+    this._format = '<IBBBB64s';
+    this._id = mavlink20.MAVLINK_MSG_ID_CANFD_FRAME;
+    this.order_map = [1, 2, 3, 4, 0, 5];
+    this.len_map = [1, 1, 1, 1, 1, 64];
+    this.array_len_map = [0, 0, 0, 0, 0, 64];
+    this.crc_extra = 4;
+    this._name = 'CANFD_FRAME';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'bus', 'len', 'id', 'data'];
+
+}
+
+mavlink20.messages.canfd_frame.prototype = new mavlink20.message;
+mavlink20.messages.canfd_frame.prototype.pack = function(mav) {
+    var orderedfields = [ this.id, this.target_system, this.target_component, this.bus, this.len, this.data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Modify the filter of what CAN messages to forward over the mavlink.
+This can be used to make CAN forwarding work well on low bandwidth
+links. The filtering is applied on bits 8 to 24 of the CAN id (2nd and
+3rd bytes) which corresponds to the DroneCAN message ID for DroneCAN.
+Filters with more than 16 IDs can be constructed by sending multiple
+CAN_FILTER_MODIFY messages.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                bus                       : bus number (uint8_t)
+                operation                 : what operation to perform on the filter list. See CAN_FILTER_OP enum. (uint8_t)
+                num_ids                   : number of IDs in filter list (uint8_t)
+                ids                       : filter IDs, length num_ids (uint16_t)
+
+*/
+    mavlink20.messages.can_filter_modify = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.bus , this.operation , this.num_ids , this.ids ] = moreargs;
+
+    this._format = '<16HBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CAN_FILTER_MODIFY;
+    this.order_map = [1, 2, 3, 4, 5, 0];
+    this.len_map = [16, 1, 1, 1, 1, 1];
+    this.array_len_map = [16, 0, 0, 0, 0, 0];
+    this.crc_extra = 8;
+    this._name = 'CAN_FILTER_MODIFY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'bus', 'operation', 'num_ids', 'ids'];
+
+}
+
+mavlink20.messages.can_filter_modify.prototype = new mavlink20.message;
+mavlink20.messages.can_filter_modify.prototype.pack = function(mav) {
+    var orderedfields = [ this.ids, this.target_system, this.target_component, this.bus, this.operation, this.num_ids];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Cumulative distance traveled for each reported wheel.
+
+                time_usec                 : Timestamp (synced to UNIX time or since system boot). (uint64_t)
+                count                     : Number of wheels reported. (uint8_t)
+                distance                  : Distance reported by individual wheel encoders. Forward rotations increase values, reverse rotations decrease them. Not all wheels will necessarily have wheel encoders; the mapping of encoders to wheel positions must be agreed/understood by the endpoints. (double)
+
+*/
+    mavlink20.messages.wheel_distance = function( ...moreargs ) {
+    [ this.time_usec , this.count , this.distance ] = moreargs;
+
+    this._format = '<Q16dB';
+    this._id = mavlink20.MAVLINK_MSG_ID_WHEEL_DISTANCE;
+    this.order_map = [0, 2, 1];
+    this.len_map = [1, 16, 1];
+    this.array_len_map = [0, 16, 0];
+    this.crc_extra = 113;
+    this._name = 'WHEEL_DISTANCE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'count', 'distance'];
+
+}
+
+mavlink20.messages.wheel_distance.prototype = new mavlink20.message;
+mavlink20.messages.wheel_distance.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.distance, this.count];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Winch status.
+
+                time_usec                 : Timestamp (synced to UNIX time or since system boot). (uint64_t)
+                line_length               : Length of line released. NaN if unknown (float)
+                speed                     : Speed line is being released or retracted. Positive values if being released, negative values if being retracted, NaN if unknown (float)
+                tension                   : Tension on the line. NaN if unknown (float)
+                voltage                   : Voltage of the battery supplying the winch. NaN if unknown (float)
+                current                   : Current draw from the winch. NaN if unknown (float)
+                temperature               : Temperature of the motor. INT16_MAX if unknown (int16_t)
+                status                    : Status flags (uint32_t)
+
+*/
+    mavlink20.messages.winch_status = function( ...moreargs ) {
+    [ this.time_usec , this.line_length , this.speed , this.tension , this.voltage , this.current , this.temperature , this.status ] = moreargs;
+
+    this._format = '<QfffffIh';
+    this._id = mavlink20.MAVLINK_MSG_ID_WINCH_STATUS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 7, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 117;
+    this._name = 'WINCH_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_usec', 'line_length', 'speed', 'tension', 'voltage', 'current', 'temperature', 'status'];
+
+}
+
+mavlink20.messages.winch_status.prototype = new mavlink20.message;
+mavlink20.messages.winch_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_usec, this.line_length, this.speed, this.tension, this.voltage, this.current, this.status, this.temperature];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data for filling the OpenDroneID Basic ID message. This and the below
+messages are primarily meant for feeding data to/from an OpenDroneID
+implementation. E.g. https://github.com/opendroneid/opendroneid-
+core-c. These messages are compatible with the ASTM F3411 Remote ID
+standard and the ASD-STAN prEN 4709-002 Direct Remote ID standard.
+Additional information and usage of these messages is documented at
+https://mavlink.io/en/services/opendroneid.html.
+
+                target_system             : System ID (0 for broadcast). (uint8_t)
+                target_component          : Component ID (0 for broadcast). (uint8_t)
+                id_or_mac                 : Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html. (uint8_t)
+                id_type                   : Indicates the format for the uas_id field of this message. (uint8_t)
+                ua_type                   : Indicates the type of UA (Unmanned Aircraft). (uint8_t)
+                uas_id                    : UAS (Unmanned Aircraft System) ID following the format specified by id_type. Shall be filled with nulls in the unused portion of the field. (uint8_t)
+
+*/
+    mavlink20.messages.open_drone_id_basic_id = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.id_or_mac , this.id_type , this.ua_type , this.uas_id ] = moreargs;
+
+    this._format = '<BB20sBB20s';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 20, 1, 1, 20];
+    this.array_len_map = [0, 0, 20, 0, 0, 20];
+    this.crc_extra = 114;
+    this._name = 'OPEN_DRONE_ID_BASIC_ID';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'id_or_mac', 'id_type', 'ua_type', 'uas_id'];
+
+}
+
+mavlink20.messages.open_drone_id_basic_id.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_basic_id.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.id_or_mac, this.id_type, this.ua_type, this.uas_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data for filling the OpenDroneID Location message. The float data
+types are 32-bit IEEE 754. The Location message provides the location,
+altitude, direction and speed of the aircraft.
+
+                target_system             : System ID (0 for broadcast). (uint8_t)
+                target_component          : Component ID (0 for broadcast). (uint8_t)
+                id_or_mac                 : Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html. (uint8_t)
+                status                    : Indicates whether the unmanned aircraft is on the ground or in the air. (uint8_t)
+                direction                 : Direction over ground (not heading, but direction of movement) measured clockwise from true North: 0 - 35999 centi-degrees. If unknown: 36100 centi-degrees. (uint16_t)
+                speed_horizontal          : Ground speed. Positive only. If unknown: 25500 cm/s. If speed is larger than 25425 cm/s, use 25425 cm/s. (uint16_t)
+                speed_vertical            : The vertical speed. Up is positive. If unknown: 6300 cm/s. If speed is larger than 6200 cm/s, use 6200 cm/s. If lower than -6200 cm/s, use -6200 cm/s. (int16_t)
+                latitude                  : Current latitude of the unmanned aircraft. If unknown: 0 (both Lat/Lon). (int32_t)
+                longitude                 : Current longitude of the unmanned aircraft. If unknown: 0 (both Lat/Lon). (int32_t)
+                altitude_barometric        : The altitude calculated from the barometric pressure. Reference is against 29.92inHg or 1013.2mb. If unknown: -1000 m. (float)
+                altitude_geodetic         : The geodetic altitude as defined by WGS84. If unknown: -1000 m. (float)
+                height_reference          : Indicates the reference point for the height field. (uint8_t)
+                height                    : The current height of the unmanned aircraft above the take-off location or the ground as indicated by height_reference. If unknown: -1000 m. (float)
+                horizontal_accuracy        : The accuracy of the horizontal position. (uint8_t)
+                vertical_accuracy         : The accuracy of the vertical position. (uint8_t)
+                barometer_accuracy        : The accuracy of the barometric altitude. (uint8_t)
+                speed_accuracy            : The accuracy of the horizontal and vertical speed. (uint8_t)
+                timestamp                 : Seconds after the full hour with reference to UTC time. Typically the GPS outputs a time-of-week value in milliseconds. First convert that to UTC and then convert for this field using ((float) (time_week_ms % (60*60*1000))) / 1000. If unknown: 0xFFFF. (float)
+                timestamp_accuracy        : The accuracy of the timestamps. (uint8_t)
+
+*/
+    mavlink20.messages.open_drone_id_location = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.id_or_mac , this.status , this.direction , this.speed_horizontal , this.speed_vertical , this.latitude , this.longitude , this.altitude_barometric , this.altitude_geodetic , this.height_reference , this.height , this.horizontal_accuracy , this.vertical_accuracy , this.barometer_accuracy , this.speed_accuracy , this.timestamp , this.timestamp_accuracy ] = moreargs;
+
+    this._format = '<iiffffHHhBB20sBBBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_LOCATION;
+    this.order_map = [9, 10, 11, 12, 6, 7, 8, 0, 1, 2, 3, 13, 4, 14, 15, 16, 17, 5, 18];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 20, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 254;
+    this._name = 'OPEN_DRONE_ID_LOCATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'id_or_mac', 'status', 'direction', 'speed_horizontal', 'speed_vertical', 'latitude', 'longitude', 'altitude_barometric', 'altitude_geodetic', 'height_reference', 'height', 'horizontal_accuracy', 'vertical_accuracy', 'barometer_accuracy', 'speed_accuracy', 'timestamp', 'timestamp_accuracy'];
+
+}
+
+mavlink20.messages.open_drone_id_location.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_location.prototype.pack = function(mav) {
+    var orderedfields = [ this.latitude, this.longitude, this.altitude_barometric, this.altitude_geodetic, this.height, this.timestamp, this.direction, this.speed_horizontal, this.speed_vertical, this.target_system, this.target_component, this.id_or_mac, this.status, this.height_reference, this.horizontal_accuracy, this.vertical_accuracy, this.barometer_accuracy, this.speed_accuracy, this.timestamp_accuracy];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data for filling the OpenDroneID Authentication message. The
+Authentication Message defines a field that can provide a means of
+authenticity for the identity of the UAS (Unmanned Aircraft System).
+The Authentication message can have two different formats. For data
+page 0, the fields PageCount, Length and TimeStamp are present and
+AuthData is only 17 bytes. For data page 1 through 15, PageCount,
+Length and TimeStamp are not present and the size of AuthData is 23
+bytes.
+
+                target_system             : System ID (0 for broadcast). (uint8_t)
+                target_component          : Component ID (0 for broadcast). (uint8_t)
+                id_or_mac                 : Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html. (uint8_t)
+                authentication_type        : Indicates the type of authentication. (uint8_t)
+                data_page                 : Allowed range is 0 - 15. (uint8_t)
+                last_page_index           : This field is only present for page 0. Allowed range is 0 - 15. See the description of struct ODID_Auth_data at https://github.com/opendroneid/opendroneid-core-c/blob/master/libopendroneid/opendroneid.h. (uint8_t)
+                length                    : This field is only present for page 0. Total bytes of authentication_data from all data pages. See the description of struct ODID_Auth_data at https://github.com/opendroneid/opendroneid-core-c/blob/master/libopendroneid/opendroneid.h. (uint8_t)
+                timestamp                 : This field is only present for page 0. 32 bit Unix Timestamp in seconds since 00:00:00 01/01/2019. (uint32_t)
+                authentication_data        : Opaque authentication data. For page 0, the size is only 17 bytes. For other pages, the size is 23 bytes. Shall be filled with nulls in the unused portion of the field. (uint8_t)
+
+*/
+    mavlink20.messages.open_drone_id_authentication = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.id_or_mac , this.authentication_type , this.data_page , this.last_page_index , this.length , this.timestamp , this.authentication_data ] = moreargs;
+
+    this._format = '<IBB20sBBBB23s';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_AUTHENTICATION;
+    this.order_map = [1, 2, 3, 4, 5, 6, 7, 0, 8];
+    this.len_map = [1, 1, 1, 20, 1, 1, 1, 1, 23];
+    this.array_len_map = [0, 0, 0, 20, 0, 0, 0, 0, 23];
+    this.crc_extra = 140;
+    this._name = 'OPEN_DRONE_ID_AUTHENTICATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'id_or_mac', 'authentication_type', 'data_page', 'last_page_index', 'length', 'timestamp', 'authentication_data'];
+
+}
+
+mavlink20.messages.open_drone_id_authentication.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_authentication.prototype.pack = function(mav) {
+    var orderedfields = [ this.timestamp, this.target_system, this.target_component, this.id_or_mac, this.authentication_type, this.data_page, this.last_page_index, this.length, this.authentication_data];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data for filling the OpenDroneID Self ID message. The Self ID Message
+is an opportunity for the operator to (optionally) declare their
+identity and purpose of the flight. This message can provide
+additional information that could reduce the threat profile of a UA
+(Unmanned Aircraft) flying in a particular area or manner. This
+message can also be used to provide optional additional clarification
+in an emergency/remote ID system failure situation.
+
+                target_system             : System ID (0 for broadcast). (uint8_t)
+                target_component          : Component ID (0 for broadcast). (uint8_t)
+                id_or_mac                 : Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html. (uint8_t)
+                description_type          : Indicates the type of the description field. (uint8_t)
+                description               : Text description or numeric value expressed as ASCII characters. Shall be filled with nulls in the unused portion of the field. (char)
+
+*/
+    mavlink20.messages.open_drone_id_self_id = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.id_or_mac , this.description_type , this.description ] = moreargs;
+
+    this._format = '<BB20sB23s';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_SELF_ID;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 20, 1, 1];
+    this.array_len_map = [0, 0, 20, 0, 23];
+    this.crc_extra = 249;
+    this._name = 'OPEN_DRONE_ID_SELF_ID';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'id_or_mac', 'description_type', 'description'];
+
+}
+
+mavlink20.messages.open_drone_id_self_id.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_self_id.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.id_or_mac, this.description_type, this.description];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data for filling the OpenDroneID System message. The System Message
+contains general system information including the operator
+location/altitude and possible aircraft group and/or category/class
+information.
+
+                target_system             : System ID (0 for broadcast). (uint8_t)
+                target_component          : Component ID (0 for broadcast). (uint8_t)
+                id_or_mac                 : Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html. (uint8_t)
+                operator_location_type        : Specifies the operator location type. (uint8_t)
+                classification_type        : Specifies the classification type of the UA. (uint8_t)
+                operator_latitude         : Latitude of the operator. If unknown: 0 (both Lat/Lon). (int32_t)
+                operator_longitude        : Longitude of the operator. If unknown: 0 (both Lat/Lon). (int32_t)
+                area_count                : Number of aircraft in the area, group or formation (default 1). (uint16_t)
+                area_radius               : Radius of the cylindrical area of the group or formation (default 0). (uint16_t)
+                area_ceiling              : Area Operations Ceiling relative to WGS84. If unknown: -1000 m. (float)
+                area_floor                : Area Operations Floor relative to WGS84. If unknown: -1000 m. (float)
+                category_eu               : When classification_type is MAV_ODID_CLASSIFICATION_TYPE_EU, specifies the category of the UA. (uint8_t)
+                class_eu                  : When classification_type is MAV_ODID_CLASSIFICATION_TYPE_EU, specifies the class of the UA. (uint8_t)
+                operator_altitude_geo        : Geodetic altitude of the operator relative to WGS84. If unknown: -1000 m. (float)
+                timestamp                 : 32 bit Unix Timestamp in seconds since 00:00:00 01/01/2019. (uint32_t)
+
+*/
+    mavlink20.messages.open_drone_id_system = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.id_or_mac , this.operator_location_type , this.classification_type , this.operator_latitude , this.operator_longitude , this.area_count , this.area_radius , this.area_ceiling , this.area_floor , this.category_eu , this.class_eu , this.operator_altitude_geo , this.timestamp ] = moreargs;
+
+    this._format = '<iifffIHHBB20sBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_SYSTEM;
+    this.order_map = [8, 9, 10, 11, 12, 0, 1, 6, 7, 2, 3, 13, 14, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 20, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0];
+    this.crc_extra = 77;
+    this._name = 'OPEN_DRONE_ID_SYSTEM';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'id_or_mac', 'operator_location_type', 'classification_type', 'operator_latitude', 'operator_longitude', 'area_count', 'area_radius', 'area_ceiling', 'area_floor', 'category_eu', 'class_eu', 'operator_altitude_geo', 'timestamp'];
+
+}
+
+mavlink20.messages.open_drone_id_system.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_system.prototype.pack = function(mav) {
+    var orderedfields = [ this.operator_latitude, this.operator_longitude, this.area_ceiling, this.area_floor, this.operator_altitude_geo, this.timestamp, this.area_count, this.area_radius, this.target_system, this.target_component, this.id_or_mac, this.operator_location_type, this.classification_type, this.category_eu, this.class_eu];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Data for filling the OpenDroneID Operator ID message, which contains
+the CAA (Civil Aviation Authority) issued operator ID.
+
+                target_system             : System ID (0 for broadcast). (uint8_t)
+                target_component          : Component ID (0 for broadcast). (uint8_t)
+                id_or_mac                 : Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html. (uint8_t)
+                operator_id_type          : Indicates the type of the operator_id field. (uint8_t)
+                operator_id               : Text description or numeric value expressed as ASCII characters. Shall be filled with nulls in the unused portion of the field. (char)
+
+*/
+    mavlink20.messages.open_drone_id_operator_id = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.id_or_mac , this.operator_id_type , this.operator_id ] = moreargs;
+
+    this._format = '<BB20sB20s';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_OPERATOR_ID;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 20, 1, 1];
+    this.array_len_map = [0, 0, 20, 0, 20];
+    this.crc_extra = 49;
+    this._name = 'OPEN_DRONE_ID_OPERATOR_ID';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'id_or_mac', 'operator_id_type', 'operator_id'];
+
+}
+
+mavlink20.messages.open_drone_id_operator_id.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_operator_id.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.id_or_mac, this.operator_id_type, this.operator_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status from the transmitter telling the flight controller if the
+remote ID system is ready for arming.
+
+                status                    : Status level indicating if arming is allowed. (uint8_t)
+                error                     : Text error message, should be empty if status is good to arm. Fill with nulls in unused portion. (char)
+
+*/
+    mavlink20.messages.open_drone_id_arm_status = function( ...moreargs ) {
+    [ this.status , this.error ] = moreargs;
+
+    this._format = '<B50s';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_ARM_STATUS;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 50];
+    this.crc_extra = 139;
+    this._name = 'OPEN_DRONE_ID_ARM_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['status', 'error'];
+
+}
+
+mavlink20.messages.open_drone_id_arm_status.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_arm_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.status, this.error];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+An OpenDroneID message pack is a container for multiple encoded
+OpenDroneID messages (i.e. not in the format given for the above
+message descriptions but after encoding into the compressed
+OpenDroneID byte format). Used e.g. when transmitting on Bluetooth 5.0
+Long Range/Extended Advertising or on WiFi Neighbor Aware Networking
+or on WiFi Beacon.
+
+                target_system             : System ID (0 for broadcast). (uint8_t)
+                target_component          : Component ID (0 for broadcast). (uint8_t)
+                id_or_mac                 : Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html. (uint8_t)
+                single_message_size        : This field must currently always be equal to 25 (bytes), since all encoded OpenDroneID messages are specified to have this length. (uint8_t)
+                msg_pack_size             : Number of encoded messages in the pack (not the number of bytes). Allowed range is 1 - 9. (uint8_t)
+                messages                  : Concatenation of encoded OpenDroneID messages. Shall be filled with nulls in the unused portion of the field. (uint8_t)
+
+*/
+    mavlink20.messages.open_drone_id_message_pack = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.id_or_mac , this.single_message_size , this.msg_pack_size , this.messages ] = moreargs;
+
+    this._format = '<BB20sBB225s';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_MESSAGE_PACK;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 20, 1, 1, 225];
+    this.array_len_map = [0, 0, 20, 0, 0, 225];
+    this.crc_extra = 94;
+    this._name = 'OPEN_DRONE_ID_MESSAGE_PACK';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'id_or_mac', 'single_message_size', 'msg_pack_size', 'messages'];
+
+}
+
+mavlink20.messages.open_drone_id_message_pack.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_message_pack.prototype.pack = function(mav) {
+    var orderedfields = [ this.target_system, this.target_component, this.id_or_mac, this.single_message_size, this.msg_pack_size, this.messages];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Update the data in the OPEN_DRONE_ID_SYSTEM message with new location
+information. This can be sent to update the location information for
+the operator when no other information in the SYSTEM message has
+changed. This message allows for efficient operation on radio links
+which have limited uplink bandwidth while meeting requirements for
+update frequency of the operator location.
+
+                target_system             : System ID (0 for broadcast). (uint8_t)
+                target_component          : Component ID (0 for broadcast). (uint8_t)
+                operator_latitude         : Latitude of the operator. If unknown: 0 (both Lat/Lon). (int32_t)
+                operator_longitude        : Longitude of the operator. If unknown: 0 (both Lat/Lon). (int32_t)
+                operator_altitude_geo        : Geodetic altitude of the operator relative to WGS84. If unknown: -1000 m. (float)
+                timestamp                 : 32 bit Unix Timestamp in seconds since 00:00:00 01/01/2019. (uint32_t)
+
+*/
+    mavlink20.messages.open_drone_id_system_update = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.operator_latitude , this.operator_longitude , this.operator_altitude_geo , this.timestamp ] = moreargs;
+
+    this._format = '<iifIBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_OPEN_DRONE_ID_SYSTEM_UPDATE;
+    this.order_map = [4, 5, 0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 7;
+    this._name = 'OPEN_DRONE_ID_SYSTEM_UPDATE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'operator_latitude', 'operator_longitude', 'operator_altitude_geo', 'timestamp'];
+
+}
+
+mavlink20.messages.open_drone_id_system_update.prototype = new mavlink20.message;
+mavlink20.messages.open_drone_id_system_update.prototype.pack = function(mav) {
+    var orderedfields = [ this.operator_latitude, this.operator_longitude, this.operator_altitude_geo, this.timestamp, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Temperature and humidity from hygrometer.
+
+                id                        : Hygrometer ID (uint8_t)
+                temperature               : Temperature (int16_t)
+                humidity                  : Humidity (uint16_t)
+
+*/
+    mavlink20.messages.hygrometer_sensor = function( ...moreargs ) {
+    [ this.id , this.temperature , this.humidity ] = moreargs;
+
+    this._format = '<hHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HYGROMETER_SENSOR;
+    this.order_map = [2, 0, 1];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 20;
+    this._name = 'HYGROMETER_SENSOR';
+
+    this._instance_field = 'id';
+    this._instance_offset = 4;
+
+    this.fieldnames = ['id', 'temperature', 'humidity'];
+
+}
+
+mavlink20.messages.hygrometer_sensor.prototype = new mavlink20.message;
+mavlink20.messages.hygrometer_sensor.prototype.pack = function(mav) {
+    var orderedfields = [ this.temperature, this.humidity, this.id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Checksum for the current mission, rally point or geofence plan, or for
+the "combined" plan (a GCS can use these checksums to determine if it
+has matching plans).         This message must be broadcast with the
+appropriate checksum following any change to a mission, geofence or
+rally point definition         (immediately after the MISSION_ACK that
+completes the upload sequence).         It may also be requested using
+MAV_CMD_REQUEST_MESSAGE, where param 2 indicates the plan type for
+which the checksum is required.         The checksum must be
+calculated on the autopilot, but may also be calculated by the GCS.
+The checksum uses the same CRC32 algorithm as MAVLink FTP
+(https://mavlink.io/en/services/ftp.html#crc32-implementation).
+The checksum for a mission, geofence or rally point definition is run
+over each item in the plan in seq order (excluding the home location
+if present in the plan), and covers the following fields (in order):
+frame, command, autocontinue, param1, param2, param3, param4, param5,
+param6, param7.         The checksum for the whole plan
+(MAV_MISSION_TYPE_ALL) is calculated using the same approach, running
+over each sub-plan in the following order: mission, geofence then
+rally point.
+
+                mission_type              : Mission type. (uint8_t)
+                checksum                  : CRC32 checksum of current plan for specified type. (uint32_t)
+
+*/
+    mavlink20.messages.mission_checksum = function( ...moreargs ) {
+    [ this.mission_type , this.checksum ] = moreargs;
+
+    this._format = '<IB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MISSION_CHECKSUM;
+    this.order_map = [1, 0];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 3;
+    this._name = 'MISSION_CHECKSUM';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['mission_type', 'checksum'];
+
+}
+
+mavlink20.messages.mission_checksum.prototype = new mavlink20.message;
+mavlink20.messages.mission_checksum.prototype.pack = function(mav) {
+    var orderedfields = [ this.checksum, this.mission_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Airspeed information from a sensor.
+
+                id                        : Sensor ID. (uint8_t)
+                airspeed                  : Calibrated airspeed (CAS). (float)
+                temperature               : Temperature. INT16_MAX for value unknown/not supplied. (int16_t)
+                raw_press                 : Raw differential pressure. NaN for value unknown/not supplied. (float)
+                flags                     : Airspeed sensor flags. (uint8_t)
+
+*/
+    mavlink20.messages.airspeed = function( ...moreargs ) {
+    [ this.id , this.airspeed , this.temperature , this.raw_press , this.flags ] = moreargs;
+
+    this._format = '<ffhBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_AIRSPEED;
+    this.order_map = [3, 0, 2, 1, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 234;
+    this._name = 'AIRSPEED';
+
+    this._instance_field = 'id';
+    this._instance_offset = 10;
+
+    this.fieldnames = ['id', 'airspeed', 'temperature', 'raw_press', 'flags'];
+
+}
+
+mavlink20.messages.airspeed.prototype = new mavlink20.message;
+mavlink20.messages.airspeed.prototype.pack = function(mav) {
+    var orderedfields = [ this.airspeed, this.raw_press, this.temperature, this.id, this.flags];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+RC channel outputs from a MAVLink RC receiver for input to a flight
+controller or other components (allows an RC receiver to connect via
+MAVLink instead of some other protocol such as PPM-Sum or S.BUS).
+Note that this is not intended to be an over-the-air format, and does
+not replace RC_CHANNELS and similar messages reported by the flight
+controller.         The target_system field should normally be set to
+the system id of the system to control, typically the flight
+controller.         The target_component field can normally be set to
+0, so that all components of the system can receive the message.
+The channels array field can publish up to 32 channels; the number of
+channel items used in the array is specified in the count field.
+The time_last_update_ms field contains the timestamp of the last
+received valid channels data in the receiver's time domain.
+The count field indicates the first index of the channel array that is
+not used for channel data (this and later indexes are zero-filled).
+The RADIO_RC_CHANNELS_FLAGS_OUTDATED flag is set by the receiver if
+the channels data is not up-to-date (for example, if new data from the
+transmitter could not be validated so the last valid data is resent).
+The RADIO_RC_CHANNELS_FLAGS_FAILSAFE failsafe flag is set by the
+receiver if the receiver's failsafe condition is met (implementation
+dependent, e.g., connection to the RC radio is lost).         In this
+case time_last_update_ms still contains the timestamp of the last
+valid channels data, but the content of the channels data is not
+defined by the protocol (it is up to the implementation of the
+receiver).         For instance, the channels data could contain
+failsafe values configured in the receiver; the default is to carry
+the last valid data.         Note: The RC channels fields are
+extensions to ensure that they are located at the end of the
+serialized payload and subject to MAVLink's trailing-zero trimming.
+
+                target_system             : System ID (ID of target system, normally flight controller). (uint8_t)
+                target_component          : Component ID (normally 0 for broadcast). (uint8_t)
+                time_last_update_ms        : Time when the data in the channels field were last updated (time since boot in the receiver's time domain). (uint32_t)
+                flags                     : Radio RC channels status flags. (uint16_t)
+                count                     : Total number of RC channels being received. This can be larger than 32, indicating that more channels are available but not given in this message. (uint8_t)
+                channels                  : RC channels.
+        Channel values are in centered 13 bit format. Range is -4096 to 4096, center is 0. Conversion to PWM is x * 5/32 + 1500.
+        Channels with indexes equal or above count should be set to 0, to benefit from MAVLink's trailing-zero trimming. (int16_t)
+
+*/
+    mavlink20.messages.radio_rc_channels = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.time_last_update_ms , this.flags , this.count , this.channels ] = moreargs;
+
+    this._format = '<IHBBB32h';
+    this._id = mavlink20.MAVLINK_MSG_ID_RADIO_RC_CHANNELS;
+    this.order_map = [2, 3, 0, 1, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 32];
+    this.array_len_map = [0, 0, 0, 0, 0, 32];
+    this.crc_extra = 20;
+    this._name = 'RADIO_RC_CHANNELS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'time_last_update_ms', 'flags', 'count', 'channels'];
+
+}
+
+mavlink20.messages.radio_rc_channels.prototype = new mavlink20.message;
+mavlink20.messages.radio_rc_channels.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_last_update_ms, this.flags, this.target_system, this.target_component, this.count, this.channels];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Get information about a particular flight modes.         The message
+can be enumerated or requested for a particular mode using
+MAV_CMD_REQUEST_MESSAGE.         Specify 0 in param2 to request that
+the message is emitted for all available modes or the specific index
+for just one mode.         The modes must be available/settable for
+the current vehicle/frame type.         Each modes should only be
+emitted once (even if it is both standard and custom).
+
+                number_modes              : The total number of available modes for the current vehicle type. (uint8_t)
+                mode_index                : The current mode index within number_modes, indexed from 1. (uint8_t)
+                standard_mode             : Standard mode. (uint8_t)
+                custom_mode               : A bitfield for use for autopilot-specific flags (uint32_t)
+                properties                : Mode properties. (uint32_t)
+                mode_name                 : Name of custom mode, with null termination character. Should be omitted for standard modes. (char)
+
+*/
+    mavlink20.messages.available_modes = function( ...moreargs ) {
+    [ this.number_modes , this.mode_index , this.standard_mode , this.custom_mode , this.properties , this.mode_name ] = moreargs;
+
+    this._format = '<IIBBB35s';
+    this._id = mavlink20.MAVLINK_MSG_ID_AVAILABLE_MODES;
+    this.order_map = [2, 3, 4, 0, 1, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 35];
+    this.crc_extra = 134;
+    this._name = 'AVAILABLE_MODES';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['number_modes', 'mode_index', 'standard_mode', 'custom_mode', 'properties', 'mode_name'];
+
+}
+
+mavlink20.messages.available_modes.prototype = new mavlink20.message;
+mavlink20.messages.available_modes.prototype.pack = function(mav) {
+    var orderedfields = [ this.custom_mode, this.properties, this.number_modes, this.mode_index, this.standard_mode, this.mode_name];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Get the current mode.         This should be emitted on any mode
+change, and broadcast at low rate (nominally 0.5 Hz).         It may
+be requested using MAV_CMD_REQUEST_MESSAGE.
+
+                standard_mode             : Standard mode. (uint8_t)
+                custom_mode               : A bitfield for use for autopilot-specific flags (uint32_t)
+                intended_custom_mode        : The custom_mode of the mode that was last commanded by the user (for example, with MAV_CMD_DO_SET_STANDARD_MODE, MAV_CMD_DO_SET_MODE or via RC). This should usually be the same as custom_mode. It will be different if the vehicle is unable to enter the intended mode, or has left that mode due to a failsafe condition. 0 indicates the intended custom mode is unknown/not supplied (uint32_t)
+
+*/
+    mavlink20.messages.current_mode = function( ...moreargs ) {
+    [ this.standard_mode , this.custom_mode , this.intended_custom_mode ] = moreargs;
+
+    this._format = '<IIB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CURRENT_MODE;
+    this.order_map = [2, 0, 1];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 193;
+    this._name = 'CURRENT_MODE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['standard_mode', 'custom_mode', 'intended_custom_mode'];
+
+}
+
+mavlink20.messages.current_mode.prototype = new mavlink20.message;
+mavlink20.messages.current_mode.prototype.pack = function(mav) {
+    var orderedfields = [ this.custom_mode, this.intended_custom_mode, this.standard_mode];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+A change to the sequence number indicates that the set of
+AVAILABLE_MODES has changed.         A receiver must re-request all
+available modes whenever the sequence number changes.         This is
+only emitted after the first change and should then be broadcast at
+low rate (nominally 0.3 Hz) and on change.
+
+                seq                       : Sequence number. The value iterates sequentially whenever AVAILABLE_MODES changes (e.g. support for a new mode is added/removed dynamically). (uint8_t)
+
+*/
+    mavlink20.messages.available_modes_monitor = function( ...moreargs ) {
+    [ this.seq ] = moreargs;
+
+    this._format = '<B';
+    this._id = mavlink20.MAVLINK_MSG_ID_AVAILABLE_MODES_MONITOR;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [0];
+    this.crc_extra = 30;
+    this._name = 'AVAILABLE_MODES_MONITOR';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['seq'];
+
+}
+
+mavlink20.messages.available_modes_monitor.prototype = new mavlink20.message;
+mavlink20.messages.available_modes_monitor.prototype.pack = function(mav) {
+    var orderedfields = [ this.seq];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about key components of GNSS receivers, like signal
+authentication, interference and system errors.
+
+                id                        : GNSS receiver id. Must match instance ids of other messages from same receiver. (uint8_t)
+                system_errors             : Errors in the GPS system. (uint32_t)
+                authentication_state        : Signal authentication state of the GPS system. (uint8_t)
+                jamming_state             : Signal jamming state of the GPS system. (uint8_t)
+                spoofing_state            : Signal spoofing state of the GPS system. (uint8_t)
+                raim_state                : The state of the RAIM processing. (uint8_t)
+                raim_hfom                 : Horizontal expected accuracy using satellites successfully validated using RAIM. (uint16_t)
+                raim_vfom                 : Vertical expected accuracy using satellites successfully validated using RAIM. (uint16_t)
+                corrections_quality        : An abstract value representing the estimated quality of incoming corrections, or 255 if not available. (uint8_t)
+                system_status_summary        : An abstract value representing the overall status of the receiver, or 255 if not available. (uint8_t)
+                gnss_signal_quality        : An abstract value representing the quality of incoming GNSS signals, or 255 if not available. (uint8_t)
+                post_processing_quality        : An abstract value representing the estimated PPK quality, or 255 if not available. (uint8_t)
+
+*/
+    mavlink20.messages.gnss_integrity = function( ...moreargs ) {
+    [ this.id , this.system_errors , this.authentication_state , this.jamming_state , this.spoofing_state , this.raim_state , this.raim_hfom , this.raim_vfom , this.corrections_quality , this.system_status_summary , this.gnss_signal_quality , this.post_processing_quality ] = moreargs;
+
+    this._format = '<IHHBBBBBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_GNSS_INTEGRITY;
+    this.order_map = [3, 0, 4, 5, 6, 7, 1, 2, 8, 9, 10, 11];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 169;
+    this._name = 'GNSS_INTEGRITY';
+
+    this._instance_field = 'id';
+    this._instance_offset = 8;
+
+    this.fieldnames = ['id', 'system_errors', 'authentication_state', 'jamming_state', 'spoofing_state', 'raim_state', 'raim_hfom', 'raim_vfom', 'corrections_quality', 'system_status_summary', 'gnss_signal_quality', 'post_processing_quality'];
+
+}
+
+mavlink20.messages.gnss_integrity.prototype = new mavlink20.message;
+mavlink20.messages.gnss_integrity.prototype.pack = function(mav) {
+    var orderedfields = [ this.system_errors, this.raim_hfom, this.raim_vfom, this.id, this.authentication_state, this.jamming_state, this.spoofing_state, this.raim_state, this.corrections_quality, this.system_status_summary, this.gnss_signal_quality, this.post_processing_quality];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+ICAROUS heartbeat
+
+                status                    : See the FMS_STATE enum. (uint8_t)
+
+*/
+    mavlink20.messages.icarous_heartbeat = function( ...moreargs ) {
+    [ this.status ] = moreargs;
+
+    this._format = '<B';
+    this._id = mavlink20.MAVLINK_MSG_ID_ICAROUS_HEARTBEAT;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [0];
+    this.crc_extra = 227;
+    this._name = 'ICAROUS_HEARTBEAT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['status'];
+
+}
+
+mavlink20.messages.icarous_heartbeat.prototype = new mavlink20.message;
+mavlink20.messages.icarous_heartbeat.prototype.pack = function(mav) {
+    var orderedfields = [ this.status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Kinematic multi bands (track) output from Daidalus
+
+                numBands                  : Number of track bands (int8_t)
+                type1                     : See the TRACK_BAND_TYPES enum. (uint8_t)
+                min1                      : min angle (degrees) (float)
+                max1                      : max angle (degrees) (float)
+                type2                     : See the TRACK_BAND_TYPES enum. (uint8_t)
+                min2                      : min angle (degrees) (float)
+                max2                      : max angle (degrees) (float)
+                type3                     : See the TRACK_BAND_TYPES enum. (uint8_t)
+                min3                      : min angle (degrees) (float)
+                max3                      : max angle (degrees) (float)
+                type4                     : See the TRACK_BAND_TYPES enum. (uint8_t)
+                min4                      : min angle (degrees) (float)
+                max4                      : max angle (degrees) (float)
+                type5                     : See the TRACK_BAND_TYPES enum. (uint8_t)
+                min5                      : min angle (degrees) (float)
+                max5                      : max angle (degrees) (float)
+
+*/
+    mavlink20.messages.icarous_kinematic_bands = function( ...moreargs ) {
+    [ this.numBands , this.type1 , this.min1 , this.max1 , this.type2 , this.min2 , this.max2 , this.type3 , this.min3 , this.max3 , this.type4 , this.min4 , this.max4 , this.type5 , this.min5 , this.max5 ] = moreargs;
+
+    this._format = '<ffffffffffbBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ICAROUS_KINEMATIC_BANDS;
+    this.order_map = [10, 11, 0, 1, 12, 2, 3, 13, 4, 5, 14, 6, 7, 15, 8, 9];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 239;
+    this._name = 'ICAROUS_KINEMATIC_BANDS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['numBands', 'type1', 'min1', 'max1', 'type2', 'min2', 'max2', 'type3', 'min3', 'max3', 'type4', 'min4', 'max4', 'type5', 'min5', 'max5'];
+
+}
+
+mavlink20.messages.icarous_kinematic_bands.prototype = new mavlink20.message;
+mavlink20.messages.icarous_kinematic_bands.prototype.pack = function(mav) {
+    var orderedfields = [ this.min1, this.max1, this.min2, this.max2, this.min3, this.max3, this.min4, this.max4, this.min5, this.max5, this.numBands, this.type1, this.type2, this.type3, this.type4, this.type5];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+The heartbeat message shows that a system or component is present and
+responding. The type and autopilot fields (along with the message
+component id), allow the receiving system to treat further messages
+from this system appropriately (e.g. by laying out the user interface
+based on the autopilot). This microservice is documented at
+https://mavlink.io/en/services/heartbeat.html
+
+                type                      : Vehicle or component type. For a flight controller component the vehicle type (quadrotor, helicopter, etc.). For other components the component type (e.g. camera, gimbal, etc.). This should be used in preference to component id for identifying the component type. (uint8_t)
+                autopilot                 : Autopilot type / class. Use MAV_AUTOPILOT_INVALID for components that are not flight controllers. (uint8_t)
+                base_mode                 : System mode bitmap. (uint8_t)
+                custom_mode               : A bitfield for use for autopilot-specific flags (uint32_t)
+                system_status             : System status flag. (uint8_t)
+
+*/
+    mavlink20.messages.heartbeat = function( ...moreargs ) {
+    [ this.type , this.autopilot , this.base_mode , this.custom_mode , this.system_status ] = moreargs;
+    this.mavlink_version = 3;
+
+    this._format = '<IBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HEARTBEAT;
+    this.order_map = [1, 2, 3, 0, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 50;
+    this._name = 'HEARTBEAT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['type', 'autopilot', 'base_mode', 'custom_mode', 'system_status', 'mavlink_version'];
+
+}
+
+mavlink20.messages.heartbeat.prototype = new mavlink20.message;
+mavlink20.messages.heartbeat.prototype.pack = function(mav) {
+    var orderedfields = [ this.custom_mode, this.type, this.autopilot, this.base_mode, this.system_status, this.mavlink_version];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Array test #0.
+
+                v1                        : Stub field (uint8_t)
+                ar_i8                     : Value array (int8_t)
+                ar_u8                     : Value array (uint8_t)
+                ar_u16                    : Value array (uint16_t)
+                ar_u32                    : Value array (uint32_t)
+
+*/
+    mavlink20.messages.array_test_0 = function( ...moreargs ) {
+    [ this.v1 , this.ar_i8 , this.ar_u8 , this.ar_u16 , this.ar_u32 ] = moreargs;
+
+    this._format = '<4I4HB4s4s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_0;
+    this.order_map = [2, 3, 4, 1, 0];
+    this.len_map = [4, 4, 1, 4, 4];
+    this.array_len_map = [4, 4, 0, 4, 4];
+    this.crc_extra = 26;
+    this._name = 'ARRAY_TEST_0';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['v1', 'ar_i8', 'ar_u8', 'ar_u16', 'ar_u32'];
+
+}
+
+mavlink20.messages.array_test_0.prototype = new mavlink20.message;
+mavlink20.messages.array_test_0.prototype.pack = function(mav) {
+    var orderedfields = [ this.ar_u32, this.ar_u16, this.v1, this.ar_i8, this.ar_u8];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Array test #1.
+
+                ar_u32                    : Value array (uint32_t)
+
+*/
+    mavlink20.messages.array_test_1 = function( ...moreargs ) {
+    [ this.ar_u32 ] = moreargs;
+
+    this._format = '<4I';
+    this._id = mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_1;
+    this.order_map = [0];
+    this.len_map = [4];
+    this.array_len_map = [4];
+    this.crc_extra = 72;
+    this._name = 'ARRAY_TEST_1';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['ar_u32'];
+
+}
+
+mavlink20.messages.array_test_1.prototype = new mavlink20.message;
+mavlink20.messages.array_test_1.prototype.pack = function(mav) {
+    var orderedfields = [ this.ar_u32];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Array test #3.
+
+                v                         : Stub field (uint8_t)
+                ar_u32                    : Value array (uint32_t)
+
+*/
+    mavlink20.messages.array_test_3 = function( ...moreargs ) {
+    [ this.v , this.ar_u32 ] = moreargs;
+
+    this._format = '<4IB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_3;
+    this.order_map = [1, 0];
+    this.len_map = [4, 1];
+    this.array_len_map = [4, 0];
+    this.crc_extra = 19;
+    this._name = 'ARRAY_TEST_3';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['v', 'ar_u32'];
+
+}
+
+mavlink20.messages.array_test_3.prototype = new mavlink20.message;
+mavlink20.messages.array_test_3.prototype.pack = function(mav) {
+    var orderedfields = [ this.ar_u32, this.v];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Array test #4.
+
+                ar_u32                    : Value array (uint32_t)
+                v                         : Stub field (uint8_t)
+
+*/
+    mavlink20.messages.array_test_4 = function( ...moreargs ) {
+    [ this.ar_u32 , this.v ] = moreargs;
+
+    this._format = '<4IB';
+    this._id = mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_4;
+    this.order_map = [0, 1];
+    this.len_map = [4, 1];
+    this.array_len_map = [4, 0];
+    this.crc_extra = 89;
+    this._name = 'ARRAY_TEST_4';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['ar_u32', 'v'];
+
+}
+
+mavlink20.messages.array_test_4.prototype = new mavlink20.message;
+mavlink20.messages.array_test_4.prototype.pack = function(mav) {
+    var orderedfields = [ this.ar_u32, this.v];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Array test #5.
+
+                c1                        : Value array (char)
+                c2                        : Value array (char)
+
+*/
+    mavlink20.messages.array_test_5 = function( ...moreargs ) {
+    [ this.c1 , this.c2 ] = moreargs;
+
+    this._format = '<5s5s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_5;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [5, 5];
+    this.crc_extra = 27;
+    this._name = 'ARRAY_TEST_5';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['c1', 'c2'];
+
+}
+
+mavlink20.messages.array_test_5.prototype = new mavlink20.message;
+mavlink20.messages.array_test_5.prototype.pack = function(mav) {
+    var orderedfields = [ this.c1, this.c2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Array test #6.
+
+                v1                        : Stub field (uint8_t)
+                v2                        : Stub field (uint16_t)
+                v3                        : Stub field (uint32_t)
+                ar_u32                    : Value array (uint32_t)
+                ar_i32                    : Value array (int32_t)
+                ar_u16                    : Value array (uint16_t)
+                ar_i16                    : Value array (int16_t)
+                ar_u8                     : Value array (uint8_t)
+                ar_i8                     : Value array (int8_t)
+                ar_c                      : Value array (char)
+                ar_d                      : Value array (double)
+                ar_f                      : Value array (float)
+
+*/
+    mavlink20.messages.array_test_6 = function( ...moreargs ) {
+    [ this.v1 , this.v2 , this.v3 , this.ar_u32 , this.ar_i32 , this.ar_u16 , this.ar_i16 , this.ar_u8 , this.ar_i8 , this.ar_c , this.ar_d , this.ar_f ] = moreargs;
+
+    this._format = '<2dI2I2i2fH2H2hB2s2s32s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_6;
+    this.order_map = [8, 5, 1, 2, 3, 6, 7, 9, 10, 11, 0, 4];
+    this.len_map = [2, 1, 2, 2, 2, 1, 2, 2, 1, 2, 2, 1];
+    this.array_len_map = [2, 0, 2, 2, 2, 0, 2, 2, 0, 2, 2, 32];
+    this.crc_extra = 14;
+    this._name = 'ARRAY_TEST_6';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['v1', 'v2', 'v3', 'ar_u32', 'ar_i32', 'ar_u16', 'ar_i16', 'ar_u8', 'ar_i8', 'ar_c', 'ar_d', 'ar_f'];
+
+}
+
+mavlink20.messages.array_test_6.prototype = new mavlink20.message;
+mavlink20.messages.array_test_6.prototype.pack = function(mav) {
+    var orderedfields = [ this.ar_d, this.v3, this.ar_u32, this.ar_i32, this.ar_f, this.v2, this.ar_u16, this.ar_i16, this.v1, this.ar_u8, this.ar_i8, this.ar_c];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Array test #7.
+
+                ar_d                      : Value array (double)
+                ar_f                      : Value array (float)
+                ar_u32                    : Value array (uint32_t)
+                ar_i32                    : Value array (int32_t)
+                ar_u16                    : Value array (uint16_t)
+                ar_i16                    : Value array (int16_t)
+                ar_u8                     : Value array (uint8_t)
+                ar_i8                     : Value array (int8_t)
+                ar_c                      : Value array (char)
+
+*/
+    mavlink20.messages.array_test_7 = function( ...moreargs ) {
+    [ this.ar_d , this.ar_f , this.ar_u32 , this.ar_i32 , this.ar_u16 , this.ar_i16 , this.ar_u8 , this.ar_i8 , this.ar_c ] = moreargs;
+
+    this._format = '<2d2f2I2i2H2h2s2s32s';
+    this._id = mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_7;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+    this.len_map = [2, 2, 2, 2, 2, 2, 2, 2, 1];
+    this.array_len_map = [2, 2, 2, 2, 2, 2, 2, 2, 32];
+    this.crc_extra = 187;
+    this._name = 'ARRAY_TEST_7';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['ar_d', 'ar_f', 'ar_u32', 'ar_i32', 'ar_u16', 'ar_i16', 'ar_u8', 'ar_i8', 'ar_c'];
+
+}
+
+mavlink20.messages.array_test_7.prototype = new mavlink20.message;
+mavlink20.messages.array_test_7.prototype.pack = function(mav) {
+    var orderedfields = [ this.ar_d, this.ar_f, this.ar_u32, this.ar_i32, this.ar_u16, this.ar_i16, this.ar_u8, this.ar_i8, this.ar_c];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Array test #8.
+
+                v3                        : Stub field (uint32_t)
+                ar_d                      : Value array (double)
+                ar_u16                    : Value array (uint16_t)
+
+*/
+    mavlink20.messages.array_test_8 = function( ...moreargs ) {
+    [ this.v3 , this.ar_d , this.ar_u16 ] = moreargs;
+
+    this._format = '<2dI2H';
+    this._id = mavlink20.MAVLINK_MSG_ID_ARRAY_TEST_8;
+    this.order_map = [1, 0, 2];
+    this.len_map = [2, 1, 2];
+    this.array_len_map = [2, 0, 2];
+    this.crc_extra = 106;
+    this._name = 'ARRAY_TEST_8';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['v3', 'ar_d', 'ar_u16'];
+
+}
+
+mavlink20.messages.array_test_8.prototype = new mavlink20.message;
+mavlink20.messages.array_test_8.prototype.pack = function(mav) {
+    var orderedfields = [ this.ar_d, this.v3, this.ar_u16];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Test all field types
+
+                c                         : char (char)
+                s                         : string (char)
+                u8                        : uint8_t (uint8_t)
+                u16                       : uint16_t (uint16_t)
+                u32                       : uint32_t (uint32_t)
+                u64                       : uint64_t (uint64_t)
+                s8                        : int8_t (int8_t)
+                s16                       : int16_t (int16_t)
+                s32                       : int32_t (int32_t)
+                s64                       : int64_t (int64_t)
+                f                         : float (float)
+                d                         : double (double)
+                u8_array                  : uint8_t_array (uint8_t)
+                u16_array                 : uint16_t_array (uint16_t)
+                u32_array                 : uint32_t_array (uint32_t)
+                u64_array                 : uint64_t_array (uint64_t)
+                s8_array                  : int8_t_array (int8_t)
+                s16_array                 : int16_t_array (int16_t)
+                s32_array                 : int32_t_array (int32_t)
+                s64_array                 : int64_t_array (int64_t)
+                f_array                   : float_array (float)
+                d_array                   : double_array (double)
+
+*/
+    mavlink20.messages.test_types = function( ...moreargs ) {
+    [ this.c , this.s , this.u8 , this.u16 , this.u32 , this.u64 , this.s8 , this.s16 , this.s32 , this.s64 , this.f , this.d , this.u8_array , this.u16_array , this.u32_array , this.u64_array , this.s8_array , this.s16_array , this.s32_array , this.s64_array , this.f_array , this.d_array ] = moreargs;
+
+    this._format = '<Qqd3Q3q3dIif3I3i3fHh3H3hc10sBb3s3s';
+    this._id = mavlink20.MAVLINK_MSG_ID_TEST_TYPES;
+    this.order_map = [16, 17, 18, 12, 6, 0, 19, 13, 7, 1, 8, 2, 20, 14, 9, 3, 21, 15, 10, 4, 11, 5];
+    this.len_map = [1, 1, 1, 3, 3, 3, 1, 1, 1, 3, 3, 3, 1, 1, 3, 3, 1, 1, 1, 1, 3, 3];
+    this.array_len_map = [0, 0, 0, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 3, 3, 0, 10, 0, 0, 3, 3];
+    this.crc_extra = 103;
+    this._name = 'TEST_TYPES';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['c', 's', 'u8', 'u16', 'u32', 'u64', 's8', 's16', 's32', 's64', 'f', 'd', 'u8_array', 'u16_array', 'u32_array', 'u64_array', 's8_array', 's16_array', 's32_array', 's64_array', 'f_array', 'd_array'];
+
+}
+
+mavlink20.messages.test_types.prototype = new mavlink20.message;
+mavlink20.messages.test_types.prototype.pack = function(mav) {
+    var orderedfields = [ this.u64, this.s64, this.d, this.u64_array, this.s64_array, this.d_array, this.u32, this.s32, this.f, this.u32_array, this.s32_array, this.f_array, this.u16, this.s16, this.u16_array, this.s16_array, this.c, this.s, this.u8, this.s8, this.u8_array, this.s8_array];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Accelerometer and Gyro biases from the navigation filter
+
+                usec                      : Timestamp (microseconds) (uint64_t)
+                accel_0                   : b_f[0] (float)
+                accel_1                   : b_f[1] (float)
+                accel_2                   : b_f[2] (float)
+                gyro_0                    : b_f[0] (float)
+                gyro_1                    : b_f[1] (float)
+                gyro_2                    : b_f[2] (float)
+
+*/
+    mavlink20.messages.nav_filter_bias = function( ...moreargs ) {
+    [ this.usec , this.accel_0 , this.accel_1 , this.accel_2 , this.gyro_0 , this.gyro_1 , this.gyro_2 ] = moreargs;
+
+    this._format = '<Qffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_NAV_FILTER_BIAS;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 34;
+    this._name = 'NAV_FILTER_BIAS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['usec', 'accel_0', 'accel_1', 'accel_2', 'gyro_0', 'gyro_1', 'gyro_2'];
+
+}
+
+mavlink20.messages.nav_filter_bias.prototype = new mavlink20.message;
+mavlink20.messages.nav_filter_bias.prototype.pack = function(mav) {
+    var orderedfields = [ this.usec, this.accel_0, this.accel_1, this.accel_2, this.gyro_0, this.gyro_1, this.gyro_2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Complete set of calibration parameters for the radio
+
+                aileron                   : Aileron setpoints: left, center, right (uint16_t)
+                elevator                  : Elevator setpoints: nose down, center, nose up (uint16_t)
+                rudder                    : Rudder setpoints: nose left, center, nose right (uint16_t)
+                gyro                      : Tail gyro mode/gain setpoints: heading hold, rate mode (uint16_t)
+                pitch                     : Pitch curve setpoints (every 25%) (uint16_t)
+                throttle                  : Throttle curve setpoints (every 25%) (uint16_t)
+
+*/
+    mavlink20.messages.radio_calibration = function( ...moreargs ) {
+    [ this.aileron , this.elevator , this.rudder , this.gyro , this.pitch , this.throttle ] = moreargs;
+
+    this._format = '<3H3H3H2H5H5H';
+    this._id = mavlink20.MAVLINK_MSG_ID_RADIO_CALIBRATION;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [3, 3, 3, 2, 5, 5];
+    this.array_len_map = [3, 3, 3, 2, 5, 5];
+    this.crc_extra = 71;
+    this._name = 'RADIO_CALIBRATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['aileron', 'elevator', 'rudder', 'gyro', 'pitch', 'throttle'];
+
+}
+
+mavlink20.messages.radio_calibration.prototype = new mavlink20.message;
+mavlink20.messages.radio_calibration.prototype.pack = function(mav) {
+    var orderedfields = [ this.aileron, this.elevator, this.rudder, this.gyro, this.pitch, this.throttle];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+System status specific to ualberta uav
+
+                mode                      : System mode, see UALBERTA_AUTOPILOT_MODE ENUM (uint8_t)
+                nav_mode                  : Navigation mode, see UALBERTA_NAV_MODE ENUM (uint8_t)
+                pilot                     : Pilot mode, see UALBERTA_PILOT_MODE (uint8_t)
+
+*/
+    mavlink20.messages.ualberta_sys_status = function( ...moreargs ) {
+    [ this.mode , this.nav_mode , this.pilot ] = moreargs;
+
+    this._format = '<BBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_UALBERTA_SYS_STATUS;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 15;
+    this._name = 'UALBERTA_SYS_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['mode', 'nav_mode', 'pilot'];
+
+}
+
+mavlink20.messages.ualberta_sys_status.prototype = new mavlink20.message;
+mavlink20.messages.ualberta_sys_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.mode, this.nav_mode, this.pilot];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Static data to configure the ADS-B transponder (send within 10 sec of
+a POR and every 10 sec thereafter)
+
+                ICAO                      : Vehicle address (24 bit) (uint32_t)
+                callsign                  : Vehicle identifier (8 characters, null terminated, valid characters are A-Z, 0-9, " " only) (char)
+                emitterType               : Transmitting vehicle type. See ADSB_EMITTER_TYPE enum (uint8_t)
+                aircraftSize              : Aircraft length and width encoding (table 2-35 of DO-282B) (uint8_t)
+                gpsOffsetLat              : GPS antenna lateral offset (table 2-36 of DO-282B) (uint8_t)
+                gpsOffsetLon              : GPS antenna longitudinal offset from nose [if non-zero, take position (in meters) divide by 2 and add one] (table 2-37 DO-282B) (uint8_t)
+                stallSpeed                : Aircraft stall speed in cm/s (uint16_t)
+                rfSelect                  : ADS-B transponder reciever and transmit enable flags (uint8_t)
+
+*/
+    mavlink20.messages.uavionix_adsb_out_cfg = function( ...moreargs ) {
+    [ this.ICAO , this.callsign , this.emitterType , this.aircraftSize , this.gpsOffsetLat , this.gpsOffsetLon , this.stallSpeed , this.rfSelect ] = moreargs;
+
+    this._format = '<IH9sBBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_CFG;
+    this.order_map = [0, 2, 3, 4, 5, 6, 1, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 9, 0, 0, 0, 0, 0];
+    this.crc_extra = 209;
+    this._name = 'UAVIONIX_ADSB_OUT_CFG';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['ICAO', 'callsign', 'emitterType', 'aircraftSize', 'gpsOffsetLat', 'gpsOffsetLon', 'stallSpeed', 'rfSelect'];
+
+}
+
+mavlink20.messages.uavionix_adsb_out_cfg.prototype = new mavlink20.message;
+mavlink20.messages.uavionix_adsb_out_cfg.prototype.pack = function(mav) {
+    var orderedfields = [ this.ICAO, this.stallSpeed, this.callsign, this.emitterType, this.aircraftSize, this.gpsOffsetLat, this.gpsOffsetLon, this.rfSelect];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Dynamic data used to generate ADS-B out transponder data (send at 5Hz)
+
+                utcTime                   : UTC time in seconds since GPS epoch (Jan 6, 1980). If unknown set to UINT32_MAX (uint32_t)
+                gpsLat                    : Latitude WGS84 (deg * 1E7). If unknown set to INT32_MAX (int32_t)
+                gpsLon                    : Longitude WGS84 (deg * 1E7). If unknown set to INT32_MAX (int32_t)
+                gpsAlt                    : Altitude (WGS84). UP +ve. If unknown set to INT32_MAX (int32_t)
+                gpsFix                    : 0-1: no fix, 2: 2D fix, 3: 3D fix, 4: DGPS, 5: RTK (uint8_t)
+                numSats                   : Number of satellites visible. If unknown set to UINT8_MAX (uint8_t)
+                baroAltMSL                : Barometric pressure altitude (MSL) relative to a standard atmosphere of 1013.2 mBar and NOT bar corrected altitude (m * 1E-3). (up +ve). If unknown set to INT32_MAX (int32_t)
+                accuracyHor               : Horizontal accuracy in mm (m * 1E-3). If unknown set to UINT32_MAX (uint32_t)
+                accuracyVert              : Vertical accuracy in cm. If unknown set to UINT16_MAX (uint16_t)
+                accuracyVel               : Velocity accuracy in mm/s (m * 1E-3). If unknown set to UINT16_MAX (uint16_t)
+                velVert                   : GPS vertical speed in cm/s. If unknown set to INT16_MAX (int16_t)
+                velNS                     : North-South velocity over ground in cm/s North +ve. If unknown set to INT16_MAX (int16_t)
+                VelEW                     : East-West velocity over ground in cm/s East +ve. If unknown set to INT16_MAX (int16_t)
+                emergencyStatus           : Emergency status (uint8_t)
+                state                     : ADS-B transponder dynamic input state flags (uint16_t)
+                squawk                    : Mode A code (typically 1200 [0x04B0] for VFR) (uint16_t)
+
+*/
+    mavlink20.messages.uavionix_adsb_out_dynamic = function( ...moreargs ) {
+    [ this.utcTime , this.gpsLat , this.gpsLon , this.gpsAlt , this.gpsFix , this.numSats , this.baroAltMSL , this.accuracyHor , this.accuracyVert , this.accuracyVel , this.velVert , this.velNS , this.VelEW , this.emergencyStatus , this.state , this.squawk ] = moreargs;
+
+    this._format = '<IiiiiIHHhhhHHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_DYNAMIC;
+    this.order_map = [0, 1, 2, 3, 13, 14, 4, 5, 6, 7, 8, 9, 10, 15, 11, 12];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 186;
+    this._name = 'UAVIONIX_ADSB_OUT_DYNAMIC';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['utcTime', 'gpsLat', 'gpsLon', 'gpsAlt', 'gpsFix', 'numSats', 'baroAltMSL', 'accuracyHor', 'accuracyVert', 'accuracyVel', 'velVert', 'velNS', 'VelEW', 'emergencyStatus', 'state', 'squawk'];
+
+}
+
+mavlink20.messages.uavionix_adsb_out_dynamic.prototype = new mavlink20.message;
+mavlink20.messages.uavionix_adsb_out_dynamic.prototype.pack = function(mav) {
+    var orderedfields = [ this.utcTime, this.gpsLat, this.gpsLon, this.gpsAlt, this.baroAltMSL, this.accuracyHor, this.accuracyVert, this.accuracyVel, this.velVert, this.velNS, this.VelEW, this.state, this.squawk, this.gpsFix, this.numSats, this.emergencyStatus];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Transceiver heartbeat with health report (updated every 10s)
+
+                rfHealth                  : ADS-B transponder messages (uint8_t)
+
+*/
+    mavlink20.messages.uavionix_adsb_transceiver_health_report = function( ...moreargs ) {
+    [ this.rfHealth ] = moreargs;
+
+    this._format = '<B';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_TRANSCEIVER_HEALTH_REPORT;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [0];
+    this.crc_extra = 4;
+    this._name = 'UAVIONIX_ADSB_TRANSCEIVER_HEALTH_REPORT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['rfHealth'];
+
+}
+
+mavlink20.messages.uavionix_adsb_transceiver_health_report.prototype = new mavlink20.message;
+mavlink20.messages.uavionix_adsb_transceiver_health_report.prototype.pack = function(mav) {
+    var orderedfields = [ this.rfHealth];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Aircraft Registration.
+
+                registration              : Aircraft Registration (ASCII string A-Z, 0-9 only), e.g. "N8644B ". Trailing spaces (0x20) only. This is null-terminated. (char)
+
+*/
+    mavlink20.messages.uavionix_adsb_out_cfg_registration = function( ...moreargs ) {
+    [ this.registration ] = moreargs;
+
+    this._format = '<9s';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_CFG_REGISTRATION;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [9];
+    this.crc_extra = 133;
+    this._name = 'UAVIONIX_ADSB_OUT_CFG_REGISTRATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['registration'];
+
+}
+
+mavlink20.messages.uavionix_adsb_out_cfg_registration.prototype = new mavlink20.message;
+mavlink20.messages.uavionix_adsb_out_cfg_registration.prototype.pack = function(mav) {
+    var orderedfields = [ this.registration];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Flight Identification for ADSB-Out vehicles.
+
+                flight_id                 : Flight Identification: 8 ASCII characters, '0' through '9', 'A' through 'Z' or space. Spaces (0x20) used as a trailing pad character, or when call sign is unavailable. Reflects Control message setting. This is null-terminated. (char)
+
+*/
+    mavlink20.messages.uavionix_adsb_out_cfg_flightid = function( ...moreargs ) {
+    [ this.flight_id ] = moreargs;
+
+    this._format = '<9s';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_CFG_FLIGHTID;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [9];
+    this.crc_extra = 103;
+    this._name = 'UAVIONIX_ADSB_OUT_CFG_FLIGHTID';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['flight_id'];
+
+}
+
+mavlink20.messages.uavionix_adsb_out_cfg_flightid.prototype = new mavlink20.message;
+mavlink20.messages.uavionix_adsb_out_cfg_flightid.prototype.pack = function(mav) {
+    var orderedfields = [ this.flight_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Request messages.
+
+                ReqMessageId              : Message ID to request. Supports any message in this 10000-10099 range (uint32_t)
+
+*/
+    mavlink20.messages.uavionix_adsb_get = function( ...moreargs ) {
+    [ this.ReqMessageId ] = moreargs;
+
+    this._format = '<I';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_GET;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [0];
+    this.crc_extra = 193;
+    this._name = 'UAVIONIX_ADSB_GET';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['ReqMessageId'];
+
+}
+
+mavlink20.messages.uavionix_adsb_get.prototype = new mavlink20.message;
+mavlink20.messages.uavionix_adsb_get.prototype.pack = function(mav) {
+    var orderedfields = [ this.ReqMessageId];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Control message with all data sent in UCP control message.
+
+                state                     : ADS-B transponder control state flags (uint8_t)
+                baroAltMSL                : Barometric pressure altitude (MSL) relative to a standard atmosphere of 1013.2 mBar and NOT bar corrected altitude (m * 1E-3). (up +ve). If unknown set to INT32_MAX (int32_t)
+                squawk                    : Mode A code (typically 1200 [0x04B0] for VFR) (uint16_t)
+                emergencyStatus           : Emergency status (uint8_t)
+                flight_id                 : Flight Identification: 8 ASCII characters, '0' through '9', 'A' through 'Z' or space. Spaces (0x20) used as a trailing pad character, or when call sign is unavailable. (char)
+                x_bit                     : X-Bit enable (military transponders only) (uint8_t)
+
+*/
+    mavlink20.messages.uavionix_adsb_out_control = function( ...moreargs ) {
+    [ this.state , this.baroAltMSL , this.squawk , this.emergencyStatus , this.flight_id , this.x_bit ] = moreargs;
+
+    this._format = '<iHBB8sB';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_CONTROL;
+    this.order_map = [2, 0, 1, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 8, 0];
+    this.crc_extra = 71;
+    this._name = 'UAVIONIX_ADSB_OUT_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['state', 'baroAltMSL', 'squawk', 'emergencyStatus', 'flight_id', 'x_bit'];
+
+}
+
+mavlink20.messages.uavionix_adsb_out_control.prototype = new mavlink20.message;
+mavlink20.messages.uavionix_adsb_out_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.baroAltMSL, this.squawk, this.state, this.emergencyStatus, this.flight_id, this.x_bit];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Status message with information from UCP Heartbeat and Status
+messages.
+
+                state                     : ADS-B transponder status state flags (uint8_t)
+                squawk                    : Mode A code (typically 1200 [0x04B0] for VFR) (uint16_t)
+                NIC_NACp                  : Integrity and Accuracy of traffic reported as a 4-bit value for each field (NACp 7:4, NIC 3:0) and encoded by Containment Radius (HPL) and Estimated Position Uncertainty (HFOM), respectively (uint8_t)
+                boardTemp                 : Board temperature in C (uint8_t)
+                fault                     : ADS-B transponder fault flags (uint8_t)
+                flight_id                 : Flight Identification: 8 ASCII characters, '0' through '9', 'A' through 'Z' or space. Spaces (0x20) used as a trailing pad character, or when call sign is unavailable. (char)
+
+*/
+    mavlink20.messages.uavionix_adsb_out_status = function( ...moreargs ) {
+    [ this.state , this.squawk , this.NIC_NACp , this.boardTemp , this.fault , this.flight_id ] = moreargs;
+
+    this._format = '<HBBBB8s';
+    this._id = mavlink20.MAVLINK_MSG_ID_UAVIONIX_ADSB_OUT_STATUS;
+    this.order_map = [1, 0, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 8];
+    this.crc_extra = 240;
+    this._name = 'UAVIONIX_ADSB_OUT_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['state', 'squawk', 'NIC_NACp', 'boardTemp', 'fault', 'flight_id'];
+
+}
+
+mavlink20.messages.uavionix_adsb_out_status.prototype = new mavlink20.message;
+mavlink20.messages.uavionix_adsb_out_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.squawk, this.state, this.NIC_NACp, this.boardTemp, this.fault, this.flight_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Composite EFI and Governor data from Loweheiser equipment.  This
+message is created by the EFI unit based on its own data and data
+received from a governor attached to that EFI unit.
+
+                volt_batt                 : Generator Battery voltage. (float)
+                curr_batt                 : Generator Battery current. (float)
+                curr_gen                  : Current being produced by generator. (float)
+                curr_rot                  : Load current being consumed by the UAV (sum of curr_gen and curr_batt) (float)
+                fuel_level                : Generator fuel remaining in litres. (float)
+                throttle                  : Throttle Output. (float)
+                runtime                   : Seconds this generator has run since it was rebooted. (uint32_t)
+                until_maintenance         : Seconds until this generator requires maintenance.  A negative value indicates maintenance is past due. (int32_t)
+                rectifier_temp            : The Temperature of the rectifier. (float)
+                generator_temp            : The temperature of the mechanical motor, fuel cell core or generator. (float)
+                efi_batt                  : EFI Supply Voltage. (float)
+                efi_rpm                   : Motor RPM. (float)
+                efi_pw                    : Injector pulse-width in miliseconds. (float)
+                efi_fuel_flow             : Fuel flow rate in litres/hour. (float)
+                efi_fuel_consumed         : Fuel consumed. (float)
+                efi_baro                  : Atmospheric pressure. (float)
+                efi_mat                   : Manifold Air Temperature. (float)
+                efi_clt                   : Cylinder Head Temperature. (float)
+                efi_tps                   : Throttle Position. (float)
+                efi_exhaust_gas_temperature        : Exhaust gas temperature. (float)
+                efi_index                 : EFI index. (uint8_t)
+                generator_status          : Generator status. (uint16_t)
+                efi_status                : EFI status. (uint16_t)
+
+*/
+    mavlink20.messages.loweheiser_gov_efi = function( ...moreargs ) {
+    [ this.volt_batt , this.curr_batt , this.curr_gen , this.curr_rot , this.fuel_level , this.throttle , this.runtime , this.until_maintenance , this.rectifier_temp , this.generator_temp , this.efi_batt , this.efi_rpm , this.efi_pw , this.efi_fuel_flow , this.efi_fuel_consumed , this.efi_baro , this.efi_mat , this.efi_clt , this.efi_tps , this.efi_exhaust_gas_temperature , this.efi_index , this.generator_status , this.efi_status ] = moreargs;
+
+    this._format = '<ffffffIiffffffffffffHHB';
+    this._id = mavlink20.MAVLINK_MSG_ID_LOWEHEISER_GOV_EFI;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 20, 21];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 195;
+    this._name = 'LOWEHEISER_GOV_EFI';
+
+    this._instance_field = 'efi_index';
+    this._instance_offset = 84;
+
+    this.fieldnames = ['volt_batt', 'curr_batt', 'curr_gen', 'curr_rot', 'fuel_level', 'throttle', 'runtime', 'until_maintenance', 'rectifier_temp', 'generator_temp', 'efi_batt', 'efi_rpm', 'efi_pw', 'efi_fuel_flow', 'efi_fuel_consumed', 'efi_baro', 'efi_mat', 'efi_clt', 'efi_tps', 'efi_exhaust_gas_temperature', 'efi_index', 'generator_status', 'efi_status'];
+
+}
+
+mavlink20.messages.loweheiser_gov_efi.prototype = new mavlink20.message;
+mavlink20.messages.loweheiser_gov_efi.prototype.pack = function(mav) {
+    var orderedfields = [ this.volt_batt, this.curr_batt, this.curr_gen, this.curr_rot, this.fuel_level, this.throttle, this.runtime, this.until_maintenance, this.rectifier_temp, this.generator_temp, this.efi_batt, this.efi_rpm, this.efi_pw, this.efi_fuel_flow, this.efi_fuel_consumed, this.efi_baro, this.efi_mat, this.efi_clt, this.efi_tps, this.efi_exhaust_gas_temperature, this.generator_status, this.efi_status, this.efi_index];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about a gimbal manager. This message should be requested
+by a ground station using MAV_CMD_REQUEST_MESSAGE. It mirrors some
+fields of the GIMBAL_DEVICE_INFORMATION message, but not all. If the
+additional information is desired, also GIMBAL_DEVICE_INFORMATION
+should be requested.
+
+                gimbal_id                 : Gimbal ID (component ID or 1-6 for non-MAVLink gimbal) that this gimbal manager is responsible for. (uint8_t)
+                device_cap_flags          : Gimbal device capability flags. Same flags as reported by GIMBAL_DEVICE_INFORMATION. The flag is only 16 bit wide, but stored in 32 bit, for backwards compatibility (high word is zero). (uint32_t)
+                manager_cap_flags         : Gimbal manager capability flags. (uint32_t)
+                roll_min                  : Hardware minimum roll angle (positive: roll to the right). NaN if unknown. (float)
+                roll_max                  : Hardware maximum roll angle (positive: roll to the right). NaN if unknown. (float)
+                pitch_min                 : Hardware minimum pitch/tilt angle (positive: tilt up). NaN if unknown. (float)
+                pitch_max                 : Hardware maximum pitch/tilt angle (positive: tilt up). NaN if unknown. (float)
+                yaw_min                   : Hardware minimum yaw/pan angle (positive: pan to the right, relative to the vehicle/gimbal base). NaN if unknown. (float)
+                yaw_max                   : Hardware maximum yaw/pan angle (positive: pan to the right, relative to the vehicle/gimbal base). NaN if unknown. (float)
+
+*/
+    mavlink20.messages.storm32_gimbal_manager_information = function( ...moreargs ) {
+    [ this.gimbal_id , this.device_cap_flags , this.manager_cap_flags , this.roll_min , this.roll_max , this.pitch_min , this.pitch_max , this.yaw_min , this.yaw_max ] = moreargs;
+
+    this._format = '<IIffffffB';
+    this._id = mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_INFORMATION;
+    this.order_map = [8, 0, 1, 2, 3, 4, 5, 6, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 208;
+    this._name = 'STORM32_GIMBAL_MANAGER_INFORMATION';
+
+    this._instance_field = 'gimbal_id';
+    this._instance_offset = 32;
+
+    this.fieldnames = ['gimbal_id', 'device_cap_flags', 'manager_cap_flags', 'roll_min', 'roll_max', 'pitch_min', 'pitch_max', 'yaw_min', 'yaw_max'];
+
+}
+
+mavlink20.messages.storm32_gimbal_manager_information.prototype = new mavlink20.message;
+mavlink20.messages.storm32_gimbal_manager_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.device_cap_flags, this.manager_cap_flags, this.roll_min, this.roll_max, this.pitch_min, this.pitch_max, this.yaw_min, this.yaw_max, this.gimbal_id];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message reporting the current status of a gimbal manager. This message
+should be broadcast at a low regular rate (e.g. 1 Hz, may be increase
+momentarily to e.g. 5 Hz for a period of 1 sec after a change).
+
+                gimbal_id                 : Gimbal ID (component ID or 1-6 for non-MAVLink gimbal) that this gimbal manager is responsible for. (uint8_t)
+                supervisor                : Client who is currently supervisor (0 = none). (uint8_t)
+                device_flags              : Gimbal device flags currently applied. Same flags as reported by GIMBAL_DEVICE_ATTITUDE_STATUS. (uint16_t)
+                manager_flags             : Gimbal manager flags currently applied. (uint16_t)
+                profile                   : Profile currently applied (0 = default). (uint8_t)
+
+*/
+    mavlink20.messages.storm32_gimbal_manager_status = function( ...moreargs ) {
+    [ this.gimbal_id , this.supervisor , this.device_flags , this.manager_flags , this.profile ] = moreargs;
+
+    this._format = '<HHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_STATUS;
+    this.order_map = [2, 3, 0, 1, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 183;
+    this._name = 'STORM32_GIMBAL_MANAGER_STATUS';
+
+    this._instance_field = 'gimbal_id';
+    this._instance_offset = 4;
+
+    this.fieldnames = ['gimbal_id', 'supervisor', 'device_flags', 'manager_flags', 'profile'];
+
+}
+
+mavlink20.messages.storm32_gimbal_manager_status.prototype = new mavlink20.message;
+mavlink20.messages.storm32_gimbal_manager_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.device_flags, this.manager_flags, this.gimbal_id, this.supervisor, this.profile];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message to a gimbal manager to control the gimbal attitude. Angles and
+rates can be set to NaN according to use case. A gimbal device is
+never to react to this message.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                gimbal_id                 : Gimbal ID of the gimbal manager to address (component ID or 1-6 for non-MAVLink gimbal, 0 for all gimbals). Send command multiple times for more than one but not all gimbals. (uint8_t)
+                client                    : Client which is contacting the gimbal manager (must be set). (uint8_t)
+                device_flags              : Gimbal device flags to be applied (UINT16_MAX to be ignored). Same flags as used in GIMBAL_DEVICE_SET_ATTITUDE. (uint16_t)
+                manager_flags             : Gimbal manager flags to be applied (0 to be ignored). (uint16_t)
+                q                         : Quaternion components, w, x, y, z (1 0 0 0 is the null-rotation). Set first element to NaN to be ignored. The frame is determined by the GIMBAL_DEVICE_FLAGS_YAW_IN_xxx_FRAME flags. (float)
+                angular_velocity_x        : X component of angular velocity (positive: roll to the right). NaN to be ignored. (float)
+                angular_velocity_y        : Y component of angular velocity (positive: tilt up). NaN to be ignored. (float)
+                angular_velocity_z        : Z component of angular velocity (positive: pan to the right). NaN to be ignored. The frame is determined by the GIMBAL_DEVICE_FLAGS_YAW_IN_xxx_FRAME flags. (float)
+
+*/
+    mavlink20.messages.storm32_gimbal_manager_control = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.gimbal_id , this.client , this.device_flags , this.manager_flags , this.q , this.angular_velocity_x , this.angular_velocity_y , this.angular_velocity_z ] = moreargs;
+
+    this._format = '<4ffffHHBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_CONTROL;
+    this.order_map = [6, 7, 8, 9, 4, 5, 0, 1, 2, 3];
+    this.len_map = [4, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [4, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 99;
+    this._name = 'STORM32_GIMBAL_MANAGER_CONTROL';
+
+    this._instance_field = 'gimbal_id';
+    this._instance_offset = 34;
+
+    this.fieldnames = ['target_system', 'target_component', 'gimbal_id', 'client', 'device_flags', 'manager_flags', 'q', 'angular_velocity_x', 'angular_velocity_y', 'angular_velocity_z'];
+
+}
+
+mavlink20.messages.storm32_gimbal_manager_control.prototype = new mavlink20.message;
+mavlink20.messages.storm32_gimbal_manager_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.q, this.angular_velocity_x, this.angular_velocity_y, this.angular_velocity_z, this.device_flags, this.manager_flags, this.target_system, this.target_component, this.gimbal_id, this.client];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message to a gimbal manager to control the gimbal tilt and pan angles.
+Angles and rates can be set to NaN according to use case. A gimbal
+device is never to react to this message.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                gimbal_id                 : Gimbal ID of the gimbal manager to address (component ID or 1-6 for non-MAVLink gimbal, 0 for all gimbals). Send command multiple times for more than one but not all gimbals. (uint8_t)
+                client                    : Client which is contacting the gimbal manager (must be set). (uint8_t)
+                device_flags              : Gimbal device flags to be applied (UINT16_MAX to be ignored). Same flags as used in GIMBAL_DEVICE_SET_ATTITUDE. (uint16_t)
+                manager_flags             : Gimbal manager flags to be applied (0 to be ignored). (uint16_t)
+                pitch                     : Pitch/tilt angle (positive: tilt up). NaN to be ignored. (float)
+                yaw                       : Yaw/pan angle (positive: pan the right). NaN to be ignored. The frame is determined by the GIMBAL_DEVICE_FLAGS_YAW_IN_xxx_FRAME flags. (float)
+                pitch_rate                : Pitch/tilt angular rate (positive: tilt up). NaN to be ignored. (float)
+                yaw_rate                  : Yaw/pan angular rate (positive: pan to the right). NaN to be ignored. The frame is determined by the GIMBAL_DEVICE_FLAGS_YAW_IN_xxx_FRAME flags. (float)
+
+*/
+    mavlink20.messages.storm32_gimbal_manager_control_pitchyaw = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.gimbal_id , this.client , this.device_flags , this.manager_flags , this.pitch , this.yaw , this.pitch_rate , this.yaw_rate ] = moreargs;
+
+    this._format = '<ffffHHBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_CONTROL_PITCHYAW;
+    this.order_map = [6, 7, 8, 9, 4, 5, 0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 129;
+    this._name = 'STORM32_GIMBAL_MANAGER_CONTROL_PITCHYAW';
+
+    this._instance_field = 'gimbal_id';
+    this._instance_offset = 22;
+
+    this.fieldnames = ['target_system', 'target_component', 'gimbal_id', 'client', 'device_flags', 'manager_flags', 'pitch', 'yaw', 'pitch_rate', 'yaw_rate'];
+
+}
+
+mavlink20.messages.storm32_gimbal_manager_control_pitchyaw.prototype = new mavlink20.message;
+mavlink20.messages.storm32_gimbal_manager_control_pitchyaw.prototype.pack = function(mav) {
+    var orderedfields = [ this.pitch, this.yaw, this.pitch_rate, this.yaw_rate, this.device_flags, this.manager_flags, this.target_system, this.target_component, this.gimbal_id, this.client];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Message to a gimbal manager to correct the gimbal roll angle. This
+message is typically used to manually correct for a tilted horizon in
+operation. A gimbal device is never to react to this message.
+
+                target_system             : System ID (uint8_t)
+                target_component          : Component ID (uint8_t)
+                gimbal_id                 : Gimbal ID of the gimbal manager to address (component ID or 1-6 for non-MAVLink gimbal, 0 for all gimbals). Send command multiple times for more than one but not all gimbals. (uint8_t)
+                client                    : Client which is contacting the gimbal manager (must be set). (uint8_t)
+                roll                      : Roll angle (positive to roll to the right). (float)
+
+*/
+    mavlink20.messages.storm32_gimbal_manager_correct_roll = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.gimbal_id , this.client , this.roll ] = moreargs;
+
+    this._format = '<fBBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_STORM32_GIMBAL_MANAGER_CORRECT_ROLL;
+    this.order_map = [1, 2, 3, 4, 0];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 134;
+    this._name = 'STORM32_GIMBAL_MANAGER_CORRECT_ROLL';
+
+    this._instance_field = 'gimbal_id';
+    this._instance_offset = 6;
+
+    this.fieldnames = ['target_system', 'target_component', 'gimbal_id', 'client', 'roll'];
+
+}
+
+mavlink20.messages.storm32_gimbal_manager_correct_roll.prototype = new mavlink20.message;
+mavlink20.messages.storm32_gimbal_manager_correct_roll.prototype.pack = function(mav) {
+    var orderedfields = [ this.roll, this.target_system, this.target_component, this.gimbal_id, this.client];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about the shot operation.
+
+                mode                      : Current shot mode. (uint16_t)
+                shot_state                : Current state in the shot. States are specific to the selected shot mode. (uint16_t)
+
+*/
+    mavlink20.messages.qshot_status = function( ...moreargs ) {
+    [ this.mode , this.shot_state ] = moreargs;
+
+    this._format = '<HH';
+    this._id = mavlink20.MAVLINK_MSG_ID_QSHOT_STATUS;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [0, 0];
+    this.crc_extra = 202;
+    this._name = 'QSHOT_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['mode', 'shot_state'];
+
+}
+
+mavlink20.messages.qshot_status.prototype = new mavlink20.message;
+mavlink20.messages.qshot_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.mode, this.shot_state];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Addition to message AUTOPILOT_STATE_FOR_GIMBAL_DEVICE.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                time_boot_us              : Timestamp (time since system boot). (uint64_t)
+                wind_x                    : Wind X speed in NED (North,Est, Down). NAN if unknown. (float)
+                wind_y                    : Wind Y speed in NED (North, East, Down). NAN if unknown. (float)
+                wind_correction_angle        : Correction angle due to wind. NaN if unknown. (float)
+
+*/
+    mavlink20.messages.autopilot_state_for_gimbal_device_ext = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.time_boot_us , this.wind_x , this.wind_y , this.wind_correction_angle ] = moreargs;
+
+    this._format = '<QfffBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_EXT;
+    this.order_map = [4, 5, 0, 1, 2, 3];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 4;
+    this._name = 'AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_EXT';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'time_boot_us', 'wind_x', 'wind_y', 'wind_correction_angle'];
+
+}
+
+mavlink20.messages.autopilot_state_for_gimbal_device_ext.prototype = new mavlink20.message;
+mavlink20.messages.autopilot_state_for_gimbal_device_ext.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_us, this.wind_x, this.wind_y, this.wind_correction_angle, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Frsky SPort passthrough multi packet container.
+
+                time_boot_ms              : Timestamp (time since system boot). (uint32_t)
+                count                     : Number of passthrough packets in this message. (uint8_t)
+                packet_buf                : Passthrough packet buffer. A packet has 6 bytes: uint16_t id + uint32_t data. The array has space for 40 packets. (uint8_t)
+
+*/
+    mavlink20.messages.frsky_passthrough_array = function( ...moreargs ) {
+    [ this.time_boot_ms , this.count , this.packet_buf ] = moreargs;
+
+    this._format = '<IB240s';
+    this._id = mavlink20.MAVLINK_MSG_ID_FRSKY_PASSTHROUGH_ARRAY;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 240];
+    this.array_len_map = [0, 0, 240];
+    this.crc_extra = 156;
+    this._name = 'FRSKY_PASSTHROUGH_ARRAY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'count', 'packet_buf'];
+
+}
+
+mavlink20.messages.frsky_passthrough_array.prototype = new mavlink20.message;
+mavlink20.messages.frsky_passthrough_array.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.count, this.packet_buf];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Parameter multi param value container.
+
+                param_count               : Total number of onboard parameters. (uint16_t)
+                param_index_first         : Index of the first onboard parameter in this array. (uint16_t)
+                param_array_len           : Number of onboard parameters in this array. (uint8_t)
+                flags                     : Flags. (uint16_t)
+                packet_buf                : Parameters buffer. Contains a series of variable length parameter blocks, one per parameter, with format as specified elsewhere. (uint8_t)
+
+*/
+    mavlink20.messages.param_value_array = function( ...moreargs ) {
+    [ this.param_count , this.param_index_first , this.param_array_len , this.flags , this.packet_buf ] = moreargs;
+
+    this._format = '<HHHB248s';
+    this._id = mavlink20.MAVLINK_MSG_ID_PARAM_VALUE_ARRAY;
+    this.order_map = [0, 1, 3, 2, 4];
+    this.len_map = [1, 1, 1, 1, 248];
+    this.array_len_map = [0, 0, 0, 0, 248];
+    this.crc_extra = 191;
+    this._name = 'PARAM_VALUE_ARRAY';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['param_count', 'param_index_first', 'param_array_len', 'flags', 'packet_buf'];
+
+}
+
+mavlink20.messages.param_value_array.prototype = new mavlink20.message;
+mavlink20.messages.param_value_array.prototype.pack = function(mav) {
+    var orderedfields = [ this.param_count, this.param_index_first, this.flags, this.param_array_len, this.packet_buf];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Radio link statistics for a MAVLink RC receiver or transmitter and
+other links. Tx: ground-side device, Rx: vehicle-side device.
+The message is normally emitted in regular time intervals upon each
+actual or expected reception of an over-the-air data packet on the
+link.         A MAVLink RC receiver should emit it shortly after it
+emits a RADIO_RC_CHANNELS message (if it is emitting that message).
+Per default, rssi values are in MAVLink units: 0 represents weakest
+signal, 254 represents maximum signal, UINT8_MAX represents unknown.
+The RADIO_LINK_STATS_FLAGS_RSSI_DBM flag is set if the rssi units are
+negative dBm: 1..254 correspond to -1..-254 dBm, 0 represents no
+reception, UINT8_MAX represents unknown.         The target_system
+field should normally be set to the system id of the system the link
+is connected to, typically the flight controller.         The
+target_component field can normally be set to 0, so that all
+components of the system can receive the message.         Note: The
+frequency fields are extensions to ensure that they are located at the
+end of the serialized payload and subject to MAVLink's trailing-zero
+trimming.
+
+                target_system             : System ID (ID of target system, normally flight controller). (uint8_t)
+                target_component          : Component ID (normally 0 for broadcast). (uint8_t)
+                flags                     : Radio link statistics flags. (uint16_t)
+                rx_LQ_rc                  : Link quality of RC data stream from Tx to Rx. Values: 1..100, 0: no link connection, UINT8_MAX: unknown. (uint8_t)
+                rx_LQ_ser                 : Link quality of serial MAVLink data stream from Tx to Rx. Values: 1..100, 0: no link connection, UINT8_MAX: unknown. (uint8_t)
+                rx_rssi1                  : Rssi of antenna 1. 0: no reception, UINT8_MAX: unknown. (uint8_t)
+                rx_snr1                   : Noise on antenna 1. Radio link dependent. INT8_MAX: unknown. (int8_t)
+                tx_LQ_ser                 : Link quality of serial MAVLink data stream from Rx to Tx. Values: 1..100, 0: no link connection, UINT8_MAX: unknown. (uint8_t)
+                tx_rssi1                  : Rssi of antenna 1. 0: no reception. UINT8_MAX: unknown. (uint8_t)
+                tx_snr1                   : Noise on antenna 1. Radio link dependent. INT8_MAX: unknown. (int8_t)
+                rx_rssi2                  : Rssi of antenna 2. 0: no reception, UINT8_MAX: use rx_rssi1 if it is known else unknown. (uint8_t)
+                rx_snr2                   : Noise on antenna 2. Radio link dependent. INT8_MAX: use rx_snr1 if it is known else unknown. (int8_t)
+                tx_rssi2                  : Rssi of antenna 2. 0: no reception. UINT8_MAX: use tx_rssi1 if it is known else unknown. (uint8_t)
+                tx_snr2                   : Noise on antenna 2. Radio link dependent. INT8_MAX: use tx_snr1 if it is known else unknown. (int8_t)
+                frequency1                : Frequency on antenna1 in Hz. 0: unknown. (float)
+                frequency2                : Frequency on antenna2 in Hz. 0: unknown. (float)
+
+*/
+    mavlink20.messages.mlrs_radio_link_stats = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.flags , this.rx_LQ_rc , this.rx_LQ_ser , this.rx_rssi1 , this.rx_snr1 , this.tx_LQ_ser , this.tx_rssi1 , this.tx_snr1 , this.rx_rssi2 , this.rx_snr2 , this.tx_rssi2 , this.tx_snr2 , this.frequency1 , this.frequency2 ] = moreargs;
+
+    this._format = '<HBBBBBbBBbBbBbff';
+    this._id = mavlink20.MAVLINK_MSG_ID_MLRS_RADIO_LINK_STATS;
+    this.order_map = [1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 14;
+    this._name = 'MLRS_RADIO_LINK_STATS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'flags', 'rx_LQ_rc', 'rx_LQ_ser', 'rx_rssi1', 'rx_snr1', 'tx_LQ_ser', 'tx_rssi1', 'tx_snr1', 'rx_rssi2', 'rx_snr2', 'tx_rssi2', 'tx_snr2', 'frequency1', 'frequency2'];
+
+}
+
+mavlink20.messages.mlrs_radio_link_stats.prototype = new mavlink20.message;
+mavlink20.messages.mlrs_radio_link_stats.prototype.pack = function(mav) {
+    var orderedfields = [ this.flags, this.target_system, this.target_component, this.rx_LQ_rc, this.rx_LQ_ser, this.rx_rssi1, this.rx_snr1, this.tx_LQ_ser, this.tx_rssi1, this.tx_snr1, this.rx_rssi2, this.rx_snr2, this.tx_rssi2, this.tx_snr2, this.frequency1, this.frequency2];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Radio link information. Tx: ground-side device, Rx: vehicle-side
+device.         The values of the fields in this message do normally
+not or only slowly change with time, and for most times the message
+can be send at a low rate, like 0.2 Hz.         If values change then
+the message should temporarily be send more often to inform the system
+about the changes.         The target_system field should normally be
+set to the system id of the system the link is connected to, typically
+the flight controller.         The target_component field can normally
+be set to 0, so that all components of the system can receive the
+message.
+
+                target_system             : System ID (ID of target system, normally flight controller). (uint8_t)
+                target_component          : Component ID (normally 0 for broadcast). (uint8_t)
+                type                      : Radio link type. 0: unknown/generic type. (uint8_t)
+                mode                      : Operation mode. Radio link dependent. UINT8_MAX: ignore/unknown. (uint8_t)
+                tx_power                  : Tx transmit power in dBm. INT8_MAX: unknown. (int8_t)
+                rx_power                  : Rx transmit power in dBm. INT8_MAX: unknown. (int8_t)
+                tx_frame_rate             : Frame rate in Hz (frames per second) for Tx to Rx transmission. 0: unknown. (uint16_t)
+                rx_frame_rate             : Frame rate in Hz (frames per second) for Rx to Tx transmission. Normally equal to tx_packet_rate. 0: unknown. (uint16_t)
+                mode_str                  : Operation mode as human readable string. Radio link dependent. Terminated by NULL if the string length is less than 6 chars and WITHOUT NULL termination if the length is exactly 6 chars - applications have to provide 6+1 bytes storage if the mode is stored as string. Use a zero-length string if not known. (char)
+                band_str                  : Frequency band as human readable string. Radio link dependent. Terminated by NULL if the string length is less than 6 chars and WITHOUT NULL termination if the length is exactly 6 chars - applications have to provide 6+1 bytes storage if the mode is stored as string. Use a zero-length string if not known. (char)
+                tx_ser_data_rate          : Maximum data rate of serial stream in bytes/s for Tx to Rx transmission. 0: unknown. UINT16_MAX: data rate is 64 KBytes/s or larger. (uint16_t)
+                rx_ser_data_rate          : Maximum data rate of serial stream in bytes/s for Rx to Tx transmission. 0: unknown. UINT16_MAX: data rate is 64 KBytes/s or larger. (uint16_t)
+                tx_receive_sensitivity        : Receive sensitivity of Tx in inverted dBm. 1..255 represents -1..-255 dBm, 0: unknown. (uint8_t)
+                rx_receive_sensitivity        : Receive sensitivity of Rx in inverted dBm. 1..255 represents -1..-255 dBm, 0: unknown. (uint8_t)
+
+*/
+    mavlink20.messages.mlrs_radio_link_information = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.type , this.mode , this.tx_power , this.rx_power , this.tx_frame_rate , this.rx_frame_rate , this.mode_str , this.band_str , this.tx_ser_data_rate , this.rx_ser_data_rate , this.tx_receive_sensitivity , this.rx_receive_sensitivity ] = moreargs;
+
+    this._format = '<HHHHBBBBbb6s6sBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MLRS_RADIO_LINK_INFORMATION;
+    this.order_map = [4, 5, 6, 7, 8, 9, 0, 1, 10, 11, 2, 3, 12, 13];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0];
+    this.crc_extra = 171;
+    this._name = 'MLRS_RADIO_LINK_INFORMATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'type', 'mode', 'tx_power', 'rx_power', 'tx_frame_rate', 'rx_frame_rate', 'mode_str', 'band_str', 'tx_ser_data_rate', 'rx_ser_data_rate', 'tx_receive_sensitivity', 'rx_receive_sensitivity'];
+
+}
+
+mavlink20.messages.mlrs_radio_link_information.prototype = new mavlink20.message;
+mavlink20.messages.mlrs_radio_link_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.tx_frame_rate, this.rx_frame_rate, this.tx_ser_data_rate, this.rx_ser_data_rate, this.target_system, this.target_component, this.type, this.mode, this.tx_power, this.rx_power, this.mode_str, this.band_str, this.tx_receive_sensitivity, this.rx_receive_sensitivity];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Injected by a radio link endpoint into the MAVLink stream for purposes
+of flow control. Should be emitted only by components with component
+id MAV_COMP_ID_TELEMETRY_RADIO.
+
+                tx_ser_rate               : Transmitted bytes per second, UINT16_MAX: invalid/unknown. (uint16_t)
+                rx_ser_rate               : Received bytes per second, UINT16_MAX: invalid/unknown. (uint16_t)
+                tx_used_ser_bandwidth        : Transmit bandwidth consumption. Values: 0..100, UINT8_MAX: invalid/unknown. (uint8_t)
+                rx_used_ser_bandwidth        : Receive bandwidth consumption. Values: 0..100, UINT8_MAX: invalid/unknown. (uint8_t)
+                txbuf                     : For compatibility with legacy method. UINT8_MAX: unknown. (uint8_t)
+
+*/
+    mavlink20.messages.mlrs_radio_link_flow_control = function( ...moreargs ) {
+    [ this.tx_ser_rate , this.rx_ser_rate , this.tx_used_ser_bandwidth , this.rx_used_ser_bandwidth , this.txbuf ] = moreargs;
+
+    this._format = '<HHBBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_MLRS_RADIO_LINK_FLOW_CONTROL;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 55;
+    this._name = 'MLRS_RADIO_LINK_FLOW_CONTROL';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['tx_ser_rate', 'rx_ser_rate', 'tx_used_ser_bandwidth', 'rx_used_ser_bandwidth', 'txbuf'];
+
+}
+
+mavlink20.messages.mlrs_radio_link_flow_control.prototype = new mavlink20.message;
+mavlink20.messages.mlrs_radio_link_flow_control.prototype.pack = function(mav) {
+    var orderedfields = [ this.tx_ser_rate, this.rx_ser_rate, this.tx_used_ser_bandwidth, this.rx_used_ser_bandwidth, this.txbuf];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+AVSS PRS system status.
+
+                time_boot_ms              : Timestamp (time since PRS boot). (uint32_t)
+                error_status              : PRS error statuses (uint32_t)
+                battery_status            : Estimated battery run-time without a remote connection and PRS battery voltage (uint32_t)
+                arm_status                : PRS arm statuses (uint8_t)
+                charge_status             : PRS battery charge statuses (uint8_t)
+
+*/
+    mavlink20.messages.avss_prs_sys_status = function( ...moreargs ) {
+    [ this.time_boot_ms , this.error_status , this.battery_status , this.arm_status , this.charge_status ] = moreargs;
+
+    this._format = '<IIIBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_AVSS_PRS_SYS_STATUS;
+    this.order_map = [0, 1, 2, 3, 4];
+    this.len_map = [1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0];
+    this.crc_extra = 220;
+    this._name = 'AVSS_PRS_SYS_STATUS';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'error_status', 'battery_status', 'arm_status', 'charge_status'];
+
+}
+
+mavlink20.messages.avss_prs_sys_status.prototype = new mavlink20.message;
+mavlink20.messages.avss_prs_sys_status.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.error_status, this.battery_status, this.arm_status, this.charge_status];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Drone position.
+
+                time_boot_ms              : Timestamp (time since FC boot). (uint32_t)
+                lat                       : Latitude, expressed (int32_t)
+                lon                       : Longitude, expressed (int32_t)
+                alt                       : Altitude (MSL). Note that virtually all GPS modules provide both WGS84 and MSL. (int32_t)
+                ground_alt                : Altitude above ground, This altitude is measured by a ultrasound, Laser rangefinder or millimeter-wave radar (float)
+                barometer_alt             : This altitude is measured by a barometer (float)
+
+*/
+    mavlink20.messages.avss_drone_position = function( ...moreargs ) {
+    [ this.time_boot_ms , this.lat , this.lon , this.alt , this.ground_alt , this.barometer_alt ] = moreargs;
+
+    this._format = '<Iiiiff';
+    this._id = mavlink20.MAVLINK_MSG_ID_AVSS_DRONE_POSITION;
+    this.order_map = [0, 1, 2, 3, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0];
+    this.crc_extra = 245;
+    this._name = 'AVSS_DRONE_POSITION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'lat', 'lon', 'alt', 'ground_alt', 'barometer_alt'];
+
+}
+
+mavlink20.messages.avss_drone_position.prototype = new mavlink20.message;
+mavlink20.messages.avss_drone_position.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.lat, this.lon, this.alt, this.ground_alt, this.barometer_alt];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Drone IMU data. Quaternion order is w, x, y, z and a zero rotation
+would be expressed as (1 0 0 0).
+
+                time_boot_ms              : Timestamp (time since FC boot). (uint32_t)
+                q1                        : Quaternion component 1, w (1 in null-rotation) (float)
+                q2                        : Quaternion component 2, x (0 in null-rotation) (float)
+                q3                        : Quaternion component 3, y (0 in null-rotation) (float)
+                q4                        : Quaternion component 4, z (0 in null-rotation) (float)
+                xacc                      : X acceleration (float)
+                yacc                      : Y acceleration (float)
+                zacc                      : Z acceleration (float)
+                xgyro                     : Angular speed around X axis (float)
+                ygyro                     : Angular speed around Y axis (float)
+                zgyro                     : Angular speed around Z axis (float)
+
+*/
+    mavlink20.messages.avss_drone_imu = function( ...moreargs ) {
+    [ this.time_boot_ms , this.q1 , this.q2 , this.q3 , this.q4 , this.xacc , this.yacc , this.zacc , this.xgyro , this.ygyro , this.zgyro ] = moreargs;
+
+    this._format = '<Iffffffffff';
+    this._id = mavlink20.MAVLINK_MSG_ID_AVSS_DRONE_IMU;
+    this.order_map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 101;
+    this._name = 'AVSS_DRONE_IMU';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'q1', 'q2', 'q3', 'q4', 'xacc', 'yacc', 'zacc', 'xgyro', 'ygyro', 'zgyro'];
+
+}
+
+mavlink20.messages.avss_drone_imu.prototype = new mavlink20.message;
+mavlink20.messages.avss_drone_imu.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.q1, this.q2, this.q3, this.q4, this.xacc, this.yacc, this.zacc, this.xgyro, this.ygyro, this.zgyro];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Drone operation mode.
+
+                time_boot_ms              : Timestamp (time since FC boot). (uint32_t)
+                M300_operation_mode        : DJI M300 operation mode (uint8_t)
+                horsefly_operation_mode        : horsefly operation mode (uint8_t)
+
+*/
+    mavlink20.messages.avss_drone_operation_mode = function( ...moreargs ) {
+    [ this.time_boot_ms , this.M300_operation_mode , this.horsefly_operation_mode ] = moreargs;
+
+    this._format = '<IBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_AVSS_DRONE_OPERATION_MODE;
+    this.order_map = [0, 1, 2];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 45;
+    this._name = 'AVSS_DRONE_OPERATION_MODE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['time_boot_ms', 'M300_operation_mode', 'horsefly_operation_mode'];
+
+}
+
+mavlink20.messages.avss_drone_operation_mode.prototype = new mavlink20.message;
+mavlink20.messages.avss_drone_operation_mode.prototype.pack = function(mav) {
+    var orderedfields = [ this.time_boot_ms, this.M300_operation_mode, this.horsefly_operation_mode];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Raw RC Data
+
+                rc_raw                    :  (uint8_t)
+
+*/
+    mavlink20.messages.cubepilot_raw_rc = function( ...moreargs ) {
+    [ this.rc_raw ] = moreargs;
+
+    this._format = '<32s';
+    this._id = mavlink20.MAVLINK_MSG_ID_CUBEPILOT_RAW_RC;
+    this.order_map = [0];
+    this.len_map = [32];
+    this.array_len_map = [32];
+    this.crc_extra = 246;
+    this._name = 'CUBEPILOT_RAW_RC';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['rc_raw'];
+
+}
+
+mavlink20.messages.cubepilot_raw_rc.prototype = new mavlink20.message;
+mavlink20.messages.cubepilot_raw_rc.prototype.pack = function(mav) {
+    var orderedfields = [ this.rc_raw];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Information about video stream
+
+                camera_id                 : Video Stream ID (1 for first, 2 for second, etc.) (uint8_t)
+                status                    : Number of streams available. (uint8_t)
+                framerate                 : Frame rate. (float)
+                resolution_h              : Horizontal resolution. (uint16_t)
+                resolution_v              : Vertical resolution. (uint16_t)
+                bitrate                   : Bit rate. (uint32_t)
+                rotation                  : Video image rotation clockwise. (uint16_t)
+                uri                       : Video stream URI (TCP or RTSP URI ground station should connect to) or port number (UDP port ground station should listen to). (char)
+
+*/
+    mavlink20.messages.herelink_video_stream_information = function( ...moreargs ) {
+    [ this.camera_id , this.status , this.framerate , this.resolution_h , this.resolution_v , this.bitrate , this.rotation , this.uri ] = moreargs;
+
+    this._format = '<fIHHHBB230s';
+    this._id = mavlink20.MAVLINK_MSG_ID_HERELINK_VIDEO_STREAM_INFORMATION;
+    this.order_map = [5, 6, 0, 2, 3, 1, 4, 7];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0, 230];
+    this.crc_extra = 181;
+    this._name = 'HERELINK_VIDEO_STREAM_INFORMATION';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['camera_id', 'status', 'framerate', 'resolution_h', 'resolution_v', 'bitrate', 'rotation', 'uri'];
+
+}
+
+mavlink20.messages.herelink_video_stream_information.prototype = new mavlink20.message;
+mavlink20.messages.herelink_video_stream_information.prototype.pack = function(mav) {
+    var orderedfields = [ this.framerate, this.bitrate, this.resolution_h, this.resolution_v, this.rotation, this.camera_id, this.status, this.uri];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Herelink Telemetry
+
+                rssi                      :  (uint8_t)
+                snr                       :  (int16_t)
+                rf_freq                   :  (uint32_t)
+                link_bw                   :  (uint32_t)
+                link_rate                 :  (uint32_t)
+                cpu_temp                  :  (int16_t)
+                board_temp                :  (int16_t)
+
+*/
+    mavlink20.messages.herelink_telem = function( ...moreargs ) {
+    [ this.rssi , this.snr , this.rf_freq , this.link_bw , this.link_rate , this.cpu_temp , this.board_temp ] = moreargs;
+
+    this._format = '<IIIhhhB';
+    this._id = mavlink20.MAVLINK_MSG_ID_HERELINK_TELEM;
+    this.order_map = [6, 3, 0, 1, 2, 4, 5];
+    this.len_map = [1, 1, 1, 1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0, 0, 0, 0];
+    this.crc_extra = 62;
+    this._name = 'HERELINK_TELEM';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['rssi', 'snr', 'rf_freq', 'link_bw', 'link_rate', 'cpu_temp', 'board_temp'];
+
+}
+
+mavlink20.messages.herelink_telem.prototype = new mavlink20.message;
+mavlink20.messages.herelink_telem.prototype.pack = function(mav) {
+    var orderedfields = [ this.rf_freq, this.link_bw, this.link_rate, this.snr, this.cpu_temp, this.board_temp, this.rssi];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Start firmware update with encapsulated data.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                size                      : FW Size. (uint32_t)
+                crc                       : FW CRC. (uint32_t)
+
+*/
+    mavlink20.messages.cubepilot_firmware_update_start = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.size , this.crc ] = moreargs;
+
+    this._format = '<IIBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CUBEPILOT_FIRMWARE_UPDATE_START;
+    this.order_map = [2, 3, 0, 1];
+    this.len_map = [1, 1, 1, 1];
+    this.array_len_map = [0, 0, 0, 0];
+    this.crc_extra = 240;
+    this._name = 'CUBEPILOT_FIRMWARE_UPDATE_START';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'size', 'crc'];
+
+}
+
+mavlink20.messages.cubepilot_firmware_update_start.prototype = new mavlink20.message;
+mavlink20.messages.cubepilot_firmware_update_start.prototype.pack = function(mav) {
+    var orderedfields = [ this.size, this.crc, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+offset response to encapsulated data.
+
+                target_system             : System ID. (uint8_t)
+                target_component          : Component ID. (uint8_t)
+                offset                    : FW Offset. (uint32_t)
+
+*/
+    mavlink20.messages.cubepilot_firmware_update_resp = function( ...moreargs ) {
+    [ this.target_system , this.target_component , this.offset ] = moreargs;
+
+    this._format = '<IBB';
+    this._id = mavlink20.MAVLINK_MSG_ID_CUBEPILOT_FIRMWARE_UPDATE_RESP;
+    this.order_map = [1, 2, 0];
+    this.len_map = [1, 1, 1];
+    this.array_len_map = [0, 0, 0];
+    this.crc_extra = 152;
+    this._name = 'CUBEPILOT_FIRMWARE_UPDATE_RESP';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['target_system', 'target_component', 'offset'];
+
+}
+
+mavlink20.messages.cubepilot_firmware_update_resp.prototype = new mavlink20.message;
+mavlink20.messages.cubepilot_firmware_update_resp.prototype.pack = function(mav) {
+    var orderedfields = [ this.offset, this.target_system, this.target_component];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Authorization package
+
+                login                     : Login (char)
+                password                  : Password (char)
+
+*/
+    mavlink20.messages.airlink_auth = function( ...moreargs ) {
+    [ this.login , this.password ] = moreargs;
+
+    this._format = '<50s50s';
+    this._id = mavlink20.MAVLINK_MSG_ID_AIRLINK_AUTH;
+    this.order_map = [0, 1];
+    this.len_map = [1, 1];
+    this.array_len_map = [50, 50];
+    this.crc_extra = 13;
+    this._name = 'AIRLINK_AUTH';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['login', 'password'];
+
+}
+
+mavlink20.messages.airlink_auth.prototype = new mavlink20.message;
+mavlink20.messages.airlink_auth.prototype.pack = function(mav) {
+    var orderedfields = [ this.login, this.password];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+/* 
+Response to the authorization request
+
+                resp_type                 : Response type (uint8_t)
+
+*/
+    mavlink20.messages.airlink_auth_response = function( ...moreargs ) {
+    [ this.resp_type ] = moreargs;
+
+    this._format = '<B';
+    this._id = mavlink20.MAVLINK_MSG_ID_AIRLINK_AUTH_RESPONSE;
+    this.order_map = [0];
+    this.len_map = [1];
+    this.array_len_map = [0];
+    this.crc_extra = 239;
+    this._name = 'AIRLINK_AUTH_RESPONSE';
+
+    this._instance_field = undefined;
+    this._instance_offset = -1;
+
+    this.fieldnames = ['resp_type'];
+
+}
+
+mavlink20.messages.airlink_auth_response.prototype = new mavlink20.message;
+mavlink20.messages.airlink_auth_response.prototype.pack = function(mav) {
+    var orderedfields = [ this.resp_type];
+    var j = jspack.Pack(this._format, orderedfields);
+    if (j === false ) throw new Error("jspack unable to handle this packet");
+    return mavlink20.message.prototype.pack.call(this, mav, this.crc_extra, j );
+}
+
+
+mavlink20.map = {
+        150: { format: '<fiiffffffhhh', type: mavlink20.messages.sensor_offsets, order_map: [9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 134 },
+        151: { format: '<hhhBB', type: mavlink20.messages.set_mag_offsets, order_map: [3, 4, 0, 1, 2], crc_extra: 219 },
+        152: { format: '<HHI', type: mavlink20.messages.meminfo, order_map: [0, 1, 2], crc_extra: 208 },
+        153: { format: '<HHHHHH', type: mavlink20.messages.ap_adc, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 188 },
+        154: { format: '<fHBBBBBBBBB', type: mavlink20.messages.digicam_configure, order_map: [2, 3, 4, 1, 5, 6, 7, 8, 9, 10, 0], crc_extra: 84 },
+        155: { format: '<fBBBBbBBBB', type: mavlink20.messages.digicam_control, order_map: [1, 2, 3, 4, 5, 6, 7, 8, 9, 0], crc_extra: 22 },
+        156: { format: '<BBBBBB', type: mavlink20.messages.mount_configure, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 19 },
+        157: { format: '<iiiBBB', type: mavlink20.messages.mount_control, order_map: [3, 4, 0, 1, 2, 5], crc_extra: 21 },
+        158: { format: '<iiiBBB', type: mavlink20.messages.mount_status, order_map: [3, 4, 0, 1, 2, 5], crc_extra: 134 },
+        160: { format: '<ffBBBB', type: mavlink20.messages.fence_point, order_map: [2, 3, 4, 5, 0, 1], crc_extra: 78 },
+        161: { format: '<BBB', type: mavlink20.messages.fence_fetch_point, order_map: [0, 1, 2], crc_extra: 68 },
+        163: { format: '<fffffff', type: mavlink20.messages.ahrs, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 127 },
+        164: { format: '<fffffffffii', type: mavlink20.messages.simstate, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 154 },
+        165: { format: '<HB', type: mavlink20.messages.hwstatus, order_map: [0, 1], crc_extra: 21 },
+        166: { format: '<HHBBBBB', type: mavlink20.messages.radio, order_map: [2, 3, 4, 5, 6, 0, 1], crc_extra: 21 },
+        167: { format: '<IIIIHBBBB', type: mavlink20.messages.limits_status, order_map: [5, 0, 1, 2, 3, 4, 6, 7, 8], crc_extra: 144 },
+        168: { format: '<fff', type: mavlink20.messages.wind, order_map: [0, 1, 2], crc_extra: 1 },
+        169: { format: '<BB16s', type: mavlink20.messages.data16, order_map: [0, 1, 2], crc_extra: 234 },
+        170: { format: '<BB32s', type: mavlink20.messages.data32, order_map: [0, 1, 2], crc_extra: 73 },
+        171: { format: '<BB64s', type: mavlink20.messages.data64, order_map: [0, 1, 2], crc_extra: 181 },
+        172: { format: '<BB96s', type: mavlink20.messages.data96, order_map: [0, 1, 2], crc_extra: 22 },
+        173: { format: '<ff', type: mavlink20.messages.rangefinder, order_map: [0, 1], crc_extra: 83 },
+        174: { format: '<ffffffffffff', type: mavlink20.messages.airspeed_autocal, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 167 },
+        175: { format: '<iihhHBBBBB', type: mavlink20.messages.rally_point, order_map: [5, 6, 7, 8, 0, 1, 2, 3, 4, 9], crc_extra: 138 },
+        176: { format: '<BBB', type: mavlink20.messages.rally_fetch_point, order_map: [0, 1, 2], crc_extra: 234 },
+        177: { format: '<ffffHH', type: mavlink20.messages.compassmot_status, order_map: [4, 0, 5, 1, 2, 3], crc_extra: 240 },
+        178: { format: '<ffffii', type: mavlink20.messages.ahrs2, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 47 },
+        179: { format: '<QffffHBBB', type: mavlink20.messages.camera_status, order_map: [0, 6, 7, 5, 8, 1, 2, 3, 4], crc_extra: 189 },
+        180: { format: '<QiiffffffHBBBH', type: mavlink20.messages.camera_feedback, order_map: [0, 10, 11, 9, 1, 2, 3, 4, 5, 6, 7, 8, 12, 13], crc_extra: 52 },
+        181: { format: '<Hh', type: mavlink20.messages.battery2, order_map: [0, 1], crc_extra: 174 },
+        182: { format: '<ffffiiffff', type: mavlink20.messages.ahrs3, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], crc_extra: 229 },
+        183: { format: '<BB', type: mavlink20.messages.autopilot_version_request, order_map: [0, 1], crc_extra: 85 },
+        184: { format: '<IBB200s', type: mavlink20.messages.remote_log_data_block, order_map: [1, 2, 0, 3], crc_extra: 159 },
+        185: { format: '<IBBB', type: mavlink20.messages.remote_log_block_status, order_map: [1, 2, 0, 3], crc_extra: 186 },
+        186: { format: '<BBBBB24s', type: mavlink20.messages.led_control, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 72 },
+        191: { format: '<fffBBBBB10s', type: mavlink20.messages.mag_cal_progress, order_map: [3, 4, 5, 6, 7, 8, 0, 1, 2], crc_extra: 92 },
+        193: { format: '<fffffHf', type: mavlink20.messages.ekf_status_report, order_map: [5, 0, 1, 2, 3, 4, 6], crc_extra: 71 },
+        194: { format: '<ffffffBff', type: mavlink20.messages.pid_tuning, order_map: [6, 0, 1, 2, 3, 4, 5, 7, 8], crc_extra: 98 },
+        195: { format: '<iiiiiifffB', type: mavlink20.messages.deepstall, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], crc_extra: 120 },
+        200: { format: '<ffffffffffBB', type: mavlink20.messages.gimbal_report, order_map: [10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], crc_extra: 134 },
+        201: { format: '<fffBB', type: mavlink20.messages.gimbal_control, order_map: [3, 4, 0, 1, 2], crc_extra: 205 },
+        214: { format: '<hhhBB', type: mavlink20.messages.gimbal_torque_cmd_report, order_map: [3, 4, 0, 1, 2], crc_extra: 69 },
+        215: { format: '<BBB', type: mavlink20.messages.gopro_heartbeat, order_map: [0, 1, 2], crc_extra: 101 },
+        216: { format: '<BBB', type: mavlink20.messages.gopro_get_request, order_map: [0, 1, 2], crc_extra: 50 },
+        217: { format: '<BB4s', type: mavlink20.messages.gopro_get_response, order_map: [0, 1, 2], crc_extra: 202 },
+        218: { format: '<BBB4s', type: mavlink20.messages.gopro_set_request, order_map: [0, 1, 2, 3], crc_extra: 17 },
+        219: { format: '<BB', type: mavlink20.messages.gopro_set_response, order_map: [0, 1], crc_extra: 162 },
+        226: { format: '<ff', type: mavlink20.messages.rpm, order_map: [0, 1], crc_extra: 207 },
+        11000: { format: '<IBBBBB40sBBB', type: mavlink20.messages.device_op_read, order_map: [1, 2, 0, 3, 4, 5, 6, 7, 8, 9], crc_extra: 134 },
+        11001: { format: '<IBBB128sB', type: mavlink20.messages.device_op_read_reply, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 15 },
+        11002: { format: '<IBBBBB40sBB128sB', type: mavlink20.messages.device_op_write, order_map: [1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 234 },
+        11003: { format: '<IB', type: mavlink20.messages.device_op_write_reply, order_map: [0, 1], crc_extra: 64 },
+        11004: { format: '<IIBBBB220s', type: mavlink20.messages.secure_command, order_map: [2, 3, 0, 1, 4, 5, 6], crc_extra: 11 },
+        11005: { format: '<IIBB220s', type: mavlink20.messages.secure_command_reply, order_map: [0, 1, 2, 3, 4], crc_extra: 93 },
+        11010: { format: '<ffffffffffffB', type: mavlink20.messages.adap_tuning, order_map: [12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 46 },
+        11011: { format: '<QQ3f3ff', type: mavlink20.messages.vision_position_delta, order_map: [0, 1, 2, 3, 4], crc_extra: 106 },
+        11020: { format: '<Qff', type: mavlink20.messages.aoa_ssa, order_map: [0, 1, 2], crc_extra: 205 },
+        11030: { format: '<4H4H4H4H4H4s', type: mavlink20.messages.esc_telemetry_1_to_4, order_map: [5, 0, 1, 2, 3, 4], crc_extra: 144 },
+        11031: { format: '<4H4H4H4H4H4s', type: mavlink20.messages.esc_telemetry_5_to_8, order_map: [5, 0, 1, 2, 3, 4], crc_extra: 133 },
+        11032: { format: '<4H4H4H4H4H4s', type: mavlink20.messages.esc_telemetry_9_to_12, order_map: [5, 0, 1, 2, 3, 4], crc_extra: 85 },
+        11033: { format: '<IfffBBBB16sB', type: mavlink20.messages.osd_param_config, order_map: [4, 5, 0, 6, 7, 8, 9, 1, 2, 3], crc_extra: 195 },
+        11034: { format: '<IB', type: mavlink20.messages.osd_param_config_reply, order_map: [0, 1], crc_extra: 79 },
+        11035: { format: '<IBBBB', type: mavlink20.messages.osd_param_show_config, order_map: [1, 2, 0, 3, 4], crc_extra: 128 },
+        11036: { format: '<IfffB16sB', type: mavlink20.messages.osd_param_show_config_reply, order_map: [0, 4, 5, 6, 1, 2, 3], crc_extra: 177 },
+        11037: { format: '<IfffffHBB', type: mavlink20.messages.obstacle_distance_3d, order_map: [0, 7, 8, 6, 1, 2, 3, 4, 5], crc_extra: 130 },
+        11038: { format: '<IiiffffffBB', type: mavlink20.messages.water_depth, order_map: [0, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 47 },
+        11039: { format: '<hHHHB', type: mavlink20.messages.mcu_status, order_map: [4, 0, 1, 2, 3], crc_extra: 142 },
+        11040: { format: '<4H4H4H4H4H4s', type: mavlink20.messages.esc_telemetry_13_to_16, order_map: [5, 0, 1, 2, 3, 4], crc_extra: 132 },
+        11041: { format: '<4H4H4H4H4H4s', type: mavlink20.messages.esc_telemetry_17_to_20, order_map: [5, 0, 1, 2, 3, 4], crc_extra: 208 },
+        11042: { format: '<4H4H4H4H4H4s', type: mavlink20.messages.esc_telemetry_21_to_24, order_map: [5, 0, 1, 2, 3, 4], crc_extra: 201 },
+        11043: { format: '<4H4H4H4H4H4s', type: mavlink20.messages.esc_telemetry_25_to_28, order_map: [5, 0, 1, 2, 3, 4], crc_extra: 193 },
+        11044: { format: '<4H4H4H4H4H4s', type: mavlink20.messages.esc_telemetry_29_to_32, order_map: [5, 0, 1, 2, 3, 4], crc_extra: 189 },
+        223: { format: '<QIffffiifHBBBBB', type: mavlink20.messages.command_int_stamped, order_map: [1, 0, 10, 11, 12, 9, 13, 14, 2, 3, 4, 5, 6, 7, 8], crc_extra: 119 },
+        224: { format: '<QIfffffffHBBB', type: mavlink20.messages.command_long_stamped, order_map: [1, 0, 10, 11, 9, 12, 2, 3, 4, 5, 6, 7, 8], crc_extra: 102 },
+        8002: { format: '<ffff', type: mavlink20.messages.sens_power, order_map: [0, 1, 2, 3], crc_extra: 218 },
+        8003: { format: '<QffffffHHHBBB', type: mavlink20.messages.sens_mppt, order_map: [0, 1, 2, 7, 10, 3, 4, 8, 11, 5, 6, 9, 12], crc_extra: 231 },
+        8004: { format: '<QffffffffffffffffffffffBB', type: mavlink20.messages.aslctrl_data, order_map: [0, 23, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 24, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22], crc_extra: 172 },
+        8005: { format: '<IffffffffBB', type: mavlink20.messages.aslctrl_debug, order_map: [0, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 251 },
+        8006: { format: '<fBB8s', type: mavlink20.messages.asluav_status, order_map: [1, 2, 3, 0], crc_extra: 97 },
+        8007: { format: '<Qffffff', type: mavlink20.messages.ekf_ext, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 64 },
+        8008: { format: '<QffffffB', type: mavlink20.messages.asl_obctrl, order_map: [0, 1, 2, 3, 4, 5, 6, 7], crc_extra: 234 },
+        8009: { format: '<Qff', type: mavlink20.messages.sens_atmos, order_map: [0, 1, 2], crc_extra: 144 },
+        8010: { format: '<QfIIHhHHHHHHHHB', type: mavlink20.messages.sens_batmon, order_map: [0, 1, 4, 5, 14, 6, 7, 2, 3, 8, 9, 10, 11, 12, 13], crc_extra: 155 },
+        8011: { format: '<QQfffffffffffffffffffffBB', type: mavlink20.messages.fw_soaring_data, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], crc_extra: 20 },
+        8012: { format: '<QHBBBBBB', type: mavlink20.messages.sensorpod_status, order_map: [0, 2, 3, 4, 5, 6, 7, 1], crc_extra: 54 },
+        8013: { format: '<QfffffffffBB', type: mavlink20.messages.sens_power_board, order_map: [0, 10, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9], crc_extra: 222 },
+        8014: { format: '<QBBBBBB', type: mavlink20.messages.gsm_link_status, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 200 },
+        8015: { format: '<QQHHBBBB', type: mavlink20.messages.satcom_link_status, order_map: [0, 1, 2, 3, 4, 5, 6, 7], crc_extra: 23 },
+        8016: { format: '<QffBB', type: mavlink20.messages.sensor_airflow_angles, order_map: [0, 1, 3, 2, 4], crc_extra: 149 },
+        1: { format: '<IIIHHhHHHHHHb', type: mavlink20.messages.sys_status, order_map: [0, 1, 2, 3, 4, 5, 12, 6, 7, 8, 9, 10, 11], crc_extra: 124 },
+        2: { format: '<QI', type: mavlink20.messages.system_time, order_map: [0, 1], crc_extra: 137 },
+        4: { format: '<QIBB', type: mavlink20.messages.ping, order_map: [0, 1, 2, 3], crc_extra: 237 },
+        5: { format: '<BBB25s', type: mavlink20.messages.change_operator_control, order_map: [0, 1, 2, 3], crc_extra: 217 },
+        6: { format: '<BBB', type: mavlink20.messages.change_operator_control_ack, order_map: [0, 1, 2], crc_extra: 104 },
+        7: { format: '<32s', type: mavlink20.messages.auth_key, order_map: [0], crc_extra: 119 },
+        11: { format: '<IBB', type: mavlink20.messages.set_mode, order_map: [1, 2, 0], crc_extra: 89 },
+        20: { format: '<hBB16s', type: mavlink20.messages.param_request_read, order_map: [1, 2, 3, 0], crc_extra: 214 },
+        21: { format: '<BB', type: mavlink20.messages.param_request_list, order_map: [0, 1], crc_extra: 159 },
+        22: { format: '<fHH16sB', type: mavlink20.messages.param_value, order_map: [3, 0, 4, 1, 2], crc_extra: 220 },
+        23: { format: '<fBB16sB', type: mavlink20.messages.param_set, order_map: [1, 2, 3, 0, 4], crc_extra: 168 },
+        24: { format: '<QiiiHHHHBBiIIIIH', type: mavlink20.messages.gps_raw_int, order_map: [0, 8, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15], crc_extra: 24 },
+        25: { format: '<B20s20s20s20s20s', type: mavlink20.messages.gps_status, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 23 },
+        26: { format: '<Ihhhhhhhhhh', type: mavlink20.messages.scaled_imu, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 170 },
+        27: { format: '<QhhhhhhhhhBh', type: mavlink20.messages.raw_imu, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 144 },
+        28: { format: '<Qhhhh', type: mavlink20.messages.raw_pressure, order_map: [0, 1, 2, 3, 4], crc_extra: 67 },
+        29: { format: '<Iffhh', type: mavlink20.messages.scaled_pressure, order_map: [0, 1, 2, 3, 4], crc_extra: 115 },
+        30: { format: '<Iffffff', type: mavlink20.messages.attitude, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 39 },
+        31: { format: '<Ifffffff4f', type: mavlink20.messages.attitude_quaternion, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 246 },
+        32: { format: '<Iffffff', type: mavlink20.messages.local_position_ned, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 185 },
+        33: { format: '<IiiiihhhH', type: mavlink20.messages.global_position_int, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 104 },
+        34: { format: '<IhhhhhhhhBB', type: mavlink20.messages.rc_channels_scaled, order_map: [0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 10], crc_extra: 237 },
+        35: { format: '<IHHHHHHHHBB', type: mavlink20.messages.rc_channels_raw, order_map: [0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 10], crc_extra: 244 },
+        36: { format: '<IHHHHHHHHBHHHHHHHH', type: mavlink20.messages.servo_output_raw, order_map: [0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17], crc_extra: 222 },
+        37: { format: '<hhBBB', type: mavlink20.messages.mission_request_partial_list, order_map: [2, 3, 0, 1, 4], crc_extra: 212 },
+        38: { format: '<hhBBB', type: mavlink20.messages.mission_write_partial_list, order_map: [2, 3, 0, 1, 4], crc_extra: 9 },
+        39: { format: '<fffffffHHBBBBBB', type: mavlink20.messages.mission_item, order_map: [9, 10, 7, 11, 8, 12, 13, 0, 1, 2, 3, 4, 5, 6, 14], crc_extra: 254 },
+        40: { format: '<HBBB', type: mavlink20.messages.mission_request, order_map: [1, 2, 0, 3], crc_extra: 230 },
+        41: { format: '<HBB', type: mavlink20.messages.mission_set_current, order_map: [1, 2, 0], crc_extra: 28 },
+        42: { format: '<HHBB', type: mavlink20.messages.mission_current, order_map: [0, 1, 2, 3], crc_extra: 28 },
+        43: { format: '<BBB', type: mavlink20.messages.mission_request_list, order_map: [0, 1, 2], crc_extra: 132 },
+        44: { format: '<HBBB', type: mavlink20.messages.mission_count, order_map: [1, 2, 0, 3], crc_extra: 221 },
+        45: { format: '<BBB', type: mavlink20.messages.mission_clear_all, order_map: [0, 1, 2], crc_extra: 232 },
+        46: { format: '<H', type: mavlink20.messages.mission_item_reached, order_map: [0], crc_extra: 11 },
+        47: { format: '<BBBB', type: mavlink20.messages.mission_ack, order_map: [0, 1, 2, 3], crc_extra: 153 },
+        48: { format: '<iiiBQ', type: mavlink20.messages.set_gps_global_origin, order_map: [3, 0, 1, 2, 4], crc_extra: 41 },
+        49: { format: '<iiiQ', type: mavlink20.messages.gps_global_origin, order_map: [0, 1, 2, 3], crc_extra: 39 },
+        50: { format: '<ffffhBB16sB', type: mavlink20.messages.param_map_rc, order_map: [5, 6, 7, 4, 8, 0, 1, 2, 3], crc_extra: 78 },
+        51: { format: '<HBBB', type: mavlink20.messages.mission_request_int, order_map: [1, 2, 0, 3], crc_extra: 196 },
+        54: { format: '<ffffffBBB', type: mavlink20.messages.safety_set_allowed_area, order_map: [6, 7, 8, 0, 1, 2, 3, 4, 5], crc_extra: 15 },
+        55: { format: '<ffffffB', type: mavlink20.messages.safety_allowed_area, order_map: [6, 0, 1, 2, 3, 4, 5], crc_extra: 3 },
+        61: { format: '<Q4ffff9f', type: mavlink20.messages.attitude_quaternion_cov, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 167 },
+        62: { format: '<fffffhhH', type: mavlink20.messages.nav_controller_output, order_map: [0, 1, 5, 6, 7, 2, 3, 4], crc_extra: 183 },
+        63: { format: '<Qiiiifff36fB', type: mavlink20.messages.global_position_int_cov, order_map: [0, 9, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 119 },
+        64: { format: '<Qfffffffff45fB', type: mavlink20.messages.local_position_ned_cov, order_map: [0, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 191 },
+        65: { format: '<IHHHHHHHHHHHHHHHHHHBB', type: mavlink20.messages.rc_channels, order_map: [0, 19, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20], crc_extra: 118 },
+        66: { format: '<HBBBB', type: mavlink20.messages.request_data_stream, order_map: [1, 2, 3, 0, 4], crc_extra: 148 },
+        67: { format: '<HBB', type: mavlink20.messages.data_stream, order_map: [1, 0, 2], crc_extra: 21 },
+        69: { format: '<hhhhHBHBhhhhhhhh', type: mavlink20.messages.manual_control, order_map: [5, 0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], crc_extra: 243 },
+        70: { format: '<HHHHHHHHBBHHHHHHHHHH', type: mavlink20.messages.rc_channels_override, order_map: [8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], crc_extra: 124 },
+        73: { format: '<ffffiifHHBBBBBB', type: mavlink20.messages.mission_item_int, order_map: [9, 10, 7, 11, 8, 12, 13, 0, 1, 2, 3, 4, 5, 6, 14], crc_extra: 38 },
+        74: { format: '<ffffhH', type: mavlink20.messages.vfr_hud, order_map: [0, 1, 4, 5, 2, 3], crc_extra: 20 },
+        75: { format: '<ffffiifHBBBBB', type: mavlink20.messages.command_int, order_map: [8, 9, 10, 7, 11, 12, 0, 1, 2, 3, 4, 5, 6], crc_extra: 158 },
+        76: { format: '<fffffffHBBB', type: mavlink20.messages.command_long, order_map: [8, 9, 7, 10, 0, 1, 2, 3, 4, 5, 6], crc_extra: 152 },
+        77: { format: '<HBBiBB', type: mavlink20.messages.command_ack, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 143 },
+        81: { format: '<IffffBB', type: mavlink20.messages.manual_setpoint, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 106 },
+        82: { format: '<I4fffffBBB', type: mavlink20.messages.set_attitude_target, order_map: [0, 6, 7, 8, 1, 2, 3, 4, 5], crc_extra: 49 },
+        83: { format: '<I4fffffB', type: mavlink20.messages.attitude_target, order_map: [0, 6, 1, 2, 3, 4, 5], crc_extra: 22 },
+        84: { format: '<IfffffffffffHBBB', type: mavlink20.messages.set_position_target_local_ned, order_map: [0, 13, 14, 15, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 143 },
+        85: { format: '<IfffffffffffHB', type: mavlink20.messages.position_target_local_ned, order_map: [0, 13, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 140 },
+        86: { format: '<IiifffffffffHBBB', type: mavlink20.messages.set_position_target_global_int, order_map: [0, 13, 14, 15, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 5 },
+        87: { format: '<IiifffffffffHB', type: mavlink20.messages.position_target_global_int, order_map: [0, 13, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 150 },
+        89: { format: '<Iffffff', type: mavlink20.messages.local_position_ned_system_global_offset, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 231 },
+        90: { format: '<Qffffffiiihhhhhh', type: mavlink20.messages.hil_state, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], crc_extra: 183 },
+        91: { format: '<QffffffffBB', type: mavlink20.messages.hil_controls, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 63 },
+        92: { format: '<QHHHHHHHHHHHHB', type: mavlink20.messages.hil_rc_inputs_raw, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], crc_extra: 54 },
+        93: { format: '<QQ16fB', type: mavlink20.messages.hil_actuator_controls, order_map: [0, 2, 3, 1], crc_extra: 47 },
+        100: { format: '<QfffhhBBff', type: mavlink20.messages.optical_flow, order_map: [0, 6, 4, 5, 1, 2, 7, 3, 8, 9], crc_extra: 175 },
+        101: { format: '<Qffffff21fB', type: mavlink20.messages.global_vision_position_estimate, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 102 },
+        102: { format: '<Qffffff21fB', type: mavlink20.messages.vision_position_estimate, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 158 },
+        103: { format: '<Qfff9fB', type: mavlink20.messages.vision_speed_estimate, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 208 },
+        104: { format: '<Qffffff21f', type: mavlink20.messages.vicon_position_estimate, order_map: [0, 1, 2, 3, 4, 5, 6, 7], crc_extra: 56 },
+        105: { format: '<QfffffffffffffHB', type: mavlink20.messages.highres_imu, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], crc_extra: 93 },
+        106: { format: '<QIfffffIfhBB', type: mavlink20.messages.optical_flow_rad, order_map: [0, 10, 1, 2, 3, 4, 5, 6, 9, 11, 7, 8], crc_extra: 138 },
+        107: { format: '<QfffffffffffffIB', type: mavlink20.messages.hil_sensor, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], crc_extra: 108 },
+        108: { format: '<fffffffffffffffffffffii', type: mavlink20.messages.sim_state, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22], crc_extra: 32 },
+        109: { format: '<HHBBBBB', type: mavlink20.messages.radio_status, order_map: [2, 3, 4, 5, 6, 0, 1], crc_extra: 185 },
+        110: { format: '<BBB251s', type: mavlink20.messages.file_transfer_protocol, order_map: [0, 1, 2, 3], crc_extra: 84 },
+        111: { format: '<qq', type: mavlink20.messages.timesync, order_map: [0, 1], crc_extra: 34 },
+        112: { format: '<QI', type: mavlink20.messages.camera_trigger, order_map: [0, 1], crc_extra: 174 },
+        113: { format: '<QiiiHHHhhhHBBBH', type: mavlink20.messages.hil_gps, order_map: [0, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14], crc_extra: 124 },
+        114: { format: '<QIfffffIfhBB', type: mavlink20.messages.hil_optical_flow, order_map: [0, 10, 1, 2, 3, 4, 5, 6, 9, 11, 7, 8], crc_extra: 237 },
+        115: { format: '<Q4ffffiiihhhHHhhh', type: mavlink20.messages.hil_state_quaternion, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], crc_extra: 4 },
+        116: { format: '<Ihhhhhhhhhh', type: mavlink20.messages.scaled_imu2, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 76 },
+        117: { format: '<HHBB', type: mavlink20.messages.log_request_list, order_map: [2, 3, 0, 1], crc_extra: 128 },
+        118: { format: '<IIHHH', type: mavlink20.messages.log_entry, order_map: [2, 3, 4, 0, 1], crc_extra: 56 },
+        119: { format: '<IIHBB', type: mavlink20.messages.log_request_data, order_map: [3, 4, 2, 0, 1], crc_extra: 116 },
+        120: { format: '<IHB90s', type: mavlink20.messages.log_data, order_map: [1, 0, 2, 3], crc_extra: 134 },
+        121: { format: '<BB', type: mavlink20.messages.log_erase, order_map: [0, 1], crc_extra: 237 },
+        122: { format: '<BB', type: mavlink20.messages.log_request_end, order_map: [0, 1], crc_extra: 203 },
+        123: { format: '<BBB110s', type: mavlink20.messages.gps_inject_data, order_map: [0, 1, 2, 3], crc_extra: 250 },
+        124: { format: '<QiiiIHHHHBBBHiIIII', type: mavlink20.messages.gps2_raw, order_map: [0, 9, 1, 2, 3, 5, 6, 7, 8, 10, 11, 4, 12, 13, 14, 15, 16, 17], crc_extra: 87 },
+        125: { format: '<HHH', type: mavlink20.messages.power_status, order_map: [0, 1, 2], crc_extra: 203 },
+        126: { format: '<IHBBB70s', type: mavlink20.messages.serial_control, order_map: [2, 3, 1, 0, 4, 5], crc_extra: 220 },
+        127: { format: '<IIiiiIiHBBBBB', type: mavlink20.messages.gps_rtk, order_map: [0, 8, 7, 1, 9, 10, 11, 12, 2, 3, 4, 5, 6], crc_extra: 25 },
+        128: { format: '<IIiiiIiHBBBBB', type: mavlink20.messages.gps2_rtk, order_map: [0, 8, 7, 1, 9, 10, 11, 12, 2, 3, 4, 5, 6], crc_extra: 226 },
+        129: { format: '<Ihhhhhhhhhh', type: mavlink20.messages.scaled_imu3, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 46 },
+        130: { format: '<IHHHBBB', type: mavlink20.messages.data_transmission_handshake, order_map: [4, 0, 1, 2, 3, 5, 6], crc_extra: 29 },
+        131: { format: '<H253s', type: mavlink20.messages.encapsulated_data, order_map: [0, 1], crc_extra: 223 },
+        132: { format: '<IHHHBBBBff4fB', type: mavlink20.messages.distance_sensor, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 85 },
+        133: { format: '<QiiH', type: mavlink20.messages.terrain_request, order_map: [1, 2, 3, 0], crc_extra: 6 },
+        134: { format: '<iiH16hB', type: mavlink20.messages.terrain_data, order_map: [0, 1, 2, 4, 3], crc_extra: 229 },
+        135: { format: '<ii', type: mavlink20.messages.terrain_check, order_map: [0, 1], crc_extra: 203 },
+        136: { format: '<iiffHHH', type: mavlink20.messages.terrain_report, order_map: [0, 1, 4, 2, 3, 5, 6], crc_extra: 1 },
+        137: { format: '<Iffhh', type: mavlink20.messages.scaled_pressure2, order_map: [0, 1, 2, 3, 4], crc_extra: 195 },
+        138: { format: '<Q4ffff21f', type: mavlink20.messages.att_pos_mocap, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 109 },
+        139: { format: '<Q8fBBB', type: mavlink20.messages.set_actuator_control_target, order_map: [0, 2, 3, 4, 1], crc_extra: 168 },
+        140: { format: '<Q8fB', type: mavlink20.messages.actuator_control_target, order_map: [0, 2, 1], crc_extra: 181 },
+        141: { format: '<Qffffff', type: mavlink20.messages.altitude, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 47 },
+        142: { format: '<BB120sB120s', type: mavlink20.messages.resource_request, order_map: [0, 1, 2, 3, 4], crc_extra: 72 },
+        143: { format: '<Iffhh', type: mavlink20.messages.scaled_pressure3, order_map: [0, 1, 2, 3, 4], crc_extra: 131 },
+        144: { format: '<QQiif3f3f4f3f3fB', type: mavlink20.messages.follow_target, order_map: [0, 10, 2, 3, 4, 5, 6, 7, 8, 9, 1], crc_extra: 127 },
+        146: { format: '<Qffffffffff3f3f4ffff', type: mavlink20.messages.control_system_state, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], crc_extra: 103 },
+        147: { format: '<iih10HhBBBbiB4HBI', type: mavlink20.messages.battery_status, order_map: [5, 6, 7, 2, 3, 4, 0, 1, 8, 9, 10, 11, 12, 13], crc_extra: 154 },
+        148: { format: '<QQIIIIHH8s8s8s18s', type: mavlink20.messages.autopilot_version, order_map: [0, 2, 3, 4, 5, 8, 9, 10, 6, 7, 1, 11], crc_extra: 178 },
+        149: { format: '<QfffffBBfff4fBB', type: mavlink20.messages.landing_target, order_map: [0, 6, 7, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13], crc_extra: 200 },
+        162: { format: '<IHBBB', type: mavlink20.messages.fence_status, order_map: [2, 1, 3, 0, 4], crc_extra: 189 },
+        192: { format: '<ffffffffffBBBBfBBf', type: mavlink20.messages.mag_cal_report, order_map: [10, 11, 12, 13, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 14, 15, 16, 17], crc_extra: 36 },
+        225: { format: '<ffffffffffffffffBff', type: mavlink20.messages.efi_status, order_map: [16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18], crc_extra: 208 },
+        230: { format: '<QffffffffH', type: mavlink20.messages.estimator_status, order_map: [0, 9, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 163 },
+        231: { format: '<Qffffffff', type: mavlink20.messages.wind_cov, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 105 },
+        232: { format: '<QIiifffffffffHHBBBH', type: mavlink20.messages.gps_input, order_map: [0, 15, 13, 1, 14, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 17, 18], crc_extra: 151 },
+        233: { format: '<BB180s', type: mavlink20.messages.gps_rtcm_data, order_map: [0, 1, 2], crc_extra: 35 },
+        234: { format: '<IiihhHhhhHBBbBBBbBBBbbBB', type: mavlink20.messages.high_latency, order_map: [10, 0, 11, 3, 4, 5, 12, 6, 1, 2, 7, 8, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 9], crc_extra: 150 },
+        235: { format: '<IiiHhhHHHBBBBBBBBBBBBbbbbbb', type: mavlink20.messages.high_latency2, order_map: [0, 9, 10, 3, 1, 2, 4, 5, 11, 12, 6, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 7, 8, 24, 25, 26], crc_extra: 179 },
+        241: { format: '<QfffIII', type: mavlink20.messages.vibration, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 90 },
+        242: { format: '<iiifff4ffffQ', type: mavlink20.messages.home_position, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 104 },
+        243: { format: '<iiifff4ffffBQ', type: mavlink20.messages.set_home_position, order_map: [10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11], crc_extra: 85 },
+        244: { format: '<iH', type: mavlink20.messages.message_interval, order_map: [1, 0], crc_extra: 95 },
+        245: { format: '<BB', type: mavlink20.messages.extended_sys_state, order_map: [0, 1], crc_extra: 130 },
+        246: { format: '<IiiiHHhHHB9sBB', type: mavlink20.messages.adsb_vehicle, order_map: [0, 1, 2, 9, 3, 4, 5, 6, 10, 11, 12, 7, 8], crc_extra: 184 },
+        247: { format: '<IfffBBB', type: mavlink20.messages.collision, order_map: [4, 0, 5, 6, 1, 2, 3], crc_extra: 81 },
+        248: { format: '<HBBB249s', type: mavlink20.messages.v2_extension, order_map: [1, 2, 3, 0, 4], crc_extra: 8 },
+        249: { format: '<HBB32s', type: mavlink20.messages.memory_vect, order_map: [0, 1, 2, 3], crc_extra: 204 },
+        250: { format: '<Qfff10s', type: mavlink20.messages.debug_vect, order_map: [4, 0, 1, 2, 3], crc_extra: 49 },
+        251: { format: '<If10s', type: mavlink20.messages.named_value_float, order_map: [0, 2, 1], crc_extra: 170 },
+        252: { format: '<Ii10s', type: mavlink20.messages.named_value_int, order_map: [0, 2, 1], crc_extra: 44 },
+        253: { format: '<B50sHB', type: mavlink20.messages.statustext, order_map: [0, 1, 2, 3], crc_extra: 83 },
+        254: { format: '<IfB', type: mavlink20.messages.debug, order_map: [0, 2, 1], crc_extra: 46 },
+        256: { format: '<QBB32s', type: mavlink20.messages.setup_signing, order_map: [1, 2, 3, 0], crc_extra: 71 },
+        257: { format: '<IIB', type: mavlink20.messages.button_change, order_map: [0, 1, 2], crc_extra: 131 },
+        258: { format: '<BB30s200s', type: mavlink20.messages.play_tune, order_map: [0, 1, 2, 3], crc_extra: 187 },
+        259: { format: '<IIfffIHHH32s32sB140sB', type: mavlink20.messages.camera_information, order_map: [0, 9, 10, 1, 2, 3, 4, 6, 7, 11, 5, 8, 12, 13], crc_extra: 92 },
+        260: { format: '<IBff', type: mavlink20.messages.camera_settings, order_map: [0, 1, 2, 3], crc_extra: 146 },
+        261: { format: '<IfffffBBBB32s', type: mavlink20.messages.storage_information, order_map: [0, 6, 7, 8, 1, 2, 3, 4, 5, 9, 10], crc_extra: 179 },
+        262: { format: '<IfIfBBi', type: mavlink20.messages.camera_capture_status, order_map: [0, 4, 5, 1, 2, 3, 6], crc_extra: 12 },
+        263: { format: '<QIiiii4fiBb205s', type: mavlink20.messages.camera_image_captured, order_map: [1, 0, 8, 2, 3, 4, 5, 6, 7, 9, 10], crc_extra: 133 },
+        264: { format: '<QQQI', type: mavlink20.messages.flight_information, order_map: [3, 0, 1, 2], crc_extra: 49 },
+        265: { format: '<Iffff', type: mavlink20.messages.mount_orientation, order_map: [0, 1, 2, 3, 4], crc_extra: 26 },
+        266: { format: '<HBBBB249s', type: mavlink20.messages.logging_data, order_map: [1, 2, 0, 3, 4, 5], crc_extra: 193 },
+        267: { format: '<HBBBB249s', type: mavlink20.messages.logging_data_acked, order_map: [1, 2, 0, 3, 4, 5], crc_extra: 35 },
+        268: { format: '<HBB', type: mavlink20.messages.logging_ack, order_map: [1, 2, 0], crc_extra: 14 },
+        269: { format: '<fIHHHHHBBB32s160sB', type: mavlink20.messages.video_stream_information, order_map: [7, 8, 9, 2, 0, 3, 4, 1, 5, 6, 10, 11, 12], crc_extra: 109 },
+        270: { format: '<fIHHHHHB', type: mavlink20.messages.video_stream_status, order_map: [7, 2, 0, 3, 4, 1, 5, 6], crc_extra: 59 },
+        271: { format: '<Iiiiiii4fff', type: mavlink20.messages.camera_fov_status, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], crc_extra: 22 },
+        275: { format: '<fffffffBBB', type: mavlink20.messages.camera_tracking_image_status, order_map: [7, 8, 9, 0, 1, 2, 3, 4, 5, 6], crc_extra: 126 },
+        276: { format: '<iiffffffffffB', type: mavlink20.messages.camera_tracking_geo_status, order_map: [12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], crc_extra: 18 },
+        277: { format: '<IffffffBB', type: mavlink20.messages.camera_thermal_range, order_map: [0, 7, 8, 1, 2, 3, 4, 5, 6], crc_extra: 62 },
+        280: { format: '<IIffffffB', type: mavlink20.messages.gimbal_manager_information, order_map: [0, 1, 8, 2, 3, 4, 5, 6, 7], crc_extra: 70 },
+        281: { format: '<IIBBBBB', type: mavlink20.messages.gimbal_manager_status, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 48 },
+        282: { format: '<I4ffffBBB', type: mavlink20.messages.gimbal_manager_set_attitude, order_map: [5, 6, 0, 7, 1, 2, 3, 4], crc_extra: 123 },
+        283: { format: '<QIIIffffffHH32s32s32sB', type: mavlink20.messages.gimbal_device_information, order_map: [1, 12, 13, 14, 2, 3, 0, 10, 11, 4, 5, 6, 7, 8, 9, 15], crc_extra: 74 },
+        284: { format: '<4ffffHBB', type: mavlink20.messages.gimbal_device_set_attitude, order_map: [5, 6, 4, 0, 1, 2, 3], crc_extra: 99 },
+        285: { format: '<I4ffffIHBBffB', type: mavlink20.messages.gimbal_device_attitude_status, order_map: [7, 8, 0, 6, 1, 2, 3, 4, 5, 9, 10, 11], crc_extra: 137 },
+        286: { format: '<Q4fIfffIfHBBBf', type: mavlink20.messages.autopilot_state_for_gimbal_device, order_map: [9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 12], crc_extra: 210 },
+        287: { format: '<IffffBBB', type: mavlink20.messages.gimbal_manager_set_pitchyaw, order_map: [5, 6, 0, 7, 1, 2, 3, 4], crc_extra: 1 },
+        288: { format: '<IffffBBB', type: mavlink20.messages.gimbal_manager_set_manual_control, order_map: [5, 6, 0, 7, 1, 2, 3, 4], crc_extra: 20 },
+        299: { format: '<32s64s', type: mavlink20.messages.wifi_config_ap, order_map: [0, 1], crc_extra: 19 },
+        301: { format: '<IiiHHHHHHHbBBBB7s20s', type: mavlink20.messages.ais_vessel, order_map: [0, 1, 2, 3, 4, 5, 10, 11, 12, 6, 7, 13, 14, 15, 16, 8, 9], crc_extra: 243 },
+        310: { format: '<QIHBBB', type: mavlink20.messages.uavcan_node_status, order_map: [0, 1, 3, 4, 5, 2], crc_extra: 28 },
+        311: { format: '<QII80sBB16sBB', type: mavlink20.messages.uavcan_node_info, order_map: [0, 1, 3, 4, 5, 6, 7, 8, 2], crc_extra: 95 },
+        320: { format: '<hBB16s', type: mavlink20.messages.param_ext_request_read, order_map: [1, 2, 3, 0], crc_extra: 243 },
+        321: { format: '<BB', type: mavlink20.messages.param_ext_request_list, order_map: [0, 1], crc_extra: 88 },
+        322: { format: '<HH16s128sB', type: mavlink20.messages.param_ext_value, order_map: [2, 3, 4, 0, 1], crc_extra: 243 },
+        323: { format: '<BB16s128sB', type: mavlink20.messages.param_ext_set, order_map: [0, 1, 2, 3, 4], crc_extra: 78 },
+        324: { format: '<16s128sBB', type: mavlink20.messages.param_ext_ack, order_map: [0, 1, 2, 3], crc_extra: 132 },
+        330: { format: '<Q72HHHBBffB', type: mavlink20.messages.obstacle_distance, order_map: [0, 4, 1, 5, 2, 3, 6, 7, 8], crc_extra: 23 },
+        331: { format: '<Qfff4fffffff21f21fBBBBb', type: mavlink20.messages.odometry, order_map: [0, 13, 14, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 17], crc_extra: 91 },
+        332: { format: '<Q5f5f5f5f5f5f5f5f5f5f5f5HB', type: mavlink20.messages.trajectory_representation_waypoints, order_map: [0, 13, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], crc_extra: 236 },
+        333: { format: '<Q5f5f5f5f5fB', type: mavlink20.messages.trajectory_representation_bezier, order_map: [0, 6, 1, 2, 3, 4, 5], crc_extra: 231 },
+        335: { format: '<QQHHBBBB', type: mavlink20.messages.isbd_link_status, order_map: [0, 1, 2, 3, 4, 5, 6, 7], crc_extra: 225 },
+        339: { format: '<fB', type: mavlink20.messages.raw_rpm, order_map: [1, 0], crc_extra: 199 },
+        340: { format: '<QiiiiiiihhhHHHH18sBB', type: mavlink20.messages.utm_global_position, order_map: [0, 15, 1, 2, 3, 4, 8, 9, 10, 11, 12, 13, 5, 6, 7, 14, 16, 17], crc_extra: 99 },
+        350: { format: '<QH10s58f', type: mavlink20.messages.debug_float_array, order_map: [0, 2, 1, 3], crc_extra: 232 },
+        370: { format: '<iiHHHHHBBB16s50sHBII11s', type: mavlink20.messages.smart_battery_info, order_map: [7, 8, 9, 0, 1, 2, 10, 11, 3, 4, 5, 6, 12, 13, 14, 15, 16], crc_extra: 75 },
+        373: { format: '<QfffffIiHhh', type: mavlink20.messages.generator_status, order_map: [0, 8, 1, 2, 3, 4, 9, 5, 10, 6, 7], crc_extra: 117 },
+        375: { format: '<QI32f', type: mavlink20.messages.actuator_output_status, order_map: [0, 1, 2], crc_extra: 251 },
+        376: { format: '<IHH', type: mavlink20.messages.relay_status, order_map: [0, 1, 2], crc_extra: 199 },
+        385: { format: '<HBBB128s', type: mavlink20.messages.tunnel, order_map: [1, 2, 0, 3, 4], crc_extra: 147 },
+        386: { format: '<IBBBB8s', type: mavlink20.messages.can_frame, order_map: [1, 2, 3, 4, 0, 5], crc_extra: 132 },
+        387: { format: '<IBBBB64s', type: mavlink20.messages.canfd_frame, order_map: [1, 2, 3, 4, 0, 5], crc_extra: 4 },
+        388: { format: '<16HBBBBB', type: mavlink20.messages.can_filter_modify, order_map: [1, 2, 3, 4, 5, 0], crc_extra: 8 },
+        9000: { format: '<Q16dB', type: mavlink20.messages.wheel_distance, order_map: [0, 2, 1], crc_extra: 113 },
+        9005: { format: '<QfffffIh', type: mavlink20.messages.winch_status, order_map: [0, 1, 2, 3, 4, 5, 7, 6], crc_extra: 117 },
+        12900: { format: '<BB20sBB20s', type: mavlink20.messages.open_drone_id_basic_id, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 114 },
+        12901: { format: '<iiffffHHhBB20sBBBBBBB', type: mavlink20.messages.open_drone_id_location, order_map: [9, 10, 11, 12, 6, 7, 8, 0, 1, 2, 3, 13, 4, 14, 15, 16, 17, 5, 18], crc_extra: 254 },
+        12902: { format: '<IBB20sBBBB23s', type: mavlink20.messages.open_drone_id_authentication, order_map: [1, 2, 3, 4, 5, 6, 7, 0, 8], crc_extra: 140 },
+        12903: { format: '<BB20sB23s', type: mavlink20.messages.open_drone_id_self_id, order_map: [0, 1, 2, 3, 4], crc_extra: 249 },
+        12904: { format: '<iifffIHHBB20sBBBB', type: mavlink20.messages.open_drone_id_system, order_map: [8, 9, 10, 11, 12, 0, 1, 6, 7, 2, 3, 13, 14, 4, 5], crc_extra: 77 },
+        12905: { format: '<BB20sB20s', type: mavlink20.messages.open_drone_id_operator_id, order_map: [0, 1, 2, 3, 4], crc_extra: 49 },
+        12918: { format: '<B50s', type: mavlink20.messages.open_drone_id_arm_status, order_map: [0, 1], crc_extra: 139 },
+        12915: { format: '<BB20sBB225s', type: mavlink20.messages.open_drone_id_message_pack, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 94 },
+        12919: { format: '<iifIBB', type: mavlink20.messages.open_drone_id_system_update, order_map: [4, 5, 0, 1, 2, 3], crc_extra: 7 },
+        12920: { format: '<hHB', type: mavlink20.messages.hygrometer_sensor, order_map: [2, 0, 1], crc_extra: 20 },
+        53: { format: '<IB', type: mavlink20.messages.mission_checksum, order_map: [1, 0], crc_extra: 3 },
+        295: { format: '<ffhBB', type: mavlink20.messages.airspeed, order_map: [3, 0, 2, 1, 4], crc_extra: 234 },
+        420: { format: '<IHBBB32h', type: mavlink20.messages.radio_rc_channels, order_map: [2, 3, 0, 1, 4, 5], crc_extra: 20 },
+        435: { format: '<IIBBB35s', type: mavlink20.messages.available_modes, order_map: [2, 3, 4, 0, 1, 5], crc_extra: 134 },
+        436: { format: '<IIB', type: mavlink20.messages.current_mode, order_map: [2, 0, 1], crc_extra: 193 },
+        437: { format: '<B', type: mavlink20.messages.available_modes_monitor, order_map: [0], crc_extra: 30 },
+        441: { format: '<IHHBBBBBBBBB', type: mavlink20.messages.gnss_integrity, order_map: [3, 0, 4, 5, 6, 7, 1, 2, 8, 9, 10, 11], crc_extra: 169 },
+        42000: { format: '<B', type: mavlink20.messages.icarous_heartbeat, order_map: [0], crc_extra: 227 },
+        42001: { format: '<ffffffffffbBBBBB', type: mavlink20.messages.icarous_kinematic_bands, order_map: [10, 11, 0, 1, 12, 2, 3, 13, 4, 5, 14, 6, 7, 15, 8, 9], crc_extra: 239 },
+        0: { format: '<IBBBBB', type: mavlink20.messages.heartbeat, order_map: [1, 2, 3, 0, 4, 5], crc_extra: 50 },
+        17150: { format: '<4I4HB4s4s', type: mavlink20.messages.array_test_0, order_map: [2, 3, 4, 1, 0], crc_extra: 26 },
+        17151: { format: '<4I', type: mavlink20.messages.array_test_1, order_map: [0], crc_extra: 72 },
+        17153: { format: '<4IB', type: mavlink20.messages.array_test_3, order_map: [1, 0], crc_extra: 19 },
+        17154: { format: '<4IB', type: mavlink20.messages.array_test_4, order_map: [0, 1], crc_extra: 89 },
+        17155: { format: '<5s5s', type: mavlink20.messages.array_test_5, order_map: [0, 1], crc_extra: 27 },
+        17156: { format: '<2dI2I2i2fH2H2hB2s2s32s', type: mavlink20.messages.array_test_6, order_map: [8, 5, 1, 2, 3, 6, 7, 9, 10, 11, 0, 4], crc_extra: 14 },
+        17157: { format: '<2d2f2I2i2H2h2s2s32s', type: mavlink20.messages.array_test_7, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8], crc_extra: 187 },
+        17158: { format: '<2dI2H', type: mavlink20.messages.array_test_8, order_map: [1, 0, 2], crc_extra: 106 },
+        17000: { format: '<Qqd3Q3q3dIif3I3i3fHh3H3hc10sBb3s3s', type: mavlink20.messages.test_types, order_map: [16, 17, 18, 12, 6, 0, 19, 13, 7, 1, 8, 2, 20, 14, 9, 3, 21, 15, 10, 4, 11, 5], crc_extra: 103 },
+        220: { format: '<Qffffff', type: mavlink20.messages.nav_filter_bias, order_map: [0, 1, 2, 3, 4, 5, 6], crc_extra: 34 },
+        221: { format: '<3H3H3H2H5H5H', type: mavlink20.messages.radio_calibration, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 71 },
+        222: { format: '<BBB', type: mavlink20.messages.ualberta_sys_status, order_map: [0, 1, 2], crc_extra: 15 },
+        10001: { format: '<IH9sBBBBB', type: mavlink20.messages.uavionix_adsb_out_cfg, order_map: [0, 2, 3, 4, 5, 6, 1, 7], crc_extra: 209 },
+        10002: { format: '<IiiiiIHHhhhHHBBB', type: mavlink20.messages.uavionix_adsb_out_dynamic, order_map: [0, 1, 2, 3, 13, 14, 4, 5, 6, 7, 8, 9, 10, 15, 11, 12], crc_extra: 186 },
+        10003: { format: '<B', type: mavlink20.messages.uavionix_adsb_transceiver_health_report, order_map: [0], crc_extra: 4 },
+        10004: { format: '<9s', type: mavlink20.messages.uavionix_adsb_out_cfg_registration, order_map: [0], crc_extra: 133 },
+        10005: { format: '<9s', type: mavlink20.messages.uavionix_adsb_out_cfg_flightid, order_map: [0], crc_extra: 103 },
+        10006: { format: '<I', type: mavlink20.messages.uavionix_adsb_get, order_map: [0], crc_extra: 193 },
+        10007: { format: '<iHBB8sB', type: mavlink20.messages.uavionix_adsb_out_control, order_map: [2, 0, 1, 3, 4, 5], crc_extra: 71 },
+        10008: { format: '<HBBBB8s', type: mavlink20.messages.uavionix_adsb_out_status, order_map: [1, 0, 2, 3, 4, 5], crc_extra: 240 },
+        10151: { format: '<ffffffIiffffffffffffHHB', type: mavlink20.messages.loweheiser_gov_efi, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 20, 21], crc_extra: 195 },
+        60010: { format: '<IIffffffB', type: mavlink20.messages.storm32_gimbal_manager_information, order_map: [8, 0, 1, 2, 3, 4, 5, 6, 7], crc_extra: 208 },
+        60011: { format: '<HHBBB', type: mavlink20.messages.storm32_gimbal_manager_status, order_map: [2, 3, 0, 1, 4], crc_extra: 183 },
+        60012: { format: '<4ffffHHBBBB', type: mavlink20.messages.storm32_gimbal_manager_control, order_map: [6, 7, 8, 9, 4, 5, 0, 1, 2, 3], crc_extra: 99 },
+        60013: { format: '<ffffHHBBBB', type: mavlink20.messages.storm32_gimbal_manager_control_pitchyaw, order_map: [6, 7, 8, 9, 4, 5, 0, 1, 2, 3], crc_extra: 129 },
+        60014: { format: '<fBBBB', type: mavlink20.messages.storm32_gimbal_manager_correct_roll, order_map: [1, 2, 3, 4, 0], crc_extra: 134 },
+        60020: { format: '<HH', type: mavlink20.messages.qshot_status, order_map: [0, 1], crc_extra: 202 },
+        60000: { format: '<QfffBB', type: mavlink20.messages.autopilot_state_for_gimbal_device_ext, order_map: [4, 5, 0, 1, 2, 3], crc_extra: 4 },
+        60040: { format: '<IB240s', type: mavlink20.messages.frsky_passthrough_array, order_map: [0, 1, 2], crc_extra: 156 },
+        60041: { format: '<HHHB248s', type: mavlink20.messages.param_value_array, order_map: [0, 1, 3, 2, 4], crc_extra: 191 },
+        60045: { format: '<HBBBBBbBBbBbBbff', type: mavlink20.messages.mlrs_radio_link_stats, order_map: [1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], crc_extra: 14 },
+        60046: { format: '<HHHHBBBBbb6s6sBB', type: mavlink20.messages.mlrs_radio_link_information, order_map: [4, 5, 6, 7, 8, 9, 0, 1, 10, 11, 2, 3, 12, 13], crc_extra: 171 },
+        60047: { format: '<HHBBB', type: mavlink20.messages.mlrs_radio_link_flow_control, order_map: [0, 1, 2, 3, 4], crc_extra: 55 },
+        60050: { format: '<IIIBB', type: mavlink20.messages.avss_prs_sys_status, order_map: [0, 1, 2, 3, 4], crc_extra: 220 },
+        60051: { format: '<Iiiiff', type: mavlink20.messages.avss_drone_position, order_map: [0, 1, 2, 3, 4, 5], crc_extra: 245 },
+        60052: { format: '<Iffffffffff', type: mavlink20.messages.avss_drone_imu, order_map: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crc_extra: 101 },
+        60053: { format: '<IBB', type: mavlink20.messages.avss_drone_operation_mode, order_map: [0, 1, 2], crc_extra: 45 },
+        50001: { format: '<32s', type: mavlink20.messages.cubepilot_raw_rc, order_map: [0], crc_extra: 246 },
+        50002: { format: '<fIHHHBB230s', type: mavlink20.messages.herelink_video_stream_information, order_map: [5, 6, 0, 2, 3, 1, 4, 7], crc_extra: 181 },
+        50003: { format: '<IIIhhhB', type: mavlink20.messages.herelink_telem, order_map: [6, 3, 0, 1, 2, 4, 5], crc_extra: 62 },
+        50004: { format: '<IIBB', type: mavlink20.messages.cubepilot_firmware_update_start, order_map: [2, 3, 0, 1], crc_extra: 240 },
+        50005: { format: '<IBB', type: mavlink20.messages.cubepilot_firmware_update_resp, order_map: [1, 2, 0], crc_extra: 152 },
+        52000: { format: '<50s50s', type: mavlink20.messages.airlink_auth, order_map: [0, 1], crc_extra: 13 },
+        52001: { format: '<B', type: mavlink20.messages.airlink_auth_response, order_map: [0], crc_extra: 239 },
+}
+
+
+// Special mavlink message to capture malformed data packets for debugging
+mavlink20.messages.bad_data = function(data, reason) {
+    this._id = mavlink20.MAVLINK_MSG_ID_BAD_DATA;
+    this._data = data;
+    this._reason = reason;
+    this._msgbuf = data;
+}
+mavlink20.messages.bad_data.prototype = new mavlink20.message;
+
+//  MAVLink signing state class
+MAVLinkSigning = function MAVLinkSigning(object){
+        this.secret_key = new Uint8Array();
+        this.timestamp = 1;
+        this.link_id = 0;
+        this.sign_outgoing = false; // todo false this
+        this.allow_unsigned_callback = undefined;
+        this.stream_timestamps = {};
+        this.sig_count = 0;
+        this.badsig_count = 0;
+        this.goodsig_count = 0;
+        this.unsigned_count = 0;
+        this.reject_count = 0;
+}
+
+/* MAVLink protocol handling class */
+MAVLink20Processor = function(logger, srcSystem, srcComponent) {
+
+    this.logger = logger;
+
+    this.seq = 0;
+    this.buf = new Uint8Array();
+    this.bufInError = new Uint8Array();
+
+    this.srcSystem = (typeof srcSystem === 'undefined') ? 0 : srcSystem;
+    this.srcComponent =  (typeof srcComponent === 'undefined') ? 0 : srcComponent;
+
+    this.have_prefix_error = false;
+
+    // The first packet we expect is a valid header, 6 bytes.
+    this.protocol_marker = 253;
+    this.expected_length = mavlink20.HEADER_LEN;
+    this.little_endian = true;
+
+    this.crc_extra = true;
+    this.sort_fields = true;
+    this.total_packets_sent = 0;
+    this.total_bytes_sent = 0;
+    this.total_packets_received = 0;
+    this.total_bytes_received = 0;
+    this.total_receive_errors = 0;
+    this.startup_time = Date.now();
+
+    // optional , but when used we store signing state in this object:
+    this.signing = new MAVLinkSigning();
+}
+
+if (!isNode) {
+    // Browser-compatible util.inherits replacement
+    MAVLink20Processor.prototype = Object.create(events.EventEmitter.prototype);
+    MAVLink20Processor.prototype.constructor = MAVLink20Processor;
+} else {
+    // Implements EventEmitter
+    util.inherits(MAVLink20Processor, events.EventEmitter);
+}
+
+// If the logger exists, this function will add a message to it.
+// Assumes the logger is a winston object.
+MAVLink20Processor.prototype.log = function(message) {
+    if(this.logger) {
+        this.logger.info(message);
+    }
+}
+
+MAVLink20Processor.prototype.log = function(level, message) {
+    if(this.logger) {
+        this.logger.log(level, message);
+    }
+}
+
+MAVLink20Processor.prototype.send = function(mavmsg) {
+    buf = mavmsg.pack(this);
+    this.file.write(buf);
+    this.seq = (this.seq + 1) % 256;
+    this.total_packets_sent +=1;
+    this.total_bytes_sent += buf.length;
+}
+
+// return number of bytes needed for next parsing stage
+MAVLink20Processor.prototype.bytes_needed = function() {
+    ret = this.expected_length - this.buf.length;
+    return ( ret <= 0 ) ? 1 : ret;
+}
+
+// Combine two buffers into one
+MAVLink20Processor.prototype.concat_buffer = function(A, B) {
+    const out = new Uint8Array(A.length + B.length)
+    out.set(A, 0)
+    out.set(B, A.length)
+    return out
+}
+
+// add data to the local buffer
+MAVLink20Processor.prototype.pushBuffer = function(data) {
+    if (typeof data.length === 'undefined') {
+       data = [data];
+    }
+    this.buf = this.concat_buffer(this.buf, data);
+    this.total_bytes_received += data.length;
+}
+
+// Decode prefix.  Elides the prefix.
+MAVLink20Processor.prototype.parsePrefix = function() {
+
+    // Test for a message prefix.
+    if( this.buf.length >= 1 &&
+        this.buf[0] != mavlink20.PROTOCOL_MARKER_V2 &&
+        this.buf[0] != mavlink20.PROTOCOL_MARKER_V1) {
+
+        // Strip the offending initial bytes and throw an error.
+        var badPrefix = this.buf[0];
+        var idx1 = this.buf.indexOf(mavlink20.PROTOCOL_MARKER_V1);
+        var idx2 = this.buf.indexOf(mavlink20.PROTOCOL_MARKER_V2);
+        if (idx1 == -1) {
+            idx1 = idx2;
+        }
+        if (idx1 == -1 && idx2 == -1) {
+            this.bufInError = this.buf;
+            this.buf = new Uint8Array();
+        } else {
+            this.bufInError = this.buf.slice(0,idx1);
+            this.buf = this.buf.slice(idx1);
+        }
+        this.expected_length = mavlink20.HEADER_LEN; //initially we 'expect' at least the length of the header, later parseLength corrects for this. 
+        throw new Error("Bad prefix ("+badPrefix+")");
+    }
+
+}
+
+// Determine the length.  Leaves buffer untouched.
+// Although the 'len' of a packet is available as of the second byte, the third byte with 'incompat_flags' lets
+//  us know if we have signing enabled, which affects the real-world length by the signature-block length of 13 bytes.
+// once successful, 'this.expected_length' is correctly set for the whole packet.
+MAVLink20Processor.prototype.parseLength = function() {
+
+    if( this.buf.length >= 3 ) {
+        var unpacked = jspack.Unpack('BBB', this.buf.slice(0, 3));
+        var magic = unpacked[0]; // stx ie fd or fe etc
+        this.expected_length = unpacked[1] + mavlink20.HEADER_LEN + 2 // length of message + header + CRC (ie non-signed length)
+        this.incompat_flags = unpacked[2];
+        // mavlink2 only..  in mavlink1, incompat_flags var above is actually the 'seq', but for this test its ok.
+        if ((magic == mavlink20.PROTOCOL_MARKER_V2 ) && ( this.incompat_flags & mavlink20.MAVLINK_IFLAG_SIGNED )){
+            this.expected_length += mavlink20.MAVLINK_SIGNATURE_BLOCK_LEN;
+        }
+    }
+
+}
+
+// input some data bytes, possibly returning a new message - python equiv function is called parse_char / __parse_char_legacy
+// c can be null to process any remaining data in the input buffer from a previous call
+MAVLink20Processor.prototype.parseChar = function(c) {
+
+    var m = null;
+
+    try {
+        if (c != null) {
+            this.pushBuffer(c);
+        }
+        this.parsePrefix();
+        this.parseLength();
+        m = this.parsePayload();
+
+    } catch(e) {
+        this.log('error', e.message);
+        this.total_receive_errors += 1;
+        m = new mavlink20.messages.bad_data(this.bufInError, e.message);
+        this.bufInError = new Uint8Array();
+
+    }
+
+    // emit a packet-specific message as well as a generic message, user/s can choose to use either or both of these.
+    if (isNode && null != m) {
+        this.emit(m._name, m);
+        this.emit('message', m);
+    }
+
+    return m;
+
+}
+
+// continuation of python's  __parse_char_legacy 
+MAVLink20Processor.prototype.parsePayload = function() {
+
+    var m = null;
+
+    // tip: this.expected_length and this.incompat_flags both already set correctly by parseLength(..) above 
+
+    // If we have enough bytes to try and read it, read it.  
+    //  shortest packet is header+checksum(2) with no payload, so we need at least that many 
+    //  but once we have a longer 'expected length' we have to read all of it. 
+    if(( this.expected_length >= mavlink20.HEADER_LEN+2) && (this.buf.length >= this.expected_length) ) { 
+
+        // Slice off the expected packet length, reset expectation to be to find a header.
+        var mbuf = this.buf.slice(0, this.expected_length);
+
+        // TODO: slicing off the buffer should depend on the error produced by the decode() function
+        // - if we find a well formed message, cut-off the expected_length 
+        // - if the message is not well formed (correct prefix by accident), cut-off 1 char only
+        this.buf = this.buf.slice(this.expected_length);
+        this.expected_length = mavlink20.HEADER_LEN; // after attempting a parse, we'll next expect to find just a header. 
+
+        try {
+            m = this.decode(mbuf);
+            this.total_packets_received += 1;
+        }
+        catch(e) {
+            // Set buffer in question and re-throw to generic error handling
+            this.bufInError = mbuf;
+            throw e;
+        }
+    }
+
+    return m;
+
+}
+
+// input some data bytes, possibly returning an array of new messages
+MAVLink20Processor.prototype.parseBuffer = function(s) {
+
+    // Get a message, if one is available in the stream.
+    var m = this.parseChar(s);
+
+    // No messages available, bail.
+    if ( null === m ) {
+        return null;
+    }
+
+    // While more valid messages can be read from the existing buffer, add
+    // them to the array of new messages and return them.
+    var ret = [];
+    ret.push(m);
+    while(true) {
+        m = this.parseChar(null);
+        if ( null === m ) {
+            // No more messages left.
+            return ret;
+        }
+        ret.push(m);
+    }
+
+}
+
+//check signature on incoming message , many of the comments in this file come from the python impl
+MAVLink20Processor.prototype.check_signature = function(msgbuf, srcSystem, srcComponent) {
+    var timestamp_buf = msgbuf.slice(-12,-6);
+ 
+    var link_id;
+    if (isNode) {
+        var link_id_buf = Buffer.from ? Buffer.from(msgbuf.slice(-13,-12)) : new Buffer(msgbuf.slice(-13,-12));
+        link_id = link_id_buf[0]; // get the first byte.
+    } else {
+        // Browser-compatible buffer handling
+        link_id = msgbuf.slice(-13,-12)[0];
+    }
+
+    function unpackUint48LE(bytes) {
+        let value = 0n;
+        for (let i = 5; i >= 0; i--) {
+            value = (value << 8n) | BigInt(bytes[i]);
+        }
+        return value;
+    }
+    var timestamp = Number(unpackUint48LE(timestamp_buf));
+
+    // see if the timestamp is acceptable
+
+    // we'll use a STRING containing these three things in it as a unique key eg: '0,1,1'
+    stream_key = new Array(link_id,srcSystem,srcComponent).toString();
+
+    if (stream_key in this.signing.stream_timestamps){
+	if (timestamp <= this.signing.stream_timestamps[stream_key]){
+	    //# reject old timestamp
+	    //console.log('old timestamp')
+	    return false
+	}
+    }else{
+	//# a new stream has appeared. Accept the timestamp if it is at most
+	//# one minute behind our current timestamp
+    if (timestamp + 6000*1000 < this.signing.timestamp){
+	    //console.log('bad new stream ', timestamp/(100.0*1000*60*60*24*365), this.signing.timestamp/(100.0*1000*60*60*24*365))
+	    return false
+	}
+	this.signing.stream_timestamps[stream_key] = timestamp;
+	//console.log('new stream',this.signing.stream_timestamps)
+    }
+
+    // just the last 6 of 13 available are the actual sig . ie excluding the linkid(1) and timestamp(6)
+    var sigpart = msgbuf.slice(-6);
+    sigpart = Uint8Array.from(sigpart);
+    // not sig part 0- end-minus-6
+    var notsigpart = msgbuf.slice(0,-6);
+    notsigpart = Uint8Array.from(notsigpart);
+
+    var sig1 = mavlink20.create_signature(this.signing.secret_key, notsigpart);
+
+    // Browser-compatible buffer comparison
+    var signaturesMatch;
+    if (isNode) {
+        signaturesMatch = Buffer.from(sig1).equals(Buffer.from(sigpart));
+    } else {
+        // Compare arrays element by element in browser
+        signaturesMatch = sig1.length === sigpart.length && 
+                         sig1.every((val, index) => val === sigpart[index]);
+    }
+    if (!signaturesMatch) {
+        return false;
+    }
+    //# the timestamp we next send with is the max of the received timestamp and
+    //# our current timestamp
+    this.signing.timestamp = Math.max(this.signing.timestamp, timestamp+1);
+    return true
+}
+
+/* decode a buffer as a MAVLink message */
+MAVLink20Processor.prototype.decode = function(msgbuf) {
+
+    var magic, incompat_flags, compat_flags, mlen, seq, srcSystem, srcComponent, unpacked, msgId, signature_len, header_len;
+
+    // decode the header
+    try {
+        if (msgbuf[0] == 253) {
+    var unpacked = jspack.Unpack('BBBBBBBHB', msgbuf.slice(0, 10));  // the H in here causes msgIDlow to takeup 2 bytes, the rest 1
+        magic = unpacked[0];
+        mlen = unpacked[1];
+        incompat_flags = unpacked[2];
+        compat_flags = unpacked[3];
+        seq = unpacked[4];
+        srcSystem = unpacked[5];
+        srcComponent = unpacked[6];
+        var msgIDlow = ((unpacked[7] & 0xFF) << 8) | ((unpacked[7] >> 8) & 0xFF); // first-two msgid bytes 
+        var msgIDhigh = unpacked[8];   // the 3rd msgid byte 
+        msgId = msgIDlow | (msgIDhigh<<16);  // combined result. 0 - 16777215  24bit number
+        header_len = 10;
+} else {
+    var unpacked = jspack.Unpack('BBBBBB', msgbuf.slice(0, 6));
+        magic = unpacked[0];
+        mlen = unpacked[1];
+        seq = unpacked[2];
+        srcSystem = unpacked[3];
+        srcComponent = unpacked[4];
+        msgID = unpacked[5];
+        incompat_flags = 0;
+        compat_flags = 0;
+        header_len = 6;
+}
+        }
+    catch(e) {
+        throw new Error('Unable to unpack MAVLink header: ' + e.message);
+    }
+
+    if (magic != this.protocol_marker) {
+        throw new Error("Invalid MAVLink prefix ("+magic+")");
+    }
+
+    // is packet supposed to be signed?
+    if ( incompat_flags & mavlink20.MAVLINK_IFLAG_SIGNED ){
+        signature_len = mavlink20.MAVLINK_SIGNATURE_BLOCK_LEN;
+    } else {
+        signature_len = 0;
+    }
+
+    // header's declared len compared to packets actual len
+    var actual_len = (msgbuf.length - (header_len + 2 + signature_len));
+    var actual_len_nosign = (msgbuf.length - (header_len + 2 ));
+
+    if ((mlen == actual_len) && (signature_len > 0)){
+        var len_if_signed = mlen+signature_len;
+        //console.log("Packet appears signed && labeled as signed, OK. msgId=" + msgId);
+
+    } else  if ((mlen == actual_len_nosign) && (signature_len > 0)){
+
+        var len_if_signed = mlen+signature_len;
+        throw new Error("Packet appears unsigned when labeled as signed. Got actual_len "+actual_len_nosign+" expected " + len_if_signed + ", msgId=" + msgId);     
+
+    } else if( mlen != actual_len) {
+          throw new Error("Invalid MAVLink message length.  Got " + (msgbuf.length - (header_len + 2)) + " expected " + mlen + ", msgId=" + msgId);
+
+    }
+
+    if (!(msgId in mavlink20.map)) {
+        throw new Error("Unknown MAVLink message ID (" + msgId + ")");
+    }
+
+    // here's the common chunks of packet we want to work with below..
+    var payloadBuf = msgbuf.slice(mavlink20.HEADER_LEN, -(signature_len+2)); // the remaining bit between the header and the crc
+    var crcCheckBuf = msgbuf.slice(1, -(signature_len+2)); // the part uses to calculate the crc - ie between the magic and signature,
+
+    // decode the payload
+    // refs: (fmt, type, order_map, crc_extra) = mavlink20.map[msgId]
+    var decoder = mavlink20.map[msgId];
+
+    // decode the checksum
+    var receivedChecksum = undefined;
+    if ( signature_len == 0 ) { // unsigned
+        try {
+            var crcBuf1 = msgbuf.slice(-2);
+            receivedChecksum = jspack.Unpack('<H', crcBuf1);
+        } catch (e) {
+            throw new Error("Unable to unpack MAVLink unsigned CRC: " + e.message);
+        }
+    } else { // signed
+        try {
+            var crcBuf2 = msgbuf.slice(-15,-13);
+            receivedChecksum = jspack.Unpack('<H', crcBuf2);
+        } catch (e) {
+            throw new Error("Unable to unpack MAVLink signed CRC: " + e.message);
+        }
+    }
+    receivedChecksum = receivedChecksum[0];
+
+    // make our own chksum of the relevant part of the packet...
+    var messageChecksum = mavlink20.x25Crc(crcCheckBuf);
+    var messageChecksum2 = mavlink20.x25Crc([decoder.crc_extra], messageChecksum);
+
+    if ( receivedChecksum != messageChecksum2 ) {
+        throw new Error('invalid MAVLink CRC in msgID ' +msgId+ ', got ' + receivedChecksum + ' checksum, calculated payload checksum as '+messageChecksum2 );
+    }
+
+    // now check the signature...
+    var sig_ok = false 
+    if (signature_len == mavlink20.MAVLINK_SIGNATURE_BLOCK_LEN){
+        this.signing.sig_count += 1
+    }
+
+    // it's a Buffer, zero-length means unused
+    if (this.signing.secret_key.length != 0 ){
+        var accept_signature = false;
+        if (signature_len == mavlink20.MAVLINK_SIGNATURE_BLOCK_LEN){
+            sig_ok = this.check_signature(msgbuf, srcSystem, srcComponent);
+            accept_signature = sig_ok;
+            if (sig_ok){
+                this.signing.goodsig_count += 1;
+            }else{
+                this.signing.badsig_count += 1;
+            }
+            if ( (! accept_signature) && (this.signing.allow_unsigned_callback != undefined) ){
+                accept_signature = this.signing.allow_unsigned_callback(this, msgId);
+                if (accept_signature){
+                    this.signing.unsigned_count += 1;
+                }else{
+                    this.signing.reject_count += 1;
+                }
+            }
+        }else if (this.signing.allow_unsigned_callback != undefined){
+            accept_signature = this.signing.allow_unsigned_callback(this, msgId);
+            if (accept_signature){
+                this.signing.unsigned_count += 1;
+            }else{
+                this.signing.reject_count += 1;
+            }
+        }
+        if (!accept_signature) throw new Error('Invalid signature');
+    }
+
+    // now look at the specifics of the payload...
+    var paylen = jspack.CalcLength(decoder.format);
+
+    //put any truncated 0's back in (ie zero-pad )
+    if (paylen > payloadBuf.length) {
+        payloadBuf = this.concat_buffer(payloadBuf, new Uint8Array(paylen - payloadBuf.length).fill(0));
+    }
+    // Decode the payload and reorder the fields to match the order map.
+    try {
+        var t = jspack.Unpack(decoder.format, payloadBuf); 
+    }
+    catch (e) {
+        throw new Error('Unable to unpack MAVLink payload type='+decoder.type+' format='+decoder.format+' payloadLength='+ payloadBuf +': '+ e.message); 
+    }
+
+    // Need to check if the message contains arrays
+    var args = {};
+    const elementsInMsg = decoder.order_map.length;
+    const actualElementsInMsg = JSON.parse(JSON.stringify(t)).length;
+
+    if (elementsInMsg == actualElementsInMsg) {
+        // Reorder the fields to match the order map
+        t.forEach(function(e, i, l) {
+            args[i] = t[decoder.order_map[i]]
+        });
+    } else {
+        // This message contains arrays
+        var typeIndex = 1;
+        var orderIndex = 0;
+        var memberIndex = 0;
+        var tempArgs = {};
+
+        // Walk through the fields 
+        for(var i = 0, size = decoder.format.length-1; i <= size; ++i) {
+            var order = decoder.order_map[orderIndex];
+            var currentType =  decoder.format[typeIndex];
+
+            if (isNaN(parseInt(currentType))) {
+                // This field is not an array check the type and add it to the args
+                tempArgs[orderIndex] = t[memberIndex];
+                memberIndex++;
+            } else {
+                // This field is part of an array, need to find the length of the array
+                var arraySize = ''
+                var newArray = []
+                while (!isNaN(decoder.format[typeIndex])) {
+                    arraySize = arraySize + decoder.format[typeIndex];
+                    typeIndex++;
+                }
+
+                // Now that we know how long the array is, create an array with the values
+                for(var j = 0, size = parseInt(arraySize); j < size; ++j){
+                    newArray.push(t[j+orderIndex]);
+                    memberIndex++;
+                }
+
+                // Add the array to the args object
+                arraySize = arraySize + decoder.format[typeIndex];
+                currentType = arraySize;
+                tempArgs[orderIndex] = newArray;
+            }
+            orderIndex++;
+            typeIndex++;
+        }
+
+        // Finally reorder the fields to match the order map
+        t.forEach(function(e, i, l) {
+            args[i] = tempArgs[decoder.order_map[i]]
+        });
+    }
+
+    // construct the message object
+    try {
+        // args at this point might look like:  { '0': 6, '1': 8, '2': 0, '3': 0, '4': 3, '5': 3 }
+        var m = new decoder.type();   // make a new 'empty' instance of the right class,
+        m.set(args,false); // associate ordered-field-numbers to names, after construction not during.
+    }
+    catch (e) {
+        throw new Error('Unable to instantiate MAVLink message of type '+decoder.type+' : ' + e.message);
+    }
+
+    m._signed = sig_ok;
+    if (m._signed) { m._link_id = msgbuf[-13]; }
+ 
+    m._msgbuf = msgbuf;
+    m._payload = payloadBuf;
+    m.crc = receivedChecksum;
+    m._header = new mavlink20.header(msgId, mlen, seq, srcSystem, srcComponent, incompat_flags, compat_flags);
+    this.log(m);
+    return m;
+}
+
+
+// Browser and Node.js compatible module exports
+if (!isNode) {
+    // For browsers, attach to window or use global namespace
+    if (typeof window !== 'undefined') {
+        window.mavlink20 = mavlink20;
+        window.MAVLink20Processor = MAVLink20Processor;
+    }
+    // Also support global assignment
+    if (typeof global !== 'undefined') {
+        global.mavlink20 = mavlink20;
+        global.MAVLink20Processor = MAVLink20Processor;
+    }
+} else {
+    // For Node.js, use module.exports
+    if (typeof module === "object" && module.exports) {
+        module.exports = {mavlink20, MAVLink20Processor};
+    }
+}
+
diff --git a/modules/MAVLink/mavlink_store.js b/modules/MAVLink/mavlink_store.js
new file mode 100644
index 00000000..f24a9b5e
--- /dev/null
+++ b/modules/MAVLink/mavlink_store.js
@@ -0,0 +1,94 @@
+/*
+    MAVLink store of recently received messages
+    use the mavlink_store object to store and retrieve messages
+*/
+
+class MAVLinkMessageStore {
+  static _instance = null;        // holds the one and only instance
+
+  constructor() {
+    // return the existing instance if it already exists
+    if (MAVLinkMessageStore._instance) {
+      return MAVLinkMessageStore._instance;
+    }
+
+    // first construction, do normal init
+    this.store = {};
+
+    // default system and component ids
+    this.sysid_default = 1;
+    this.compid_default = 1;
+
+    // remember this instance for future constructions
+    MAVLinkMessageStore._instance = this;
+  }
+
+  // optional helper, some teams prefer this call site
+  static getInstance() {
+    return new MAVLinkMessageStore();
+  }
+
+  // store message in the message store
+  // indexed by system id, component id and message id
+  store_message(msg) {
+    // sanity check msg
+    if (
+      msg == null ||
+      msg._id == null ||
+      msg._header == null ||
+      msg._header.srcSystem == null ||
+      msg._header.srcComponent == null
+    ) {
+      return;
+    }
+
+    // retrieve sender system id and component id
+    const sysid = msg._header.srcSystem;
+    const compid = msg._header.srcComponent;
+
+    // store message
+    if (this.store[sysid] == null) {
+      this.store[sysid] = {};
+    }
+    if (this.store[sysid][compid] == null) {
+      this.store[sysid][compid] = {};
+    }
+    this.store[sysid][compid][msg._id] = msg;
+  }
+
+  // retrieve latest message, returns null if not found
+  get_latest_message(msgid, sysid = this.sysid_default, compid = this.compid_default) {
+    if (this.store[sysid] == null) return null;
+    if (this.store[sysid][compid] == null) return null;
+    return this.store[sysid][compid][msgid];
+  }
+
+  find_message_by_name(name, sysid = this.sysid_default, compid = this.compid_default) {
+    if (!this.store[sysid] || !this.store[sysid][compid]) return null;
+    for (const id in this.store[sysid][compid]) {
+      const msg = this.store[sysid][compid][id];
+      if (msg._name === name) return msg;
+    }
+    return null;
+  }
+
+  // get available message names, returns array or null
+  get_available_message_names(sysid = this.sysid_default, compid = this.compid_default) {
+    if (this.store[sysid] == null) return null;
+    if (this.store[sysid][compid] == null) return null;
+
+    const msg_ids = Object.keys(this.store[sysid][compid]);
+    if (msg_ids.length === 0) return null;
+
+    const msg_names = msg_ids.map(id => this.store[sysid][compid][id]._name);
+    if (msg_names.length === 0) return null;
+    return msg_names;
+  }
+}
+
+// export the class
+export default MAVLinkMessageStore;
+
+// export the singleton instance
+const mavlink_store = MAVLinkMessageStore.getInstance();
+export { mavlink_store };