diff --git a/radio/src/Makefile b/radio/src/Makefile
index 9e1649446..c03f2374f 100644
--- a/radio/src/Makefile
+++ b/radio/src/Makefile
@@ -1812,5 +1812,5 @@ gtest_main.a : gtest-all.o gtest_main.o
 GTEST_TESTS_SRCS = $(shell find tests/ -type f -name '*.cpp')
 
 gtests: allsimusrc.cpp $(GTEST_TESTS_SRCS) targets/simu/simpgmspace.cpp *.h gtest_main.a
-	g++ -std=gnu++0x $(CPPFLAGS) $(SIMUCPPFLAGS) allsimusrc.cpp $(LUASRC) $(GTEST_TESTS_SRCS) targets/simu/simpgmspace.cpp -I$(GTEST_DIR) ${INCFLAGS} -I$(GTEST_DIR)/include -o gtests -lpthread -MD -DSIMU -lQtCore -lQtGui gtest_main.a -fexceptions
+	g++ -std=gnu++0x $(CPPFLAGS) $(SIMUCPPFLAGS) allsimusrc.cpp $(LUASRC) $(GTEST_TESTS_SRCS) targets/simu/simpgmspace.cpp -I$(GTEST_DIR) ${INCFLAGS} -I$(GTEST_DIR)/include -I/usr/include/qt4 -o gtests -lpthread -MD -DSIMU -lQtCore -lQtGui gtest_main.a -fexceptions
 
diff --git a/radio/src/functions.cpp b/radio/src/functions.cpp
index b072335c3..33e8a0648 100644
--- a/radio/src/functions.cpp
+++ b/radio/src/functions.cpp
@@ -87,7 +87,7 @@ PLAY_FUNCTION(playValue, source_t idx)
         }
       }
     }
