diff --git a/companion/src/helpers_html.cpp b/companion/src/helpers_html.cpp
index 43605f574..9625b8818 100644
--- a/companion/src/helpers_html.cpp
+++ b/companion/src/helpers_html.cpp
@@ -20,32 +20,63 @@
 
 #include "helpers_html.h"
 
-QString tdAlign(const QString &s, const QString &align, const QString &color, bool bold)
+QString tdAlign(const QString & s, const QString & align, const QString & color, bool bold)
 {
   QString str = s;
   if (bold) str = "<b>" + str + "</b>";
-  if (!color.isEmpty()) str = "<font color=" + color + ">" + str + "</font>";
-  return "<td align=" + align + ">" + str + "</td>";
+  if (!color.isEmpty()) str = "<font color='" + color + "'>" + str + "</font>";
+  return "<td align='" + align + "'>" + str + "</td>";
 }
 
-QString doTC(const QString &s, const QString &color, bool bold)
+QString doTC(const QString & s, const QString & color, bool bold)
 {
   return tdAlign(s, "center", color, bold);
 }
 
-QString doTR(const QString &s, const QString &color, bool bold)
+QString doTR(const QString & s, const QString & color, bool bold)
 {
   return tdAlign(s, "right", color, bold);
 }
 
-QString doTL(const QString &s, const QString &color, bool bold)
+QString doTL(const QString & s, const QString & color, bool bold)
 {
   return tdAlign(s, "left", color, bold);
 }
 
-QString fv(const QString &name, const QString &value, const QString &color)
+QString fv(const QString & name, const QString & value, const QString & color)
 {
-  return "<b>" + name + ": </b><font color=" +color + ">" + value + "</font><br>";
+  return "<b>" + name + ": </b><font color='" + color + "'>" + value + "</font><br>";
 }
 
+QString doTableCell(const QString & s, const unsigned int width, const QString & align, const QString & color, bool bold)
+{
+  QString prfx = "<td";
+  if (width)
+    prfx.append(QString(" width='%1%'").arg(QString::number(width)));
+  if (!align.isEmpty())
+    prfx.append(QString(" align='%1'").arg(align));
+  prfx.append(">");
 
+  QString str = s;
+  if (bold)
+    str = "<b>" + str + "</b>";
+  if (!color.isEmpty())
+    str = QString("<font color='%1'>%2</font>").arg(color).arg(str);
+
+  str =  prfx + str + "</td>";
+  return str;
+}
+
+QString doTableRow(const QStringList & strl, const unsigned int width, const QString & align, const QString & color, bool bold)
+{
+  QString str;
+  for (int i=0; i<strl.count(); i++) {
+    str.append(doTableCell(strl.at(i), width, align, color, bold));
+  }
+  return "<tr>" + str + "</tr>";
+}
+
+QString doTableBlankRow()
+{
+  return "<tr></tr>";
+}
diff --git a/companion/src/helpers_html.h b/companion/src/helpers_html.h
index 06f171c4e..e126624e9 100644
--- a/companion/src/helpers_html.h
+++ b/companion/src/helpers_html.h
@@ -22,10 +22,15 @@
 #define _HELPERS_HTML_H_
 
 #include <QString>
+#include <QStringList>
 
-QString doTC(const QString &s, const QString &color="", bool bold=false);
-QString doTR(const QString &s, const QString &color="", bool bold=false);
-QString doTL(const QString &s, const QString &color="", bool bold=false);
-QString fv(const QString &name, const QString &value, const QString &color="green");
+QString tdAlign(const QString & s, const QString & align, const QString & color, bool bold);
+QString doTC(const QString & s, const QString & color = "", bool bold = false);
+QString doTR(const QString & s, const QString & color = "", bool bold = false);
+QString doTL(const QString & s, const QString & color = "", bool bold = false);
+QString fv(const QString & name, const QString & value, const QString & color = "green");
+QString doTableCell(const QString & s, const unsigned int width = 0, const QString & align = "", const QString & color = "", bool bold = false);
+QString doTableRow(const QStringList & strl, const unsigned int width = 0, const QString & align = "", const QString & color = "", bool bold = false);
+QString doTableBlankRow();
 
 #endif // _HELPERS_HTML_H_
diff --git a/companion/src/modelprinter.cpp b/companion/src/modelprinter.cpp
index 966cdebed..1b17d16df 100644
--- a/companion/src/modelprinter.cpp
+++ b/companion/src/modelprinter.cpp
@@ -22,12 +22,13 @@
 #include "modelprinter.h"
 #include "multiprotocols.h"
 #include "boards.h"
+#include "helpers_html.h"
+#include "multiprotocols.h"
 
 #include <QApplication>
 #include <QPainter>
 #include <QFile>
 #include <QUrl>
-#include "multiprotocols.h"
 
 QString changeColor(const QString & input, const QString & to, const QString & from)
 {
@@ -76,6 +77,25 @@ QString addFont(const QString & input, const QString & color, const QString & si
   return "<font " + sizeStr + " " + faceStr + " " + colorStr + ">" + input + "</font>";
 }
 
+QString ModelPrinter::printLabelValue(const QString & lbl, const QString & val, const bool sep) {
+  return QString("<b>%1:</b> %2%3 ").arg(lbl, val, (sep ? ";" : ""));
+}
+
+QString ModelPrinter::printLabelValues(const QString & lbl, const QStringList & vals, const bool sep) {
+  QString str;
+  if (vals.count() > 1)
+    str.append("(");
+  for (int i=0;i<vals.count();i++) {
+    str.append(vals.at(i));
+    if (i<(vals.count()-1))
+      str.append(", ");
+  }
+  if (vals.count() > 1)
+    str.append(")");
+
+  return printLabelValue(lbl, str, sep);
+}
+
 #define MASK_TIMEVALUE_HRSMINS 1
 #define MASK_TIMEVALUE_ZEROHRS 2
 #define MASK_TIMEVALUE_PADSIGN 3
@@ -245,48 +265,47 @@ QString ModelPrinter::printModule(int idx)
   QString result;
   ModuleData module = model.moduleData[(idx<0 ? CPN_MAX_MODULES : idx)];
   if (idx < 0) {
-    str += tr("Mode") + QString("(%1)").arg(printTrainerMode());
+    str << printLabelValue(tr("Mode"), printTrainerMode());
     if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
       if (model.trainerMode == TRAINER_SLAVE_JACK) {
-        str += tr("Channels") + QString("(%1-%2)").arg(module.channelsStart + 1).arg(module.channelsStart + module.channelsCount);
-        str += tr("Frame length") + QString("(%1ms)").arg(printPPMFrameLength(module.ppm.frameLength));
-        str += tr("PPM delay") + QString("(%1us)").arg(module.ppm.delay);
-        str += tr("Polarity") + QString("(%1)").arg(module.polarityToString());
+        str << printLabelValue(tr("Channels"), QString("%1-%2").arg(module.channelsStart + 1).arg(module.channelsStart + module.channelsCount));
+        str << printLabelValue(tr("Frame length"), QString("%1ms").arg(printPPMFrameLength(module.ppm.frameLength)));
+        str << printLabelValue(tr("PPM delay"), QString("%1us").arg(module.ppm.delay));
+        str << printLabelValue(tr("Polarity"), module.polarityToString());
       }
     }
-    result = str.join(", ");
+    result = str.join(" ");
   }
   else {
-    str += printModuleType(idx);
-    str += tr("Protocol") + QString("(%1)").arg(printModuleProtocol(module.protocol));
+    str << printLabelValue(tr("Protocol"), printModuleProtocol(module.protocol));
     if (module.protocol) {
-      str += tr("Channels") + QString("(%1-%2)").arg(module.channelsStart + 1).arg(module.channelsStart + module.channelsCount);
+      str << printLabelValue(tr("Channels"), QString("%1-%2").arg(module.channelsStart + 1).arg(module.channelsStart + module.channelsCount));
       if (module.protocol == PULSES_PPM || module.protocol == PULSES_SBUS) {
-        str += tr("Frame length") + QString("(%1ms)").arg(printPPMFrameLength(module.ppm.frameLength));
-        str += tr("Polarity") + QString("(%1)").arg(module.polarityToString());
+        str << printLabelValue(tr("Frame length"), QString("%1ms").arg(printPPMFrameLength(module.ppm.frameLength)));
+        str << printLabelValue(tr("Polarity"), module.polarityToString());
         if (module.protocol == PULSES_PPM)
-          str += tr("Delay") + QString("(%1us)").arg(module.ppm.delay);
+          str << printLabelValue(tr("Delay"), QString("%1us").arg(module.ppm.delay));
       }
       else {
         if (!(module.protocol == PULSES_PXX_XJT_D8 || module.protocol == PULSES_CROSSFIRE || module.protocol == PULSES_SBUS)) {
-          str += tr("Receiver") + QString("(%1)").arg(module.modelId);
+          str << printLabelValue(tr("Receiver"), QString::number(module.modelId));
         }
         if (module.protocol == PULSES_MULTIMODULE) {
-          str += tr("Radio protocol") + QString("(%1)").arg(printMultiRfProtocol(module.multi.rfProtocol, module.multi.customProto));
-          str += tr("Subtype") + QString("(%1)").arg(printMultiSubType(module.multi.rfProtocol, module.multi.customProto, module.subType));
-          str += tr("Option value") + QString("(%1)").arg(module.multi.optionValue);
+          str << printLabelValue(tr("Radio protocol"), printMultiRfProtocol(module.multi.rfProtocol, module.multi.customProto));
+          str << printLabelValue(tr("Subtype"), printMultiSubType(module.multi.rfProtocol, module.multi.customProto, module.subType));
+          str << printLabelValue(tr("Option value"), QString::number(module.multi.optionValue));
         }
         if (module.protocol == PULSES_PXX_R9M) {
-          str += tr("Sub Type") + QString("(%1)").arg(printModuleSubType(module.protocol, module.subType));
-          str += tr("RF Output Power") + QString("(%1)").arg(printR9MPowerValue(module.subType, module.pxx.power, module.pxx.sport_out));
-          str += tr("Telemetry") + QString("(%1)").arg(printBoolean(module.pxx.sport_out, BOOLEAN_ENABLEDISABLE));
+          str << printLabelValue(tr("Sub Type"), printModuleSubType(module.protocol, module.subType));
+          str << printLabelValue(tr("RF Output Power"), printR9MPowerValue(module.subType, module.pxx.power, module.pxx.sport_out));
+          str << printLabelValue(tr("Telemetry"), printBoolean(module.pxx.sport_out, BOOLEAN_ENABLEDISABLE));
         }
       }
     }
-    result = str.join(", ");
+    result = str.join(" ");
     if (((PulsesProtocol)module.protocol == PulsesProtocol::PULSES_PXX_XJT_X16 || (PulsesProtocol)module.protocol == PulsesProtocol::PULSES_PXX_R9M)
        && firmware->getCapability(HasFailsafe))
-      result.append(printFailsafe(idx));
+      result.append("<br/>" + printFailsafe(idx));
   }
   return result;
 }
