src/test/unit/rx_sumd_unittest.cc

   1 /*
   2  * This file is part of Betaflight.
   3  *
   4  * Betaflight 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  * Betaflight 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 Betaflight.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <stdint.h>
  19
  20 extern "C" {
  21 #include "platform.h"
  22 #include "pg/pg.h"
  23 #include "pg/rx.h"
  24 #include "drivers/serial.h"
  25 #include "drivers/time.h"
  26 #include "io/serial.h"
  27 #include "rx/rx.h"
  28 #include "rx/sumd.h"
  29 #include "telemetry/telemetry.h"
  30 #include "fc/rc_controls.h"
  31 #include "fc/rc_modes.h"
  32 #include "sensors/barometer.h"
  33 #include "sensors/battery.h"
  34 }
  35
  36 #include "unittest_macros.h"
  37 #include "gtest/gtest.h"
  38
  39
  40 extern "C" {
  41     uint8_t batteryCellCount = 3;
  42     float rcCommand[4] = {0, 0, 0, 0};
  43     int16_t telemTemperature1 = 0;
  44     baro_t baro = { .baroTemperature = 50 };
  45     telemetryConfig_t telemetryConfig_System;
  46     timeUs_t rxFrameTimeUs(void) { return 0; }
  47 }
  48
  49
  50 bool telemetryCheckRxPortShared(const serialPortConfig_t *portConfig, const SerialRXType serialrxProvider)
  51 {
  52     //TODO: implement
  53     UNUSED(portConfig);
  54     UNUSED(serialrxProvider);
  55
  56     return false;
  57 }
  58
  59 serialPort_t *telemetrySharedPort = NULL;
  60
  61 static uint16_t vbat = 100;
  62 uint16_t getVbat(void)
  63 {
  64     return vbat;
  65 }
  66
  67 uint32_t microseconds_stub_value = 0;
  68 uint32_t micros(void)
  69 {
  70     return microseconds_stub_value;
  71 }
  72
  73 uint32_t microsISR(void)
  74 {
  75     return micros();
  76 }
  77
  78 #define SERIAL_BUFFER_SIZE 256
  79 #define SERIAL_PORT_DUMMY_IDENTIFIER  (serialPortIdentifier_e)0x12
  80
  81 typedef struct serialPortStub_s {
  82     uint8_t buffer[SERIAL_BUFFER_SIZE];
  83     int pos = 0;
  84     int end = 0;
  85 } serialPortStub_t;
  86
  87 static serialPort_t serialTestInstance;
  88 static serialPortConfig_t serialTestInstanceConfig = {
  89     .identifier = SERIAL_PORT_DUMMY_IDENTIFIER,
  90     .functionMask = 0
  91 };
  92
  93 static serialReceiveCallbackPtr stub_serialRxCallback;
  94 static serialPortConfig_t *findSerialPortConfig_stub_retval;
  95 static bool openSerial_called = false;
  96 static serialPortStub_t serialWriteStub;
  97 static bool portIsShared = false;
  98
  99 static portMode_e serialExpectedMode = MODE_RX;
 100 static portOptions_e serialExpectedOptions = SERIAL_UNIDIR;
 101
 102
 103 const serialPortConfig_t *findSerialPortConfig(serialPortFunction_e function)
 104 {
 105     EXPECT_EQ(function, FUNCTION_RX_SERIAL);
 106     return findSerialPortConfig_stub_retval;
 107 }
 108
 109 serialPort_t *openSerialPort(
 110     serialPortIdentifier_e identifier,
 111     serialPortFunction_e function,
 112     serialReceiveCallbackPtr callback,
 113     void *callbackData,
 114     uint32_t baudrate,
 115     portMode_e mode,
 116     portOptions_e options
 117 )
 118 {
 119     openSerial_called = true;
 120     EXPECT_FALSE(NULL == callback);
 121     EXPECT_TRUE(NULL == callbackData);
 122     EXPECT_EQ(identifier, SERIAL_PORT_DUMMY_IDENTIFIER);
 123     EXPECT_EQ(options, serialExpectedOptions);
 124     EXPECT_EQ(function, FUNCTION_RX_SERIAL);
 125     EXPECT_EQ(baudrate, 115200);
 126     EXPECT_EQ(mode, serialExpectedMode);
 127     stub_serialRxCallback = callback;
 128     return &serialTestInstance;
 129 }
 130
 131 void serialWrite(serialPort_t *instance, uint8_t ch)
 132 {
 133     EXPECT_EQ(instance, &serialTestInstance);
 134     EXPECT_LT(serialWriteStub.pos, sizeof(serialWriteStub.buffer));
 135     serialWriteStub.buffer[serialWriteStub.pos++] = ch;
 136 }
 137
 138 void serialTestResetPort()
 139 {
 140     openSerial_called = false;
 141     stub_serialRxCallback = NULL;
 142     portIsShared = false;
 143     serialExpectedMode = MODE_RX;
 144     serialExpectedOptions = SERIAL_UNIDIR;
 145 }
 146
 147 class SumdRxInitUnitTest : public ::testing::Test
 148 {
 149 protected:
 150     virtual void SetUp()
 151     {
 152         serialTestResetPort();
 153     }
 154 };
 155
 156
 157 TEST_F(SumdRxInitUnitTest, Test_SumdRxNotEnabled)
 158 {
 159     const rxConfig_t initialRxConfig = {};
 160     rxRuntimeState_t rxRuntimeState = {};
 161     findSerialPortConfig_stub_retval = NULL;
 162
 163     EXPECT_FALSE(sumdInit(&initialRxConfig, &rxRuntimeState));
 164
 165     EXPECT_EQ(18, rxRuntimeState.channelCount);
 166     EXPECT_EQ(11000, rxRuntimeState.rxRefreshRate);
 167     EXPECT_FALSE(NULL == rxRuntimeState.rcReadRawFn);
 168     EXPECT_FALSE(NULL == rxRuntimeState.rcFrameStatusFn);
 169 }
 170
 171
 172 TEST_F(SumdRxInitUnitTest, Test_SumdRxEnabled)
 173 {
 174     const rxConfig_t initialRxConfig = {};
 175     rxRuntimeState_t rxRuntimeState = {};
 176     findSerialPortConfig_stub_retval = &serialTestInstanceConfig;
 177
 178     EXPECT_TRUE(sumdInit(&initialRxConfig, &rxRuntimeState));
 179
 180     EXPECT_EQ(18, rxRuntimeState.channelCount);
 181     EXPECT_EQ(11000, rxRuntimeState.rxRefreshRate);
 182     EXPECT_FALSE(NULL == rxRuntimeState.rcReadRawFn);
 183     EXPECT_FALSE(NULL == rxRuntimeState.rcFrameStatusFn);
 184
 185     EXPECT_TRUE(openSerial_called);
 186 }
 187
 188
 189
 190 class SumdRxProtocollUnitTest : public ::testing::Test
 191 {
 192 protected:
 193     rxRuntimeState_t rxRuntimeState = {};
 194     virtual void SetUp()
 195     {
 196         serialTestResetPort();
 197
 198         const rxConfig_t initialRxConfig = {};
 199         findSerialPortConfig_stub_retval = &serialTestInstanceConfig;
 200
 201         EXPECT_TRUE(sumdInit(&initialRxConfig, &rxRuntimeState));
 202         microseconds_stub_value += 5000;
 203         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 204     }
 205
 206     virtual void checkValidChannels()
 207     {
 208         //report frame complete once
 209         EXPECT_EQ(RX_FRAME_COMPLETE, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 210         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 211
 212         EXPECT_EQ(900, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 0));
 213         EXPECT_EQ(1100, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 1));
 214         EXPECT_EQ(1500, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 2));
 215         EXPECT_EQ(1900, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 3));
 216         EXPECT_EQ(2100, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 4));
 217     }
 218
 219     /*
 220      * the structure of a sumd packet is
 221      * 0xA8 = sync byte, 0x01 = status byte, number of channels
 222      * Channel data two bytes per channel
 223      * two bytes checksum
 224      */
 225     virtual void sendValidPacket()
 226     {
 227         uint8_t packet[] = {0xA8, 0x01, 20,
 228                             0x1c, 0x20, 0x22, 0x60, 0x2e, 0xe0, 0x3b, 0x60, 0x41, 0xa0,
 229                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 230                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 231                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 232                             0x06, 0x3f
 233                            };
 234
 235         for (size_t i = 0; i < sizeof(packet); i++) {
 236             EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 237             stub_serialRxCallback(packet[i], NULL);
 238         }
 239         checkValidChannels();
 240     }
 241
 242     virtual void sendValidLongPacket()
 243     {
 244         uint8_t packet[] = {0xA8, 0x01, 32,
 245                             0x1c, 0x20, 0x22, 0x60, 0x2e, 0xe0, 0x3b, 0x60, 0x41, 0xa0,
 246                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 247                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 248                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 249                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 250                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 251                             0x1c, 0x20, 0x1c, 0x20,
 252                             0xeb, 0x61
 253                            };
 254
 255         for (size_t i = 0; i < sizeof(packet); i++) {
 256             EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 257             stub_serialRxCallback(packet[i], NULL);
 258         }
 259         checkValidChannels();
 260     }
 261
 262     virtual void sendValidShortPacket()
 263     {
 264         uint8_t packet[] = {0xA8, 0x01, 16,
 265                             0x1c, 0x20, 0x22, 0x60, 0x2e, 0xe0, 0x3b, 0x60, 0x41, 0xa0,
 266                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 267                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 268                             0x1c, 0x20,
 269                             0x37, 0x24
 270                            };
 271
 272         for (size_t i = 0; i < sizeof(packet); i++) {
 273             EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 274             stub_serialRxCallback(packet[i], NULL);
 275         }
 276
 277         checkValidChannels();
 278     }
 279
 280     virtual void sendValidFsPacket()
 281     {
 282
 283         uint8_t packet[] = {0xA8, 0x81, 0x08,
 284                             0x2E, 0xE0, 0x2E, 0xE0, 0x2E, 0xE0, 0x2E, 0xE0, 0x2E, 0xE0, 0x2E, 0xE0, 0x2E, 0xE0, 0x2E, 0xE0,
 285                             0xF9, 0x0F
 286                            };
 287
 288         for (size_t i = 0; i < sizeof(packet); i++) {
 289             EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 290             stub_serialRxCallback(packet[i], NULL);
 291         }
 292
 293         EXPECT_EQ(RX_FRAME_COMPLETE | RX_FRAME_FAILSAFE, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 294         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 295
 296         for  (size_t i = 0; i < 8; i++) {
 297             EXPECT_EQ(1500, rxRuntimeState.rcReadRawFn(&rxRuntimeState, i));
 298         }
 299     }
 300
 301     virtual void sendInvalidPacket()
 302     {
 303         uint8_t packet[] = {0xA8, 0x01, 20,
 304                             0x1c, 0x21, 0x22, 0x60, 0x2e, 0xe0, 0x3b, 0x60, 0x41, 0xa0,
 305                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 306                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 307                             0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20, 0x1c, 0x20,
 308                             0x06, 0x3f
 309                            };
 310
 311         for (size_t i = 0; i < sizeof(packet); i++) {
 312             EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 313             stub_serialRxCallback(packet[i], NULL);
 314         }
 315
 316         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 317
 318         EXPECT_EQ(900, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 0));
 319         EXPECT_EQ(1100, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 1));
 320         EXPECT_EQ(1500, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 2));
 321         EXPECT_EQ(1900, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 3));
 322         EXPECT_EQ(2100, rxRuntimeState.rcReadRawFn(&rxRuntimeState, 4));
 323     }
 324
 325     virtual void sendIncompletePacket()
 326     {
 327         uint8_t packet[] = {0xA8, 0x01, 20,
 328                             0x1c, 0x20, 0x22, 0x60, 0x2e, 0xe0, 0x3b, 0x60, 0x41, 0xa0
 329                            };
 330
 331         for (size_t i = 0; i < sizeof(packet); i++) {
 332             EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 333             stub_serialRxCallback(packet[i], NULL);
 334         }
 335
 336         microseconds_stub_value += 5000;
 337
 338         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 339     }
 340 };
 341
 342
 343 TEST_F(SumdRxProtocollUnitTest, Test_OnePacketReceived)
 344 {
 345     sendValidPacket();
 346 }
 347
 348 TEST_F(SumdRxProtocollUnitTest, Test_MultiplePacketsReceived)
 349 {
 350     sendValidPacket();
 351     sendValidPacket();
 352 }
 353
 354 TEST_F(SumdRxProtocollUnitTest, Test_Resync)
 355 {
 356     sendIncompletePacket();
 357     sendValidPacket();
 358 }
 359
 360 TEST_F(SumdRxProtocollUnitTest, Test_IgnoreInvalidCRC)
 361 {
 362     sendValidPacket();
 363     sendInvalidPacket();
 364 }
 365
 366 TEST_F(SumdRxProtocollUnitTest, Test_ShortPacketsReceived)
 367 {
 368     sendValidShortPacket();
 369     sendValidShortPacket();
 370 }
 371
 372 TEST_F(SumdRxProtocollUnitTest, TestShortPacketsReceivedWithFailsafe)
 373 {
 374     sendValidFsPacket();
 375 }
 376
 377 TEST_F(SumdRxProtocollUnitTest, Test_LongPacketsReceived)
 378 {
 379     sendValidLongPacket();
 380     sendValidLongPacket();
 381 }