-    PLAY_NUMBER(val, 1+telemetrySensor.unit, attr);
+    PLAY_NUMBER(val, telemetrySensor.unit == UNIT_CELLS ? UNIT_VOLTS : telemetrySensor.unit, attr);
   }
   else if (idx >= MIXSRC_FIRST_TIMER && idx <= MIXSRC_LAST_TIMER) {
     PLAY_DURATION(val, 0);
@@ -96,7 +96,7 @@ PLAY_FUNCTION(playValue, source_t idx)
     PLAY_DURATION(val*60, PLAY_TIME);
   }
   else if (idx == MIXSRC_TX_VOLTAGE) {
-    PLAY_NUMBER(val, 1+UNIT_VOLTS, PREC1);
+    PLAY_NUMBER(val, UNIT_VOLTS, PREC1);
   }
   else {
     if (idx <= MIXSRC_LAST_CH) {
diff --git a/radio/src/telemetry/telemetry.cpp b/radio/src/telemetry/telemetry.cpp
index d8b3dca97..dae0f902e 100644
--- a/radio/src/telemetry/telemetry.cpp
+++ b/radio/src/telemetry/telemetry.cpp
@@ -25,12 +25,16 @@ void TelemetryItem::setValue(const TelemetrySensor & sensor, int32_t val, uint32
     uint16_t cellValue = (data & 0xFFFF);
     if (cellsCount == 0) {
       cellsCount = (cellIndex >= cells.count ? cellIndex + 1 : cells.count);
+      if (cellsCount != cells.count) {
+        clear();
+        cells.count = cellsCount;
+        // we skip this round as we are not sure we received all cells values
+        return;
+      }
     }
-    if (cellsCount != cells.count) {
+    else if (cellsCount != cells.count) {
       clear();
       cells.count = cellsCount;
-      // we skip this round
-      return;
     }
     cells.values[cellIndex].set(cellValue);
     if (cellIndex+1 == cells.count) {
@@ -217,7 +221,7 @@ void TelemetryItem::setValue(const TelemetrySensor & sensor, int32_t val, uint32
   else if (newVal > valueMax) {
     valueMax = newVal;
     if (sensor.unit == UNIT_VOLTS) {
-      valueMin = newVal;
+      valueMin = newVal; // the batt was changed
     }
   }
 
@@ -484,37 +488,34 @@ bool isSensorAvailableInResetSpecialFunction(int index)
 
 void setTelemetryValue(TelemetryProtocol protocol, uint16_t id, uint8_t instance, int32_t value, uint32_t unit, uint32_t prec)
 {
-  bool available = false;
-  
   for (int index=0; index<MAX_SENSORS; index++) {
     TelemetrySensor & telemetrySensor = g_model.telemetrySensors[index];
-    if (telemetrySensor.id == id && telemetrySensor.instance == instance) {
-      telemetryItems[index].setValue(g_model.telemetrySensors[index], value, unit, prec);
-      available = true;
+    if (telemetrySensor.type == TELEM_TYPE_CUSTOM && telemetrySensor.id == id && telemetrySensor.instance == instance) {
+     telemetryItems[index].setValue(telemetrySensor, value, unit, prec);
+     return;
     }
   }
   
-  if (!available) {
-    int index = availableTelemetryIndex();
-    if (index >= 0) {
-      switch (protocol) {
+  int index = availableTelemetryIndex();
+  if (index >= 0) {
+    switch (protocol) {
 #if defined(FRSKY_SPORT)
-        case TELEM_PROTO_FRSKY_SPORT:
-          frskySportSetDefault(index, id, instance);
-          break;
+      case TELEM_PROTO_FRSKY_SPORT:
+        frskySportSetDefault(index, id, instance);
+        break;
 #endif
 #if defined(FRSKY)
-        case TELEM_PROTO_FRSKY_D:
-          frskyDSetDefault(index, id);
-          break;
+      case TELEM_PROTO_FRSKY_D:
+        frskyDSetDefault(index, id);
+        break;
 #endif
-        default:
-          break;
-      }
-    }
-    else {
-      POPUP_WARNING(STR_TELEMETRYFULL);
+      default:
+        return;
     }
+    telemetryItems[index].setValue(g_model.telemetrySensors[index], value, unit, prec);
+  }
+  else {
+    POPUP_WARNING(STR_TELEMETRYFULL);
   }
 }
 
@@ -598,6 +599,10 @@ int32_t TelemetrySensor::getValue(int32_t value, uint8_t unit, uint8_t prec) con
 
   if (type == TELEM_TYPE_CUSTOM) {
     value += custom.offset;
+    if (value < 0 && unit >= UNIT_VOLTS && unit <= UNIT_MPH) {
+      value = 0;
+    }
+
   }
 
   return value;
diff --git a/radio/src/telemetry/telemetry.h b/radio/src/telemetry/telemetry.h
index 4aabff69c..8fa6da99d 100644
--- a/radio/src/telemetry/telemetry.h
+++ b/radio/src/telemetry/telemetry.h
@@ -85,16 +85,16 @@ class TelemetryItem
     };
 
     union {
-      int32_t  valueMin;             // min store
+      int32_t  valueMin;        // min store
       uint32_t pilotLongitude;
     };
 
     union {
-      int32_t  valueMax;             // max store
+      int32_t  valueMax;        // max store
       uint32_t pilotLatitude;
     };
 
-    uint8_t lastReceived;    // for detection of sensor loss
+    uint8_t lastReceived;       // for detection of sensor loss
 
     union {
       struct {
diff --git a/radio/src/tests/frsky.cpp b/radio/src/tests/frsky.cpp
index 44f330e47..90854460a 100644
--- a/radio/src/tests/frsky.cpp
+++ b/radio/src/tests/frsky.cpp
@@ -36,8 +36,17 @@
 
 #include "gtests.h"
 
+void frskyDProcessPacket(uint8_t *packet);
+
+#if defined(FRSKY_SPORT)
+bool checkSportPacket(uint8_t *packet);
+void processSportPacket(uint8_t *packet);
+bool checkSportPacket(uint8_t *packet);
+void frskyCalculateCellStats(void);
+void displayVoltagesScreen();
+#endif
+
 #if defined(FRSKY) && !defined(CPUARM)
-extern void frskyDProcessPacket(uint8_t *packet);
 TEST(FrSky, gpsNfuel)
 {
   g_model.frsky.usrProto = 1;
@@ -115,10 +124,7 @@ TEST(FrSky, FrskyValueWithMinAveraging)
 }
 #endif
 
-
-
 #if defined(FRSKY_SPORT)
-extern bool checkSportPacket(uint8_t *packet);
 TEST(FrSkySPORT, checkCrc)
 {
   // uint8_t pkt[] = { 0x7E, 0x98, 0x10, 0x10, 0x00, 0x7D, 0x5E, 0x02, 0x00, 0x00, 0x5F };
@@ -126,11 +132,6 @@ TEST(FrSkySPORT, checkCrc)
   EXPECT_EQ(checkSportPacket(pkt+1), true);
 }
 
-extern void processSportPacket(uint8_t *packet);
-extern bool checkSportPacket(uint8_t *packet);
-extern void frskyCalculateCellStats(void);
-extern void displayVoltagesScreen();
-
 void setSportPacketCrc(uint8_t * packet)
 {
   short crc = 0;
@@ -145,15 +146,9 @@ void setSportPacketCrc(uint8_t * packet)
   //TRACE("crc set: %x", packet[FRSKY_SPORT_PACKET_SIZE-1]);
 }
 
-void generateSportCellPacket(uint8_t * packet, uint8_t cells, uint8_t battnumber, uint16_t cell1, uint16_t cell2)
+void generateSportCellPacket(uint8_t * packet, uint8_t cells, uint8_t battnumber, uint16_t cell1, uint16_t cell2, uint8_t sensorId=DATA_ID_FLVSS)
 {
-  if (battnumber < 6) {
-    packet[0] = 0xA1; //DATA_ID_FLVSS;
-  }
-  else {
-    packet[0] = 0xA1+1; //DATA_ID_FLVSS+1;
-    battnumber -= 6;
-  }
+  packet[0] = sensorId;
   packet[1] = 0x10; //DATA_FRAME
   *((uint16_t *)(packet+2)) = 0x0300; //CELLS_FIRST_ID
   uint32_t data = 0;
@@ -182,12 +177,14 @@ TEST(FrSkySPORT, FrSkyDCells)
   processSportPacket(pkt2+1);
   processSportPacket(pkt3+1);
   EXPECT_EQ(telemetryItems[0].cells.count, 3);
-//  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(000)); // now we ignore such low values
-//  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(413));
+  EXPECT_EQ(telemetryItems[0].value, 1200);
+  for (int i=0; i<3; i++) {
+    EXPECT_EQ(telemetryItems[0].cells.values[i].state, 1);
+    EXPECT_EQ(telemetryItems[0].cells.values[i].value, 400);
+  }
 }
 
-#if 0
-TEST(FrSkySPORT, DISABLED_frskySetCellVoltage)
+TEST(FrSkySPORT, frskySetCellVoltage)
 {
   uint8_t packet[FRSKY_SPORT_PACKET_SIZE];
 
@@ -202,15 +199,14 @@ TEST(FrSkySPORT, DISABLED_frskySetCellVoltage)
   generateSportCellPacket(packet, 3, 0, _V(405), _V(300)); processSportPacket(packet);
   generateSportCellPacket(packet, 3, 2, _V(430), _V(  0)); processSportPacket(packet);
   
-  EXPECT_EQ(frskyData.hub.cellsCount,         3);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(405));
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(300));
-  EXPECT_EQ(frskyData.hub.cellVolts[2], _V(430));
-  EXPECT_EQ(frskyData.hub.cellVolts[4], _V(  0));
-  EXPECT_EQ(frskyData.hub.minCellVolts, _V(300));   //current minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCell,      _V(300));   //all time minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCells,     _V(113));   //all time cells sum minimum
-  EXPECT_EQ(frskyData.hub.cellsSum,     _V(113));   //current cells sum
+  EXPECT_EQ(telemetryItems[0].cells.count, 3);
+  EXPECT_EQ(telemetryItems[0].cells.values[0].value, 405);
+  EXPECT_EQ(telemetryItems[0].cells.values[1].value, 300);
+  EXPECT_EQ(telemetryItems[0].cells.values[2].value, 430);
+  EXPECT_EQ(telemetryItems[0].cells.values[4].value, 0);
+  EXPECT_EQ(telemetryItems[0].value, 1135);
+  EXPECT_EQ(telemetryItems[0].valueMin, 1135);
+  EXPECT_EQ(telemetryItems[0].valueMax, 1260);
 
   generateSportCellPacket(packet, 3, 0, _V(405), _V(250)); processSportPacket(packet);
   generateSportCellPacket(packet, 3, 2, _V(430), _V(  0)); processSportPacket(packet);
@@ -218,84 +214,83 @@ TEST(FrSkySPORT, DISABLED_frskySetCellVoltage)
   generateSportCellPacket(packet, 3, 0, _V(410), _V(420)); processSportPacket(packet);
   generateSportCellPacket(packet, 3, 2, _V(430), _V(  0)); processSportPacket(packet);
   
-  EXPECT_EQ(frskyData.hub.cellsCount,         3);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(410));
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(420));
-  EXPECT_EQ(frskyData.hub.cellVolts[2], _V(430));
-  EXPECT_EQ(frskyData.hub.cellVolts[4], _V(  0));
-  EXPECT_EQ(frskyData.hub.minCellVolts, _V(410));   //current minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCell,      _V(250));   //all time minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCells,     _V(108));   //all time cells sum minimum
-  EXPECT_EQ(frskyData.hub.cellsSum,     _V(126));   //current cells sum
+  EXPECT_EQ(telemetryItems[0].cells.count, 3);
+  EXPECT_EQ(telemetryItems[0].cells.values[0].value, 410);
+  EXPECT_EQ(telemetryItems[0].cells.values[1].value, 420);
+  EXPECT_EQ(telemetryItems[0].cells.values[2].value, 430);
+  EXPECT_EQ(telemetryItems[0].cells.values[4].value, 0);
+  EXPECT_EQ(telemetryItems[0].value, 1260);
+  EXPECT_EQ(telemetryItems[0].valueMin, 1085);
+  EXPECT_EQ(telemetryItems[0].valueMax, 1260);
 
   //add another two cells - 5 cell battery
   generateSportCellPacket(packet, 5, 0, _V(418), _V(408)); processSportPacket(packet);
   generateSportCellPacket(packet, 5, 2, _V(415), _V(420)); processSportPacket(packet);
   generateSportCellPacket(packet, 5, 4, _V(410), _V(  0)); processSportPacket(packet);
 
-  EXPECT_EQ(frskyData.hub.cellsCount,         5);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418));
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(408));
-  EXPECT_EQ(frskyData.hub.cellVolts[2], _V(415));
-  EXPECT_EQ(frskyData.hub.cellVolts[3], _V(420));
-  EXPECT_EQ(frskyData.hub.cellVolts[4], _V(410));
-  EXPECT_EQ(frskyData.hub.cellVolts[5], _V(  0));
-  EXPECT_EQ(frskyData.hub.minCellVolts, _V(408));   //current minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCell,      _V(408));   //all time minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCells,     _V(207));   //all time cells sum minimum
-  EXPECT_EQ(frskyData.hub.cellsSum,     _V(207));   //current cells sum
+  EXPECT_EQ(telemetryItems[0].cells.count, 5);
+  EXPECT_EQ(telemetryItems[0].cells.values[0].value, 418);
+  EXPECT_EQ(telemetryItems[0].cells.values[1].value, 408);
+  EXPECT_EQ(telemetryItems[0].cells.values[2].value, 415);
+  EXPECT_EQ(telemetryItems[0].cells.values[3].value, 420);
+  EXPECT_EQ(telemetryItems[0].cells.values[4].value, 410);
+  EXPECT_EQ(telemetryItems[0].cells.values[5].value, 0);
+  EXPECT_EQ(telemetryItems[0].value, 2071);
+  EXPECT_EQ(telemetryItems[0].valueMin, 2071);
+  EXPECT_EQ(telemetryItems[0].valueMax, 2071);
 
   //simulate very low voltage for cell 3
   generateSportCellPacket(packet, 5, 0, _V(418), _V(408)); processSportPacket(packet);
   generateSportCellPacket(packet, 5, 2, _V(100), _V(420)); processSportPacket(packet);
   generateSportCellPacket(packet, 5, 4, _V(410), _V(  0)); processSportPacket(packet);
 
-  EXPECT_EQ(frskyData.hub.cellsCount,         5);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418));
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(408));
-  EXPECT_EQ(frskyData.hub.cellVolts[2], _V(100));
-  EXPECT_EQ(frskyData.hub.cellVolts[3], _V(420));
-  EXPECT_EQ(frskyData.hub.cellVolts[4], _V(410));
-  EXPECT_EQ(frskyData.hub.cellVolts[5], _V(  0));
-  EXPECT_EQ(frskyData.hub.minCellVolts, _V(100));   //current minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCell,      _V(100));   //all time minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCells,     _V(175));   //all time cells sum minimum
-  EXPECT_EQ(frskyData.hub.cellsSum,     _V(175));   //current cells sum
+  EXPECT_EQ(telemetryItems[0].cells.count, 5);
+  EXPECT_EQ(telemetryItems[0].cells.values[0].value, 418);
+  EXPECT_EQ(telemetryItems[0].cells.values[1].value, 408);
+  EXPECT_EQ(telemetryItems[0].cells.values[2].value, 100);
+  EXPECT_EQ(telemetryItems[0].cells.values[3].value, 420);
+  EXPECT_EQ(telemetryItems[0].cells.values[4].value, 410);
+  EXPECT_EQ(telemetryItems[0].cells.values[5].value, 0);
+  EXPECT_EQ(telemetryItems[0].value, 1756);
+  EXPECT_EQ(telemetryItems[0].valueMin, 1756);
+  EXPECT_EQ(telemetryItems[0].valueMax, 2071);
 
   //back to normal (but with reversed order of packets)
   generateSportCellPacket(packet, 5, 4, _V(410), _V(  0)); processSportPacket(packet);
   generateSportCellPacket(packet, 5, 0, _V(418), _V(408)); processSportPacket(packet);
   generateSportCellPacket(packet, 5, 2, _V(412), _V(420)); processSportPacket(packet);
+  generateSportCellPacket(packet, 5, 4, _V(410), _V(  0)); processSportPacket(packet);
 
-  EXPECT_EQ(frskyData.hub.cellsCount,         5);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418));
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(408));
-  EXPECT_EQ(frskyData.hub.cellVolts[2], _V(412));
-  EXPECT_EQ(frskyData.hub.cellVolts[3], _V(420));
-  EXPECT_EQ(frskyData.hub.cellVolts[4], _V(410));
-  EXPECT_EQ(frskyData.hub.cellVolts[5], _V(  0));
-  EXPECT_EQ(frskyData.hub.minCellVolts, _V(408));   //current minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCell,      _V(100));   //all time minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCells,     _V(175));   //all time cells sum minimum
-  EXPECT_EQ(frskyData.hub.cellsSum,     _V(206));   //current cells sum
+  EXPECT_EQ(telemetryItems[0].cells.count, 5);
+  EXPECT_EQ(telemetryItems[0].cells.values[0].value, 418);
+  EXPECT_EQ(telemetryItems[0].cells.values[1].value, 408);
+  EXPECT_EQ(telemetryItems[0].cells.values[2].value, 412);
+  EXPECT_EQ(telemetryItems[0].cells.values[3].value, 420);
+  EXPECT_EQ(telemetryItems[0].cells.values[4].value, 410);
+  EXPECT_EQ(telemetryItems[0].cells.values[5].value, 0);
+  EXPECT_EQ(telemetryItems[0].value, 2068);
+  EXPECT_EQ(telemetryItems[0].valueMin, 1756);
+  EXPECT_EQ(telemetryItems[0].valueMax, 2071);
 
   //display test
   lcd_clear();
   g_model.frsky.voltsSource = FRSKY_VOLTS_SOURCE_A1;
 }
 