@@ -369,7 +388,7 @@ QString ModelPrinter::printCenterBeep()
     if (model.beepANACenter & 0x40)
       strl << "P3";
   }
-  return (strl.isEmpty() ? tr("None") : strl.join(", "));
+  return (strl.isEmpty() ? tr("None") : strl.join(" "));
 }
 
 QString ModelPrinter::printTimer(int idx)
@@ -588,6 +607,27 @@ QString ModelPrinter::printFlightModes(unsigned int flightModes)
     return "";
 }
 
+QString ModelPrinter::printInputFlightModes(unsigned int flightModes)
+{
+  int numFlightModes = firmware->getCapability(FlightModes);
+  if (numFlightModes && flightModes) {
+    if (flightModes == (unsigned int)(1<<numFlightModes) - 1) {
+      return tr("None");
+    }
+    else {
+      QStringList list;
+      for (int i=0; i<numFlightModes; i++) {
+        if (!(flightModes & (1<<i))) {
+          list << printFlightModeName(i);
+        }
+      }
+      return QString("%1").arg(list.join(" "));
+    }
+  }
+  else
+    return tr("All");
+}
+
 QString ModelPrinter::printLogicalSwitchLine(int idx)
 {
   QString result = "";
@@ -875,13 +915,12 @@ QString ModelPrinter::printOutputSymetrical(int idx)
 QString ModelPrinter::printSettingsOther()
 {
   QStringList str;
-  if (model.extendedLimits)
-    str += tr("Extended Limits");
-  if (firmware->getCapability(HasDisplayText) && model.displayChecklist)
-    str += tr("Display Checklist");
-  if (firmware->getCapability(GlobalFunctions) && !model.noGlobalFunctions)
-    str += tr("Global Functions");
-  return str.join(", ");
+  str << printLabelValue(tr("Extended Limits"), printBoolean(model.extendedLimits, BOOLEAN_YESNO));
+  if (firmware->getCapability(HasDisplayText))
+    str << printLabelValue(tr("Display Checklist"), printBoolean(model.displayChecklist, BOOLEAN_YESNO));
+  if (firmware->getCapability(GlobalFunctions))
+    str << printLabelValue(tr("Global Functions"), printBoolean(!model.noGlobalFunctions, BOOLEAN_YESNO));
+  return str.join(" ");
 }
 
 QString ModelPrinter::printSwitchWarnings()
@@ -908,7 +947,7 @@ QString ModelPrinter::printSwitchWarnings()
       str += RawSwitch(SWITCH_TYPE_SWITCH, 1+idx*3+value).toString(board.getBoardType(), &generalSettings, &model);
     }
   }
-  return (str.isEmpty() ? tr("None") : str.join(", ")) ;
+  return (str.isEmpty() ? tr("None") : str.join(" ")) ;
 }
 
 QString ModelPrinter::printPotWarnings()
@@ -916,7 +955,6 @@ QString ModelPrinter::printPotWarnings()
   QStringList str;
   int genAryIdx = 0;
   Boards board = firmware->getBoard();
-  str += (model.potsWarningMode ? tr("Mode") + QString("(%1)").arg(printPotsWarningMode()) : tr("None"));
   if (model.potsWarningMode) {
     for (int i=0; i<board.getCapability(Board::Pots)+board.getCapability(Board::Sliders); i++) {
       RawSource src(SOURCE_TYPE_STICK, CPN_MAX_STICKS + i);
@@ -926,7 +964,8 @@ QString ModelPrinter::printPotWarnings()
       }
     }
   }
-  return str.join(", ");
+  str << printLabelValue(tr("Mode"), printPotsWarningMode());
+  return str.join(" ");
 }
 
 QString ModelPrinter::printPotsWarningMode()
@@ -947,13 +986,14 @@ QString ModelPrinter::printFailsafe(int idx)
 {
   QStringList strl;
   ModuleData module = model.moduleData[idx];
-  strl += "<br>" + tr("Failsafe Mode") + QString("(%1)").arg(printFailsafeMode(module.failsafeMode));
+  strl << printLabelValue(tr("Failsafe Mode"), printFailsafeMode(module.failsafeMode));
   if (module.failsafeMode == FAILSAFE_CUSTOM) {
     for (int i=0; i<module.channelsCount; i++) {
-      strl += QString("%1(%2)").arg(printChannelName(module.channelsStart + i).trimmed()).arg(printFailsafeValue(module.failsafeChannels[i]));
+      //strl << QString("%1(%2)").arg(printChannelName(module.channelsStart + i).trimmed()).arg(printFailsafeValue(module.failsafeChannels[i]));
+      strl << printLabelValue(printChannelName(module.channelsStart + i).trimmed(), printFailsafeValue(module.failsafeChannels[i]));
     }
   }
-  return strl.join(", ");
+  return strl.join(" ");
 }
 
 QString ModelPrinter::printFailsafeValue(int val)
@@ -1019,12 +1059,11 @@ QString ModelPrinter::printTimerPersistent(unsigned int persistent)
 QString ModelPrinter::printSettingsTrim()
 {
   QStringList str;
-  str += tr("Step") + QString("(%1)").arg(printTrimIncrementMode());
-  if (IS_ARM(firmware->getBoard()) && model.trimsDisplay)
-    str += tr("Display") + QString("(%1)").arg(printTrimsDisplayMode());
-  if (model.extendedTrims)
-    str += tr("Extended");
-  return str.join(", ");
+  str << printLabelValue(tr("Step"), printTrimIncrementMode());
+  if (IS_ARM(firmware->getBoard()))
+    str << printLabelValue(tr("Display"), printTrimsDisplayMode());
+  str << printLabelValue(tr("Extended"), printBoolean(model.extendedTrims, BOOLEAN_YESNO));
+  return str.join(" ");
 }
 
 QString ModelPrinter::printThrottleSource(int idx)
@@ -1049,7 +1088,7 @@ QString ModelPrinter::printTrimsDisplayMode()
     case 2:
       return tr("Always");
     default:
-      return tr("Unknown");
+      return tr("???");
   }
 }
 
@@ -1082,14 +1121,11 @@ QString ModelPrinter::printPxxPower(int power)
 QString ModelPrinter::printThrottle()
 {
   QStringList result;
-  result += tr("Source") + QString("(%1)").arg(printThrottleSource(model.thrTraceSrc));
-  if (model.thrTrim)
-    result += tr("Trim idle only");
-  if (!model.disableThrottleWarning)
-    result += tr("Warning");
-  if (model.throttleReversed)
-    result +=  tr("Reversed");
-  return result.join(", ");
+  result << printLabelValue(tr("Source"), printThrottleSource(model.thrTraceSrc));
+  result << printLabelValue(tr("Trim idle only"), printBoolean(model.thrTrim, BOOLEAN_YESNO));
+  result << printLabelValue(tr("Warning"), printBoolean(!model.disableThrottleWarning, BOOLEAN_YESNO));
+  result << printLabelValue(tr("Reversed"), printBoolean(model.throttleReversed, BOOLEAN_YESNO));
+  return result.join(" ");
 }
 
 QString ModelPrinter::printPPMFrameLength(int ppmFL)
@@ -1117,3 +1153,409 @@ QString ModelPrinter::printTimerMinuteBeep(bool mb)
 {
   return printBoolean(mb, BOOLEAN_YESNO);
 }
