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
  55     uint16_t testBatteryVoltage = 0;
  56     int32_t testAmperage = 0;
  57     int32_t testMAhDrawn = 0;
  58
  59 }
  60
  61 #include "unittest_macros.h"
  62 #include "gtest/gtest.h"
  63
  64 extern "C" {
  65     void addGPSCoordinates(HOTT_GPS_MSG_t *hottGPSMessage, int32_t latitude, int32_t longitude);
  66 }
  67 // See http://en.wikipedia.org/wiki/Geographic_coordinate_conversion
  68
  69 HOTT_GPS_MSG_t hottGPSMessage;
  70
  71 HOTT_GPS_MSG_t *getGPSMessageForTest(void)
  72 {
  73     memset(&hottGPSMessage, 0, sizeof(hottGPSMessage));
  74     return &hottGPSMessage;
  75 }
  76
  77 TEST(TelemetryHottTest, UpdateGPSCoordinates1)
  78 {
  79     // given
  80     HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
  81
  82     // Mayrhofen, Austria
  83     uint32_t longitude = GPS_coord_to_degrees("4710.5186");
  84     uint32_t latitude = GPS_coord_to_degrees("1151.4252");
  85
  86     // when
  87     addGPSCoordinates(hottGPSMessage, latitude, longitude);
  88
  89     // then
  90     EXPECT_EQ(hottGPSMessage->pos_NS, 0);
  91     EXPECT_EQ(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L, 1151);
  92     EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L), 4251);
  93
  94     EXPECT_EQ(hottGPSMessage->pos_EW, 0);
  95     EXPECT_EQ(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L, 4710);
  96     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), 5186);
  97 }
  98
  99 TEST(TelemetryHottTest, UpdateGPSCoordinates2)
 100 {
 101     // given
 102     HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
 103
 104     // Hampstead Heath, London
 105     // 51.563886, -0.159960
 106     uint32_t longitude = GPS_coord_to_degrees("5156.3886");
 107     uint32_t latitude  = -GPS_coord_to_degrees("015.9960");
 108
 109     // when
 110     addGPSCoordinates(hottGPSMessage, longitude, latitude);
 111
 112     // then
 113     EXPECT_EQ(hottGPSMessage->pos_NS, 0);
 114     EXPECT_EQ(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L, 5156);
 115     EXPECT_EQ(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L, 3886);
 116
 117     EXPECT_EQ(hottGPSMessage->pos_EW, 1);
 118     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L), -15);
 119     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), -9960);
 120 }
 121
 122
 123 TEST(TelemetryHottTest, UpdateGPSCoordinates3)
 124 {
 125     // given
 126     HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
 127
 128     int32_t longitude = -GPS_coord_to_degrees("17999.9999");
 129     int32_t latitude = GPS_coord_to_degrees("8999.9999");
 130
 131     // when
 132     addGPSCoordinates(hottGPSMessage, longitude, latitude);
 133
 134     // then
 135     EXPECT_EQ(hottGPSMessage->pos_NS, 1);
 136     EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L), -18039);
 137     EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L), -9999);
 138
 139     EXPECT_EQ(hottGPSMessage->pos_EW, 0);
 140     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L), 9039);
 141     EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), 9999);
 142 }
 143
 144 /*
 145 TEST(TelemetryHottTest, PrepareGPSMessage_Altitude1m)
 146 {
 147     // given
 148     HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
 149
 150     stateFlags = GPS_FIX;
 151     uint16_t altitudeInMeters = 1;
 152     GPS_altitude = altitudeInMeters * (1 / 0.1f); // 1 = 0.1m
 153
 154     // when
 155     hottPrepareGPSResponse(hottGPSMessage);
 156
 157     // then
 158     EXPECT_EQ((int16_t)(hottGPSMessage->altitude_H << 8 | hottGPSMessage->altitude_L), 1 + HOTT_GPS_ALTITUDE_OFFSET);
 159 }
 160 */
 161
 162 // STUBS
 163
 164 extern "C" {
 165
 166 int16_t debug[DEBUG16_VALUE_COUNT];
 167
 168 uint8_t stateFlags;
 169
 170 uint16_t batteryWarningVoltage;
 171 uint8_t useHottAlarmSoundPeriod (void) { return 0; }
 172
 173
 174 gpsSolutionData_t gpsSol;
 175 uint16_t GPS_distanceToHome;        // distance to home point in meters
 176 int16_t GPS_directionToHome;        // direction to home or hol point in degrees
 177
 178
 179 uint32_t fixedMillis = 0;
 180
 181 baro_t baro;
 182
 183 int32_t getEstimatedAltitudeCm() { return 0; }
 184 int16_t getEstimatedVario() { return 0; }
 185
 186 uint32_t millis(void) {
 187     return fixedMillis;
 188 }
 189
 190 uint32_t micros(void) { return 0; }
 191
 192 uint32_t serialRxBytesWaiting(const serialPort_t *instance)
 193 {
 194     UNUSED(instance);
 195     return 0;
 196 }
 197
 198 uint32_t serialTxBytesFree(const serialPort_t *instance)
 199 {
 200     UNUSED(instance);
 201     return 0;
 202 }
 203
 204 uint8_t serialRead(serialPort_t *instance)
 205 {
 206     UNUSED(instance);
 207     return 0;
 208 }
 209
 210 void serialWrite(serialPort_t *instance, uint8_t ch)
 211 {
 212     UNUSED(instance);
 213     UNUSED(ch);
 214 }
 215
 216 void serialSetMode(serialPort_t *instance, portMode_e mode)
 217 {
 218     UNUSED(instance);
 219     UNUSED(mode);
 220 }
 221
 222 serialPort_t *openSerialPort(serialPortIdentifier_e identifier, serialPortFunction_e functionMask, serialReceiveCallbackPtr callback, void *callbackData, uint32_t baudRate, portMode_e mode, portOptions_e options)
 223 {
 224     UNUSED(identifier);
 225     UNUSED(functionMask);
 226     UNUSED(baudRate);
 227     UNUSED(callback);
 228     UNUSED(callbackData);
 229     UNUSED(mode);
 230     UNUSED(options);
 231
 232     return NULL;
 233 }
 234
 235 void closeSerialPort(serialPort_t *serialPort)
 236 {
 237     UNUSED(serialPort);
 238 }
 239
 240 const serialPortConfig_t *findSerialPortConfig(serialPortFunction_e function)
 241 {
 242     UNUSED(function);
 243
 244     return NULL;
 245 }
 246
 247 bool sensors(uint32_t mask)
 248 {
 249     UNUSED(mask);
 250     return false;
 251 }
 252
 253 bool telemetryDetermineEnabledState(portSharing_e)
 254 {
 255     return true;
 256 }
 257
 258 bool telemetryIsSensorEnabled(sensor_e sensor) {
 259     UNUSED(sensor);
 260     return true;
 261 }
 262
 263 portSharing_e determinePortSharing(const serialPortConfig_t *, serialPortFunction_e)
 264 {
 265     return PORTSHARING_NOT_SHARED;
 266 }
 267
 268 batteryState_e getBatteryState(void)
 269 {
 270         return BATTERY_OK;
 271 }
 272
 273 batteryState_e getVoltageState(void)
 274 {
 275         return BATTERY_OK;
 276 }
 277
 278 batteryState_e getConsumptionState(void)
 279 {
 280         return BATTERY_OK;
 281 }
 282
 283 uint16_t getBatteryVoltage(void)
 284 {
 285     return testBatteryVoltage;
 286 }
 287
 288 uint16_t getLegacyBatteryVoltage(void)
 289 {
 290     return (testBatteryVoltage + 5) / 10;
 291 }
 292
 293 int32_t getAmperage(void) {
 294     return testAmperage;
 295 }
 296
 297 int32_t getMAhDrawn(void) {
 298     return testMAhDrawn;
 299 }
 300
 301 }