-TEST(FrSkySPORT, DISABLED_StrangeCellsBug)
+TEST(FrSkySPORT, StrangeCellsBug)
 {
+  MODEL_RESET();
   TELEMETRY_RESET();
+
   uint8_t pkt[] = { 0x7E, 0x48, 0x10, 0x00, 0x03, 0x30, 0x15, 0x50, 0x81, 0xD5 };
   EXPECT_EQ(checkSportPacket(pkt+1), true);
   processSportPacket(pkt+1);
-  EXPECT_EQ(frskyData.hub.cellsCount,         3);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(000)); // now we ignore such low values 
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(413));
+  EXPECT_EQ(telemetryItems[0].cells.count, 3);
+  EXPECT_EQ(telemetryItems[0].cells.values[0].value, 0); // now we ignore such low values
+  EXPECT_EQ(telemetryItems[0].cells.values[1].value, 413);
 }
 
-TEST(FrSkySPORT, DISABLED_frskySetCellVoltageTwoSensors)
+TEST(FrSkySPORT, frskySetCellVoltageTwoSensors)
 {
   uint8_t packet[FRSKY_SPORT_PACKET_SIZE];
 
@@ -306,59 +301,51 @@ TEST(FrSkySPORT, DISABLED_frskySetCellVoltageTwoSensors)
   generateSportCellPacket(packet, 3, 0, _V(418), _V(416)); processSportPacket(packet);
   generateSportCellPacket(packet, 3, 2, _V(415), _V(  0)); processSportPacket(packet);
 
-  EXPECT_EQ(frskyData.hub.cellsCount,         3);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418));
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(416));
-  EXPECT_EQ(frskyData.hub.cellVolts[2], _V(415));
-  EXPECT_EQ(frskyData.hub.cellVolts[3], _V(  0));
-  EXPECT_EQ(frskyData.hub.minCellVolts, _V(415));   //current minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCell,      _V(415));   //all time minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCells,     _V(124));   //all time cells sum minimum
-  EXPECT_EQ(frskyData.hub.cellsSum,     _V(124));   //current cells sum
+  EXPECT_EQ(telemetryItems[0].cells.count, 3);
+  EXPECT_EQ(telemetryItems[0].cells.values[0].value, 418);
+  EXPECT_EQ(telemetryItems[0].cells.values[1].value, 416);
+  EXPECT_EQ(telemetryItems[0].cells.values[2].value, 415);
+  EXPECT_EQ(telemetryItems[0].cells.values[3].value, 0);
+  EXPECT_EQ(telemetryItems[0].value, 1249);
+  EXPECT_EQ(telemetryItems[0].valueMin, 1249);
+  EXPECT_EQ(telemetryItems[0].valueMax, 1249);
 
   //sensor 2: 4 cell battery