+
+QString ModelPrinter::printTelemetryProtocol(unsigned int val)
+{
+  switch (val) {
+    case 0:
+      return tr("FrSky S.PORT");
+    case 1:
+      return tr("FrSky D");
+    case 2:
+      return tr("FrSky D (cable)");
+    default:
+      return tr("???");
+  }
+}
+
+QString ModelPrinter::printRssiAlarmsDisabled(bool mb)
+{
+  return printBoolean(!mb, BOOLEAN_ENABLEDISABLE);
+}
+
+QString ModelPrinter::printTelemetrySource(int val)
+{
+  QStringList strings = QStringList() << tr("None");
+
+  for (int i=1; i<=CPN_MAX_SENSORS; ++i) {
+    strings << QString("%1").arg(model.sensorData[i-1].label);
+  }
+
+  return QString("%1%2").arg((val < 0 ? "-" : "")).arg(strings.value(abs(val)));
+}
+
+QString ModelPrinter::printVarioSource(unsigned int val)
+{
+  switch (val) {
+    case TELEMETRY_VARIO_SOURCE_ALTI:
+      return tr("Alti");
+    case TELEMETRY_VARIO_SOURCE_ALTI_PLUS:
+      return tr("Alti+");
+    case TELEMETRY_VARIO_SOURCE_VSPEED:
+      return tr("VSpeed");
+    case TELEMETRY_VARIO_SOURCE_A1:
+      return tr("A1");
+    case TELEMETRY_VARIO_SOURCE_A2:
+      return tr("A2");
+    default:
+      return tr("???");
+  }
+}
+
+QString ModelPrinter::printVarioCenterSilent(bool mb)
+{
+  return printBoolean(mb, BOOLEAN_YESNO);
+}
+
+QString ModelPrinter::printVoltsSource(unsigned int val)
+{
+  switch (val) {
+    case TELEMETRY_VOLTS_SOURCE_A1:
+      return tr("A1");
+    case TELEMETRY_VOLTS_SOURCE_A2:
+      return tr("A2");
+    case TELEMETRY_VOLTS_SOURCE_A3:
+      return tr("A3");
+    case TELEMETRY_VOLTS_SOURCE_A4:
+      return tr("A4");
+    case TELEMETRY_VOLTS_SOURCE_FAS:
+      return tr("FAS");
+    case TELEMETRY_VOLTS_SOURCE_CELLS:
+      return tr("Cells");
+    default:
+      return tr("???");
+  }
+}
+
+QString ModelPrinter::printCurrentSource(unsigned int val)
+{
+  switch (val) {
+    case TELEMETRY_CURRENT_SOURCE_NONE:
+      return tr("None");
+    case TELEMETRY_CURRENT_SOURCE_A1:
+      return tr("A1");
+    case TELEMETRY_CURRENT_SOURCE_A2:
+      return tr("A2");
+    case TELEMETRY_CURRENT_SOURCE_A3:
+      return tr("A3");
+    case TELEMETRY_CURRENT_SOURCE_A4:
+      return tr("A4");
+    case TELEMETRY_CURRENT_SOURCE_FAS:
+      return tr("FAS");
+    default:
+      return tr("???");
+  }
+}
+
+QString ModelPrinter::printMahPersistent(bool mb)
+{
+  return printBoolean(mb, BOOLEAN_YESNO);
+}
+
+QString ModelPrinter::printIgnoreSensorIds(bool mb)
+{
+  return printBoolean(mb, BOOLEAN_ENABLEDISABLE);
+}
+
+QString ModelPrinter::printSensorType(unsigned int val)
+{
+  switch (val) {
+    case SensorData::TELEM_TYPE_CUSTOM:
+      return tr("Custom");
+    case SensorData::TELEM_TYPE_CALCULATED:
+      return tr("Calculated");
+    default:
+      return tr("???");
+  }
+}
+
+QString ModelPrinter::printSensorFormula(unsigned int val)
+{
+  switch (val) {
+    case SensorData::TELEM_FORMULA_ADD:
+      return tr("Add");
+    case SensorData::TELEM_FORMULA_AVERAGE:
+      return tr("Average");
+    case SensorData::TELEM_FORMULA_MIN:
+      return tr("Min");
+    case SensorData::TELEM_FORMULA_MAX:
+      return tr("Max");
+    case SensorData::TELEM_FORMULA_MULTIPLY:
+      return tr("Multiply");
+    case SensorData::TELEM_FORMULA_TOTALIZE:
+      return tr("Totalise");
+    case SensorData::TELEM_FORMULA_CELL:
+      return tr("Cell");
+    case SensorData::TELEM_FORMULA_CONSUMPTION:
+      return tr("Consumption");
+    case SensorData::TELEM_FORMULA_DIST:
+      return tr("Distance");
+    default:
+      return tr("???");
+  }
+}
+
+QString ModelPrinter::printSensorCells(unsigned int val)
+{
+  QStringList strings;
+
+  strings << tr("Lowest");
+  for (int i=1; i<=6; i++)
+    strings << tr("Cell %1").arg(i);
+  strings << tr("Highest") << tr("Delta");
+
+  return strings.value(val);
+}
+
+QString ModelPrinter::printSensorTypeCond(unsigned int idx)
+{
+  if (!model.sensorData[idx].isAvailable())
+    return "";
+  else
+    return printSensorType(model.sensorData[idx].type);
+}
+
+QString ModelPrinter::printSensorDetails(unsigned int idx)
+{
+  QString str = "";
+  SensorData sensor = model.sensorData[idx];
+
+  if (!sensor.isAvailable())
+    return str;
+
+  bool isConfigurable = false;
+  bool gpsFieldsPrinted = false;
+  bool cellsFieldsPrinted = false;
+  bool consFieldsPrinted = false;
+  bool ratioFieldsPrinted = false;
+  bool totalizeFieldsPrinted = false;
+  bool sources12FieldsPrinted = false;
+  bool sources34FieldsPrinted = false;
+
+  str.append(doTableCell(printSensorTypeCond(idx)));
+
+  QString tc = "";
+  if (sensor.type == SensorData::TELEM_TYPE_CALCULATED) {
+    isConfigurable = (sensor.formula < SensorData::TELEM_FORMULA_CELL);
+    gpsFieldsPrinted = (sensor.formula == SensorData::TELEM_FORMULA_DIST);
+    cellsFieldsPrinted = (sensor.formula == SensorData::TELEM_FORMULA_CELL);
+    consFieldsPrinted = (sensor.formula == SensorData::TELEM_FORMULA_CONSUMPTION);
+    sources12FieldsPrinted = (sensor.formula <= SensorData::TELEM_FORMULA_MULTIPLY);
+    sources34FieldsPrinted = (sensor.formula < SensorData::TELEM_FORMULA_MULTIPLY);
+    totalizeFieldsPrinted = (sensor.formula == SensorData::TELEM_FORMULA_TOTALIZE);
+
+    tc.append(printLabelValue(tr("Formula"), printSensorFormula(sensor.formula)));
+  }
+  else {
+    isConfigurable = sensor.unit < SensorData::UNIT_FIRST_VIRTUAL;
+    ratioFieldsPrinted = (sensor.unit < SensorData::UNIT_FIRST_VIRTUAL);
+
+    tc.append(printLabelValue(tr("Id"), QString::number(sensor.id,16).toUpper()));
+    tc.append(printLabelValue(tr("Instance"), QString::number(sensor.instance)));
+  }
+  if (cellsFieldsPrinted) {
+    tc.append(printLabelValue(tr("Sensor"), QString("%1 > %2").arg(printTelemetrySource(sensor.source), false).arg(printSensorCells(sensor.index))));
+  }
+  if (sources12FieldsPrinted) {
+    QStringList srcs;
+    for (int i=0;i<4;i++) {
+      if (i < 2 || sources34FieldsPrinted) {
+        srcs << printTelemetrySource(sensor.sources[i]);
+      }
+    }
+    tc.append(printLabelValues(tr("Sources"), srcs));
+  }
+  if (consFieldsPrinted || totalizeFieldsPrinted)
+    tc.append(printLabelValue(tr("Sensor"), printTelemetrySource(sensor.amps)));
+  if (gpsFieldsPrinted) {
+    tc.append(printLabelValue(tr("GPS"), printTelemetrySource(sensor.gps)));
+    tc.append(printLabelValue(tr("Alt."), printTelemetrySource(sensor.alt)));
+  }
+  if (ratioFieldsPrinted && sensor.unit == SensorData::UNIT_RPMS) {
+      tc.append(printLabelValue(tr("Blades"), QString::number(sensor.ratio)));
+      tc.append(printLabelValue(tr("Multi."), QString::number(sensor.offset)));
+  }
+  str.append(doTableCell(tc));
+
+  tc = sensor.unitString();
+  tc = tc.trimmed() == "" ? "-" : tc;
+  str.append(doTableCell(tc));
+
+  if (isConfigurable && sensor.unit != SensorData::UNIT_FAHRENHEIT)
+    tc = QString::number(sensor.prec);
+  else
+    tc = "";
+  str.append(doTableCell(tc));
+
+  if (!ratioFieldsPrinted) {
+    str.append(doTableCell(""));
+    str.append(doTableCell(""));
+  }
+  else if (sensor.unit != SensorData::UNIT_RPMS) {
+      int prec = sensor.prec == 0 ? 1 : pow(10, sensor.prec);
+      str.append(doTableCell(QString::number((float)sensor.ratio / prec)));
+      str.append(doTableCell(QString::number((float)sensor.offset / prec)));
+  }
+
+  if (sensor.unit != SensorData::UNIT_RPMS && isConfigurable)
+    str.append(doTableCell(printBoolean(sensor.autoOffset, BOOLEAN_YN)));
+  else
+    str.append(doTableCell(""));
+
+  if (isConfigurable)
+    str.append(doTableCell(printBoolean(sensor.filter, BOOLEAN_YN)));
+  else
+    str.append(doTableCell(""));
+
+  if (sensor.type == SensorData::TELEM_TYPE_CALCULATED)
+    str.append(doTableCell(printBoolean(sensor.persistent, BOOLEAN_YN)));
+  else
+    str.append(doTableCell(""));
+
+  str.append(doTableCell(printBoolean(sensor.onlyPositive, BOOLEAN_YN)));
+  str.append(doTableCell(printBoolean(sensor.logs, BOOLEAN_YN), false));
+  return str;
+}
+
+QString ModelPrinter::printSensorParams(unsigned int idx)
+{
+  QString str = "";
+  SensorData sensor = model.sensorData[idx];
+
+  if (!sensor.isAvailable())
+    return str;
+
+  bool isConfigurable = false;
+  bool gpsFieldsPrinted = false;
+  bool cellsFieldsPrinted = false;
+  bool consFieldsPrinted = false;
+  bool ratioFieldsPrinted = false;
+  bool totalizeFieldsPrinted = false;
+  bool sources12FieldsPrinted = false;
+  bool sources34FieldsPrinted = false;
+
+  if (sensor.type == SensorData::TELEM_TYPE_CALCULATED) {
+    isConfigurable = (sensor.formula < SensorData::TELEM_FORMULA_CELL);
+    gpsFieldsPrinted = (sensor.formula == SensorData::TELEM_FORMULA_DIST);
+    cellsFieldsPrinted = (sensor.formula == SensorData::TELEM_FORMULA_CELL);
+    consFieldsPrinted = (sensor.formula == SensorData::TELEM_FORMULA_CONSUMPTION);
+    sources12FieldsPrinted = (sensor.formula <= SensorData::TELEM_FORMULA_MULTIPLY);
+    sources34FieldsPrinted = (sensor.formula < SensorData::TELEM_FORMULA_MULTIPLY);
+    totalizeFieldsPrinted = (sensor.formula == SensorData::TELEM_FORMULA_TOTALIZE);
+
+    str.append(printLabelValue(tr("F"), printSensorFormula(sensor.formula)));
+  }
+  else {
+    isConfigurable = sensor.unit < SensorData::UNIT_FIRST_VIRTUAL;
+    ratioFieldsPrinted = (sensor.unit < SensorData::UNIT_FIRST_VIRTUAL);
+
+    str.append(printLabelValue(tr("Id"), QString::number(sensor.id,16).toUpper()));
+    str.append(printLabelValue(tr("Inst"), QString::number(sensor.instance)));
+  }
+  if (cellsFieldsPrinted) {
+    str.append(printLabelValue(tr("Sensor"), QString("%1 %2").arg(printTelemetrySource(sensor.source), false).arg(printSensorCells(sensor.index))));
+  }
+  if (sources12FieldsPrinted) {
+    QStringList srcs;
+    for (int i=0;i<4;i++) {
+      if (i < 2 || sources34FieldsPrinted) {
+        srcs << printTelemetrySource(sensor.sources[i]);
+      }
+    }
+    str.append(printLabelValues(tr("Sources"), srcs));
+  }
+  if (consFieldsPrinted || totalizeFieldsPrinted)
+    str.append(printLabelValue(tr("Sensor"), printTelemetrySource(sensor.amps)));
+  if (gpsFieldsPrinted) {
+    str.append(printLabelValue(tr("GPS"), printTelemetrySource(sensor.gps)));
+    str.append(printLabelValue(tr("Alt"), printTelemetrySource(sensor.alt)));
+  }
+  QString u = sensor.unitString();
+  u = u.trimmed() == "" ? "-" : u;
+  str.append(printLabelValue(tr("Unit"), u));
+  if (isConfigurable && sensor.unit != SensorData::UNIT_FAHRENHEIT)
+    str.append(printLabelValue(tr("Prec"), QString::number(sensor.prec)));
+  if (ratioFieldsPrinted) {
+    if (sensor.unit != SensorData::UNIT_RPMS) {
+      int prec = sensor.prec == 0 ? 1 : pow(10, sensor.prec);
+      str.append(printLabelValue(tr("Ratio"), QString::number((float)sensor.ratio / prec)));
+      str.append(printLabelValue(tr("Offset"), QString::number((float)sensor.offset / prec)));
+    }
+    else if (sensor.unit == SensorData::UNIT_RPMS) {
+      str.append(printLabelValue(tr("Blades"), QString::number(sensor.ratio)));
+      str.append(printLabelValue(tr("Multi"), QString::number(sensor.offset)));
+    }
+  }
+  if (sensor.unit != SensorData::UNIT_RPMS && isConfigurable)
+    str.append(printLabelValue(tr("A/Offset"), printBoolean(sensor.autoOffset, BOOLEAN_YN)));
+  if (isConfigurable)
+    str.append(printLabelValue(tr("Filter"), printBoolean(sensor.filter, BOOLEAN_YN)));
+  if (sensor.type == SensorData::TELEM_TYPE_CALCULATED)
+    str.append(printLabelValue(tr("Persist"), printBoolean(sensor.persistent, BOOLEAN_YN)));
+  str.append(printLabelValue(tr("Positive"), printBoolean(sensor.onlyPositive, BOOLEAN_YN)));
+  str.append(printLabelValue(tr("Log"), printBoolean(sensor.logs, BOOLEAN_YN), false));
+  return str;
+}
+
+QString ModelPrinter::printTelemetryScreenType(unsigned int val)
+{
+  switch (val) {
+    case TelemetryScreenEnum::TELEMETRY_SCREEN_NONE:
+      return tr("None");
+    case TelemetryScreenEnum::TELEMETRY_SCREEN_NUMBERS:
+      return tr("Numbers");
+    case TelemetryScreenEnum::TELEMETRY_SCREEN_BARS:
+      return tr("Bars");
+    case TelemetryScreenEnum::TELEMETRY_SCREEN_SCRIPT:
+      return tr("Script");
+    default:
+      return tr("???");
+  }
+}
+
+QString ModelPrinter::printTelemetryScreen(unsigned int idx, unsigned int line, unsigned int width)
+{
+  QStringList strl;
+  QStringList hd;
+  FrSkyScreenData screen = model.frsky.screens[idx];
+  hd << "";  // blank 1st column
+  strl << "";
+  if (screen.type == TelemetryScreenEnum::TELEMETRY_SCREEN_NUMBERS) {
+    if (line == 0) {
+      for (int c=0; c<firmware->getCapability(TelemetryCustomScreensFieldsPerLine); c++) {
+        hd << tr("Source");
+      }
+    }
+    for (int c=0; c<firmware->getCapability(TelemetryCustomScreensFieldsPerLine); c++) {
+      RawSource source = screen.body.lines[line].source[c];
+      strl << source.toString(&model, &generalSettings);
+    }
+  }
+  else if (screen.type == TelemetryScreenEnum::TELEMETRY_SCREEN_BARS) {
+    if (line == 0) {
+      hd << tr("Source") << tr("Min") << tr("Max");
+    }
+    RawSource source = screen.body.bars[line].source;
+    RawSourceRange range = source.getRange(&model, generalSettings);
+    strl << source.toString(&model, &generalSettings);
+    QString unit;
+    QString minstr;
+    QString maxstr;
+    if (source.isTimeBased()){
+      minstr = printTimeValue((float)screen.body.bars[line].barMin, MASK_TIMEVALUE_HRSMINS);
+      maxstr = printTimeValue((float)screen.body.bars[line].barMax, MASK_TIMEVALUE_HRSMINS);
+    }
+    else {
+      minstr = QString::number(range.getValue(screen.body.bars[line].barMin));
+      maxstr = QString::number(range.getValue(screen.body.bars[line].barMax));
+      unit = range.unit;
+    }
+    strl << QString("%1%2").arg(minstr).arg(unit);
+    strl << QString("%1%2").arg(maxstr).arg(unit);
+  }
+  else if (screen.type == TelemetryScreenEnum::TELEMETRY_SCREEN_SCRIPT && line == 0) {
+    hd << tr("Filename");
+    strl << QString("%1.lua").arg(screen.body.script.filename);
+  }
+  return (hd.count() > 1 ? doTableRow(hd, width / hd.count(), "left", "", true) : "" ) + doTableRow(strl, width / strl.count());
+}
diff --git a/companion/src/modelprinter.h b/companion/src/modelprinter.h
index 290d4a06e..777772164 100644
--- a/companion/src/modelprinter.h
+++ b/companion/src/modelprinter.h
@@ -65,6 +65,7 @@ class ModelPrinter: public QObject
     QString printFlightModeSwitch(const RawSwitch & swtch);
     QString printFlightModeName(int index);
     QString printFlightModes(unsigned int flightModes);
