Add debug view

TouchGFX/gui/include/gui/common/DataField.hpp

@@ -2,6 +2,7 @@
 #define DATAFIELD_HPP
 
 #include "touchgfx/TypedText.hpp"
+#include "touchgfx/Unicode.hpp"
 #include <stddef.h>
 #include <stdint.h>
 
@@ -20,17 +21,51 @@ CountedEnum(DataFieldType, size_t, DF_TSState, DF_ASState, DF_ActiveMission,
             DF_TSSoC, DF_LVSoC, DF_TSCurrent, DF_TSVoltageBat, DF_TSVoltageVeh,
             DF_Speed, DF_BBal);
 
-enum class DataFieldKind { Numeric, Bool, Text };
+enum class DataFieldKind { Float, Bool, Text, Int };
 
 struct DataFieldDescription {
   DataFieldKind kind;
-  touchgfx::TypedText title;
+  const char *title;
   size_t int_digits;
   size_t decimal_digits;
 
-  void* (*getValue)(void);
+  void *(*getValue)(void);
 };
 
 extern DataFieldDescription dataFieldDescs[];
 
+class DataField {
+public:
+  virtual ~DataField() {}
+
+  void setType(DataFieldType type);
+  DataFieldType getType();
+
+  virtual void updateValue();
+
+protected:
+  touchgfx::Unicode::UnicodeChar titleBuffer[16];
+  touchgfx::Unicode::UnicodeChar valueBuffer[16];
+
+  DataFieldType type;
+  const DataFieldDescription *desc;
+  union {
+    float f;
+    int b;
+    int i;
+  } fieldValue;
+
+  virtual void typeUpdated() = 0;
+  virtual void titleBufferUpdated() = 0;
+  virtual void valueBufferUpdated() = 0;
+
+private:
+  void setFloatValue(float floatValue);
+  void setBoolValue(int boolValue);
+  void setIntValue(int intValue);
+  void setStrValue(const char *strValue);
+
+  void updateValueBuffer();
+};
+
 #endif // DATAFIELD_HPP

TouchGFX/gui/include/gui/containers/DebugViewItem.hpp

@@ -0,0 +1,20 @@
+#ifndef DEBUGVIEWITEM_HPP
+#define DEBUGVIEWITEM_HPP
+
+#include "gui/common/DataField.hpp"
+#include <gui_generated/containers/DebugViewItemBase.hpp>
+
+class DebugViewItem : public DebugViewItemBase, public DataField {
+public:
+  DebugViewItem();
+  virtual ~DebugViewItem() {}
+
+  virtual void initialize() override;
+
+protected:
+  virtual void typeUpdated() override;
+  virtual void titleBufferUpdated() override;
+  virtual void valueBufferUpdated() override;
+};
+
+#endif // DEBUGVIEWITEM_HPP

TouchGFX/gui/include/gui/containers/DebugViewLine.hpp

@@ -0,0 +1,27 @@
+#ifndef DEBUGVIEWLINE_HPP
+#define DEBUGVIEWLINE_HPP
+
+#include "gui/common/DataField.hpp"
+#include "gui/containers/DebugViewItem.hpp"
+#include <gui_generated/containers/DebugViewLineBase.hpp>
+
+class DebugViewLine : public DebugViewLineBase {
+public:
+  DebugViewLine();
+  virtual ~DebugViewLine() {}
+
+  virtual void initialize();
+
+  void setFieldType(size_t i, DataFieldType type);
+  void setFieldVisible(size_t i, int visible);
+  void updateFieldValues();
+  void setLightBG(int light);
+
+  static constexpr size_t NUM_FIELDS = 2;
+
+protected:
+private:
+  DebugViewItem *fields[NUM_FIELDS];
+};
+
+#endif // DEBUGVIEWLINE_HPP

TouchGFX/gui/include/gui/containers/DriverViewField.hpp

@@ -7,31 +7,20 @@
 
 #include "gui/common/DataField.hpp"
 