-  generateSportCellPacket(packet, 4, 6, _V(410), _V(420)); processSportPacket(packet);
-  generateSportCellPacket(packet, 4, 8, _V(400), _V(405)); processSportPacket(packet);
+  generateSportCellPacket(packet, 4, 0, _V(410), _V(420), DATA_ID_FLVSS+1); processSportPacket(packet);
+  generateSportCellPacket(packet, 4, 2, _V(400), _V(405), DATA_ID_FLVSS+1); processSportPacket(packet);
 
-  //we need to send all cells from first battery before a new calculation will be made
-  generateSportCellPacket(packet, 3, 0, _V(418), _V(416)); processSportPacket(packet);
-  generateSportCellPacket(packet, 3, 2, _V(415), _V(  0)); processSportPacket(packet);
-  
-  EXPECT_EQ(frskyData.hub.cellsCount,        7);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418));
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(416));
-  EXPECT_EQ(frskyData.hub.cellVolts[2], _V(415));
-  EXPECT_EQ(frskyData.hub.cellVolts[3], _V(410));
-  EXPECT_EQ(frskyData.hub.cellVolts[4], _V(420));
-  EXPECT_EQ(frskyData.hub.cellVolts[5], _V(400));
-  EXPECT_EQ(frskyData.hub.cellVolts[6], _V(405));
-  EXPECT_EQ(frskyData.hub.cellVolts[7], _V(  0));
-  EXPECT_EQ(frskyData.hub.cellVolts[8], _V(  0));
-  EXPECT_EQ(frskyData.hub.minCellVolts, _V(400));   //current minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCell,      _V(400));   //all time minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCells,     _V(288));   //all time cells sum minimum
-  EXPECT_EQ(frskyData.hub.cellsSum,     _V(288));   //current cells sum
+  EXPECT_EQ(telemetryItems[1].cells.count, 4);
+  EXPECT_EQ(telemetryItems[1].cells.values[0].value, 410);
+  EXPECT_EQ(telemetryItems[1].cells.values[1].value, 420);
+  EXPECT_EQ(telemetryItems[1].cells.values[2].value, 400);
+  EXPECT_EQ(telemetryItems[1].cells.values[3].value, 405);
+  EXPECT_EQ(telemetryItems[1].value, 1635);
+  EXPECT_EQ(telemetryItems[1].valueMin, 1635);
+  EXPECT_EQ(telemetryItems[1].valueMax, 1635);
+
+  g_model.telemetrySensors[2].type = TELEM_TYPE_CALCULATED;
+  g_model.telemetrySensors[2].formula = TELEM_FORMULA_ADD;
+  g_model.telemetrySensors[2].prec = 1;
+  g_model.telemetrySensors[2].calc.sources[0] = 1;
+  g_model.telemetrySensors[2].calc.sources[1] = 2;
+
+  telemetryWakeup();
+
+  EXPECT_EQ(telemetryItems[2].value, 287);
+  EXPECT_EQ(telemetryItems[2].valueMin, 287);
+  EXPECT_EQ(telemetryItems[2].valueMax, 287);
 
   //now change some voltages
   generateSportCellPacket(packet, 3, 2, _V(415), _V(  0)); processSportPacket(packet);