+    QString printInputFlightModes(unsigned int flightModes);
     QString printModule(int idx);
     QString printTrainerMode();
     QString printCenterBeep();
@@ -116,6 +117,26 @@ class ModelPrinter: public QObject
     QString printTimeValue(const int value, const unsigned int mask);
     QString printTimerMinuteBeep(bool mb);
     QString printTimerTimeValue(unsigned int val);
+    QString printTelemetryProtocol(unsigned int val);
+    QString printLabelValue(const QString & lbl, const QString & val, const bool sep = false);
+    QString printLabelValues(const QString & lbl, const QStringList & vals, const bool sep = false);
+    QString printRssiAlarmsDisabled(bool mb);
+    QString printTelemetrySource(int val);
+    QString printVarioSource(unsigned int val);
+    QString printVarioCenterSilent(bool mb);
+    QString printVoltsSource(unsigned int val);
+    QString printCurrentSource(unsigned int val);
+    QString printMahPersistent(bool mb);
+    QString printIgnoreSensorIds(bool mb);
+    QString printSensorType(unsigned int val);
+    QString printSensorFormula(unsigned int val);
+    QString printSensorCells(unsigned int val);
+    QString printSensorTypeCond(unsigned int idx);
+    QString printSensorParams(unsigned int idx);
+    QString printSensorDetails(unsigned int idx);
+    QString printTelemetryScreenType(unsigned int val);
+    QString printTelemetryScreen(unsigned int idx, unsigned int line, unsigned int width);
+
   private:
     Firmware * firmware;
     const GeneralSettings & generalSettings;
diff --git a/companion/src/multimodelprinter.cpp b/companion/src/multimodelprinter.cpp
index 64a4da418..a198432bc 100644
--- a/companion/src/multimodelprinter.cpp
+++ b/companion/src/multimodelprinter.cpp
@@ -21,6 +21,7 @@
 #include "helpers.h"
 #include "helpers_html.h"
 #include "multimodelprinter.h"
+#include "appdata.h"
 #include <algorithm>
 
 MultiModelPrinter::MultiColumns::MultiColumns(int count):
@@ -68,7 +69,35 @@ void MultiModelPrinter::MultiColumns::endCompare(const QString & color)
       cellColor = "green";
     else if (i>0 && compareColumns[i]!=compareColumns[0])
       cellColor = "red";
-    columns[i].append(QString("<font color='%1'>%2</font>").arg(cellColor).arg(compareColumns[i]));
+    // font instructions must be applied at table cell level if they exist in the comparison string
+    if (compareColumns[i].indexOf(QString("<td")) > -1) {
+      QString t = compareColumns[i];
+      int p1 = 0;
+      int p2 = 0;
+      int p3 = 0;
+      while (t.indexOf(QString("<td"), p1) > -1) {
+        p1 = t.indexOf(QString("<td"), p1);
+        p2 = t.indexOf(QString(">"), p1 + 3);
+        p3 = t.indexOf(QString("</td>"), p2 + 1);
+        QString td = t.mid(p2 + 1, p3 - (p2 + 1));
+        // remove existing font instructions from current cell
+        if (td.contains(QString("<font "))) {
+          int p4 = t.indexOf(QString("<font "), p2 + 1);
+          int p5 = t.indexOf(QString("</font>"), p4) + 6;
+          if (p5 < p3)
+            t.remove(p4, p5 - p4 + 1);
+        }
+        t.insert(p2 + 1, QString("<font color='%1'>").arg(cellColor));
+        p3 = t.indexOf(QString("</td>"), p2);
+        t.insert(p3, QString("</font>"));
+        p1 = p3 + QString("</font></td>").size();
+      }
+      compareColumns[i] = t;
+      columns[i].append(QString("%1").arg(compareColumns[i]));
+    }
+    else {
+      columns[i].append(QString("<font color='%1'>%2</font>").arg(cellColor).arg(compareColumns[i]));
+    }
   }
   delete[] compareColumns;
   compareColumns = NULL;
@@ -99,6 +128,88 @@ bool MultiModelPrinter::MultiColumns::isEmpty()
   return true;
 }
 
+void MultiModelPrinter::MultiColumns::appendLineBreak()
+{
+  append("<br/>");
+}
+
+void MultiModelPrinter::MultiColumns::appendSectionTableStart()
+{
+  append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
+}
+
+void MultiModelPrinter::MultiColumns::appendTableEnd()
+{
+  append("</table>");
+}
+
+void MultiModelPrinter::MultiColumns::appendRowStart(const QString & title, const unsigned int titlewidth)
+{
+  append("<tr>");
+  if (!(title.isEmpty()) || (titlewidth))
+    appendLabelCell(QString(title), titlewidth);
+}
+
+void MultiModelPrinter::MultiColumns::appendRowEnd()
+{
+  append("</tr>");
+}
+
+void MultiModelPrinter::MultiColumns::appendCellStart(const unsigned int width, const bool bold)
+{
+  QString str = "<td";
+  if (width)
+    str.append(QString(" width='%1%'").arg(QString::number(width)));
+  str.append(">");
+  str.append(bold ? "<b>" : "");
+  append(str);
+}
+
+void MultiModelPrinter::MultiColumns::appendCellEnd(const bool bold)
+{
+  QString str;
+  str.append(bold ? "</b>" : "");
+  str.append("</td>");
+  append(str);
+}
+
+void MultiModelPrinter::MultiColumns::appendLabelCell(const QString & str, const unsigned int width, const QString & align, const QString & color)
+{
+  append(doTableCell(str, width, align, color, true));
+}
+
+void MultiModelPrinter::MultiColumns::appendValueCell(const QString & str, const unsigned int width, const QString & align, const QString & color)
+{
+  append(doTableCell(str, width, align, color, false));
+}
+
+void MultiModelPrinter::MultiColumns::appendRow(const QStringList & strl, const unsigned int width, const QString & align, const QString & color)
+{
+  append(doTableRow(strl, width, align, color, false));
+}
+
+void MultiModelPrinter::MultiColumns::appendRowHeader(const QStringList & strl, const unsigned int width, const QString & align, const QString & color)
+{
+  append(doTableRow(strl, width, align, color, true));
+}
+
+void MultiModelPrinter::MultiColumns::appendRowBlank()
+{
+  append(doTableBlankRow());
+}
+
+void MultiModelPrinter::MultiColumns::appendFieldLabel(const QString & lbl)
+{
+  if (!lbl.isEmpty())
+    appendTitle(QString("%1:").arg(lbl));
+}
+
+void MultiModelPrinter::MultiColumns::appendFieldSeparator(const bool sep)
+{
+  if (sep)
+    append(";&nbsp;");
+}
+
 #define COMPARE(what) \
   columns.beginCompare(); \
   for (int cc=0; cc < modelPrinterMap.size(); cc++) { \
@@ -109,6 +220,34 @@ bool MultiModelPrinter::MultiColumns::isEmpty()
   } \
   columns.endCompare();
 
