src/test/unit/telemetry_hott_unittest.cc

   1 /*
   2  * This file is part of Cleanflight.
   3  *
   4  * Cleanflight is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * Cleanflight is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with Cleanflight.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <stdbool.h>
  19 #include <stdint.h>
  20 #include <string.h>
  21
  22 #include <limits.h>
  23
  24 extern "C" {
  25     #include "platform.h"
  26
  27     #include "build/debug.h"
  28
  29     #include "common/axis.h"
  30     #include "common/gps_conversion.h"
  31
  32     #include "pg/pg.h"
  33     #include "pg/pg_ids.h"
  34
  35     #include "drivers/system.h"
  36     #include "drivers/serial.h"
  37     #include "drivers/system.h"
  38
  39     #include "fc/runtime_config.h"
  40
  41     #include "flight/pid.h"
  42
  43     #include "io/gps.h"
  44     #include "io/serial.h"
  45
  46     #include "sensors/barometer.h"
  47     #include "sensors/battery.h"
  48     #include "sensors/sensors.h"
  49
  50     #include "telemetry/telemetry.h"
  51     #include "telemetry/hott.h"
  52
  53     PG_REGISTER(telemetryConfig_t, telemetryConfig, PG_TELEMETRY_CONFIG, 0);
  54     PG_REGISTER(gpsConfig_t, gpsConfig, PG_GPS_CONFIG, 0);
  55
  56     uint16_t testBatteryVoltage = 0;
  57     int32_t testAmperage = 0;
  58     int32_t testMAhDrawn = 0;
  59
  60 }
  61
  62 #include "unittest_macros.h"
  63 #include "gtest/gtest.h"
  64
  65 extern "C" {
  66     void addGPSCoordinates(HOTT_GPS_MSG_t *hottGPSMessage, int32_t latitude, int32_t longitude);
  67 }
  68 // See http://en.wikipedia.org/wiki/Geographic_coordinate_conversion
  69
  70 HOTT_GPS_MSG_t hottGPSMessage;
  71
  72 HOTT_GPS_MSG_t *getGPSMessageForTest(void)
  73 {
  74     memset(&hottGPSMessage, 0, sizeof(hottGPSMessage));
  75     return &hottGPSMessage;
  76 }
  77
  78 TEST(TelemetryHottTest, UpdateGPSCoordinates1)
  79 {
  80     // given
  81     HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
  82
  83     // Mayrhofen, Austria
  84     uint32_t longitude = GPS_coord_to_degrees("4710.5186");
  85     uint32_t latitude = GPS_coord_to_degrees("1151.4252");
  86
  87     // when
  88     addGPSCoordinates(hottGPSMessage, latitude, longitude);
  89
  90     // then
  91     EXPECT_EQ(hottGPSMessage->pos_NS, 0);
  92     EXPECT_EQ(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L, 1151);
  93     EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L), 4251);
  94
  95     EXPECT_EQ(hottGPSMessage->pos_EW, 0);
  96     EXPECT_EQ(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L, 4710);
  97     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), 5186);
  98 }
  99
 100 TEST(TelemetryHottTest, UpdateGPSCoordinates2)
 101 {
 102     // given
 103     HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
 104
 105     // Hampstead Heath, London
 106     // 51.563886, -0.159960
 107     uint32_t longitude = GPS_coord_to_degrees("5156.3886");
 108     uint32_t latitude  = -GPS_coord_to_degrees("015.9960");
 109
 110     // when
 111     addGPSCoordinates(hottGPSMessage, longitude, latitude);
 112
 113     // then
 114     EXPECT_EQ(hottGPSMessage->pos_NS, 0);
 115     EXPECT_EQ(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L, 5156);
 116     EXPECT_EQ(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L, 3886);
 117
 118     EXPECT_EQ(hottGPSMessage->pos_EW, 1);
 119     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L), -15);
 120     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), -9960);
 121 }
 122
 123
 124 TEST(TelemetryHottTest, UpdateGPSCoordinates3)
 125 {
 126     // given
 127     HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
 128
 129     int32_t longitude = -GPS_coord_to_degrees("17999.9999");
 130     int32_t latitude = GPS_coord_to_degrees("8999.9999");
 131
 132     // when
 133     addGPSCoordinates(hottGPSMessage, longitude, latitude);
 134
 135     // then
 136     EXPECT_EQ(hottGPSMessage->pos_NS, 1);
 137     EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L), -18039);
 138     EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L), -9999);
 139
 140     EXPECT_EQ(hottGPSMessage->pos_EW, 0);
 141     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L), 9039);
 142     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), 9999);
 143 }
 144
 145 /*
 146 TEST(TelemetryHottTest, PrepareGPSMessage_Altitude1m)
 147 {
 148     // given
 149     HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
 150
 151     stateFlags = GPS_FIX;
 152     uint16_t altitudeInMeters = 1;
 153     GPS_altitude = altitudeInMeters * (1 / 0.1f); // 1 = 0.1m
 154
 155     // when
 156     hottPrepareGPSResponse(hottGPSMessage);
 157
 158     // then
 159     EXPECT_EQ((int16_t)(hottGPSMessage->altitude_H << 8 | hottGPSMessage->altitude_L), 1 + HOTT_GPS_ALTITUDE_OFFSET);
 160 }
 161 */
 162
 163 // STUBS
 164
 165 extern "C" {
 166
 167 int16_t debug[DEBUG16_VALUE_COUNT];
 168
 169 uint8_t stateFlags;
 170
 171 uint16_t batteryWarningVoltage;
 172 uint8_t useHottAlarmSoundPeriod (void) { return 0; }
 173
 174
 175 gpsSolutionData_t gpsSol;
 176 uint16_t GPS_distanceToHome;        // distance to home point in meters
 177 int16_t GPS_directionToHome;        // direction to home or hol point in degrees
 178
 179
 180 uint32_t fixedMillis = 0;
 181
 182 baro_t baro;
 183
 184 int32_t getEstimatedAltitudeCm() { return 0; }
 185 int16_t getEstimatedVario() { return 0; }
 186
 187 uint32_t millis(void) {
 188     return fixedMillis;
 189 }
 190
 191 uint32_t micros(void) { return 0; }
 192
 193 uint32_t serialRxBytesWaiting(const serialPort_t *instance)
 194 {
 195     UNUSED(instance);
 196     return 0;
 197 }
 198
 199 uint32_t serialTxBytesFree(const serialPort_t *instance)
 200 {
 201     UNUSED(instance);
 202     return 0;
 203 }
 204
 205 uint8_t serialRead(serialPort_t *instance)
 206 {
 207     UNUSED(instance);
 208     return 0;
 209 }
 210
 211 void serialWrite(serialPort_t *instance, uint8_t ch)
 212 {
 213     UNUSED(instance);
 214     UNUSED(ch);
 215 }
 216
 217 void serialSetMode(serialPort_t *instance, portMode_e mode)
 218 {
 219     UNUSED(instance);
 220     UNUSED(mode);
 221 }
 222
 223 serialPort_t *openSerialPort(serialPortIdentifier_e identifier, serialPortFunction_e functionMask, serialReceiveCallbackPtr callback, void *callbackData, uint32_t baudRate, portMode_e mode, portOptions_e options)
 224 {
 225     UNUSED(identifier);
 226     UNUSED(functionMask);
 227     UNUSED(baudRate);
 228     UNUSED(callback);
 229     UNUSED(callbackData);
 230     UNUSED(mode);
 231     UNUSED(options);
 232
 233     return NULL;
 234 }
 235
 236 void closeSerialPort(serialPort_t *serialPort)
 237 {
 238     UNUSED(serialPort);
 239 }
 240
 241 const serialPortConfig_t *findSerialPortConfig(serialPortFunction_e function)
 242 {
 243     UNUSED(function);
 244
 245     return NULL;
 246 }
 247
 248 bool sensors(uint32_t mask)
 249 {
 250     UNUSED(mask);
 251     return false;
 252 }
 253
 254 bool telemetryDetermineEnabledState(portSharing_e)
 255 {
 256     return true;
 257 }
 258
 259 bool telemetryIsSensorEnabled(sensor_e sensor) {
 260     UNUSED(sensor);
 261     return true;
 262 }
 263
 264 portSharing_e determinePortSharing(const serialPortConfig_t *, serialPortFunction_e)
 265 {
 266     return PORTSHARING_NOT_SHARED;
 267 }
 268
 269 batteryState_e getBatteryState(void)
 270 {
 271         return BATTERY_OK;
 272 }
 273
 274 batteryState_e getVoltageState(void)
 275 {
 276         return BATTERY_OK;
 277 }
 278
 279 batteryState_e getConsumptionState(void)
 280 {
 281         return BATTERY_OK;
 282 }
 283
 284 uint16_t getBatteryVoltage(void)
 285 {
 286     return testBatteryVoltage;
 287 }
 288
 289 uint16_t getLegacyBatteryVoltage(void)
 290 {
 291     return (testBatteryVoltage + 5) / 10;
 292 }
 293
 294 int32_t getAmperage(void) {
 295     return testAmperage;
 296 }
 297
 298 int32_t getMAhDrawn(void) {
 299     return testMAhDrawn;
 300 }
 301
 302 }