-  generateSportCellPacket(packet, 4, 8, _V(390), _V(370)); processSportPacket(packet);
+  generateSportCellPacket(packet, 4, 2, _V(390), _V(370), DATA_ID_FLVSS+1); processSportPacket(packet);
   generateSportCellPacket(packet, 3, 0, _V(420), _V(410)); processSportPacket(packet);
-  generateSportCellPacket(packet, 4, 6, _V(410), _V(420)); processSportPacket(packet);
+  generateSportCellPacket(packet, 4, 0, _V(410), _V(420), DATA_ID_FLVSS+1); processSportPacket(packet);
 
-  EXPECT_EQ(frskyData.hub.cellsCount,        7);
-  EXPECT_EQ(frskyData.hub.cellVolts[0], _V(420));
-  EXPECT_EQ(frskyData.hub.cellVolts[1], _V(410));
-  EXPECT_EQ(frskyData.hub.cellVolts[2], _V(415));
-  EXPECT_EQ(frskyData.hub.cellVolts[3], _V(410));
-  EXPECT_EQ(frskyData.hub.cellVolts[4], _V(420));
-  EXPECT_EQ(frskyData.hub.cellVolts[5], _V(390));
-  EXPECT_EQ(frskyData.hub.cellVolts[6], _V(370));
-  EXPECT_EQ(frskyData.hub.cellVolts[7],_V(  0));
-  EXPECT_EQ(frskyData.hub.cellVolts[8],_V(  0));
-  EXPECT_EQ(frskyData.hub.minCellVolts, _V(370));   //current minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCell,      _V(370));   //all time minimum cell voltage
-  EXPECT_EQ(frskyData.hub.minCells,     _V(283));   //all time cells sum minimum
-  EXPECT_EQ(frskyData.hub.cellsSum,     _V(283));   //current cells sum
+  telemetryWakeup();
+
+  EXPECT_EQ(telemetryItems[2].value, 283);
+  EXPECT_EQ(telemetryItems[2].valueMin, 283);
+  EXPECT_EQ(telemetryItems[2].valueMax, 287);
 
   //display test
   lcd_clear();