+#define COMPARECELL(what) \
+  columns.appendCellStart(); \
+  COMPARE(what); \
+  columns.appendCellEnd();
+
+#define COMPARECELLWIDTH(what, width) \
+  columns.appendCellStart(width); \
+  COMPARE(what); \
+  columns.appendCellEnd();
+
+#define LABELCOMPARECELL(lbl, what, width) \
+  columns.appendCellStart(width); \
+  columns.appendFieldLabel(lbl); \
+  COMPARE(what); \
+  columns.appendCellEnd();
+
+#define ROWLABELCOMPARECELL(lbl, lblw, what, width) \
+  columns.appendRowStart(lbl, lblw); \
+  columns.appendCellStart(width); \
+  COMPARE(what); \
+  columns.appendCellEnd(); \
+  columns.appendRowEnd();
+
+#define COMPARESTRING(lbl, what, sep) \
+  columns.appendFieldLabel(lbl); \
+  COMPARE(what); \
+  columns.appendFieldSeparator(sep);
+
 QString MultiModelPrinter::printTitle(const QString & label)
 {
   return QString("<tr><td colspan='%1'><h2>").arg(modelPrinterMap.count()) + label + "</h2></td></tr>";
@@ -171,45 +310,38 @@ QString MultiModelPrinter::print(QTextDocument * document)
   if (firmware->getCapability(Gvars) && !firmware->getCapability(GvarsFlightModes))
     str.append(printGvars());
   str.append(printLogicalSwitches());
-  str.append(printCustomFunctions());
-  str.append(printTelemetry());
+  str.append(printSpecialFunctions());
+  if (firmware->getCapability(Telemetry) & TM_HASTELEMETRY) {
+    str.append(printTelemetry());
+    str.append(printSensors());
+    if (firmware->getCapability(TelemetryCustomScreens)) {
+      str.append(printTelemetryScreens());
+    }
+  }
   str.append("</table>");
   return str;
 }
 
 QString MultiModelPrinter::printSetup()
 {
-  QString str = printTitle(tr("General Model Settings"));
+  QString str = printTitle(tr("General"));
 
   MultiColumns columns(modelPrinterMap.size());
-  columns.appendTitle(tr("Name:"));
-  COMPARE(model->name);
-  columns.append(tr("  EEprom Size: "));
-  COMPARE(modelPrinter->printEEpromSize());
+  columns.appendSectionTableStart();
+  ROWLABELCOMPARECELL(tr("Name"), 25, model->name, 75);
+  ROWLABELCOMPARECELL(tr("EEprom Size"), 0, modelPrinter->printEEpromSize(), 0);
   if (firmware->getCapability(ModelImage)) {
-    columns.append(tr("  Model Image: "));
-    COMPARE(model->bitmap);
+    ROWLABELCOMPARECELL(tr("Model Image"), 0, model->bitmap, 0);
   }
-  columns.append("<br/>");
-  columns.appendTitle(tr("Throttle:"));
-  COMPARE(modelPrinter->printThrottle());
-  columns.append("<br/>");
-  columns.appendTitle(tr("Trims:"));
-  COMPARE(modelPrinter->printSettingsTrim());
-  columns.append("<br/>");
-  columns.appendTitle(tr("Center Beep:"));
-  COMPARE(modelPrinter->printCenterBeep());
-  columns.append("<br/>");
-  columns.appendTitle(tr("Switch Warnings:"));
-  COMPARE(modelPrinter->printSwitchWarnings());
-  columns.append("<br/>");
+  ROWLABELCOMPARECELL(tr("Throttle"), 0, modelPrinter->printThrottle(), 0);
+  ROWLABELCOMPARECELL(tr("Trims"), 0, modelPrinter->printSettingsTrim(), 0);
+  ROWLABELCOMPARECELL(tr("Center Beep"), 0, modelPrinter->printCenterBeep(), 0);
+  ROWLABELCOMPARECELL(tr("Switch Warnings"), 0, modelPrinter->printSwitchWarnings(), 0);
   if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
-      columns.appendTitle(tr("Pot Warnings:"));
-      COMPARE(modelPrinter->printPotWarnings());
-      columns.append("<br/>");
+    ROWLABELCOMPARECELL(tr("Pot Warnings"), 0, modelPrinter->printPotWarnings(), 0);
   }
-  columns.appendTitle(tr("Other:"));
-  COMPARE(modelPrinter->printSettingsOther());
+  ROWLABELCOMPARECELL(tr("Other"), 0, modelPrinter->printSettingsOther(), 0);
+  columns.appendTableEnd();
   str.append(columns.print());
   return str;
 }
@@ -218,32 +350,22 @@ QString MultiModelPrinter::printTimers()
 {
   QString str;
   MultiColumns columns(modelPrinterMap.size());
-  columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
-  columns.append("<tr>");
-  columns.append("<td><b>" + tr("Timers") + "</b></td>");
-  columns.append("<td><b>" + tr("Time") + "</b></td>");
-  columns.append("<td><b>" + tr("Switch") + "</b></td>");
-  columns.append("<td><b>" + tr("Countdown") + "</b></td>");
-  columns.append("<td><b>" + tr("Minute call") + "</b></td>");
-  columns.append("<td><b>" + tr("Persistence") + "</b></td>");
-  columns.append("</tr>");
+  columns.appendSectionTableStart();
+  columns.appendRowHeader(QStringList() << tr("Timers") << tr("Time") << tr("Switch") << tr("Countdown") << tr("Minute call") << tr("Persistence"));
 
   for (int i=0; i<firmware->getCapability(Timers); i++) {
-    columns.append("<tr><td><b>");
+    columns.appendRowStart();
+    columns.appendCellStart(20, true);
     COMPARE(modelPrinter->printTimerName(i));
-    columns.append("</b></td><td>");
-    COMPARE(modelPrinter->printTimerTimeValue(model->timers[i].val));
-    columns.append("</td><td>");
-    COMPARE(model->timers[i].mode.toString());
-    columns.append("</td><td>");
-    COMPARE(modelPrinter->printTimerCountdownBeep(model->timers[i].countdownBeep));
-    columns.append("</td><td>");
-    COMPARE(modelPrinter->printTimerMinuteBeep(model->timers[i].minuteBeep));
-    columns.append("</td><td>");
-    COMPARE(modelPrinter->printTimerPersistent(model->timers[i].persistent));
-    columns.append("</td></tr>");
+    columns.appendCellEnd(true);
+    COMPARECELL(modelPrinter->printTimerTimeValue(model->timers[i].val));
+    COMPARECELL(model->timers[i].mode.toString());
+    COMPARECELL(modelPrinter->printTimerCountdownBeep(model->timers[i].countdownBeep));
+    COMPARECELL(modelPrinter->printTimerMinuteBeep(model->timers[i].minuteBeep));
+    COMPARECELL(modelPrinter->printTimerPersistent(model->timers[i].persistent));
+    columns.appendRowEnd();
   }
-  columns.append("</table>");
+  columns.appendTableEnd();
   str.append(columns.print());
   return str;
 }
@@ -252,19 +374,20 @@ QString MultiModelPrinter::printModules()
 {
   QString str = printTitle(tr("Modules"));
   MultiColumns columns(modelPrinterMap.size());
-  columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
+  columns.appendSectionTableStart();
   for (int i=0; i<firmware->getCapability(NumModules); i++) {
-    columns.append("<tr><td>");
-    columns.appendTitle(tr("%1:").arg(i+1));
-    COMPARE(modelPrinter->printModule(i));
-    columns.append("</td></tr>");
+    columns.appendRowStart();
+    columns.appendCellStart(25, true);
+    COMPARE(modelPrinter->printModuleType(i));
+    columns.appendCellEnd(true);
+    COMPARECELLWIDTH(modelPrinter->printModule(i), 75);
+    columns.appendRowEnd();
   }
   if (firmware->getCapability(ModelTrainerEnable))
-    columns.append("<tr><td>");
-    columns.appendTitle(tr("Trainer port:"));
-    COMPARE(modelPrinter->printModule(-1));
-    columns.append("</td></tr>");
-  columns.append("</table>");
+    columns.appendRowStart(tr("Trainer port"));
+    COMPARECELL(modelPrinter->printModule(-1));
+    columns.appendRowEnd();
+  columns.appendTableEnd();
   str.append(columns.print());
   return str;
 }
@@ -279,42 +402,32 @@ QString MultiModelPrinter::printHeliSetup()
   if (!heliEnabled)
     return "";
 
-  QString str = printTitle(tr("Helicopter Setup"));
+  QString str = printTitle(tr("Helicopter"));
   MultiColumns columns(modelPrinterMap.size());
-  columns.appendTitle (tr("Swash Type:"));
-  COMPARE(modelPrinter->printHeliSwashType());
-  columns.append ("<br/>");
+  columns.appendSectionTableStart();
+  columns.appendRowStart(tr("Swash"), 20);
+  LABELCOMPARECELL(tr("Type"), modelPrinter->printHeliSwashType(), 20);
+  LABELCOMPARECELL(tr("Ring"), model->swashRingData.value, 20);
+  columns.appendRowEnd();
 
-  columns.appendTitle (tr("Swash Ring:"));
-  COMPARE(model->swashRingData.value);
-
-  columns.append ("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
-  columns.append("<tr>");
-  columns.append("<td></td><td><b>" + tr("Input") + "</b></td><td><b>" + tr("Weight") + "</b></td>");
-  columns.append("</tr>");
-
-  columns.append("<tr><td><b>" + tr("Long. cyc") + "</b></td><td>");
-  COMPARE(model->swashRingData.elevatorSource.toString(model));
-  columns.append("</td><td>");
-  COMPARE(model->swashRingData.elevatorWeight)
-  columns.append("</td></tr>");
-
-  columns.append("<tr><td><b>" + tr("Lateral cyc") + "</b></td><td>");
-  COMPARE(model->swashRingData.aileronSource.toString(model));
-  columns.append("</td><td>");
-  COMPARE(model->swashRingData.aileronWeight)
-  columns.append("</td></tr>");
-
-
-  columns.append("<tr><td><b>" + tr("Collective") + "</b></td><td>");
-  COMPARE(model->swashRingData.collectiveSource.toString(model));
-  columns.append("</td><td>");
-  COMPARE(model->swashRingData.collectiveWeight)
-  columns.append("</td></tr>");
-  columns.append("</table>");
+  columns.appendRowBlank();
+  columns.appendRowHeader(QStringList() << "" << tr("Input") << tr("Weight"));
+  columns.appendRowStart(tr("Long. cyc"));
+  COMPARECELL(model->swashRingData.elevatorSource.toString(model));
+  COMPARECELL(model->swashRingData.elevatorWeight);
+  columns.appendRowEnd();
 
+  columns.appendRowStart(tr("Lateral cyc"));
+  COMPARECELL(model->swashRingData.aileronSource.toString(model));
+  COMPARECELL(model->swashRingData.aileronWeight)
+  columns.appendRowEnd();
 
+  columns.appendRowStart(tr("Collective"));
+  COMPARECELL(model->swashRingData.collectiveSource.toString(model));
+  COMPARECELL(model->swashRingData.collectiveWeight)
+  columns.appendRowEnd();
 
+  columns.appendTableEnd();
   str.append(columns.print());
   return str;
 }
