diff --git a/companion/src/firmwares/edgetx/yaml_modeldata.cpp b/companion/src/firmwares/edgetx/yaml_modeldata.cpp
index cf8348129..61a4f077d 100644
--- a/companion/src/firmwares/edgetx/yaml_modeldata.cpp
+++ b/companion/src/firmwares/edgetx/yaml_modeldata.cpp
@@ -47,6 +47,17 @@ static const YamlLookupTable trainerModeLut = {
   {  TRAINER_MODE_MULTI, "MASTER_MULTI"  },
 };
 
+struct YamlTrim {
+  int mode = 0;
+  int ref = 0;
+  int value = 0;
+
+  YamlTrim() = default;
+  YamlTrim(int mode, int ref, int value):
+    mode(mode), ref(ref), value(value)
+  {}
+};
+
 namespace YAML
 {
 Node convert<TimerData>::encode(const TimerData& rhs)
@@ -110,6 +121,72 @@ struct convert<LimitData> {
   }
 };
 
+template <>
+struct convert<YamlTrim> {
+  static Node encode(const YamlTrim& rhs)
+  {
+    Node node;
+    node["value"] = rhs.value;
+    if (rhs.mode < 0) {
+      node["mode"] = -1;
+    } else {
+      node["mode"] = 2 * rhs.ref + rhs.mode;
+    }
+    return node;
+  }
+  static bool decode(const Node& node, YamlTrim& rhs)
+  {
+    node["value"] >> rhs.value;
+
+    int trimMode = 0;
+    node["mode"] >> trimMode;
+    if (trimMode < 0) {
+      rhs.mode = trimMode;
+    } else {
+      rhs.mode = trimMode % 2;
+      rhs.ref = trimMode / 2;
+    }
+    return true;
+  }
+};
+  
+template <>
+struct convert<FlightModeData> {
+  static Node encode(const FlightModeData& rhs)
+  {
+    Node node;
+    // TODO: use max number of trims for radio instead
+    YamlTrim yt[CPN_MAX_TRIMS];
+    for (int i=0; i<CPN_MAX_TRIMS; i++) {
+      yt[i] = { rhs.trimMode[i], rhs.trimRef[i], rhs.trim[i] };
+    }
+    node["trim"] = convert_array<YamlTrim,CPN_MAX_TRIMS>::encode(yt);
+    node["swtch"] = rhs.swtch;
+    node["name"] = rhs.name;
+    node["fadeIn"] = rhs.fadeIn;
+    node["fadeOut"] = rhs.fadeOut;
+    node["gvars"] = convert_array<int,CPN_MAX_GVARS>::encode(rhs.gvars);
+    return node;
+  }
+
+  static bool decode(const Node& node, FlightModeData& rhs)
+  {
+    YamlTrim trims[CPN_MAX_TRIMS];
+    node["trim"] >> trims;
+    for (size_t i=0; i<CPN_MAX_TRIMS; i++) {
+      rhs.trimMode[i] = trims[i].mode;
+      rhs.trimRef[i] = trims[i].ref;
+      rhs.trim[i] = trims[i].value;
+    }
+    node["swtch"] >> rhs.swtch;
+    node["name"] >> rhs.name;
+    node["fadeIn"] >> rhs.fadeIn;
+    node["fadeOut"] >> rhs.fadeOut;
+    node["gvars"] >> rhs.gvars;
+    return true;
+  }
+};
+
 Node convert<ModelData>::encode(const ModelData& rhs)
 {
   Node node;
@@ -133,22 +210,26 @@ Node convert<ModelData>::encode(const ModelData& rhs)
   node["extendedTrims"] = (int)rhs.extendedTrims;
   node["throttleReversed"] = (int)rhs.throttleReversed;
 
-  // flightModeData[]
-
-  for (int i=0; i<CPN_MAX_MIXERS; i++) {
-      const MixData& mix = rhs.mixData[i];
-      if (!mix.isEmpty()) {
-          Node mixNode;
-          mixNode = rhs.mixData[i];
-          node["mixData"].push_back(mixNode);
-      }
+  for (int i = 0; i < CPN_MAX_FLIGHT_MODES; i++) {
+    Node fmNode;
+    fmNode = rhs.flightModeData[i];
+    node["flightModeData"].push_back(fmNode);
   }
 
-  for (int i=0; i<CPN_MAX_CHNOUT; i++) {
+  for (int i = 0; i < CPN_MAX_MIXERS; i++) {
+    const MixData& mix = rhs.mixData[i];
+    if (!mix.isEmpty()) {
+      Node mixNode;
+      mixNode = mix;
+      node["mixData"].push_back(mixNode);
+    }
+  }
+
+  for (int i = 0; i < CPN_MAX_CHNOUT; i++) {
     const LimitData& limit = rhs.limitData[i];
     if (!limit.isEmpty()) {
       Node limitNode;
-      limitNode = rhs.limitData[i];
+      limitNode = limit;
       node["limitData"].push_back(limitNode);
     }
   }
@@ -221,8 +302,7 @@ bool convert<ModelData>::decode(const Node& node, ModelData& rhs)
   node["extendedTrims"] >> rhs.extendedTrims;
   node["throttleReversed"] >> rhs.throttleReversed;
 
-  // flightModeData[]
-
+  node["flightModeData"] >> rhs.flightModeData;
   node["mixData"] >> rhs.mixData;
   node["limitData"] >> rhs.limitData;
 
diff --git a/companion/src/firmwares/edgetx/yaml_ops.h b/companion/src/firmwares/edgetx/yaml_ops.h
index 5597bba42..9e9f67967 100644
--- a/companion/src/firmwares/edgetx/yaml_ops.h
+++ b/companion/src/firmwares/edgetx/yaml_ops.h
@@ -99,11 +99,10 @@ void operator>>(const YAML::Node& node, T (&value)[N])
     for (const auto& elmt : node) {
       try {
         int idx = std::stoi(elmt.first.Scalar());
-        if (idx < 0 || idx >= N) return;  // false;
+        if (idx < 0 || idx >= N) return;
 
         elmt.second >> value[idx];
       } catch (...) {
-        // return false;
         return;
       }
     }
@@ -121,6 +120,21 @@ namespace YAML {
 std::string LookupValue(const YamlLookupTable& lut, const int& value);
 Node operator << (const YamlLookupTable& lut, const int& value);
 
+template <typename T, size_t N>
+struct convert_array
+{
+  static YAML::Node encode(const T (&rhs)[N])
+  {
+    Node node;
+    for (size_t i=0; i<N; i++) {
+      Node elmt;
+      elmt = rhs[i];
+      node.push_back(elmt);
+    }
+    return node;
+  }
+};
+  
 template <typename T>
 struct convert_enum
 {
diff --git a/companion/src/firmwares/edgetx/yaml_rawsource.cpp b/companion/src/firmwares/edgetx/yaml_rawsource.cpp
index 0c459fbce..1b345d3a1 100644
--- a/companion/src/firmwares/edgetx/yaml_rawsource.cpp
+++ b/companion/src/firmwares/edgetx/yaml_rawsource.cpp
@@ -70,73 +70,76 @@ const YamlLookupTable specialSourceLut = {
 };
 
 namespace YAML {
-
 Node convert<RawSource>::encode(const RawSource& rhs)
 {
   std::string src_str;
-  switch(rhs.type) {
-  case SOURCE_TYPE_VIRTUAL_INPUT:
+  switch (rhs.type) {
+    case SOURCE_TYPE_VIRTUAL_INPUT:
       src_str += "I" + std::to_string(rhs.index);
       break;
-  case SOURCE_TYPE_LUA_OUTPUT:
+    case SOURCE_TYPE_LUA_OUTPUT:
       src_str += "lua(";
       src_str += std::to_string(rhs.index / 16);
       src_str += ",";
       src_str += std::to_string(rhs.index % 16);
       src_str += ")";
       break;
-  case SOURCE_TYPE_STICK:
+    case SOURCE_TYPE_STICK:
       src_str = LookupValue(analogSourceLut, rhs.index);
       break;
-  case SOURCE_TYPE_TRIM:
+    case SOURCE_TYPE_TRIM:
       src_str = LookupValue(trimSourceLut, rhs.index);
       break;
-  case SOURCE_TYPE_MAX:
+    case SOURCE_TYPE_MAX:
       src_str += "MAX";
       break;
-  case SOURCE_TYPE_SWITCH:
-      src_str += "S" + (rhs.index + 'A');
+    case SOURCE_TYPE_SWITCH:
+      src_str += "S";
+      src_str += (rhs.index + 'A');
       break;
-  case SOURCE_TYPE_CUSTOM_SWITCH:
+    case SOURCE_TYPE_CUSTOM_SWITCH:
       src_str += "ls(";
       src_str += std::to_string(rhs.index);
       src_str += ")";
       break;
-  case SOURCE_TYPE_CYC:
+    case SOURCE_TYPE_CYC:
       src_str = LookupValue(cycSourceLut, rhs.index);
       break;
-  case SOURCE_TYPE_PPM:
+    case SOURCE_TYPE_PPM:
       src_str += "tr(";
       src_str += std::to_string(rhs.index);
       src_str += ")";
       break;
-  case SOURCE_TYPE_CH:
+    case SOURCE_TYPE_CH:
       src_str += "ch(";
       src_str += std::to_string(rhs.index);
       src_str += ")";
       break;
-  case SOURCE_TYPE_GVAR:
+    case SOURCE_TYPE_GVAR:
       src_str += "gv(";
       src_str += std::to_string(rhs.index);
       src_str += ")";
       break;
-  case SOURCE_TYPE_SPECIAL:
+    case SOURCE_TYPE_SPECIAL:
       src_str = LookupValue(specialSourceLut, rhs.index);
       break;
-  case SOURCE_TYPE_TELEMETRY:
+    case SOURCE_TYPE_TELEMETRY:
       src_str = "tele(";
-      switch(rhs.index % 3) {
-      case 0:
+      switch (rhs.index % 3) {
+        case 0:
           break;
-      case 1:
+        case 1:
           src_str += '-';
           break;
-      case 2:
+        case 2:
           src_str += '+';
           break;
       }
       src_str += std::to_string(rhs.index / 3);
       break;
+    default:
+      src_str = "NONE";
+      break;
   }
 
   return Node(src_str);