@@ -374,29 +361,33 @@ void generateSportFasVoltagePacket(uint8_t * packet, uint32_t voltage)
   setSportPacketCrc(packet);
 }
 
-TEST(FrSkySPORT, DISABLED_frskyVfas)
+TEST(FrSkySPORT, frskyVfas)
 {
   uint8_t packet[FRSKY_SPORT_PACKET_SIZE];
 
-  //telemetryReset();
+  MODEL_RESET();
   TELEMETRY_RESET();
 
   // tests for Vfas
   generateSportFasVoltagePacket(packet, 5000); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.vfas,    500);
-  EXPECT_EQ(frskyData.hub.minVfas, 500);
+  EXPECT_EQ(telemetryItems[0].value, 5000);
+  EXPECT_EQ(telemetryItems[0].valueMin, 5000);
+  EXPECT_EQ(telemetryItems[0].valueMax, 5000);
 
   generateSportFasVoltagePacket(packet, 6524); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.vfas,    652);
-  EXPECT_EQ(frskyData.hub.minVfas, 500);
+  EXPECT_EQ(telemetryItems[0].value, 6524);
+  EXPECT_EQ(telemetryItems[0].valueMin, 6524); // the batt was changed (val > old max)
+  EXPECT_EQ(telemetryItems[0].valueMax, 6524);
 
   generateSportFasVoltagePacket(packet, 1248); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.vfas,    124);
