Mirror/opentx
1
0
Fork 0
mirror of https://github.com/opentx/opentx.git synced 2025-07-24 16:55:20 +03:00
Code Issues Wiki Activity

All disabled telemetry google tests are now enabled

Browse source
This commit is contained in:
bsongis 2015-06-15 22:05:53 +02:00
parent 414070bde1
commit 34d096e115
6 changed files with 192 additions and 184 deletions
Download patch file Download diff file Expand all files Collapse all files

2
radio/src/Makefile
View file

@ -1812,5 +1812,5 @@ gtest_main.a : gtest-all.o gtest_main.o
GTEST_TESTS_SRCS = $(shell find tests/ -type f -name '*.cpp') GTEST_TESTS_SRCS = $(shell find tests/ -type f -name '*.cpp')
gtests: allsimusrc.cpp $(GTEST_TESTS_SRCS) targets/simu/simpgmspace.cpp *.h gtest_main.a 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

4
radio/src/functions.cpp
View file

@ -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) { else if (idx >= MIXSRC_FIRST_TIMER && idx <= MIXSRC_LAST_TIMER) {
PLAY_DURATION(val, 0); PLAY_DURATION(val, 0);
@ -96,7 +96,7 @@ PLAY_FUNCTION(playValue, source_t idx)
PLAY_DURATION(val*60, PLAY_TIME); PLAY_DURATION(val*60, PLAY_TIME);
} }
else if (idx == MIXSRC_TX_VOLTAGE) { else if (idx == MIXSRC_TX_VOLTAGE) {
PLAY_NUMBER(val, 1+UNIT_VOLTS, PREC1); PLAY_NUMBER(val, UNIT_VOLTS, PREC1);
} }
else { else {
if (idx <= MIXSRC_LAST_CH) { if (idx <= MIXSRC_LAST_CH) {

55
radio/src/telemetry/telemetry.cpp
View file

@ -25,12 +25,16 @@ void TelemetryItem::setValue(const TelemetrySensor & sensor, int32_t val, uint32
uint16_t cellValue = (data & 0xFFFF); uint16_t cellValue = (data & 0xFFFF);
if (cellsCount == 0) { if (cellsCount == 0) {
cellsCount = (cellIndex >= cells.count ? cellIndex + 1 : cells.count); 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(); clear();
cells.count = cellsCount; cells.count = cellsCount;
// we skip this round
return;
} }
cells.values[cellIndex].set(cellValue); cells.values[cellIndex].set(cellValue);
if (cellIndex+1 == cells.count) { if (cellIndex+1 == cells.count) {
@ -217,7 +221,7 @@ void TelemetryItem::setValue(const TelemetrySensor & sensor, int32_t val, uint32
else if (newVal > valueMax) { else if (newVal > valueMax) {
valueMax = newVal; valueMax = newVal;
if (sensor.unit == UNIT_VOLTS) { 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) 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++) { for (int index=0; index<MAX_SENSORS; index++) {
TelemetrySensor & telemetrySensor = g_model.telemetrySensors[index]; TelemetrySensor & telemetrySensor = g_model.telemetrySensors[index];
if (telemetrySensor.id == id && telemetrySensor.instance == instance) { if (telemetrySensor.type == TELEM_TYPE_CUSTOM && telemetrySensor.id == id && telemetrySensor.instance == instance) {
telemetryItems[index].setValue(g_model.telemetrySensors[index], value, unit, prec); telemetryItems[index].setValue(telemetrySensor, value, unit, prec);
available = true; return;
} }
} }
if (!available) { int index = availableTelemetryIndex();
int index = availableTelemetryIndex(); if (index >= 0) {
if (index >= 0) { switch (protocol) {
switch (protocol) {
#if defined(FRSKY_SPORT) #if defined(FRSKY_SPORT)
case TELEM_PROTO_FRSKY_SPORT: case TELEM_PROTO_FRSKY_SPORT:
frskySportSetDefault(index, id, instance); frskySportSetDefault(index, id, instance);
break; break;
#endif #endif
#if defined(FRSKY) #if defined(FRSKY)
case TELEM_PROTO_FRSKY_D: case TELEM_PROTO_FRSKY_D:
frskyDSetDefault(index, id); frskyDSetDefault(index, id);
break; break;
#endif #endif
default: default:
break; return;
}
}
else {
POPUP_WARNING(STR_TELEMETRYFULL);
} }
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) { if (type == TELEM_TYPE_CUSTOM) {
value += custom.offset; value += custom.offset;
if (value < 0 && unit >= UNIT_VOLTS && unit <= UNIT_MPH) {
value = 0;
}
} }
return value; return value;

6
radio/src/telemetry/telemetry.h
View file

@ -85,16 +85,16 @@ class TelemetryItem
}; };
union { union {
int32_t valueMin; // min store int32_t valueMin; // min store
uint32_t pilotLongitude; uint32_t pilotLongitude;
}; };
union { union {
int32_t valueMax; // max store int32_t valueMax; // max store
uint32_t pilotLatitude; uint32_t pilotLatitude;
}; };
uint8_t lastReceived; // for detection of sensor loss uint8_t lastReceived; // for detection of sensor loss
union { union {
struct { struct {

304
radio/src/tests/frsky.cpp
View file

@ -36,8 +36,17 @@
#include "gtests.h" #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) #if defined(FRSKY) && !defined(CPUARM)
extern void frskyDProcessPacket(uint8_t *packet);
TEST(FrSky, gpsNfuel) TEST(FrSky, gpsNfuel)
{ {
g_model.frsky.usrProto = 1; g_model.frsky.usrProto = 1;
@ -115,10 +124,7 @@ TEST(FrSky, FrskyValueWithMinAveraging)
} }
#endif #endif
#if defined(FRSKY_SPORT) #if defined(FRSKY_SPORT)
extern bool checkSportPacket(uint8_t *packet);
TEST(FrSkySPORT, checkCrc) TEST(FrSkySPORT, checkCrc)
{ {
// uint8_t pkt[] = { 0x7E, 0x98, 0x10, 0x10, 0x00, 0x7D, 0x5E, 0x02, 0x00, 0x00, 0x5F }; // 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); 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) void setSportPacketCrc(uint8_t * packet)
{ {
short crc = 0; short crc = 0;
@ -145,15 +146,9 @@ void setSportPacketCrc(uint8_t * packet)
//TRACE("crc set: %x", packet[FRSKY_SPORT_PACKET_SIZE-1]); //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] = sensorId;
packet[0] = 0xA1; //DATA_ID_FLVSS;
}
else {
packet[0] = 0xA1+1; //DATA_ID_FLVSS+1;
battnumber -= 6;
}
packet[1] = 0x10; //DATA_FRAME packet[1] = 0x10; //DATA_FRAME
*((uint16_t *)(packet+2)) = 0x0300; //CELLS_FIRST_ID *((uint16_t *)(packet+2)) = 0x0300; //CELLS_FIRST_ID
uint32_t data = 0; uint32_t data = 0;
@ -182,12 +177,14 @@ TEST(FrSkySPORT, FrSkyDCells)
processSportPacket(pkt2+1); processSportPacket(pkt2+1);
processSportPacket(pkt3+1); processSportPacket(pkt3+1);
EXPECT_EQ(telemetryItems[0].cells.count, 3); EXPECT_EQ(telemetryItems[0].cells.count, 3);
// EXPECT_EQ(frskyData.hub.cellVolts[0], _V(000)); // now we ignore such low values EXPECT_EQ(telemetryItems[0].value, 1200);
// EXPECT_EQ(frskyData.hub.cellVolts[1], _V(413)); 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, frskySetCellVoltage)
TEST(FrSkySPORT, DISABLED_frskySetCellVoltage)
{ {
uint8_t packet[FRSKY_SPORT_PACKET_SIZE]; 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, 0, _V(405), _V(300)); processSportPacket(packet);
generateSportCellPacket(packet, 3, 2, _V(430), _V( 0)); processSportPacket(packet); generateSportCellPacket(packet, 3, 2, _V(430), _V( 0)); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.cellsCount, 3); EXPECT_EQ(telemetryItems[0].cells.count, 3);
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(405)); EXPECT_EQ(telemetryItems[0].cells.values[0].value, 405);
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(300)); EXPECT_EQ(telemetryItems[0].cells.values[1].value, 300);
EXPECT_EQ(frskyData.hub.cellVolts[2], _V(430)); EXPECT_EQ(telemetryItems[0].cells.values[2].value, 430);
EXPECT_EQ(frskyData.hub.cellVolts[4], _V( 0)); EXPECT_EQ(telemetryItems[0].cells.values[4].value, 0);
EXPECT_EQ(frskyData.hub.minCellVolts, _V(300)); //current minimum cell voltage EXPECT_EQ(telemetryItems[0].value, 1135);
EXPECT_EQ(frskyData.hub.minCell, _V(300)); //all time minimum cell voltage EXPECT_EQ(telemetryItems[0].valueMin, 1135);
EXPECT_EQ(frskyData.hub.minCells, _V(113)); //all time cells sum minimum EXPECT_EQ(telemetryItems[0].valueMax, 1260);
EXPECT_EQ(frskyData.hub.cellsSum, _V(113)); //current cells sum
generateSportCellPacket(packet, 3, 0, _V(405), _V(250)); processSportPacket(packet); generateSportCellPacket(packet, 3, 0, _V(405), _V(250)); processSportPacket(packet);
generateSportCellPacket(packet, 3, 2, _V(430), _V( 0)); 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, 0, _V(410), _V(420)); processSportPacket(packet);
generateSportCellPacket(packet, 3, 2, _V(430), _V( 0)); processSportPacket(packet); generateSportCellPacket(packet, 3, 2, _V(430), _V( 0)); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.cellsCount, 3); EXPECT_EQ(telemetryItems[0].cells.count, 3);
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(410)); EXPECT_EQ(telemetryItems[0].cells.values[0].value, 410);
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(420)); EXPECT_EQ(telemetryItems[0].cells.values[1].value, 420);
EXPECT_EQ(frskyData.hub.cellVolts[2], _V(430)); EXPECT_EQ(telemetryItems[0].cells.values[2].value, 430);
EXPECT_EQ(frskyData.hub.cellVolts[4], _V( 0)); EXPECT_EQ(telemetryItems[0].cells.values[4].value, 0);
EXPECT_EQ(frskyData.hub.minCellVolts, _V(410)); //current minimum cell voltage EXPECT_EQ(telemetryItems[0].value, 1260);
EXPECT_EQ(frskyData.hub.minCell, _V(250)); //all time minimum cell voltage EXPECT_EQ(telemetryItems[0].valueMin, 1085);
EXPECT_EQ(frskyData.hub.minCells, _V(108)); //all time cells sum minimum EXPECT_EQ(telemetryItems[0].valueMax, 1260);
EXPECT_EQ(frskyData.hub.cellsSum, _V(126)); //current cells sum
//add another two cells - 5 cell battery //add another two cells - 5 cell battery
generateSportCellPacket(packet, 5, 0, _V(418), _V(408)); processSportPacket(packet); generateSportCellPacket(packet, 5, 0, _V(418), _V(408)); processSportPacket(packet);
generateSportCellPacket(packet, 5, 2, _V(415), _V(420)); processSportPacket(packet); generateSportCellPacket(packet, 5, 2, _V(415), _V(420)); processSportPacket(packet);
generateSportCellPacket(packet, 5, 4, _V(410), _V( 0)); processSportPacket(packet); generateSportCellPacket(packet, 5, 4, _V(410), _V( 0)); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.cellsCount, 5); EXPECT_EQ(telemetryItems[0].cells.count, 5);
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418)); EXPECT_EQ(telemetryItems[0].cells.values[0].value, 418);
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(408)); EXPECT_EQ(telemetryItems[0].cells.values[1].value, 408);
EXPECT_EQ(frskyData.hub.cellVolts[2], _V(415)); EXPECT_EQ(telemetryItems[0].cells.values[2].value, 415);
EXPECT_EQ(frskyData.hub.cellVolts[3], _V(420)); EXPECT_EQ(telemetryItems[0].cells.values[3].value, 420);
EXPECT_EQ(frskyData.hub.cellVolts[4], _V(410)); EXPECT_EQ(telemetryItems[0].cells.values[4].value, 410);
EXPECT_EQ(frskyData.hub.cellVolts[5], _V( 0)); EXPECT_EQ(telemetryItems[0].cells.values[5].value, 0);
EXPECT_EQ(frskyData.hub.minCellVolts, _V(408)); //current minimum cell voltage EXPECT_EQ(telemetryItems[0].value, 2071);
EXPECT_EQ(frskyData.hub.minCell, _V(408)); //all time minimum cell voltage EXPECT_EQ(telemetryItems[0].valueMin, 2071);
EXPECT_EQ(frskyData.hub.minCells, _V(207)); //all time cells sum minimum EXPECT_EQ(telemetryItems[0].valueMax, 2071);
EXPECT_EQ(frskyData.hub.cellsSum, _V(207)); //current cells sum
//simulate very low voltage for cell 3 //simulate very low voltage for cell 3
generateSportCellPacket(packet, 5, 0, _V(418), _V(408)); processSportPacket(packet); generateSportCellPacket(packet, 5, 0, _V(418), _V(408)); processSportPacket(packet);
generateSportCellPacket(packet, 5, 2, _V(100), _V(420)); processSportPacket(packet); generateSportCellPacket(packet, 5, 2, _V(100), _V(420)); processSportPacket(packet);
generateSportCellPacket(packet, 5, 4, _V(410), _V( 0)); processSportPacket(packet); generateSportCellPacket(packet, 5, 4, _V(410), _V( 0)); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.cellsCount, 5); EXPECT_EQ(telemetryItems[0].cells.count, 5);
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418)); EXPECT_EQ(telemetryItems[0].cells.values[0].value, 418);
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(408)); EXPECT_EQ(telemetryItems[0].cells.values[1].value, 408);
EXPECT_EQ(frskyData.hub.cellVolts[2], _V(100)); EXPECT_EQ(telemetryItems[0].cells.values[2].value, 100);
EXPECT_EQ(frskyData.hub.cellVolts[3], _V(420)); EXPECT_EQ(telemetryItems[0].cells.values[3].value, 420);
EXPECT_EQ(frskyData.hub.cellVolts[4], _V(410)); EXPECT_EQ(telemetryItems[0].cells.values[4].value, 410);
EXPECT_EQ(frskyData.hub.cellVolts[5], _V( 0)); EXPECT_EQ(telemetryItems[0].cells.values[5].value, 0);
EXPECT_EQ(frskyData.hub.minCellVolts, _V(100)); //current minimum cell voltage EXPECT_EQ(telemetryItems[0].value, 1756);
EXPECT_EQ(frskyData.hub.minCell, _V(100)); //all time minimum cell voltage EXPECT_EQ(telemetryItems[0].valueMin, 1756);
EXPECT_EQ(frskyData.hub.minCells, _V(175)); //all time cells sum minimum EXPECT_EQ(telemetryItems[0].valueMax, 2071);
EXPECT_EQ(frskyData.hub.cellsSum, _V(175)); //current cells sum
//back to normal (but with reversed order of packets) //back to normal (but with reversed order of packets)
generateSportCellPacket(packet, 5, 4, _V(410), _V( 0)); processSportPacket(packet); generateSportCellPacket(packet, 5, 4, _V(410), _V( 0)); processSportPacket(packet);
generateSportCellPacket(packet, 5, 0, _V(418), _V(408)); 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, 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(telemetryItems[0].cells.count, 5);
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418)); EXPECT_EQ(telemetryItems[0].cells.values[0].value, 418);
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(408)); EXPECT_EQ(telemetryItems[0].cells.values[1].value, 408);
EXPECT_EQ(frskyData.hub.cellVolts[2], _V(412)); EXPECT_EQ(telemetryItems[0].cells.values[2].value, 412);
EXPECT_EQ(frskyData.hub.cellVolts[3], _V(420)); EXPECT_EQ(telemetryItems[0].cells.values[3].value, 420);
EXPECT_EQ(frskyData.hub.cellVolts[4], _V(410)); EXPECT_EQ(telemetryItems[0].cells.values[4].value, 410);
EXPECT_EQ(frskyData.hub.cellVolts[5], _V( 0)); EXPECT_EQ(telemetryItems[0].cells.values[5].value, 0);
EXPECT_EQ(frskyData.hub.minCellVolts, _V(408)); //current minimum cell voltage EXPECT_EQ(telemetryItems[0].value, 2068);
EXPECT_EQ(frskyData.hub.minCell, _V(100)); //all time minimum cell voltage EXPECT_EQ(telemetryItems[0].valueMin, 1756);
EXPECT_EQ(frskyData.hub.minCells, _V(175)); //all time cells sum minimum EXPECT_EQ(telemetryItems[0].valueMax, 2071);
EXPECT_EQ(frskyData.hub.cellsSum, _V(206)); //current cells sum
//display test //display test
lcd_clear(); lcd_clear();
g_model.frsky.voltsSource = FRSKY_VOLTS_SOURCE_A1; g_model.frsky.voltsSource = FRSKY_VOLTS_SOURCE_A1;
} }
TEST(FrSkySPORT, DISABLED_StrangeCellsBug) TEST(FrSkySPORT, StrangeCellsBug)
{ {
MODEL_RESET();
TELEMETRY_RESET(); TELEMETRY_RESET();
uint8_t pkt[] = { 0x7E, 0x48, 0x10, 0x00, 0x03, 0x30, 0x15, 0x50, 0x81, 0xD5 }; uint8_t pkt[] = { 0x7E, 0x48, 0x10, 0x00, 0x03, 0x30, 0x15, 0x50, 0x81, 0xD5 };
EXPECT_EQ(checkSportPacket(pkt+1), true); EXPECT_EQ(checkSportPacket(pkt+1), true);
processSportPacket(pkt+1); processSportPacket(pkt+1);
EXPECT_EQ(frskyData.hub.cellsCount, 3); EXPECT_EQ(telemetryItems[0].cells.count, 3);
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(000)); // now we ignore such low values EXPECT_EQ(telemetryItems[0].cells.values[0].value, 0); // now we ignore such low values
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(413)); EXPECT_EQ(telemetryItems[0].cells.values[1].value, 413);
} }
TEST(FrSkySPORT, DISABLED_frskySetCellVoltageTwoSensors) TEST(FrSkySPORT, frskySetCellVoltageTwoSensors)
{ {
uint8_t packet[FRSKY_SPORT_PACKET_SIZE]; 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, 0, _V(418), _V(416)); processSportPacket(packet);
generateSportCellPacket(packet, 3, 2, _V(415), _V( 0)); processSportPacket(packet); generateSportCellPacket(packet, 3, 2, _V(415), _V( 0)); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.cellsCount, 3); EXPECT_EQ(telemetryItems[0].cells.count, 3);
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418)); EXPECT_EQ(telemetryItems[0].cells.values[0].value, 418);
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(416)); EXPECT_EQ(telemetryItems[0].cells.values[1].value, 416);
EXPECT_EQ(frskyData.hub.cellVolts[2], _V(415)); EXPECT_EQ(telemetryItems[0].cells.values[2].value, 415);
EXPECT_EQ(frskyData.hub.cellVolts[3], _V( 0)); EXPECT_EQ(telemetryItems[0].cells.values[3].value, 0);
EXPECT_EQ(frskyData.hub.minCellVolts, _V(415)); //current minimum cell voltage EXPECT_EQ(telemetryItems[0].value, 1249);
EXPECT_EQ(frskyData.hub.minCell, _V(415)); //all time minimum cell voltage EXPECT_EQ(telemetryItems[0].valueMin, 1249);
EXPECT_EQ(frskyData.hub.minCells, _V(124)); //all time cells sum minimum EXPECT_EQ(telemetryItems[0].valueMax, 1249);
EXPECT_EQ(frskyData.hub.cellsSum, _V(124)); //current cells sum
//sensor 2: 4 cell battery //sensor 2: 4 cell battery
generateSportCellPacket(packet, 4, 6, _V(410), _V(420)); processSportPacket(packet); generateSportCellPacket(packet, 4, 0, _V(410), _V(420), DATA_ID_FLVSS+1); processSportPacket(packet);
generateSportCellPacket(packet, 4, 8, _V(400), _V(405)); 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 EXPECT_EQ(telemetryItems[1].cells.count, 4);
generateSportCellPacket(packet, 3, 0, _V(418), _V(416)); processSportPacket(packet); EXPECT_EQ(telemetryItems[1].cells.values[0].value, 410);
generateSportCellPacket(packet, 3, 2, _V(415), _V( 0)); processSportPacket(packet); EXPECT_EQ(telemetryItems[1].cells.values[1].value, 420);
EXPECT_EQ(telemetryItems[1].cells.values[2].value, 400);
EXPECT_EQ(frskyData.hub.cellsCount, 7); EXPECT_EQ(telemetryItems[1].cells.values[3].value, 405);
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(418)); EXPECT_EQ(telemetryItems[1].value, 1635);
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(416)); EXPECT_EQ(telemetryItems[1].valueMin, 1635);
EXPECT_EQ(frskyData.hub.cellVolts[2], _V(415)); EXPECT_EQ(telemetryItems[1].valueMax, 1635);
EXPECT_EQ(frskyData.hub.cellVolts[3], _V(410));
EXPECT_EQ(frskyData.hub.cellVolts[4], _V(420)); g_model.telemetrySensors[2].type = TELEM_TYPE_CALCULATED;
EXPECT_EQ(frskyData.hub.cellVolts[5], _V(400)); g_model.telemetrySensors[2].formula = TELEM_FORMULA_ADD;
EXPECT_EQ(frskyData.hub.cellVolts[6], _V(405)); g_model.telemetrySensors[2].prec = 1;
EXPECT_EQ(frskyData.hub.cellVolts[7], _V( 0)); g_model.telemetrySensors[2].calc.sources[0] = 1;
EXPECT_EQ(frskyData.hub.cellVolts[8], _V( 0)); g_model.telemetrySensors[2].calc.sources[1] = 2;
EXPECT_EQ(frskyData.hub.minCellVolts, _V(400)); //current minimum cell voltage
EXPECT_EQ(frskyData.hub.minCell, _V(400)); //all time minimum cell voltage telemetryWakeup();
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[2].value, 287);
EXPECT_EQ(telemetryItems[2].valueMin, 287);
EXPECT_EQ(telemetryItems[2].valueMax, 287);
//now change some voltages //now change some voltages
generateSportCellPacket(packet, 3, 2, _V(415), _V( 0)); processSportPacket(packet); 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, 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); telemetryWakeup();
EXPECT_EQ(frskyData.hub.cellVolts[0], _V(420));
EXPECT_EQ(frskyData.hub.cellVolts[1], _V(410)); EXPECT_EQ(telemetryItems[2].value, 283);
EXPECT_EQ(frskyData.hub.cellVolts[2], _V(415)); EXPECT_EQ(telemetryItems[2].valueMin, 283);
EXPECT_EQ(frskyData.hub.cellVolts[3], _V(410)); EXPECT_EQ(telemetryItems[2].valueMax, 287);
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
//display test //display test
lcd_clear(); lcd_clear();
@ -374,29 +361,33 @@ void generateSportFasVoltagePacket(uint8_t * packet, uint32_t voltage)
setSportPacketCrc(packet); setSportPacketCrc(packet);
} }
TEST(FrSkySPORT, DISABLED_frskyVfas) TEST(FrSkySPORT, frskyVfas)
{ {
uint8_t packet[FRSKY_SPORT_PACKET_SIZE]; uint8_t packet[FRSKY_SPORT_PACKET_SIZE];
//telemetryReset(); MODEL_RESET();
TELEMETRY_RESET(); TELEMETRY_RESET();
// tests for Vfas // tests for Vfas
generateSportFasVoltagePacket(packet, 5000); processSportPacket(packet); generateSportFasVoltagePacket(packet, 5000); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.vfas, 500); EXPECT_EQ(telemetryItems[0].value, 5000);
EXPECT_EQ(frskyData.hub.minVfas, 500); EXPECT_EQ(telemetryItems[0].valueMin, 5000);
EXPECT_EQ(telemetryItems[0].valueMax, 5000);
generateSportFasVoltagePacket(packet, 6524); processSportPacket(packet); generateSportFasVoltagePacket(packet, 6524); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.vfas, 652); EXPECT_EQ(telemetryItems[0].value, 6524);
EXPECT_EQ(frskyData.hub.minVfas, 500); EXPECT_EQ(telemetryItems[0].valueMin, 6524); // the batt was changed (val > old max)
EXPECT_EQ(telemetryItems[0].valueMax, 6524);
generateSportFasVoltagePacket(packet, 1248); processSportPacket(packet); generateSportFasVoltagePacket(packet, 1248); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.vfas, 124); EXPECT_EQ(telemetryItems[0].value, 1248);
EXPECT_EQ(frskyData.hub.minVfas, 124); EXPECT_EQ(telemetryItems[0].valueMin, 1248);
EXPECT_EQ(telemetryItems[0].valueMax, 6524);
generateSportFasVoltagePacket(packet, 2248); processSportPacket(packet); generateSportFasVoltagePacket(packet, 2248); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.vfas, 224); EXPECT_EQ(telemetryItems[0].value, 2248);
EXPECT_EQ(frskyData.hub.minVfas, 124); EXPECT_EQ(telemetryItems[0].valueMin, 1248);
EXPECT_EQ(telemetryItems[0].valueMax, 6524);
} }
void generateSportFasCurrentPacket(uint8_t * packet, uint32_t current) void generateSportFasCurrentPacket(uint8_t * packet, uint32_t current)
@ -412,49 +403,56 @@ TEST(FrSkySPORT, frskyCurrent)
{ {
uint8_t packet[FRSKY_SPORT_PACKET_SIZE]; uint8_t packet[FRSKY_SPORT_PACKET_SIZE];
MODEL_RESET();
TELEMETRY_RESET(); TELEMETRY_RESET();
g_model.frsky.fasOffset = -5; /* unit: 1/10 amps */
// tests for Curr // tests for Curr
generateSportFasCurrentPacket(packet, 0); processSportPacket(packet); generateSportFasCurrentPacket(packet, 0); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.current, 0); g_model.telemetrySensors[0].custom.offset = -5; /* unit: 1/10 amps */
EXPECT_EQ(frskyData.hub.maxCurrent, 0); 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 // measured current less then offset - value should be zero
generateSportFasCurrentPacket(packet, 4); processSportPacket(packet); generateSportFasCurrentPacket(packet, 4); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.current, 0); EXPECT_EQ(telemetryItems[0].value, 0);
EXPECT_EQ(frskyData.hub.maxCurrent, 0); EXPECT_EQ(telemetryItems[0].valueMin, 0);
EXPECT_EQ(telemetryItems[0].valueMax, 0);
generateSportFasCurrentPacket(packet, 10); processSportPacket(packet); generateSportFasCurrentPacket(packet, 10); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.current, 5); EXPECT_EQ(telemetryItems[0].value, 5);
EXPECT_EQ(frskyData.hub.maxCurrent, 5); EXPECT_EQ(telemetryItems[0].valueMin, 0);
EXPECT_EQ(telemetryItems[0].valueMax, 5);
generateSportFasCurrentPacket(packet, 500); processSportPacket(packet); generateSportFasCurrentPacket(packet, 500); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.current, 495); EXPECT_EQ(telemetryItems[0].value, 495);
EXPECT_EQ(frskyData.hub.maxCurrent, 495); EXPECT_EQ(telemetryItems[0].valueMin, 0);
EXPECT_EQ(telemetryItems[0].valueMax, 495);
generateSportFasCurrentPacket(packet, 200); processSportPacket(packet); generateSportFasCurrentPacket(packet, 200); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.current, 195); EXPECT_EQ(telemetryItems[0].value, 195);
EXPECT_EQ(frskyData.hub.maxCurrent, 495); EXPECT_EQ(telemetryItems[0].valueMin, 0);
EXPECT_EQ(telemetryItems[0].valueMax, 495);
// test with positive offset // test with positive offset
TELEMETRY_RESET(); 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); generateSportFasCurrentPacket(packet, 0); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.current, 5); EXPECT_EQ(telemetryItems[0].value, 5);
EXPECT_EQ(frskyData.hub.maxCurrent, 5); EXPECT_EQ(telemetryItems[0].valueMin, 5);
EXPECT_EQ(telemetryItems[0].valueMax, 5);
generateSportFasCurrentPacket(packet, 500); processSportPacket(packet); generateSportFasCurrentPacket(packet, 500); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.current, 505); EXPECT_EQ(telemetryItems[0].value, 505);
EXPECT_EQ(frskyData.hub.maxCurrent, 505); EXPECT_EQ(telemetryItems[0].valueMin, 5);
EXPECT_EQ(telemetryItems[0].valueMax, 505);
generateSportFasCurrentPacket(packet, 200); processSportPacket(packet); generateSportFasCurrentPacket(packet, 200); processSportPacket(packet);
EXPECT_EQ(frskyData.hub.current, 205); EXPECT_EQ(telemetryItems[0].value, 205);
EXPECT_EQ(frskyData.hub.maxCurrent, 505); EXPECT_EQ(telemetryItems[0].valueMin, 5);
EXPECT_EQ(telemetryItems[0].valueMax, 505);
} }
#endif
#endif //#if defined(FRSKY_SPORT) #endif //#if defined(FRSKY_SPORT)

5
radio/src/tests/gtests.h
View file

@ -53,6 +53,11 @@ inline void TELEMETRY_RESET()
memclear(&frskyData, sizeof(frskyData)); memclear(&frskyData, sizeof(frskyData));
TELEMETRY_RSSI() = 100; TELEMETRY_RSSI() = 100;
#endif #endif
#if defined(CPUARM) && defined(FRSKY)
for (int i=0; i<MAX_SENSORS; i++) {
telemetryItems[i].clear();
}
#endif
} }
bool checkScreenshot(QString test); bool checkScreenshot(QString test);