@@ -325,36 +438,28 @@ QString MultiModelPrinter::printFlightModes()
   // Trims
   {
     MultiColumns columns(modelPrinterMap.size());
-    columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
-    columns.append("<tr>");
-    columns.append("<td><b>" + tr("Flight mode") + "</b></td>");
-    columns.append("<td><b>" + tr("Switch") + "</b></td>");
-    columns.append("<td><b>" + tr("Fade IN") + "</b></td>");
-    columns.append("<td><b>" + tr("Fade OUT") + "</b></td>");
+    columns.appendSectionTableStart();
+    QStringList hd = QStringList() << tr("Flight mode") << tr("Switch") << tr("Fade IN") << tr("Fade OUT");
     for (int i=0; i < getBoardCapability(getCurrentBoard(), Board::NumTrims); i++) {
-      columns.append("<td><b>" + RawSource(SOURCE_TYPE_TRIM, i).toString() + "</b></td>");
+      hd << RawSource(SOURCE_TYPE_TRIM, i).toString();
     }
-    columns.append("</tr>");
+    columns.appendRowHeader(hd);
 
     for (int i=0; i<firmware->getCapability(FlightModes); i++) {
-      columns.append("<tr><td><b>" + tr("FM%1").arg(i) + "</b>&nbsp;");
-      COMPARE(model->flightModeData[i].name);
-      columns.append("</td><td>");
-      COMPARE(modelPrinter->printFlightModeSwitch(model->flightModeData[i].swtch));
-      columns.append("</td><td>");
-      COMPARE(model->flightModeData[i].fadeIn);
-      columns.append("</td><td>");
-      COMPARE(model->flightModeData[i].fadeOut);
-      columns.append("</td>");
+      columns.appendRowStart();
+      columns.appendCellStart(0,true);
+      COMPARE(modelPrinter->printFlightModeName(i));
+      columns.appendCellEnd(true);
+      COMPARECELL(modelPrinter->printFlightModeSwitch(model->flightModeData[i].swtch));
+      COMPARECELL(model->flightModeData[i].fadeIn);
+      COMPARECELL(model->flightModeData[i].fadeOut);
       for (int k=0; k < getBoardCapability(getCurrentBoard(), Board::NumTrims); k++) {
-        columns.append("<td>");
-        COMPARE(modelPrinter->printTrim(i, k));
-        columns.append("</td>");
+        COMPARECELL(modelPrinter->printTrim(i, k));
       }
-      columns.append("</tr>");
+      columns.appendRowEnd();
     }
 
-    columns.append("</table>");
+    columns.appendTableEnd();
     str.append(columns.print());
   }
 
@@ -362,84 +467,69 @@ QString MultiModelPrinter::printFlightModes()
   int gvars = firmware->getCapability(Gvars);
   if ((gvars && firmware->getCapability(GvarsFlightModes)) || firmware->getCapability(RotaryEncoders)) {
     MultiColumns columns(modelPrinterMap.size());
-    columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
-    columns.append("<tr><td><b>" + tr("Global variables") + "</b></td>");
+    columns.appendSectionTableStart();
+    QStringList hd = QStringList() << tr("Global variables");
     if (firmware->getCapability(GvarsFlightModes)) {
       for (int i=0; i<gvars; i++) {
-        columns.append("<td><b>" + tr("GV%1").arg(i+1) + "</b></td>");
+        hd << tr("GV%1").arg(i+1);
       }
     }
     for (int i=0; i<firmware->getCapability(RotaryEncoders); i++) {
-      columns.append("<td><b>" + tr("RE%1").arg(i+1) + "</b></td>");
+      hd << tr("RE%1").arg(i+1);
     }
-    columns.append("</tr>");
+    columns.appendRowHeader(hd);
 
     if (firmware->getCapability(GvarsFlightModes)) {
-      columns.append("<tr><td><b>Name</b></td>");
+      columns.appendRowStart(tr("Name"));
       for (int i=0; i<gvars; i++) {
-        columns.append("<td>");
-        COMPARE(model->gvarData[i].name);
-        columns.append("</td>");
+        COMPARECELL(model->gvarData[i].name);
       }
-      columns.append("</tr>");
-      columns.append("<tr><td><b>Unit</b></td>");
+      columns.appendRowEnd();
+      columns.appendRowStart(tr("Unit"));
       for (int i=0; i<gvars; i++) {
-        columns.append("<td>");
-        COMPARE(modelPrinter->printGlobalVarUnit(i));
-        columns.append("</td>");
+        COMPARECELL(modelPrinter->printGlobalVarUnit(i));
       }
-      columns.append("</tr>");
-      columns.append("<tr><td><b>Prec</b></td>");
+      columns.appendRowEnd();
+      columns.appendRowStart(tr("Prec"));
       for (int i=0; i<gvars; i++) {
-        columns.append("<td>");
-        COMPARE(modelPrinter->printGlobalVarPrec(i));
-        columns.append("</td>");
+        COMPARECELL(modelPrinter->printGlobalVarPrec(i));
       }
-      columns.append("</tr>");
-      columns.append("<tr><td><b>Min</b></td>");
+      columns.appendRowEnd();
+      columns.appendRowStart(tr("Min"));
       for (int i=0; i<gvars; i++) {
-        columns.append("<td>");
-        COMPARE(modelPrinter->printGlobalVarMin(i));
-        columns.append("</td>");
+        COMPARECELL(modelPrinter->printGlobalVarMin(i));
       }
-      columns.append("</tr>");
-      columns.append("<tr><td><b>Max</b></td>");
+      columns.appendRowEnd();
+      columns.appendRowStart(tr("Max"));
       for (int i=0; i<gvars; i++) {
-        columns.append("<td>");
-        COMPARE(modelPrinter->printGlobalVarMax(i));
-        columns.append("</td>");
+        COMPARECELL(modelPrinter->printGlobalVarMax(i));
       }
-      columns.append("</tr>");
-      columns.append("<tr><td><b>Popup</b></td>");
+      columns.appendRowEnd();
+      columns.appendRowStart(tr("Popup"));
       for (int i=0; i<gvars; i++) {
-        columns.append("<td>");
-        COMPARE(modelPrinter->printGlobalVarPopup(i));
-        columns.append("</td>");
+        COMPARECELL(modelPrinter->printGlobalVarPopup(i));
       }
-      columns.append("</tr>");
+      columns.appendRowEnd();
     }
 
-    columns.append("<tr><td><b>" + tr("Flight mode") + "</b></td></tr>");
+    columns.appendRowHeader(QStringList() << tr("Flight mode"));
 
     for (int i=0; i<firmware->getCapability(FlightModes); i++) {
-      columns.append("<tr><td><b>" + tr("FM%1").arg(i) + "</b>&nbsp;");
-      COMPARE(model->flightModeData[i].name);
-      columns.append("</td>");
+      columns.appendRowStart();
+      columns.appendCellStart(0,true);
+      COMPARE(modelPrinter->printFlightModeName(i));
+      columns.appendCellEnd(true);
       if (firmware->getCapability(GvarsFlightModes)) {
         for (int k=0; k<gvars; k++) {
-          columns.append("<td>");
-          COMPARE(modelPrinter->printGlobalVar(i, k));
-          columns.append("</td>");
+          COMPARECELL(modelPrinter->printGlobalVar(i, k));
         }
       }
       for (int k=0; k<firmware->getCapability(RotaryEncoders); k++) {
-        columns.append("<td>");
-        COMPARE(modelPrinter->printRotaryEncoder(i, k));
-        columns.append("</td>");
+        COMPARECELL(modelPrinter->printRotaryEncoder(i, k));
       }
-      columns.append("</tr>");
+      columns.appendRowEnd();
     }
-    columns.append("</table>");
+    columns.appendTableEnd();
     str.append(columns.print());
   }
 
@@ -450,55 +540,42 @@ QString MultiModelPrinter::printOutputs()
 {
   QString str = printTitle(tr("Outputs"));
   MultiColumns columns(modelPrinterMap.size());
-  columns.append("<table border='0' cellspacing='0' cellpadding='1' width='100%'>" \
-                 "<tr>" \
-                 "<td><b>" + tr("Channel") + "</b></td>" \
-                 "<td><b>" + tr("Subtrim") + "</b></td>" \
-                 "<td><b>" + tr("Min") + "</b></td>" \
-                 "<td><b>" + tr("Max") + "</b></td>" \
-                 "<td><b>" + tr("Direct") + "</b></td>");
+  columns.appendSectionTableStart();
+  QStringList hd = QStringList() << tr("Channel") << tr("Subtrim") << tr("Min") << tr("Max") << tr("Direct");
   if (IS_HORUS_OR_TARANIS(firmware->getBoard()))
-    columns.append(" <td><b>" + tr("Curve") + "</b></td>");
+    hd << tr("Curve");
   if (firmware->getCapability(PPMCenter))
-    columns.append(" <td><b>" + tr("PPM") + "</b></td>");
+    hd << tr("PPM");
   if (firmware->getCapability(SYMLimits))
-    columns.append(" <td><b>" + tr("Linear") + "</b></td>");
-  columns.append("</tr>");
+    hd << tr("Linear");
+  columns.appendRowHeader(hd);
+
   for (int i=0; i<firmware->getCapability(Outputs); i++) {
     int count = 0;
     for (int k=0; k < modelPrinterMap.size(); k++)
       count = std::max(count, modelPrinterMap.value(k).first->mixes(i).size());
     if (!count)
       continue;
-    columns.append("<tr><td><b>");
+    columns.appendRowStart();
+    columns.appendCellStart(0, true);
     COMPARE(modelPrinter->printChannelName(i));
-    columns.append("</td><td>");
-    COMPARE(modelPrinter->printOutputOffset(i));
-    columns.append("</td><td>");
-    COMPARE(modelPrinter->printOutputMin(i));
-    columns.append("</td><td>");
-    COMPARE(modelPrinter->printOutputMax(i));
-    columns.append("</td><td>");
-    COMPARE(modelPrinter->printOutputRevert(i));
-    columns.append("</td>");
+    columns.appendCellEnd(true);
+    COMPARECELL(modelPrinter->printOutputOffset(i));
+    COMPARECELL(modelPrinter->printOutputMin(i));
+    COMPARECELL(modelPrinter->printOutputMax(i));
+    COMPARECELL(modelPrinter->printOutputRevert(i));
     if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
-      columns.append("<td>");
-      COMPARE(modelPrinter->printOutputCurve(i));
-      columns.append("</td>");
+      COMPARECELL(modelPrinter->printOutputCurve(i));
     }
     if (firmware->getCapability(PPMCenter)) {
-      columns.append("<td>");
-      COMPARE(modelPrinter->printOutputPpmCenter(i));
-      columns.append("</td>");
+      COMPARECELL(modelPrinter->printOutputPpmCenter(i));
     }
     if (firmware->getCapability(SYMLimits)) {
-      columns.append("<td>");
-      COMPARE(modelPrinter->printOutputSymetrical(i));
-      columns.append("</td>");
+      COMPARECELL(modelPrinter->printOutputSymetrical(i));
     }
-    columns.append("</tr>");
+    columns.appendRowEnd();
   }