-class DriverViewField : public DriverViewFieldBase {
+class DriverViewField : public DriverViewFieldBase, public DataField {
 public:
   DriverViewField();
   virtual ~DriverViewField() {}
 
-  virtual void initialize();
-
-  void setType(const DataFieldDescription &desc);
-  void setValue(float newValue);
-  void setValue(const char *str);
-  void setValue(int boolValue);
+  virtual void initialize() override;
 
   void setSelected(int selected);
 
 protected:
 private:
-  Unicode::UnicodeChar valueBuffer[16];
-
-  DataFieldKind fieldKind;
-  size_t intDigits;
-  size_t decimalDigits;
-  float floatValue;
-  int boolValue;
-
-  void updateValueBuffer();
+  virtual void typeUpdated() override;
+  virtual void titleBufferUpdated() override;
+  virtual void valueBufferUpdated() override;
 };
 
 #endif // DRIVERVIEWFIELD_HPP

TouchGFX/gui/include/gui/containers/DriverViewFieldSelection.hpp

@@ -2,6 +2,7 @@
 #define DRIVERVIEWFIELDSELECTION_HPP
 
 #include "touchgfx/TypedText.hpp"
+#include "touchgfx/Unicode.hpp"
 #include <gui_generated/containers/DriverViewFieldSelectionBase.hpp>
 
 class DriverViewFieldSelection : public DriverViewFieldSelectionBase {
@@ -11,10 +12,12 @@ public:
 
   virtual void initialize();
 
-  void setName(const touchgfx::TypedText &name);
+  void setName(const char *name);
   void setSelected(int selected);
 
 protected:
+private:
+  Unicode::UnicodeChar nameBuffer[16];
 };
 
 #endif // DRIVERVIEWFIELDSELECTION_HPP

TouchGFX/gui/include/gui/debugview_screen/DebugViewPresenter.hpp

@@ -0,0 +1,38 @@
+#ifndef DEBUGVIEWPRESENTER_HPP
+#define DEBUGVIEWPRESENTER_HPP
+
+#include <gui/model/ModelListener.hpp>
+#include <mvp/Presenter.hpp>
+
+using namespace touchgfx;
+
+class DebugViewView;
+
+class DebugViewPresenter : public touchgfx::Presenter, public ModelListener {
+public:
+  DebugViewPresenter(DebugViewView &v);
+
+  /**
+   * The activate function is called automatically when this screen is "switched
+   * in" (ie. made active). Initialization logic can be placed here.
+   */
+  virtual void activate() override;
+
+  /**
+   * The deactivate function is called automatically when this screen is
+   * "switched out" (ie. made inactive). Teardown functionality can be placed
+   * here.
+   */
+  virtual void deactivate() override;
+
+  virtual ~DebugViewPresenter(){};
+
+  virtual void vehicleStateUpdated() override;
+
+private:
+  DebugViewPresenter();
+
+  DebugViewView &view;
+};
+
+#endif // DEBUGVIEWPRESENTER_HPP

TouchGFX/gui/include/gui/debugview_screen/DebugViewView.hpp

@@ -0,0 +1,21 @@
+#ifndef DEBUGVIEWVIEW_HPP
+#define DEBUGVIEWVIEW_HPP
+
+#include <gui/debugview_screen/DebugViewPresenter.hpp>
+#include <gui_generated/debugview_screen/DebugViewViewBase.hpp>
+
+class DebugViewView : public DebugViewViewBase {
+public:
+  DebugViewView();
+  virtual ~DebugViewView() {}
+  virtual void setupScreen() override;
+  virtual void tearDownScreen() override;
+
+  virtual void listUpdateItem(DebugViewLine &line, int16_t itemIndex) override;
+
+  void updateFieldValues();
+
+protected:
+};
+
+#endif // DEBUGVIEWVIEW_HPP

TouchGFX/gui/include/gui/driverview_screen/DriverViewPresenter.hpp

@@ -18,19 +18,21 @@ public:
    * The activate function is called automatically when this screen is "switched
    * in" (ie. made active). Initialization logic can be placed here.
    */
-  virtual void activate();
+  virtual void activate() override;
 
   /**
    * The deactivate function is called automatically when this screen is
    * "switched out" (ie. made inactive). Teardown functionality can be placed
    * here.
    */
-  virtual void deactivate();
+  virtual void deactivate() override;
 
   virtual ~DriverViewPresenter(){};
 
   void vehicleStateUpdated() override;
 
+  void setFieldType(size_t i, DataFieldType type);
+
 private:
   DriverViewPresenter();
 

TouchGFX/gui/include/gui/driverview_screen/DriverViewView.hpp

@@ -12,16 +12,14 @@ class DriverViewView : public DriverViewViewBase {
 public:
   DriverViewView();
   virtual ~DriverViewView() {}
-  virtual void setupScreen();
-  virtual void tearDownScreen();
+  virtual void setupScreen() override;
+  virtual void tearDownScreen() override;
 
   void fieldTypeSelectionUpdateItem(DriverViewFieldSelection &item,
                                     int16_t itemIndex) override;
 
-  void setFieldType(size_t i, const DataFieldDescription &desc);
-  void setFieldValue(size_t i, float value);
-  void setFieldValue(size_t i, const char *value);
-  void setFieldValue(size_t i, int value);
+  void setFieldType(size_t i, DataFieldType type);
+  void updateFieldValues();
 
   void setTireTemps(const TireTemps &temps);
   void setTSSoC(uint8_t soc);
@@ -37,7 +35,6 @@ public:
 protected:
 private:
   DriverViewField &getField(size_t i);
-  DriverViewFieldSelection *getFieldType(size_t i);
 
   void updateSelectedField(size_t select);
   void updateSelectedFieldType(size_t select);

TouchGFX/gui/src/common/DataField.cpp

@@ -1,6 +1,7 @@
 #include "gui/common/DataField.hpp"
 #include "texts/TextKeysAndLanguages.hpp"
 
+#include "touchgfx/Unicode.hpp"
 #include "vehicle.h"
 
 #define VEH_FIELD(FIELD) []() { return (void *)&vehicle_state.FIELD; }
@@ -11,50 +12,219 @@
     return (void *)&x;                                                         \
   }
 
-void *get_sdc_text() {
-  if (vehicle_state.errors.sdc_bfl) {
-    return (void *)"BFL";
-  } else if (vehicle_state.errors.sdc_brl) {
-    return (void *)"BRL";
-  } else if (vehicle_state.errors.sdc_acc) {
-    return (void *)"ACC";
-  } else if (vehicle_state.errors.sdc_hvb) {
-    return (void *)"HVB";
-  } else {
-    return (void *)"CLOSED";
+void *get_tsstate_text() {
+  const char *text;
+  switch (vehicle_state.ts_state) {
+  case TS_INACTIVE:
+    text = "INACT";
+    break;
+  case TS_ACTIVE:
+    text = "ACT";
+    break;
+  case TS_PRECHARGE:
+    text = "PRECH";
+    break;
+  case TS_DISCHARGE:
+    text = "DISCH";
+    break;
+  case TS_ERROR:
+    text = "ERROR";
+    break;
+  case TS_CHARGING_CHECK:
+    text = "CH_CHK";
+    break;
+  case TS_CHARGING:
+    text = "CH";
+    break;
+  default:
+    text = "UNKNOWN";
   }
+  return (void *)text;
+}
+
+void *get_asstate_text() {
+  const char *text;
+  switch (vehicle_state.as_state) {
+  case AS_OFF:
+    text = "OFF";
+    break;
+  case AS_MANUAL:
+    text = "MAN";
+    break;
+  case AS_READY:
+    text = "RDY";
+    break;
+  case AS_DRIVING:
+    text = "DRIVE";
+    break;
+  case AS_FINISHED:
+    text = "FIN";
+    break;
+  case AS_EMERGENCY:
+    text = "EMERG";
+    break;
+  default:
+    text = "UNKNOWN";
+  }
+  return (void *)text;
+}
+
+void *get_mission_text() {
+  const char *text;
+  switch (vehicle_state.active_mission) {
+  case MISSION_NONE:
+    text = "NONE";
+    break;
+  case MISSION_ACCEL:
+    text = "ACCEL";
+    break;
+  case MISSION_SKIDPAD:
+    text = "SKIDPAD";
+    break;
+  case MISSION_AUTOX:
+    text = "AUTOX";
+    break;
+  case MISSION_TRACKDRIVE:
+    text = "TRACK";
+    break;
+  case MISSION_EBS:
+    text = "EBS";
+    break;
+  case MISSION_INSPECTION:
+    text = "INSPECT";
+    break;
+  case MISSION_MANUAL:
+    text = "MAN";
+    break;
+  default:
+    text = "UNKNOWN";
+  }
+  return (void *)text;
+}
+
+void *get_r2dprog_text() {
+  const char *text;
+  switch (vehicle_state.r2d_progress) {
+  case R2D_NONE:
+    text = "NONE";
+    break;
+  case R2D_TSMS:
+    text = "TSMS";
+    break;
+  case R2D_TSACTIVE:
+    text = "TSACT";
+    break;
+  case R2D_RESETTING_NODES:
+    text = "RST NODE";
+    break;
+  case R2D_RESETTING_COMMS:
+    text = "RST COM";
+    break;
+  case R2D_WAITING_INIT:
+    text = "WAIT INIT";
+    break;
+  case R2D_INIT_STAGE1:
+    text = "INIT S1";
+    break;
+  case R2D_INIT_STAGE2:
+    text = "INIT S2";
+    break;
+  case R2D_INIT_SUCCESS:
+    text = "INIT SUCC";
+    break;
+  default:
+    text = "UNKNOWN";
+  }
+  return (void *)text;
+}
+
+void *get_inichk_text() {
+  const char *text;
+  switch (vehicle_state.ini_chk_state) {
+  case INICHK_START:
+    text = "START";
+    break;
+  case INICHK_WD_CHECK:
+    text = "WD CHK";
+    break;
+  case INICHK_WD_OK:
+    text = "WD OK";
+    break;
+  case INICHK_ASB_CHECK_1:
+    text = "ASB CHK1";
+    break;
+  case INICHK_ASB_CHECK_2:
+    text = "ASB CHK2";
+    break;
+  case INICHK_WAIT_TS:
+    text = "WAIT TS";
+    break;
+  case INICHK_EBS_CHECK_A:
+    text = "EBS CHKA";
+    break;
+  case INICHK_EBS_CHECK_B:
+    text = "EBS CHKB";
+    break;
+  case INICHK_DONE:
+    text = "DONE";
+    break;
+  case INICHK_ERROR:
+    text = "ERROR";
+    break;
+  default:
+    text = "UNKNOWN";
+  }
+  return (void *)text;
+}
+
+void *get_sdc_text() {
+  const char *text;
+  if (vehicle_state.errors.sdc_bfl) {
+    text = "BFL";
+  } else if (vehicle_state.errors.sdc_brl) {
+    text = "BRL";
+  } else if (vehicle_state.errors.sdc_acc) {
+    text = "ACC";
+  } else if (vehicle_state.errors.sdc_hvb) {
+    text = "HVB";
+  } else {
+    text = "CLOSED";
+  }
+  return (void *)text;
 }
 
 void *get_err_text() {
+  const char *text;
   if (vehicle_state.errors.err_sdc) {
-    return (void *)"SDC";
+    text = "SDC";
   } else if (vehicle_state.errors.err_ams) {
-    return (void *)"AMS";
+    text = "AMS";
   } else if (vehicle_state.errors.err_pdu) {
-    return (void *)"PDU";
+    text = "PDU";
   } else if (vehicle_state.errors.err_ini_chk) {
-    return (void *)"IniChk";
+    text = "IniChk";
   } else if (vehicle_state.errors.err_con_mon) {
-    return (void *)"ConMon";
+    text = "ConMon";
   } else if (vehicle_state.errors.err_scs) {
-    return (void *)"SCS";
+    text = "SCS";
   } else if (vehicle_state.errors.err_sbspd) {
-    return (void *)"sBSPD";
+    text = "sBSPD";
   } else if (vehicle_state.errors.err_appsp) {
-    return (void *)"APPSp";
+    text = "APPSp";
   } else if (vehicle_state.errors.err_as) {
-    return (void *)"AS";
+    text = "AS";
   } else if (vehicle_state.errors.err_ros) {
-    return (void *)"ROS";
+    text = "ROS";
   } else if (vehicle_state.errors.err_res) {
-    return (void *)"RES";
+    text = "RES";
   } else if (vehicle_state.errors.err_invl) {
-    return (void *)"INVL";
+    text = "INVL";
   } else if (vehicle_state.errors.err_invr) {
-    return (void *)"INVR";
+    text = "INVR";
   } else {
-    return (void *)"NONE";
+    text = "NONE";
   }
+  return (void *)text;
 }
 
 void *get_zero() {
@@ -63,48 +233,124 @@ void *get_zero() {
 }
 
 DataFieldDescription dataFieldDescs[] = {
-    [DF_TSState] = {DataFieldKind::Numeric, T_FIELD_TSSTATE, 1, 0,
-                    VEH_FIELD(ts_state)},
-    [DF_ASState] = {DataFieldKind::Numeric, T_FIELD_ASSTATE, 1, 0,
-                    VEH_FIELD(as_state)},
-    [DF_ActiveMission] = {DataFieldKind::Numeric, T_FIELD_ACTIVEMISSION, 1, 0,
-                          VEH_FIELD(active_mission)},
-    [DF_R2DProgress] = {DataFieldKind::Numeric, T_FIELD_R2DPROGRESS, 1, 0,
-                        VEH_FIELD(r2d_progress)},
-    [DF_INVLReady] = {DataFieldKind::Bool, T_FIELD_INVLREADY, 0, 0,
+    [DF_TSState] = {DataFieldKind::Text, "TSSTATE", 1, 0, get_tsstate_text},
+    [DF_ASState] = {DataFieldKind::Text, "ASSTATE", 1, 0, get_asstate_text},
+    [DF_ActiveMission] = {DataFieldKind::Text, "MISSION", 1, 0,
+                          get_mission_text},
+    [DF_R2DProgress] = {DataFieldKind::Text, "R2DPROG", 1, 0, get_r2dprog_text},
+    [DF_INVLReady] = {DataFieldKind::Bool, "INVLRDY", 0, 0,
                       VEH_BIT_FIELD(errors.invl_ready)},
-    [DF_INVRReady] = {DataFieldKind::Bool, T_FIELD_INVRREADY, 0, 0,
+    [DF_INVRReady] = {DataFieldKind::Bool, "INVRRDY", 0, 0,
                       VEH_BIT_FIELD(errors.invr_ready)},
-    [DF_SDC] = {DataFieldKind::Text, T_FIELD_SDC, 0, 0, get_sdc_text},
-    [DF_ERR] = {DataFieldKind::Text, T_FIELD_ERR, 0, 0, get_err_text},
-    [DF_IniChkState] = {DataFieldKind::Numeric, T_FIELD_INICHKSTATE, 1, 0,
-                        VEH_FIELD(ini_chk_state)},
-    [DF_LapCount] = {DataFieldKind::Numeric, T_FIELD_LAPCOUNT, 3, 0,
-                     VEH_FIELD(lap_count)},
-    [DF_TireTempFL] = {DataFieldKind::Numeric, T_FIELD_TIREFL, 2, 1,
+    [DF_SDC] = {DataFieldKind::Text, "SDC", 0, 0, get_sdc_text},
+    [DF_ERR] = {DataFieldKind::Text, "ERROR", 0, 0, get_err_text},
+    [DF_IniChkState] = {DataFieldKind::Text, "ICSTATE", 1, 0, get_inichk_text},
+    [DF_LapCount] = {DataFieldKind::Int, "LAPS", 3, 0, VEH_FIELD(lap_count)},
+    [DF_TireTempFL] = {DataFieldKind::Float, "TTFL", 2, 1,
                        VEH_FIELD(tire_temps.fl)},
-    [DF_TireTempFR] = {DataFieldKind::Numeric, T_FIELD_TIREFR, 2, 1,
+    [DF_TireTempFR] = {DataFieldKind::Float, "TTFR", 2, 1,
                        VEH_FIELD(tire_temps.fr)},
-    [DF_TireTempRL] = {DataFieldKind::Numeric, T_FIELD_TIRERL, 2, 1,
+    [DF_TireTempRL] = {DataFieldKind::Float, "TTRL", 2, 1,
                        VEH_FIELD(tire_temps.rl)},
-    [DF_TireTempRR] = {DataFieldKind::Numeric, T_FIELD_TIRERR, 2, 1,
+    [DF_TireTempRR] = {DataFieldKind::Float, "TTRR", 2, 1,
                        VEH_FIELD(tire_temps.rr)},
-    [DF_MinCellVolt] = {DataFieldKind::Numeric, T_FIELD_MINCELLVOLT, 1, 2,
+    [DF_MinCellVolt] = {DataFieldKind::Float, "VMIN", 1, 2,
                         VEH_FIELD(min_cell_volt)},
-    [DF_MaxCellTemp] = {DataFieldKind::Numeric, T_FIELD_MAXCELLTEMP, 2, 1,
+    [DF_MaxCellTemp] = {DataFieldKind::Float, "TMAX", 2, 1,
                         VEH_FIELD(max_cell_temp)},
-    [DF_TSSoC] = {DataFieldKind::Numeric, T_FIELD_TSSOC, 3, 0, VEH_FIELD(soc)},
-    [DF_LVSoC] = {DataFieldKind::Numeric, T_FIELD_LVSOC, 3, 0, get_zero},
-    [DF_TSCurrent] = {DataFieldKind::Numeric, T_FIELD_TSCURRENT, 3, 0,
-                      VEH_FIELD(ts_current)},
-    [DF_TSVoltageBat] = {DataFieldKind::Numeric, T_FIELD_TSVOLTBAT, 3, 1,
+    [DF_TSSoC] = {DataFieldKind::Int, "TSSOC", 3, 0, VEH_FIELD(soc)},
+    [DF_LVSoC] = {DataFieldKind::Float, "LVSOC", 3, 0, get_zero},
+    [DF_TSCurrent] = {DataFieldKind::Float, "ITS", 3, 0, VEH_FIELD(ts_current)},
+    [DF_TSVoltageBat] = {DataFieldKind::Float, "TSVBAT", 3, 1,
                          VEH_FIELD(ts_voltage_bat)},
-    [DF_TSVoltageVeh] = {DataFieldKind::Numeric, T_FIELD_TSVOLTVEH, 3, 1,
+    [DF_TSVoltageVeh] = {DataFieldKind::Float, "TSVVEH", 3, 1,
                          VEH_FIELD(ts_voltage_veh)},
-    [DF_Speed] = {DataFieldKind::Numeric, T_FIELD_SPEED, 3, 0, get_zero},
-    [DF_BBal] = {DataFieldKind::Numeric, T_FIELD_BBAL, 3, 1, get_zero},
+    [DF_Speed] = {DataFieldKind::Float, "SPEED", 3, 0, get_zero},
+    [DF_BBal] = {DataFieldKind::Float, "BBAL", 3, 1, get_zero},
 };
 
 static_assert(sizeof(dataFieldDescs) / sizeof(dataFieldDescs[0]) ==
                   DataFieldType_COUNT,
               "Incorrect number of data field descriptions");
+
+void DataField::setType(DataFieldType type) {
+  this->type = type;
+  desc = &dataFieldDescs[type];
+
+  touchgfx::Unicode::strncpy(titleBuffer, desc->title,
+                             sizeof(titleBuffer) / sizeof(*titleBuffer));
+  titleBufferUpdated();
+
+  typeUpdated();
+  updateValue();
+}
+
+void DataField::updateValue() {
+  void *val = desc->getValue();
+  switch (desc->kind) {
+  case DataFieldKind::Float:
+    setFloatValue(*static_cast<float *>(val));
+    break;
+  case DataFieldKind::Bool:
+    setBoolValue(*static_cast<int *>(val));
+    break;
+  case DataFieldKind::Text:
+    setStrValue(static_cast<const char *>(val));
+    break;
+  case DataFieldKind::Int:
+    setIntValue(*static_cast<int *>(val));
+    break;
+  }
+}
+
+void DataField::setFloatValue(float floatValue) {
+  fieldValue.f = floatValue;
+  updateValueBuffer();
+}
+
+void DataField::setBoolValue(int boolValue) {
+  fieldValue.b = boolValue;
+  updateValueBuffer();
+}
+
+void DataField::setIntValue(int intValue) {
+  fieldValue.i = intValue;
+  updateValueBuffer();
+}
+
+void DataField::setStrValue(const char *strValue) {
+  touchgfx::Unicode::strncpy(valueBuffer, strValue,
+                             sizeof(valueBuffer) / sizeof(*valueBuffer));
+  updateValueBuffer();
+}
+
+void DataField::updateValueBuffer() {
+  switch (desc->kind) {
+  case DataFieldKind::Float: {
+    size_t width = desc->int_digits;
+    if (desc->decimal_digits != 0) {
+      width += desc->decimal_digits + 1; // 1 digit for the decimal point
+    }
+    float params[3] = {(float)width, (float)desc->decimal_digits, fieldValue.f};
+    touchgfx::Unicode::snprintfFloats(
+        valueBuffer, sizeof(valueBuffer) / sizeof(*valueBuffer), "%*.*f",
+        params);
+    break;
+  }
+  case DataFieldKind::Bool: {
+    const char *str = fieldValue.b ? "YES" : "NO";
+    touchgfx::Unicode::strncpy(valueBuffer, str,
+                               sizeof(valueBuffer) / sizeof(*valueBuffer));
+    break;
+  }
+  case DataFieldKind::Text:
+    // This is handled by the child class in setValue()
+    break;
+  case DataFieldKind::Int:
+    touchgfx::Unicode::snprintf(valueBuffer,
+                                sizeof(valueBuffer) / sizeof(*valueBuffer),
+                                "%*d", desc->int_digits, fieldValue.i);
+    break;
+  }
+  valueBufferUpdated();
+}

TouchGFX/gui/src/containers/DebugViewItem.cpp

@@ -0,0 +1,19 @@
+#include <gui/containers/DebugViewItem.hpp>
+
+DebugViewItem::DebugViewItem() {}
+
+void DebugViewItem::initialize() { DebugViewItemBase::initialize(); }
+
+void DebugViewItem::typeUpdated() {
+  // We don't really need to do anything
+}
+
+void DebugViewItem::titleBufferUpdated() {
+  label.setWildcard(titleBuffer);
+  label.invalidate();
+}
+
+void DebugViewItem::valueBufferUpdated() {
+  value.setWildcard(valueBuffer);
+  value.invalidate();
+}

TouchGFX/gui/src/containers/DebugViewLine.cpp

@@ -0,0 +1,29 @@
+#include "gui/common/DataField.hpp"
+#include "touchgfx/Color.hpp"
+#include <gui/containers/DebugViewLine.hpp>
+
+DebugViewLine::DebugViewLine() : fields{&item1, &item2} {}
+
+void DebugViewLine::initialize() { DebugViewLineBase::initialize(); }
+
+void DebugViewLine::setFieldType(size_t i, DataFieldType type) {
+  assert(i < NUM_FIELDS);
+  fields[i]->setType(type);
+}
+
+void DebugViewLine::setFieldVisible(size_t i, int visible) {
+  fields[i]->setVisible(visible);
+  fields[i]->invalidate();
+}
+
+void DebugViewLine::updateFieldValues() {
+  for (size_t i = 0; i < NUM_FIELDS; i++) {
+    fields[i]->updateValue();
+  }
+}
+
+void DebugViewLine::setLightBG(int light) {
+  uint8_t val = light ? 0x33 : 0x00;
+  bg.setColor(Color::getColorFromRGB(val, val, val));
+  bg.invalidate();
+}

TouchGFX/gui/src/containers/DriverViewField.cpp

@@ -1,79 +1,40 @@
 #include "gui/common/DataField.hpp"
 #include "texts/TextKeysAndLanguages.hpp"
 #include "touchgfx/Color.hpp"
+#include "touchgfx/TypedText.hpp"
 #include "touchgfx/Unicode.hpp"
 #include <gui/containers/DriverViewField.hpp>
 
-DriverViewField::DriverViewField()
-    : intDigits{0}, decimalDigits{0}, floatValue{0}, boolValue{0} {}
+DriverViewField::DriverViewField() {}
 
 void DriverViewField::initialize() { DriverViewFieldBase::initialize(); }
 
-void DriverViewField::setType(const DataFieldDescription &desc) {
-  title.setTypedText(desc.title);
-  title.invalidate();
-  fieldKind = desc.kind;
-  switch (desc.kind) {
-  case DataFieldKind::Numeric:
-    value.setTypedText(T_NUMBERWILDCARD);
-    break;
-  case DataFieldKind::Bool:
-  case DataFieldKind::Text:
-    value.setTypedText(T_DEFAULTWILDCARD);
-    break;
-  }
-  intDigits = desc.int_digits;
-  decimalDigits = desc.decimal_digits;
-  updateValueBuffer();
-}
-
-void DriverViewField::setValue(float newValue) {
-  floatValue = newValue;
-  updateValueBuffer();
-}
-
-void DriverViewField::setValue(const char *str) {
-  Unicode::strncpy(valueBuffer, str,
-                   sizeof(valueBuffer) / sizeof(Unicode::UnicodeChar));
-  value.setWildcard(valueBuffer);
-  value.invalidate();
-}
-
-void DriverViewField::setValue(int boolValue) {
-  this->boolValue = boolValue;
-  updateValueBuffer();
-}
-
 void DriverViewField::setSelected(int selected) {
   uint8_t v = selected ? 0x44 : 0x00;
   box.setColor(touchgfx::Color::getColorFromRGB(v, v, v));
   box.invalidate();
 }
 
-void DriverViewField::updateValueBuffer() {
-  switch (fieldKind) {
-  case DataFieldKind::Numeric: {
-    size_t width = intDigits;
-    if (decimalDigits != 0) {
-      width += decimalDigits + 1; // 1 digit for the decimal point
-    }
-    float params[3] = {(float)width, (float)decimalDigits, floatValue};
-    Unicode::snprintfFloats(valueBuffer,
-                            sizeof(valueBuffer) / sizeof(Unicode::UnicodeChar),
-                            "%*.*f", params);
-    value.setWildcard(valueBuffer);
+void DriverViewField::typeUpdated() {
+  switch (desc->kind) {
+  case DataFieldKind::Float:
+  case DataFieldKind::Int:
+    value.setTypedText(T_NUMBERWILDCARD);
     break;
-  }
-  case DataFieldKind::Bool: {
-    const char *str = boolValue ? "YES" : "NO";
-    Unicode::strncpy(valueBuffer, str,
-                     sizeof(valueBuffer) / sizeof(valueBuffer[0]));
-    value.setWildcard(valueBuffer);
-    break;
-  }
+  case DataFieldKind::Bool:
   case DataFieldKind::Text:
-    // This is updated directly in setValue()
+    value.setTypedText(T_DEFAULTWILDCARD_CENTERED);
     break;
   }
   value.invalidate();
 }
+
+void DriverViewField::titleBufferUpdated() {
+  title.setWildcard(titleBuffer);
+  title.invalidate();
+}
+
+void DriverViewField::valueBufferUpdated() {
+  value.setWildcard(valueBuffer);
+  value.invalidate();
+}

TouchGFX/gui/src/containers/DriverViewFieldSelection.cpp

@@ -1,4 +1,5 @@
 #include "touchgfx/Color.hpp"
+#include "touchgfx/Unicode.hpp"
 #include <gui/containers/DriverViewFieldSelection.hpp>
 
 DriverViewFieldSelection::DriverViewFieldSelection() {}
@@ -7,8 +8,10 @@ void DriverViewFieldSelection::initialize() {
   DriverViewFieldSelectionBase::initialize();
 }
 
-void DriverViewFieldSelection::setName(const touchgfx::TypedText &name) {
-  this->name.setTypedText(name);
+void DriverViewFieldSelection::setName(const char *name) {
+  Unicode::strncpy(nameBuffer, name, sizeof(nameBuffer) / sizeof(*nameBuffer));
+  this->name.setWildcard(nameBuffer);
+  this->name.invalidate();
 }
 
 void DriverViewFieldSelection::setSelected(int selected) {

TouchGFX/gui/src/debugview_screen/DebugViewPresenter.cpp

@@ -0,0 +1,11 @@
+#include <gui/debugview_screen/DebugViewPresenter.hpp>
+#include <gui/debugview_screen/DebugViewView.hpp>
+
+
+DebugViewPresenter::DebugViewPresenter(DebugViewView &v) : view(v) {}
+
+void DebugViewPresenter::activate() {}
+
+void DebugViewPresenter::deactivate() {}
+
+void DebugViewPresenter::vehicleStateUpdated() { view.updateFieldValues(); }

TouchGFX/gui/src/debugview_screen/DebugViewView.cpp

@@ -0,0 +1,34 @@
+#include "gui/common/DataField.hpp"
+#include <gui/debugview_screen/DebugViewView.hpp>
+
+DebugViewView::DebugViewView() {}
+
+void DebugViewView::setupScreen() {
+  DebugViewViewBase::setupScreen();
+  size_t numItems = DataFieldType_COUNT / 2;
+  if (DataFieldType_COUNT % 2 == 1) {
+    numItems++;
+  }
+  list.setNumberOfItems(numItems);
+}
+
+void DebugViewView::tearDownScreen() { DebugViewViewBase::tearDownScreen(); }
+
+void DebugViewView::listUpdateItem(DebugViewLine &line, int16_t itemIndex) {
+  size_t idx = itemIndex * 2;
+  line.setFieldType(0, static_cast<DataFieldType>(idx));
+  idx++;
+  if (idx < DataFieldType_COUNT) {
+    line.setFieldType(1, static_cast<DataFieldType>(idx));
+    line.setFieldVisible(1, true);
+  } else {
+    line.setFieldVisible(1, false);
+  }
+  line.setLightBG(itemIndex % 2 == 1);
+}
+
+void DebugViewView::updateFieldValues() {
+  for (DebugViewLine &el : listListItems.element) {
+    el.updateFieldValues();
+  }
+}

TouchGFX/gui/src/driverview_screen/DriverViewPresenter.cpp

@@ -9,7 +9,7 @@ DriverViewPresenter::DriverViewPresenter(DriverViewView &v)
 
 void DriverViewPresenter::activate() {
   for (size_t i = 0; i < 3; i++) {
-    view.setFieldType(i, dataFieldDescs[fields[i]]);
+    view.setFieldType(i, fields[i]);
   }
 }
 
@@ -19,19 +19,10 @@ void DriverViewPresenter::vehicleStateUpdated() {
   view.setTireTemps(vehicle_state.tire_temps);
   view.setTSSoC(vehicle_state.soc);
 
-  for (size_t i = 0; i < 3; i++) {
-    DataFieldType field = fields[i];
-    // void *val = dataFieldDescs[field].getValue();
-    // switch (dataFieldDescs[field].kind) {
-    // case DataFieldKind::Numeric:
-    //   view.setFieldValue(i, *((float *)val));
-    //   break;
-    // case DataFieldKind::Bool:
-    //   view.setFieldValue(i, *((int *)val));
-    //   break;
-    // case DataFieldKind::Text:
-    //   view.setFieldValue(i, (const char *)val);
-    //   break;
-    // }
-  }
+  view.updateFieldValues();
+}
+
+void DriverViewPresenter::setFieldType(size_t i, DataFieldType type) {
+  fields[i] = type;
+  view.setFieldType(i, type);
 }

TouchGFX/gui/src/driverview_screen/DriverViewView.cpp

@@ -1,7 +1,9 @@
 #include "gui/common/DataField.hpp"
 #include "gui/containers/DriverViewField.hpp"
+#include "gui/driverview_screen/DriverViewPresenter.hpp"
 #include "texts/TextKeysAndLanguages.hpp"
 #include <gui/driverview_screen/DriverViewView.hpp>
+#include <stddef.h>
 
 DriverViewView::DriverViewView()
     : fieldTypes{DF_MinCellVolt, DF_Speed, DF_TSCurrent} {}
@@ -9,7 +11,7 @@ DriverViewView::DriverViewView()
 void DriverViewView::setupScreen() {
   DriverViewViewBase::setupScreen();
   for (size_t i = 0; i < NUM_FIELDS; i++) {
-    getField(i).setType(dataFieldDescs[fieldTypes[i]]);
+    getField(i).setType(fieldTypes[i]);
   }
   fieldTypeSelection.setNumberOfItems(DataFieldType_COUNT);
 }
@@ -22,20 +24,14 @@ void DriverViewView::fieldTypeSelectionUpdateItem(
   item.setSelected(itemIndex == selectedFieldType);
 }
 
-void DriverViewView::setFieldType(size_t i, const DataFieldDescription &desc) {
-  getField(i).setType(desc);
+void DriverViewView::setFieldType(size_t i, DataFieldType type) {
+  getField(i).setType(type);
 }
 
-void DriverViewView::setFieldValue(size_t i, float value) {
-  getField(i).setValue(value);
-}
-
-void DriverViewView::setFieldValue(size_t i, const char *value) {
-  getField(i).setValue(value);
-}
-
-void DriverViewView::setFieldValue(size_t i, int value) {
-  getField(i).setValue(value);
+void DriverViewView::updateFieldValues() {
+  for (size_t i = 0; i < NUM_FIELDS; i++) {
+    getField(i).updateValue();
+  }
 }
 
 void DriverViewView::setTireTemps(const TireTemps &temps) {
@@ -53,6 +49,7 @@ void DriverViewView::setTSSoC(uint8_t soc) {
 void DriverViewView::selectNextField() {
   if (!fieldTypeSelection.isVisible()) {
     fieldTypeSelection.setVisible(true);
+    fieldTypeSelection.invalidate();
     updateSelectedField(0);
   } else {
     updateSelectedField((selectedField + 1) % NUM_FIELDS);
@@ -62,6 +59,7 @@ void DriverViewView::selectNextField() {
 void DriverViewView::selectPrevField() {
   if (!fieldTypeSelection.isVisible()) {
     fieldTypeSelection.setVisible(true);
+    fieldTypeSelection.invalidate();
     updateSelectedField(NUM_FIELDS - 1);
   } else {
     if (selectedField == 0) {
@@ -98,10 +96,12 @@ void DriverViewView::confirmFieldType() {
   }
 
   DriverViewField &field = getField(selectedField);
-  field.setType(dataFieldDescs[selectedFieldType]);
+  presenter->setFieldType(selectedField,
+                          static_cast<DataFieldType>(selectedFieldType));
   field.setSelected(false);
   fieldTypes[selectedField] = static_cast<DataFieldType>(selectedFieldType);
   fieldTypeSelection.setVisible(false);
+  fieldTypeSelection.invalidate();
 }
 
 DriverViewField &DriverViewView::getField(size_t i) {
@@ -115,11 +115,6 @@ DriverViewField &DriverViewView::getField(size_t i) {
   }
 }
 
-DriverViewFieldSelection *DriverViewView::getFieldType(size_t i) {
-  return static_cast<DriverViewFieldSelection *>(
-      fieldTypeSelectionListItems.getDrawable(i));
-}
-
 void DriverViewView::updateSelectedField(size_t selected) {
   getField(selectedField).setSelected(false);
   DriverViewField &field = getField(selected);