mav_unpack

//function called by arduino to read any MAVlink messages sent by serial communication from flight controller to arduino
uint8_t received_sysid;
uint8_t received_compid;
uint8_t received_msgid;

void px_to_mp() {
  if(Serial2.available()) {
    mavlink_message_t msg;
    mavlink_status_t status;
    uint8_t c = Serial2.read();
    if(mavlink_parse_char(MAVLINK_COMM_0, c, &msg, &status)) {
      switch(msg.msgid) {
        case 0: {
          mavlink_heartbeat_t packet;
          mavlink_msg_heartbeat_decode(&msg, &packet);
          received_sysid = msg.sysid; // sysid compid msgid terpaksa dibuat -
          received_compid = msg.compid; // variabel tersendiri untuk menghindari -
          received_msgid = msg.msgid; // kerusakan data. belum diketahui penyebab -
                                      // 3 byte ini riskan rusak.
          struct combine {
            header head_data;
            hb payload_data;
          }__attribute__((packed)); struct combine merge; // paket header dan payload digabung 1 frame
                                                          // paket checksum digabungkan dengan payload
          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.custom_mode, packet.type, packet.autopilot, packet.base_mode,
            packet.system_status, packet.mavlink_version, msg.checksum};
          //payloadSize digunakan untuk pembentukan keystream dan tag
          //sizeMerge adalah total data dari head-cksum yang dikirim ke MP
          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 1: {
          mavlink_sys_status_t packet;
          mavlink_msg_sys_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            sys payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.onboard_control_sensors_present, packet.onboard_control_sensors_enabled,
            packet.onboard_control_sensors_health, packet.load, packet.voltage_battery, packet.current_battery,
            packet.drop_rate_comm, packet.errors_comm, packet.errors_count1, packet.errors_count2,
            packet.errors_count3, packet.errors_count4, packet.battery_remaining, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 2: {
          mavlink_system_time_t packet;
          mavlink_msg_system_time_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            system_time payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_unix_usec, packet.time_boot_ms, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 4: {
          mavlink_ping_t packet;
          mavlink_msg_ping_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            ping payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.seq, packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 5: {
          mavlink_change_operator_control_t packet;
          mavlink_msg_change_operator_control_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            op_control payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_system, packet.control_request,
            packet.version, {packet.passkey}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 6: {
          mavlink_change_operator_control_ack_t packet;
          mavlink_msg_change_operator_control_ack_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            control_ack payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.gcs_system_id, packet.control_request, packet.ack, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 7: {
          mavlink_auth_key_t packet;
          mavlink_msg_auth_key_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            mavkey payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {{packet.key}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 8: {
          mavlink_link_node_status_t packet;
          mavlink_msg_link_node_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            node payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.timestamp, packet.tx_rate, packet.rx_rate, packet.messages_sent,
            packet.messages_received, packet.messages_lost, packet.rx_parse_err, packet.tx_overflows,
            packet.rx_overflows, packet.tx_buf, packet.rx_buf, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 11: {
          mavlink_set_mode_t packet;
          mavlink_msg_set_mode_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            setmode payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.custom_mode, packet.target_system, packet.base_mode,
            msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 20: {
          mavlink_param_request_read_t packet;
          mavlink_msg_param_request_read_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            paramreq payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.param_index, packet.target_system, packet.target_component,
            {packet.param_id}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 21: {
          mavlink_param_request_list_t packet;
          mavlink_msg_param_request_list_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            paramreqlist payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 22: {
          mavlink_param_value_t packet;
          mavlink_msg_param_value_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            paramvalue payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.param_value, packet.param_count, packet.param_index,
            {packet.param_id}, packet.param_type, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 23: {
          mavlink_param_set_t packet;
          mavlink_msg_param_set_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            paramset payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.param_value, packet.target_system, packet.target_component,
            {packet.param_id}, packet.param_type, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 24: {
          mavlink_gps_raw_int_t packet;
          mavlink_msg_gps_raw_int_decode(&msg, &packet);

          struct combine {
            header head_data;
            gpsraw payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, msg.sysid, msg.compid, msg.msgid};
          merge.payload_data = {packet.time_usec, packet.lat, packet.lon, packet.alt, packet.eph,
            packet.epv, packet.vel, packet.cog, packet.fix_type,
            packet.satellites_visible, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 25: {
          mavlink_gps_status_t packet;
          mavlink_msg_gps_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gpsstat payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.satellites_visible, {packet.satellite_prn}, {packet.satellite_used},
            {packet.satellite_elevation}, {packet.satellite_azimuth}, {packet.satellite_snr}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 26: {
          mavlink_scaled_imu_t packet;
          mavlink_msg_scaled_imu_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            scaleimu payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.xacc, packet.yacc, packet.zacc,
            packet.xgyro, packet.ygyro, packet.zgyro, packet.xmag, packet.ymag,
            packet.zmag, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 27: {
          mavlink_raw_imu_t packet;
          mavlink_msg_raw_imu_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            rawimu payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.xacc, packet.yacc, packet.zacc,
            packet.xgyro, packet.ygyro, packet.zgyro, packet.xmag, packet.ymag, packet.zmag, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 28: {
          mavlink_raw_pressure_t packet;
          mavlink_msg_raw_pressure_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            rawpress payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.press_abs, packet.press_diff1,
            packet.press_diff2, packet.temperature, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 29: {
          mavlink_scaled_pressure_t packet;
          mavlink_msg_scaled_pressure_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            scalepress payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.press_abs, packet.press_diff,
            packet.temperature, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 30: {
          mavlink_attitude_t packet;
          mavlink_msg_attitude_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            attitude payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.roll, packet.pitch, packet.yaw,
            packet.rollspeed, packet.pitchspeed, packet.yawspeed, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 31: {
          mavlink_attitude_quaternion_t packet;
          mavlink_msg_attitude_quaternion_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            attitude_quaternion payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.q1, packet.q2, packet.q3,
            packet.q4, packet.rollspeed, packet.pitchspeed, packet.yawspeed, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 32: {
          mavlink_local_position_ned_t packet;
          mavlink_msg_local_position_ned_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            locposned payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.x, packet.y, packet.z, packet.vx,
            packet.vy, packet.vz, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 33: {
          mavlink_global_position_int_t packet;
          mavlink_msg_global_position_int_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gpsint payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.lat, packet.lon, packet.alt,
            packet.relative_alt, packet.vx, packet.vy, packet.vz, packet.hdg, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 34: {
          mavlink_rc_channels_scaled_t packet;
          mavlink_msg_rc_channels_scaled_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            rcchscale payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.chan1_scaled, packet.chan2_scaled,
            packet.chan3_scaled, packet.chan4_scaled, packet.chan5_scaled, packet.chan6_scaled,
            packet.chan7_scaled, packet.chan8_scaled, packet.port, packet.rssi, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 35: {
          mavlink_rc_channels_raw_t packet;
          mavlink_msg_rc_channels_raw_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            rcchraw payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.chan1_raw, packet.chan2_raw,
            packet.chan3_raw, packet.chan4_raw, packet.chan5_raw, packet.chan6_raw,
            packet.chan7_raw, packet.chan8_raw, packet.port, packet.rssi, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 36: {
          mavlink_servo_output_raw_t packet;
          mavlink_msg_servo_output_raw_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            servooutraw payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.servo1_raw, packet.servo2_raw,
            packet.servo3_raw, packet.servo4_raw, packet.servo5_raw, packet.servo6_raw,
            packet.servo7_raw, packet.servo8_raw, packet.port, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 37: {
          mavlink_mission_request_partial_list_t packet;
          mavlink_msg_mission_request_partial_list_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            mission_request_partial_list payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.start_index, packet.end_index, packet.target_system,
            packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 38: {
          mavlink_mission_write_partial_list_t packet;
          mavlink_msg_mission_write_partial_list_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            mission_write_partial_list payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.start_index, packet.end_index, packet.target_system,
            packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 39: {
          mavlink_mission_item_t packet;
          mavlink_msg_mission_item_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            mission_item payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.param1, packet.param2, packet.param3, packet.param4,
            packet.x, packet.y, packet.z, packet.seq, packet.command, packet.target_system,
            packet.target_component, packet.frame, packet.current, packet.autocontinue, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 40: {
          mavlink_mission_request_t packet;
          mavlink_msg_mission_request_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            missionreq payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.seq, packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 41: {
          mavlink_mission_set_current_t packet;
          mavlink_msg_mission_set_current_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            mission_set_current payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.seq, packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 42: {
          mavlink_mission_current_t packet;
          mavlink_msg_mission_current_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            missioncurr payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.seq, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 43: {
          mavlink_mission_request_list_t packet;
          mavlink_msg_mission_request_list_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            missionreqlist payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 44: {
          mavlink_mission_count_t packet;
          mavlink_msg_mission_count_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            missioncount payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.count, packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 45: {
          mavlink_mission_clear_all_t packet;
          mavlink_msg_mission_clear_all_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            missionclear payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 46: {
          mavlink_mission_item_reached_t packet;
          mavlink_msg_mission_item_reached_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            mission_item_reached payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.seq, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 47: {
          mavlink_mission_ack_t packet;
          mavlink_msg_mission_ack_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            missionack payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_system, packet.target_component,
            packet.type, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 48: {
          mavlink_set_gps_global_origin_t packet;
          mavlink_msg_set_gps_global_origin_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            set_gps_global_origin payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.latitude, packet.longitude, packet.altitude,
            packet.target_system, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 49: {
          mavlink_gps_global_origin_t packet;
          mavlink_msg_gps_global_origin_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gps_global_ori payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.latitude, packet.longitude, packet.altitude, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 50: {
          mavlink_param_map_rc_t packet;
          mavlink_msg_param_map_rc_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            param_map_rc payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.param_value0, packet.scale, packet.param_value_min,
            packet.param_value_max, packet.param_index, packet.target_system, packet.target_component,
            {packet.param_id}, packet.parameter_rc_channel_index, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 51: {
          mavlink_mission_request_int_t packet;
          mavlink_msg_mission_request_int_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            missionreqint payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.seq, packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 54: {
          mavlink_safety_set_allowed_area_t packet;
          mavlink_msg_safety_set_allowed_area_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            safety_set_allowed_area payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.p1x, packet.p1y, packet.p1z, packet.p2x, packet.p2y,
            packet.p2z, packet.target_system, packet.target_component, packet.frame, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 55: {
          mavlink_safety_allowed_area_t packet;
          mavlink_msg_safety_allowed_area_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            safety_allowed_area payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.p1x, packet.p1y, packet.p1z, packet.p2x,
            packet.p2y, packet.p2z, packet.frame, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 61: {
          mavlink_attitude_quaternion_cov_t packet;
          mavlink_msg_attitude_quaternion_cov_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            attitude_quaternion_cov payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, {packet.q}, packet.rollspeed, packet.pitchspeed,
            packet.yawspeed, {packet.covariance}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 62: {
          mavlink_nav_controller_output_t packet;
          mavlink_msg_nav_controller_output_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            navcontrol_output payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.nav_roll, packet.nav_pitch, packet.alt_error,
            packet.aspd_error, packet.xtrack_error, packet.nav_bearing, packet.target_bearing,
            packet.wp_dist, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 63: {
          mavlink_global_position_int_cov_t packet;
          mavlink_msg_global_position_int_cov_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gpsint_cov payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.lat, packet.lon, packet.alt,
            packet.relative_alt, packet.vx, packet.vy, packet.vz, {packet.covariance},
            packet.estimator_type, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 64: {
          mavlink_local_position_ned_cov_t packet;
          mavlink_msg_local_position_ned_cov_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            locposned_cov payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.x, packet.y, packet.z,
            packet.vx, packet.vy, packet.vz, packet.ax, packet.ay, packet.az,
            {packet.covariance}, packet.estimator_type, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 65: {
          mavlink_rc_channels_t packet;
          mavlink_msg_rc_channels_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            rcchs payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.chan1_raw, packet.chan2_raw, packet.chan3_raw,
            packet.chan4_raw, packet.chan5_raw, packet.chan6_raw, packet.chan7_raw,
            packet.chan8_raw, packet.chan9_raw, packet.chan10_raw, packet.chan11_raw,
            packet.chan12_raw, packet.chan13_raw, packet.chan14_raw, packet.chan15_raw,
            packet.chan16_raw, packet.chan17_raw, packet.chan18_raw, packet.chancount,
            packet.rssi, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 66: {
          mavlink_request_data_stream_t packet;
          mavlink_msg_request_data_stream_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            reqdata_stream payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.req_message_rate, packet.target_system,
            packet.target_component, packet.req_stream_id, packet.start_stop, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 67: {
          mavlink_data_stream_t packet;
          mavlink_msg_data_stream_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            data_stream payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.message_rate, packet.stream_id, packet.on_off, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 69: {
          mavlink_manual_control_t packet;
          mavlink_msg_manual_control_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            manctrl payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.x, packet.y, packet.z, packet.buttons,
            packet.target, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 70: {
          mavlink_rc_channels_override_t packet;
          mavlink_msg_rc_channels_override_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            rcchs_override payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.chan1_raw, packet.chan2_raw, packet.chan3_raw,
            packet.chan4_raw, packet.chan5_raw, packet.chan6_raw, packet.chan7_raw,
            packet.chan8_raw, packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 73: {
          mavlink_mission_item_int_t packet;
          mavlink_msg_mission_item_int_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            missionitem_int payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.param1, packet.param2, packet.param3,
            packet.param4, packet.x, packet.y, packet.z, packet.seq, packet.command,
            packet.target_system, packet.target_component, packet.frame,
            packet.current, packet.autocontinue, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 74: {
          mavlink_vfr_hud_t packet;
          mavlink_msg_vfr_hud_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            vfrhud payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.airspeed, packet.groundspeed, packet.alt,
            packet.climb, packet.heading, packet.throttle, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 75: {
          mavlink_command_int_t packet;
          mavlink_msg_command_int_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            cmdint payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.param1, packet.param2, packet.param3,
            packet.param4, packet.x, packet.y, packet.z, packet.command,
            packet.target_system, packet.target_component, packet.frame, packet.current,
            packet.autocontinue, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 76: {
          mavlink_command_long_t packet;
          mavlink_msg_command_long_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            cmdlong payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.param1, packet.param2, packet.param3,
            packet.param4, packet.param5, packet.param6, packet.param7, packet.command,
            packet.target_system, packet.target_component, packet.confirmation, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 77: {
          mavlink_command_ack_t packet;
          mavlink_msg_command_ack_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            cmdack payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.command, packet.result, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 80: {
          mavlink_command_cancel_t packet;
          mavlink_msg_command_cancel_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            cmdcancel payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.command, packet.target_system,
            packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 81: {
          mavlink_manual_setpoint_t packet;
          mavlink_msg_manual_setpoint_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            manual_setpoint payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.roll, packet.pitch,
            packet.yaw, packet.thrust, packet.mode_switch, packet.manual_override_switch,
            msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 82: {
          mavlink_set_attitude_target_t packet;
          mavlink_msg_set_attitude_target_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            set_attitude_target payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, {packet.q}, packet.body_roll_rate,
            packet.body_pitch_rate, packet.body_yaw_rate, packet.thrust,
            packet.target_system, packet.target_component, packet.type_mask, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 83: {
          mavlink_attitude_target_t packet;
          mavlink_msg_attitude_target_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            attitude_target payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, {packet.q}, packet.body_roll_rate,
            packet.body_pitch_rate, packet.body_yaw_rate, packet.thrust,
            packet.type_mask, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 84: {
          mavlink_set_position_target_local_ned_t packet;
          mavlink_msg_set_position_target_local_ned_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            set_position_target_local_ned payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.x, packet.y, packet.z,
            packet.vx, packet.vy, packet.vz, packet.afx, packet.afy, packet.afz,
            packet.yaw, packet.yaw_rate, packet.type_mask, packet.target_system,
            packet.target_component, packet.coordinate_frame, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 85: {
          mavlink_position_target_local_ned_t packet;
          mavlink_msg_position_target_local_ned_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            position_target_local_ned payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.x, packet.y, packet.z,
            packet.vx, packet.vy, packet.vz, packet.afx, packet.afy, packet.afz, packet.yaw,
            packet.yaw_rate, packet.type_mask, packet.coordinate_frame, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 86: {
          mavlink_set_position_target_global_int_t packet;
          mavlink_msg_set_position_target_global_int_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            set_position_target_global_int payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.lat_int, packet.lon_int,
            packet.alt, packet.vx, packet.vy, packet.vz, packet.afx, packet.afy,
            packet.afz, packet.yaw, packet.yaw_rate, packet.type_mask,
            packet.target_system, packet.target_component, packet.coordinate_frame, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 87: {
          mavlink_position_target_global_int_t packet;
          mavlink_msg_position_target_global_int_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            position_target_global_int payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.lat_int, packet.lon_int,
            packet.alt, packet.vx, packet.vy, packet.vz, packet.afx, packet.afy,
            packet.afz, packet.yaw, packet.yaw_rate, packet.type_mask,
            packet.coordinate_frame, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 89: {
          mavlink_local_position_ned_system_global_offset_t packet;
          mavlink_msg_local_position_ned_system_global_offset_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            local_position_ned_system_global_offset payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.x, packet.y, packet.z,
            packet.roll, packet.pitch, packet.yaw, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 90: {
          mavlink_hil_state_t packet;
          mavlink_msg_hil_state_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            hilstate payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.roll, packet.pitch, packet.yaw,
            packet.rollspeed, packet.pitchspeed, packet.yawspeed, packet.lat, packet.lon,
            packet.alt, packet.vx, packet.vy, packet.vz, packet.xacc, packet.yacc,
            packet.zacc, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 91: {
          mavlink_hil_controls_t packet;
          mavlink_msg_hil_controls_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            hilctrl payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.roll_ailerons,
            packet.pitch_elevator, packet.yaw_rudder, packet.throttle, packet.aux1,
            packet.aux2, packet.aux3, packet.aux4, packet.mode, packet.nav_mode, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 92: {
          mavlink_hil_rc_inputs_raw_t packet;
          mavlink_msg_hil_rc_inputs_raw_decode(&msg, &packet);(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            hilrcinraw payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.chan1_raw, packet.chan2_raw,
            packet.chan3_raw, packet.chan4_raw, packet.chan5_raw, packet.chan6_raw,
            packet.chan7_raw, packet.chan8_raw, packet.chan9_raw, packet.chan10_raw,
            packet.chan11_raw, packet.chan12_raw, packet.rssi, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 93: {
          mavlink_hil_actuator_controls_t packet;
          mavlink_msg_hil_actuator_controls_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            hilact_ctrl payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.flags, {packet.controls},
            packet.mode, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 100: {
          mavlink_optical_flow_t packet;
          mavlink_msg_optical_flow_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            opticflow payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.flow_comp_m_x,
            packet.flow_comp_m_y, packet.ground_distance, packet.flow_x, packet.flow_y,
            packet.sensor_id, packet.quality, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 101: {
          mavlink_global_vision_position_estimate_t packet;
          mavlink_msg_global_vision_position_estimate_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            global_vision_position_estimate payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.usec, packet.x, packet.y, packet.z, packet.roll,
            packet.pitch, packet.yaw, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 102: {
          mavlink_vision_position_estimate_t packet;
          mavlink_msg_vision_position_estimate_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            vision_position_estimate payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.usec, packet.x, packet.y, packet.z, packet.roll,
            packet.pitch, packet.yaw, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 103: {
          mavlink_vision_speed_estimate_t packet;
          mavlink_msg_vision_speed_estimate_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            visspd_estim payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.usec, packet.x, packet.y, packet.z, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 104: {
          mavlink_vicon_position_estimate_t packet;
          mavlink_msg_vicon_position_estimate_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            viconpos_estim payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.usec, packet.x, packet.y, packet.z, packet.roll,
            packet.pitch, packet.yaw, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 105: {
          mavlink_highres_imu_t packet;
          mavlink_msg_highres_imu_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            highres_imu payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.xacc, packet.yacc, packet.zacc,
            packet.xgyro, packet.ygyro, packet.zgyro, packet.xmag, packet.ymag, packet.zmag,
            packet.abs_pressure, packet.diff_pressure, packet.pressure_alt, packet.temperature,
            packet.fields_updated, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 106: {
          mavlink_optical_flow_rad_t packet;
          mavlink_msg_optical_flow_rad_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            opticflowrad payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.integration_time_us,
            packet.integrated_x, packet.integrated_y, packet.integrated_xgyro,
            packet.integrated_ygyro, packet.integrated_zgyro,
            packet.time_delta_distance_us, packet.distance, packet.temperature,
            packet.sensor_id, packet.quality, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 107: {
          mavlink_hil_sensor_t packet;
          mavlink_msg_hil_sensor_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            hilsens payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.xacc, packet.yacc, packet.zacc,
            packet.xgyro, packet.ygyro, packet.zgyro, packet.xmag, packet.ymag, packet.zmag,
            packet.abs_pressure, packet.diff_pressure, packet.pressure_alt, packet.temperature,
            packet.fields_updated, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 108: {
          mavlink_sim_state_t packet;
          mavlink_msg_sim_state_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            sim_state payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.q1, packet.q2, packet.q3, packet.q4, packet.roll,
            packet.pitch, packet.yaw, packet.xacc, packet.yacc, packet.zacc, packet.xgyro,
            packet.ygyro, packet.zgyro, packet.lat, packet.lon, packet.alt, packet.std_dev_horz,
            packet.std_dev_vert, packet.vn, packet.ve, packet.vd, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 109: {
          mavlink_radio_status_t packet;
          mavlink_msg_radio_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            radio_status payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.rxerrors, packet.fixed, packet.rssi, packet.remrssi,
            packet.txbuf, packet.noise, packet.remnoise, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 110: {
          mavlink_file_transfer_protocol_t packet;
          mavlink_msg_file_transfer_protocol_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            FTP payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_network, packet.target_system,
            packet.target_component, {packet.payload}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 111: {
          mavlink_timesync_t packet;
          mavlink_msg_timesync_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            timesync payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.tc1, packet.ts1, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 112: {
          mavlink_camera_trigger_t packet;
          mavlink_msg_camera_trigger_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            camtrigg payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.seq, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 113: {
          mavlink_hil_gps_t packet;
          mavlink_msg_hil_gps_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            hilgps payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.lat, packet.lon, packet.alt,
            packet.eph, packet.epv, packet.vel, packet.vn, packet.ve, packet.vd,
            packet.cog, packet.fix_type, packet.satellites_visible, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 114: {
          mavlink_hil_optical_flow_t packet;
          mavlink_msg_hil_optical_flow_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            hilopticflow payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.integration_time_us,
            packet.integrated_x, packet.integrated_y, packet.integrated_xgyro,
            packet.integrated_ygyro, packet.integrated_zgyro, packet.time_delta_distance_us,
            packet.distance, packet.temperature, packet.sensor_id, packet.quality, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 115: {
          mavlink_hil_state_quaternion_t packet;
          mavlink_msg_hil_state_quaternion_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            hil_state_quaternion payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, {packet.attitude_quaternion},
            packet.rollspeed, packet.pitchspeed, packet.yawspeed, packet.lat,
            packet.lon, packet.alt, packet.vx, packet.vy, packet.vz, packet.ind_airspeed,
            packet.true_airspeed, packet.xacc, packet.yacc, packet.zacc, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 116: {
          mavlink_scaled_imu2_t packet;
          mavlink_msg_scaled_imu2_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            scaleimu2 payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.xacc, packet.yacc, packet.zacc,
            packet.xgyro, packet.ygyro, packet.zgyro, packet.xmag, packet.ymag, packet.zmag,
            msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 117: {
          mavlink_log_request_list_t packet;
          mavlink_msg_log_request_list_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            logreqlist payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.start, packet.end, packet.target_system,
            packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 118: {
          mavlink_log_entry_t packet;
          mavlink_msg_log_entry_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            logentry payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_utc, packet.size, packet.id, packet.num_logs,
            packet.last_log_num, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 119: {
          mavlink_log_request_data_t packet;
          mavlink_msg_log_request_data_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            logreqdata payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.ofs, packet.count, packet.id,
            packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 120: {
          mavlink_log_data_t packet;
          mavlink_msg_log_data_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            logdata payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.ofs, packet.id, packet.count, {packet.data}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 121: {
          mavlink_log_erase_t packet;
          mavlink_msg_log_erase_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            logerase payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 122: {
          mavlink_log_request_end_t packet;
          mavlink_msg_log_request_end_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            logreqend payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 123: {
          mavlink_gps_inject_data_t packet;
          mavlink_msg_gps_inject_data_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gps_inject_data payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.target_system, packet.target_component,
            packet.len, {packet.data}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 124: {
          mavlink_gps2_raw_t packet;
          mavlink_msg_gps2_raw_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gps2raw payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.lat, packet.lon, packet.alt,
            packet.dgps_age, packet.eph, packet.epv, packet.vel, packet.cog,
            packet.fix_type, packet.satellites_visible, packet.dgps_numch, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 125: {
          mavlink_power_status_t packet;
          mavlink_msg_power_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            powerstat payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.Vcc, packet.Vservo, packet.flags, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 126: {
          mavlink_serial_control_t packet;
          mavlink_msg_serial_control_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            serctrl payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.baudrate, packet.timeout, packet.device, packet.flags,
            packet.count, {packet.data}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 127: {
          mavlink_gps_rtk_t packet;
          mavlink_msg_gps_rtk_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gpsrtk payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_last_baseline_ms, packet.tow,
            packet.baseline_a_mm, packet.baseline_b_mm, packet.baseline_c_mm,
            packet.accuracy, packet.iar_num_hypotheses, packet.wn,
            packet.rtk_receiver_id, packet.rtk_health, packet.rtk_rate, packet.nsats,
            packet.baseline_coords_type, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 128: {
          mavlink_gps2_rtk_t packet;
          mavlink_msg_gps2_rtk_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gps2rtk payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_last_baseline_ms, packet.tow,
            packet.baseline_a_mm, packet.baseline_b_mm, packet.baseline_c_mm,
            packet.accuracy, packet.iar_num_hypotheses, packet.wn,
            packet.rtk_receiver_id, packet.rtk_health, packet.rtk_rate,
            packet.nsats, packet.baseline_coords_type, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 129: {
          mavlink_scaled_imu3_t packet;
          mavlink_msg_scaled_imu3_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            scaleimu3 payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.xacc, packet.yacc, packet.zacc,
            packet.xgyro, packet.ygyro, packet.zgyro, packet.xmag, packet.ymag,
            packet.zmag, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 130: {
          mavlink_data_transmission_handshake_t packet;
          mavlink_msg_data_transmission_handshake_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            data_transmission_handshake payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.size, packet.width, packet.height, packet.packets,
            packet.type, packet.payload, packet.jpg_quality, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 131: {
          mavlink_encapsulated_data_t packet;
          mavlink_msg_encapsulated_data_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            encapsdata payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.seqnr, {packet.data}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 132: {
          mavlink_distance_sensor_t packet;
          mavlink_msg_distance_sensor_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            distance_sens payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.min_distance,
            packet.max_distance, packet.current_distance, packet.type, packet.id,
            packet.orientation, packet.covariance, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 133: {
          mavlink_terrain_request_t packet;
          mavlink_msg_terrain_request_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            terrain_request payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.mask, packet.lat, packet.lon,
            packet.grid_spacing, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 134: {
          mavlink_terrain_data_t packet;
          mavlink_msg_terrain_data_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            terrain_dat payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.lat, packet.lon, packet.grid_spacing,
            {packet.data}, packet.gridbit, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 135: {
          mavlink_terrain_check_t packet;
          mavlink_msg_terrain_check_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            terrain_chk payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.lat, packet.lon, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 136: {
          mavlink_terrain_report_t packet;
          mavlink_msg_terrain_report_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            terrain_report payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.lat, packet.lon, packet.terrain_height,
            packet.current_height, packet.spacing, packet.pending, packet.loaded, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 137: {
          mavlink_scaled_pressure2_t packet;
          mavlink_msg_scaled_pressure2_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            scalepres2 payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.press_abs, packet.press_diff,
            packet.temperature, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 138: {
          mavlink_att_pos_mocap_t packet;
          mavlink_msg_att_pos_mocap_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            att_pos_mocap payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, {packet.q}, packet.x,
            packet.y, packet.z, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 139: {
          mavlink_set_actuator_control_target_t packet;
          mavlink_msg_set_actuator_control_target_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            set_actuator_control_target payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, {packet.controls}, packet.group_mlx,
            packet.target_system, packet.target_component, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 140: {
          mavlink_actuator_control_target_t packet;
          mavlink_msg_actuator_control_target_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            actuator_control_target payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, {packet.controls}, packet.group_mlx, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 141: {
          mavlink_altitude_t packet;
          mavlink_msg_altitude_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            alt payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.altitude_monotonic,
            packet.altitude_amsl, packet.altitude_local, packet.altitude_relative,
            packet.altitude_terrain, packet.bottom_clearance, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));

        }break;

        case 142: {
          mavlink_resource_request_t packet;
          mavlink_msg_resource_request_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            rscreq payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.request_id, packet.uri_type, {packet.uri},
            packet.transfer_type, {packet.storage}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 143: {
          mavlink_scaled_pressure3_t packet;
          mavlink_msg_scaled_pressure3_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            scalepress3 payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.press_abs,
            packet.press_diff, packet.temperature, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 144: {
          mavlink_follow_target_t packet;
          mavlink_msg_follow_target_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            fol_target payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.timestamp, packet.custom_state, packet.lat,
            packet.lon, packet.alt, {packet.vel}, {packet.acc}, {packet.attitude_q}, {packet.rates},
            {packet.position_cov}, packet.est_capabilities, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 146: {
          mavlink_control_system_state_t packet;
          mavlink_msg_control_system_state_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            ctrlsys_state payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.x_acc, packet.y_acc,
            packet.z_acc, packet.x_vel, packet.y_vel, packet.z_vel, packet.x_pos,
            packet.y_pos, packet.z_pos, packet.airspeed, {packet.vel_variance},
            {packet.pos_variance}, {packet.q}, packet.roll_rate, packet.pitch_rate,
            packet.yaw_rate, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 147: {
          mavlink_battery_status_t packet;
          mavlink_msg_battery_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            battstat payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.current_consumed, packet.energy_consumed,
            packet.temperature, {packet.voltages}, packet.current_battery, packet.id,
            packet.battery_function, packet.type, packet.battery_remaining, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 148: {
          mavlink_autopilot_version_t packet;
          mavlink_msg_autopilot_version_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            autopilotver payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.capabilities, packet.uid, packet.flight_sw_version,
            packet.middleware_sw_version, packet.os_sw_version, packet.board_version,
            packet.vendor_id, packet.product_id, {packet.flight_custom_version},
            {packet.middleware_custom_version}, {packet.os_custom_version}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 149: {
          mavlink_landing_target_t packet;
          mavlink_msg_landing_target_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            ldg_target payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.angle_x, packet.angle_y,
            packet.distance, packet.size_x, packet.size_y, packet.target_num,
            packet.frame, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 162: {
          mavlink_fence_status_t packet;
          mavlink_msg_fence_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            fencestat payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.breach_time, packet.breach_count, packet.breach_status,
            packet.breach_type, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 192: {
          mavlink_mag_cal_report_t packet;
          mavlink_msg_mag_cal_report_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            mag_cal_report payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.fitness, packet.ofs_x, packet.ofs_y,
            packet.ofs_z, packet.diag_x, packet.diag_y, packet.diag_z, packet.offdiag_x,
            packet.offdiag_y, packet.offdiag_z, packet.compass_id, packet.cal_mask,
            packet.cal_status, packet.autosaved, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 225: {
          mavlink_efi_status_t packet;
          mavlink_msg_efi_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            efistat payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.ecu_index, packet.rpm, packet.fuel_consumed,
            packet.fuel_flow, packet.engine_load, packet.throttle_position,
            packet.spark_dwell_time, packet.barometric_pressure, packet.intake_manifold_pressure,
            packet.intake_manifold_temperature, packet.cylinder_head_temperature,
            packet.ignition_timing, packet.injection_time, packet.exhaust_gas_temperature,
            packet.throttle_out, packet.pt_compensation, packet.health, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 230: {
          mavlink_estimator_status_t packet;
          mavlink_msg_estimator_status_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            estimstat payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.vel_ratio,
            packet.pos_horiz_ratio, packet.pos_vert_ratio, packet.mag_ratio,
            packet.hagl_ratio, packet.tas_ratio, packet.pos_horiz_accuracy,
            packet.pos_vert_accuracy, packet.flags, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 231: {
          mavlink_wind_cov_t packet;
          mavlink_msg_wind_cov_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            windcov payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.wind_x, packet.wind_y,
            packet.wind_z, packet.var_horiz, packet.var_vert, packet.wind_alt,
            packet.horiz_accuracy, packet.vert_accuracy, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 232: {
          mavlink_gps_input_t packet;
          mavlink_msg_gps_input_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gpsin payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.time_week_ms, packet.lat,
            packet.lon, packet.alt, packet.hdop, packet.vdop, packet.vn, packet.ve,
            packet.vd, packet.speed_accuracy, packet.horiz_accuracy, packet.vert_accuracy,
            packet.ignore_flags, packet.time_week, packet.gps_id, packet.fix_type,
            packet.satellites_visible, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 233: {
          mavlink_gps_rtcm_data_t packet;
          mavlink_msg_gps_rtcm_data_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            gps_rtcm_data payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.flags, packet.len, {packet.data}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 234: {
          mavlink_high_latency_t packet;
          mavlink_msg_high_latency_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            highlaten payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.custom_mode, packet.latitude, packet.longitude,
            packet.roll, packet.pitch, packet.heading, packet.heading_sp,
            packet.altitude_amsl, packet.altitude_sp, packet.wp_distance, packet.base_mode,
            packet.landed_state, packet.throttle, packet.airspeed, packet.airspeed_sp,
            packet.groundspeed, packet.climb_rate, packet.gps_nsat, packet.gps_fix_type,
            packet.battery_remaining, packet.temperature, packet.temperature_air,
            packet.failsafe, packet.wp_num, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 235: {
          mavlink_high_latency2_t packet;
          mavlink_msg_high_latency2_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            highlaten2 payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.timestamp, packet.latitude, packet.longitude,
            packet.custom_mode, packet.altitude, packet.target_altitude, packet.target_distance,
            packet.wp_num, packet.failure_flags, packet.type, packet.autopilot, packet.heading,
            packet.target_heading, packet.throttle, packet.airspeed, packet.airspeed_sp,
            packet.groundspeed, packet.windspeed, packet.wind_heading, packet.eph,
            packet.epv, packet.temperature_air, packet.climb_rate, packet.battery, packet.custom0,
            packet.custom1, packet.custom2, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 241: {
          mavlink_vibration_t packet;
          mavlink_msg_vibration_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            vibrat payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.vibration_x,
            packet.vibration_y, packet.vibration_z, packet.clipping_0, packet.clipping_1,
            packet.clipping_2, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 242: {
          mavlink_home_position_t packet;
          mavlink_msg_home_position_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            homepos payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.latitude, packet.longitude, packet.altitude,
            packet.x, packet.y, packet.z, {packet.q}, packet.approach_x,
            packet.approach_y, packet.approach_z, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 243: {
          mavlink_set_home_position_t packet;
          mavlink_msg_set_home_position_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            sethome_pos payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.latitude, packet.longitude, packet.altitude,
            packet.x, packet.y, packet.z, {packet.q}, packet.approach_x, packet.approach_y,
            packet.approach_z, packet.target_system, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 244: {
          mavlink_message_interval_t packet;
          mavlink_msg_message_interval_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            message_interval payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.interval_us, packet.message_id, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 245: {
          mavlink_extended_sys_state_t packet;
          mavlink_msg_extended_sys_state_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            extended_sys_state payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.vtol_state, packet.landed_state, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 246: {
          mavlink_adsb_vehicle_t packet;
          mavlink_msg_adsb_vehicle_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            adsb_vehicle payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.ICAO_address, packet.lat, packet.lon,
            packet.altitude, packet.heading, packet.hor_velocity, packet.ver_velocity, packet.flags,
            packet.squawk, packet.altitude_type, {packet.callsign}, packet.emitter_type,
            packet.tslc, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 247: {
          mavlink_collision_t packet;
          mavlink_msg_collision_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            collision payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.id, packet.time_to_minimum_delta,
            packet.altitude_minimum_delta, packet.horizontal_minimum_delta, packet.src,
            packet.action, packet.threat_level, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 248: {
          mavlink_v2_extension_t packet;
          mavlink_msg_v2_extension_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            v2ext payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.message_type, packet.target_network,
            packet.target_system, packet.target_component, {packet.payload}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 249: {
          mavlink_memory_vect_t packet;
          mavlink_msg_memory_vect_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            mem_vect payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.address, packet.ver, packet.type, {packet.value}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 250: {
          mavlink_debug_vect_t packet;
          mavlink_msg_debug_vect_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            debug_vect payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_usec, packet.x, packet.y, packet.z,
            {packet.name}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 251: {
          mavlink_named_value_float_t packet;
          mavlink_msg_named_value_float_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            namedval_float payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.value, {packet.name}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 252: {
          mavlink_named_value_int_t packet;
          mavlink_msg_named_value_int_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            namedval_int payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.value, {packet.name}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 253: {
          mavlink_statustext_t packet;
          mavlink_msg_statustext_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            statustext payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.severity, {packet.text}, msg.checksum};

          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        case 254: {
          mavlink_debug_t packet;
          mavlink_msg_debug_decode(&msg, &packet);
          received_sysid = msg.sysid;
          received_compid = msg.compid;
          received_msgid = msg.msgid;

          struct combine {
            header head_data;
            debugging payload_data;
          }__attribute__((packed)); struct combine merge;

          merge.head_data = {msg.magic, msg.len, msg.seq, received_sysid, received_compid, received_msgid};
          merge.payload_data = {packet.time_boot_ms, packet.value, packet.ind, msg.checksum};


          //sizeMerge = sizeof(merge); payloadSize = sizeof(merge.payload_data);
          char _data[sizeof(merge)];
          memcpy(_data, &merge, sizeof(merge));
          encryption_start(_data, sizeof(merge), sizeof(merge.payload_data));
        }break;

        default: {
          if ((Serial2.available()) && c == 0xFE) {
            uint8_t len = Serial2.read();
            /* +6 for stx, len, seq, sysid, compid, msgid;
            len for total payload;
            +2 for cksum */
            char mav[6+len+2];
            mav[0] = c;
            mav[1] = len;

            for (int x = 2; x < sizeof(mav); x++) {
              if (Serial2.available()) {
                mav[x] = Serial2.read();
              }
            }
            encryption_start(mav, sizeof(mav), len+2);
          }
        }break;
      }
    }
  }
}