-  columns.append("</table>");
+  columns.appendTableEnd();
   str.append(columns.print());
   return str;
 }
@@ -508,17 +585,18 @@ QString MultiModelPrinter::printGvars()
   QString str = printTitle(tr("Global Variables"));
   int gvars = firmware->getCapability(Gvars);
   MultiColumns columns(modelPrinterMap.size());
-  columns.append("<table border='0' cellspacing='0' cellpadding='1' width='100%'><tr>");
+  columns.appendSectionTableStart();
+  QStringList hd;
   for (int i=0; i<gvars; i++) {
-    columns.append(QString("<td><b>") + tr("GV%1").arg(i+1) + "</b></td>");
+    hd << tr("GV%1").arg(i+1);
   }
-  columns.append("</tr><tr>");
+  columns.appendRowHeader(hd);
+
   for (int i=0; i<gvars; i++) {
-    columns.append("<td>");
-    COMPARE(model->flightModeData[0].gvars[i]);
-    columns.append("</td>");
+    COMPARECELL(model->flightModeData[0].gvars[i]);
   }
-  columns.append("</tr>");
+  columns.appendRowEnd();
+  columns.appendTableEnd();
   str.append(columns.print());
   return str;
 }
@@ -527,24 +605,28 @@ QString MultiModelPrinter::printInputs()
 {
   QString str = printTitle(tr("Inputs"));
   MultiColumns columns(modelPrinterMap.size());
-  columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
+  columns.appendSectionTableStart();
   for (int i=0; i<std::max(4, firmware->getCapability(VirtualInputs)); i++) {
     int count = 0;
     for (int k=0; k < modelPrinterMap.size(); k++) {
       count = std::max(count, modelPrinterMap.value(k).first->expos(i).size());
     }
     if (count > 0) {
-      columns.append("<tr><td width='20%'><b>");
+      columns.appendRowStart();
+      columns.appendCellStart(20, true);
       COMPARE(modelPrinter->printInputName(i));
-      columns.append("</b></td><td>");
+      columns.appendCellEnd(true);
+      columns.appendCellStart(80);
       for (int j=0; j<count; j++) {
         if (j > 0)
-          columns.append("<br/>");
+          columns.appendLineBreak();
         COMPARE(j<model->expos(i).size() ? modelPrinter->printInputLine(*model->expos(i)[j]) : "");
       }
-      columns.append("</td></tr>");
+      columns.appendCellEnd();
+      columns.appendRowEnd();
     }
   }
+  columns.appendTableEnd();
   str.append(columns.print());
   return str;
 }
@@ -553,24 +635,28 @@ QString MultiModelPrinter::printMixers()
 {
   QString str = printTitle(tr("Mixers"));
   MultiColumns columns(modelPrinterMap.size());
-  columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
+  columns.appendSectionTableStart();
   for (int i=0; i<firmware->getCapability(Outputs); i++) {
     int count = 0;
     for (int k=0; k < modelPrinterMap.size(); k++) {
       count = std::max(count, modelPrinterMap.value(k).first->mixes(i).size());
     }
     if (count > 0) {
-      columns.append("<tr><td width='20%'><b>");
+      columns.appendRowStart();
+      columns.appendCellStart(20, true);
       COMPARE(modelPrinter->printChannelName(i));
-      columns.append("</b></td><td>");
+      columns.appendCellEnd(true);
+      columns.appendCellStart(80);
       for (int j=0; j<count; j++) {
         if (j > 0)
-          columns.append("<br/>");
+          columns.appendLineBreak();
         COMPARE((j < model->mixes(i).size()) ? modelPrinter->printMixerLine(*model->mixes(i)[j], (j>0)) : "&nbsp;");
       }
-      columns.append("</td></tr>");
+      columns.appendCellEnd();
+      columns.appendRowEnd();
     }
   }
+  columns.appendTableEnd();
   str.append(columns.print());
   return str;
 }
@@ -580,7 +666,7 @@ QString MultiModelPrinter::printCurves(QTextDocument * document)
   QString str;
   MultiColumns columns(modelPrinterMap.size());
   int count = 0;
-  columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
+  columns.appendSectionTableStart();
   for (int i=0; i<firmware->getCapability(NumCurves); i++) {
     bool curveEmpty = true;
     for (int k=0; k < modelPrinterMap.size(); k++) {
@@ -591,16 +677,21 @@ QString MultiModelPrinter::printCurves(QTextDocument * document)
     }
     if (!curveEmpty) {
       count++;
-      columns.append("<tr><td width='20%'><b>");
+      columns.appendRowStart();
+      columns.appendCellStart(20, true);
       COMPARE(modelPrinter->printCurveName(i));
-      columns.append("</b></td><td>");
-      COMPARE(modelPrinter->printCurve(i));
+      columns.appendCellEnd(true);
+      COMPARECELL(modelPrinter->printCurve(i));
+      columns.appendRowEnd();
+      columns.appendRowStart("", 20);
+      columns.appendCellStart();
       for (int k=0; k < modelPrinterMap.size(); k++)
-        columns.append(k, QString("<br/><img src='%1' border='0' />").arg(modelPrinterMap.value(k).second->createCurveImage(i, document)));
-      columns.append("</td></tr>");
+        columns.append(k, QString("<br/><img src='%1' border='0' /><br/>").arg(modelPrinterMap.value(k).second->createCurveImage(i, document)));
+      columns.appendCellEnd();
+      columns.appendRowEnd();
     }
   }