-  EXPECT_EQ(frskyData.hub.minVfas, 124);
+  EXPECT_EQ(telemetryItems[0].value, 1248);
+  EXPECT_EQ(telemetryItems[0].valueMin, 1248);
+  EXPECT_EQ(telemetryItems[0].valueMax, 6524);
 
   generateSportFasVoltagePacket(packet, 2248); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.vfas,    224);
-  EXPECT_EQ(frskyData.hub.minVfas, 124);
+  EXPECT_EQ(telemetryItems[0].value, 2248);
+  EXPECT_EQ(telemetryItems[0].valueMin, 1248);
+  EXPECT_EQ(telemetryItems[0].valueMax, 6524);
 }
 
 void generateSportFasCurrentPacket(uint8_t * packet, uint32_t current)
@@ -412,49 +403,56 @@ TEST(FrSkySPORT, frskyCurrent)
 {
   uint8_t packet[FRSKY_SPORT_PACKET_SIZE];
 
+  MODEL_RESET();
   TELEMETRY_RESET();
-  g_model.frsky.fasOffset = -5;  /* unit: 1/10 amps */
 
   // tests for Curr
   generateSportFasCurrentPacket(packet, 0); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.current,      0);
-  EXPECT_EQ(frskyData.hub.maxCurrent,   0);
+  g_model.telemetrySensors[0].custom.offset = -5;  /* unit: 1/10 amps */
+  generateSportFasCurrentPacket(packet, 0); processSportPacket(packet);
+  EXPECT_EQ(telemetryItems[0].value, 0);
+  EXPECT_EQ(telemetryItems[0].valueMin, 0);
+  EXPECT_EQ(telemetryItems[0].valueMax, 0);
 
   // measured current less then offset - value should be zero
   generateSportFasCurrentPacket(packet, 4); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.current,      0);
-  EXPECT_EQ(frskyData.hub.maxCurrent,   0);
+  EXPECT_EQ(telemetryItems[0].value, 0);
+  EXPECT_EQ(telemetryItems[0].valueMin, 0);
+  EXPECT_EQ(telemetryItems[0].valueMax, 0);
 
   generateSportFasCurrentPacket(packet, 10); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.current,      5);
-  EXPECT_EQ(frskyData.hub.maxCurrent,   5);
+  EXPECT_EQ(telemetryItems[0].value, 5);
+  EXPECT_EQ(telemetryItems[0].valueMin, 0);
+  EXPECT_EQ(telemetryItems[0].valueMax, 5);
 
   generateSportFasCurrentPacket(packet, 500); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.current,      495);
-  EXPECT_EQ(frskyData.hub.maxCurrent,   495);
+  EXPECT_EQ(telemetryItems[0].value, 495);
+  EXPECT_EQ(telemetryItems[0].valueMin, 0);
+  EXPECT_EQ(telemetryItems[0].valueMax, 495);
 
   generateSportFasCurrentPacket(packet, 200); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.current,      195);
-  EXPECT_EQ(frskyData.hub.maxCurrent,   495);
+  EXPECT_EQ(telemetryItems[0].value, 195);
+  EXPECT_EQ(telemetryItems[0].valueMin, 0);
+  EXPECT_EQ(telemetryItems[0].valueMax, 495);
 
   // test with positive offset
   TELEMETRY_RESET();
-  g_model.frsky.fasOffset = 5;  /* unit: 1/10 amps */
+  g_model.telemetrySensors[0].custom.offset = +5;  /* unit: 1/10 amps */
 
   generateSportFasCurrentPacket(packet, 0); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.current,      5);
-  EXPECT_EQ(frskyData.hub.maxCurrent,   5);
+  EXPECT_EQ(telemetryItems[0].value, 5);
+  EXPECT_EQ(telemetryItems[0].valueMin, 5);
+  EXPECT_EQ(telemetryItems[0].valueMax, 5);
 
   generateSportFasCurrentPacket(packet, 500); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.current,      505);
-  EXPECT_EQ(frskyData.hub.maxCurrent,   505);
+  EXPECT_EQ(telemetryItems[0].value, 505);
+  EXPECT_EQ(telemetryItems[0].valueMin, 5);
+  EXPECT_EQ(telemetryItems[0].valueMax, 505);
 
   generateSportFasCurrentPacket(packet, 200); processSportPacket(packet);
-  EXPECT_EQ(frskyData.hub.current,      205);
-  EXPECT_EQ(frskyData.hub.maxCurrent,   505);
+  EXPECT_EQ(telemetryItems[0].value, 205);
+  EXPECT_EQ(telemetryItems[0].valueMin, 5);
+  EXPECT_EQ(telemetryItems[0].valueMax, 505);
 }
-#endif
 
 #endif  //#if defined(FRSKY_SPORT)
-
-
diff --git a/radio/src/tests/gtests.h b/radio/src/tests/gtests.h
index c151824da..d50149e67 100644
--- a/radio/src/tests/gtests.h
+++ b/radio/src/tests/gtests.h
@@ -53,6 +53,11 @@ inline void TELEMETRY_RESET()
   memclear(&frskyData, sizeof(frskyData));
   TELEMETRY_RSSI() = 100;
 #endif
+#if defined(CPUARM) && defined(FRSKY)
+  for (int i=0; i<MAX_SENSORS; i++) {
+    telemetryItems[i].clear();
+  }
+#endif
 }
 
 bool checkScreenshot(QString test);