-  columns.append("</table><br/>");
+  columns.appendTableEnd();
   if (count > 0) {
     str.append(printTitle(tr("Curves")));
     str.append(columns.print());
@@ -612,8 +703,8 @@ QString MultiModelPrinter::printLogicalSwitches()
 {
   QString str;
   MultiColumns columns(modelPrinterMap.size());
+  columns.appendSectionTableStart();
   int count = 0;
-  columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
   for (int i=0; i<firmware->getCapability(LogicalSwitches); i++) {
     bool lsEmpty = true;
     for (int k=0; k < modelPrinterMap.size(); k++) {
@@ -624,12 +715,12 @@ QString MultiModelPrinter::printLogicalSwitches()
     }
     if (!lsEmpty) {
       count++;
-      columns.append("<tr><td width='20%'><b>" + tr("L%1").arg(i+1) + "</b></td><td>");
-      COMPARE(modelPrinter->printLogicalSwitchLine(i));
-      columns.append("</td></tr>");
+      columns.appendRowStart(tr("L%1").arg(i+1), 20);
+      COMPARECELL(modelPrinter->printLogicalSwitchLine(i));
+      columns.appendRowEnd();
     }
   }
-  columns.append("</table>");
+  columns.appendTableEnd();
   if (count > 0) {
     str.append(printTitle(tr("Logical Switches")));
     str.append(columns.print());
@@ -637,12 +728,12 @@ QString MultiModelPrinter::printLogicalSwitches()
   return str;
 }
 
-QString MultiModelPrinter::printCustomFunctions()
+QString MultiModelPrinter::printSpecialFunctions()
 {
   QString str;
   MultiColumns columns(modelPrinterMap.size());
   int count = 0;
-  columns.append("<table cellspacing='0' cellpadding='1' width='100%' border='0' style='border-collapse:collapse'>");
+  columns.appendSectionTableStart();
   for (int i=0; i < firmware->getCapability(CustomFunctions); i++) {
     bool sfEmpty = true;
     for (int k=0; k < modelPrinterMap.size(); k++) {
@@ -653,12 +744,12 @@ QString MultiModelPrinter::printCustomFunctions()
     }
     if (!sfEmpty) {
       count++;
-      columns.append("<tr><td width='20%'><b>" + tr("SF%1").arg(i+1) + "</b></td><td>");
-      COMPARE(modelPrinter->printCustomFunctionLine(i));
-      columns.append("</td></tr>");
+      columns.appendRowStart(tr("SF%1").arg(i+1), 20);
+      COMPARECELL(modelPrinter->printCustomFunctionLine(i));
+      columns.appendRowEnd();
     }
   }
-  columns.append("</table>");
+  columns.appendTableEnd();
   if (count > 0) {
     str.append(printTitle(tr("Special Functions")));
     str.append(columns.print());
@@ -668,51 +759,179 @@ QString MultiModelPrinter::printCustomFunctions()
 
 QString MultiModelPrinter::printTelemetry()
 {
-  QString str = printTitle(tr("Telemetry Settings"));
+  QString str = printTitle(tr("Telemetry"));
+  MultiColumns columns(modelPrinterMap.size());
+  columns.appendSectionTableStart();
 
   // Analogs on non ARM boards
   if (!IS_ARM(firmware->getBoard())) {
-    MultiColumns columns(modelPrinterMap.size());
-    columns.append("<table border='0' cellspacing='0' cellpadding='1' width='100%'>" \
-                   "<tr><td width='22%'><b>" + tr("Analogs") + "</b></td><td width='26%'><b>" + tr("Unit") + "</b></td><td width='26%'><b>" + tr("Scale") + "</b></td><td width='26%'><b>" + tr("Offset") + "</b></td></tr>");
+    columns.appendRowHeader(QStringList() << tr("Analogs") << tr("Unit") << tr("Scale") << tr("Offset"));
     for (int i=0; i<2; i++) {
-      columns.append("<tr><td><b>"+tr("A%1").arg(i+1)+"</b></td><td>");
-      COMPARE(getFrSkyUnits(model->frsky.channels[i].type));
-      columns.append("</td><td>");
-      COMPARE(QString::number((model->frsky.channels[i].ratio / (model->frsky.channels[i].type==0 ? 10.0 : 1)), 10, (model->frsky.channels[i].type==0 ? 1 : 0)));
-      columns.append("</td><td>");
-      COMPARE(QString::number((model->frsky.channels[i].offset*(model->frsky.channels[i].ratio / (model->frsky.channels[i].type==0 ?10.0 : 1)))/255, 10, (model->frsky.channels[i].type==0 ? 1 : 0)));
-      columns.append("</td></tr>");
+      columns.appendRowStart(QString("A%1").arg(i+1), 20);
+      COMPARECELLWIDTH(getFrSkyUnits(model->frsky.channels[i].type), 20);
+      COMPARECELLWIDTH(QString::number((model->frsky.channels[i].ratio / (model->frsky.channels[i].type==0 ? 10.0 : 1)), 10, (model->frsky.channels[i].type==0 ? 1 : 0)), 20);
+      COMPARECELLWIDTH(QString::number((model->frsky.channels[i].offset*(model->frsky.channels[i].ratio / (model->frsky.channels[i].type==0 ?10.0 : 1)))/255, 10, (model->frsky.channels[i].type==0 ? 1 : 0)), 40);
+      columns.appendRowEnd();
     }
-    columns.append("</table><br/>");
-    str.append(columns.print());
-    // TODO I remove the analogs alarms for now
+  }
+  else {
+    // Protocol
+    columns.appendRowStart(tr("Protocol"), 20);
+    COMPARECELL(modelPrinter->printTelemetryProtocol(model->telemetryProtocol));
+    columns.appendRowEnd();
   }
 
   // RSSI alarms
   {
-    MultiColumns columns(modelPrinterMap.size());
-    columns.append("<table border='0' cellspacing='0' cellpadding='1' width='100%'>");
-    for (int i=0; i<2; i++) {
-      columns.append("<tr><td><b>" + QString(i==0 ? tr("RSSI Alarms") : "") + "</b></td><td>");
-      if (IS_ARM(getCurrentBoard())) {
-        COMPARE(i==0 ? tr("Low Alarm") : tr("Critical Alarm"));
-      }
-      else {
-        COMPARE(getFrSkyAlarmType(model->rssiAlarms.level[i]));
-      }
-      columns.append("</td><td>&lt;</td><td>");
-      if (i == 0) {
-        COMPARE(QString::number(model->rssiAlarms.warning, 10));
-      }
-      else {
-        COMPARE(QString::number(model->rssiAlarms.critical, 10));
-      }
-      columns.append("</td></tr>");
-    }
-    columns.append("</table><br/>");
-    str.append(columns.print());
+    columns.appendRowStart(tr("RSSI Alarms"), 20);
+    columns.appendCellStart(80);
+    COMPARESTRING("", (IS_ARM(getCurrentBoard()) ? tr("Low") : getFrSkyAlarmType(model->rssiAlarms.level[0])), false);
+    columns.append(": ");
+    COMPARESTRING("", QString("&lt; %1").arg(QString::number(model->rssiAlarms.warning, 10)), true);
+    COMPARESTRING("", (IS_ARM(getCurrentBoard()) ? tr("Critical") : getFrSkyAlarmType(model->rssiAlarms.level[1])), false);
+    columns.append(": ");
+    COMPARESTRING("", QString("&lt; %1").arg(QString::number(model->rssiAlarms.critical, 10)), true);
+    COMPARESTRING(tr("Telemetry audio"), modelPrinter->printRssiAlarmsDisabled(model->rssiAlarms.disabled), false);
+    columns.appendCellEnd();
+    columns.appendRowEnd();
   }
 
+  // Altimetry
+  if (firmware->getCapability(HasVario)) {
+    columns.appendRowStart(tr("Altimetry"), 20);
+    if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
+      LABELCOMPARECELL(tr("Vario source"), modelPrinter->printTelemetrySource(model->frsky.varioSource), 80);
+    }
+    else {
+      LABELCOMPARECELL(tr("Vario source"), modelPrinter->printVarioSource(model->frsky.varioSource), 80);
+    }
+    columns.appendRowEnd();
+    columns.appendRowStart("", 20);
+    columns.appendCellStart(80);
+    columns.appendTitle(tr("Vario limits >"));
+    if (firmware->getCapability(HasVarioSink)) {
+      COMPARESTRING(tr("Sink max"), QString::number(model->frsky.varioMin - 10), true);
+      COMPARESTRING(tr("Sink min"), QString::number((float(model->frsky.varioCenterMin) / 10.0) - 0.5), true);
+    }
+    COMPARESTRING(tr("Climb min"), QString::number((float(model->frsky.varioCenterMax) / 10.0) + 0.5), true);
+    COMPARESTRING(tr("Climb max"), QString::number(model->frsky.varioMax + 10), true);
+    COMPARESTRING(tr("Center silent"), modelPrinter->printVarioCenterSilent(model->frsky.varioCenterSilent), false);
+    columns.appendCellEnd();
+    columns.appendRowEnd();
+  }
+
+  // Top Bar
+  if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
+    columns.appendRowStart(tr("Top Bar"), 20);
+    columns.appendCellStart(80);
+    COMPARESTRING(tr("Volts source"), modelPrinter->printTelemetrySource(model->frsky.voltsSource), true);
+    COMPARESTRING(tr("Altitude source"), modelPrinter->printTelemetrySource(model->frsky.altitudeSource), false);
+    columns.appendCellEnd();
+    columns.appendRowEnd();
+  }
+
+  if (IS_ARM(firmware->getBoard())) {
+    ROWLABELCOMPARECELL("Multi sensors", 0, modelPrinter->printIgnoreSensorIds(!model->frsky.ignoreSensorIds), 0);
+  }
+
+  // Various
+  if (!IS_ARM(firmware->getBoard())) {
+    columns.appendRowHeader(QStringList() << tr("Various"));
+    if (!firmware->getCapability(NoTelemetryProtocol)) {
+      columns.appendRowStart("", 20);
+      LABELCOMPARECELL(tr("Serial protocol"), modelPrinter->printTelemetrySource(model->frsky.voltsSource), 80);
+      columns.appendRowEnd();
+    }
+    columns.appendRowStart("", 20);
+    columns.appendCellStart(80);
+    QString firmware_id = g.profile[g.id()].fwType();
+    if (firmware->getCapability(HasFasOffset) && firmware_id.contains("fasoffset")) {
+      COMPARESTRING(tr("FAS offset"), QString("%1 A").arg(model->frsky.fasOffset/10.0), true);
+    }
+    if (firmware->getCapability(HasMahPersistent)) {
+      COMPARESTRING(tr("mAh count"), QString("%1 mAh").arg(model->frsky.storedMah), true);
+      COMPARESTRING(tr("Persistent mAh"), modelPrinter->printMahPersistent(model->frsky.mAhPersistent), false);
+    }
+    columns.appendRowEnd();
+    columns.appendRowStart("", 20);
+    columns.appendCellStart(80);
+    COMPARESTRING(tr("Volts source"), modelPrinter->printVoltsSource(model->frsky.voltsSource), true);
+    COMPARESTRING(tr("Current source"), modelPrinter->printCurrentSource(model->frsky.currentSource), false);
+    columns.appendCellEnd();
+    columns.appendRowEnd();
+    columns.appendRowStart("", 20);
+    LABELCOMPARECELL(tr("Blades"), model->frsky.blades, 80);
+    columns.appendRowEnd();
+  }
+  columns.appendTableEnd();
+  str.append(columns.print());
+  return str;
+}
+
+QString MultiModelPrinter::printSensors()
+{
+  MultiColumns columns(modelPrinterMap.size());
+  QString str;
+  int count = 0;
+  columns.appendSectionTableStart();
+  columns.appendRowHeader(QStringList() << tr("Name") << tr("Type") << tr("Parameters"));
+  //columns.appendRowHeader(QStringList() << tr("Name") << tr("Type") << tr("Formula/Source") << tr("Unit") << tr("Prec") << tr("Ratio") << tr("Ofst") << tr("A.Ofst") << tr("Fltr") << tr("Pers.") << tr("+ve") << tr("Log"));
+  for (int i=0; i<CPN_MAX_SENSORS; ++i) {
+    bool tsEmpty = true;
+    for (int k=0; k < modelPrinterMap.size(); k++) {
+      if (modelPrinterMap.value(k).first->sensorData[i].isAvailable()) {
+        tsEmpty = false;
+        break;
+      }
+    }
+    if (!tsEmpty) {
+      count++;
+      columns.appendRowStart();
+      columns.appendCellStart(15, true);
+      COMPARE(model->sensorData[i].nameToString(i));
+      columns.appendCellEnd(true);
+      COMPARECELLWIDTH(modelPrinter->printSensorTypeCond(i), 15);
+      COMPARECELLWIDTH(modelPrinter->printSensorParams(i), 70);
+      //COMPARESTRING("", modelPrinter->printSensorDetails(i), 0);
+      columns.appendRowEnd();
+    }
+  }
+  columns.appendTableEnd();
+  if (count > 0) {
+    str.append(printTitle(tr("Telemetry Sensors")));
+    str.append(columns.print());
+  }
+  return str;
+}
+
+QString MultiModelPrinter::printTelemetryScreens()
+{
+  MultiColumns columns(modelPrinterMap.size());
+  QString str;
+  int count = 0;
+  columns.appendSectionTableStart();
+  for (int i=0; i<firmware->getCapability(TelemetryCustomScreens); ++i) {
+    bool tsEmpty = true;
+    for (int k=0; k < modelPrinterMap.size(); k++) {
+      if (!modelPrinterMap.value(k).first->frsky.screens[i].type == TELEMETRY_SCREEN_NONE) {
+        tsEmpty = false;
+        break;
+      }
+    }
+    if (!tsEmpty) {
+      count++;
+      columns.appendRowStart();
+      LABELCOMPARECELL(QString("%1").arg(i+1), modelPrinter->printTelemetryScreenType(model->frsky.screens[i].type), 20);
+      columns.appendRowEnd();
+      for (int l=0; l<4; l++) {
+        COMPARE(modelPrinter->printTelemetryScreen(i, l, 80));
+      }
+    }
+  }
+  columns.appendTableEnd();
+  if (count > 0) {
+    str.append(printTitle(tr("Telemetry Screens")));
+    str.append(columns.print());
+  }
   return str;
 }
diff --git a/companion/src/multimodelprinter.h b/companion/src/multimodelprinter.h
index c9045ae5c..f5a0f609d 100644
--- a/companion/src/multimodelprinter.h
+++ b/companion/src/multimodelprinter.h
@@ -51,7 +51,22 @@ class MultiModelPrinter: public QObject
         void append(int idx, const QString & str);
         template <class T> void append(int idx, T val);
         void beginCompare();
-        void endCompare(const QString & color = "grey");
+        void endCompare(const QString & color = "black"); // was grey
+        void appendLineBreak();
+        void appendSectionTableStart();
+        void appendTableEnd();
+        void appendRowStart(const QString & title = "", const unsigned int titlewidth = 0);
+        void appendRowEnd();
+        void appendCellStart(const unsigned int width = 0, const bool bold = false);
+        void appendCellEnd(const bool bold = false);
+        void appendLabelCell(const QString & str, const unsigned int width = 0, const QString & align = "left", const QString & color = "");
+        void appendValueCell(const QString & str, const unsigned int width = 0, const QString & align = "left", const QString & color = "");
+        void appendRow(const QStringList & strl, const unsigned int width = 0, const QString & align = "left", const QString & color = "");
+        void appendRowHeader(const QStringList & strl, const unsigned int width = 0, const QString & align = "left", const QString & color = "");
+        void appendRowBlank();
+        void appendFieldLabel(const QString & lbl = "");
+        void appendFieldSeparator(const bool sep = false);
+
       private:
         int count;
         QString * columns;
@@ -73,9 +88,11 @@ class MultiModelPrinter: public QObject
     QString printCurves(QTextDocument * document);
     QString printGvars();
     QString printLogicalSwitches();
-    QString printCustomFunctions();
+    QString printSpecialFunctions();
     QString printTelemetry();
     QString printTimers();
+    QString printSensors();
+    QString printTelemetryScreens();
 };
 
 #endif // _MULTIMODELPRINTER_H_