src/test/unit/rx_ibus_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 <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/ibus.h"
  29 #include "telemetry/ibus_shared.h"
  30 #include "telemetry/telemetry.h"
  31 #include "fc/rc_controls.h"
  32 #include "fc/rc_modes.h"
  33 #include "sensors/barometer.h"
  34 #include "sensors/battery.h"
  35 }
  36
  37 #include "unittest_macros.h"
  38 #include "gtest/gtest.h"
  39
  40
  41 extern "C" {
  42     uint8_t batteryCellCount = 3;
  43     float rcCommand[4] = {0, 0, 0, 0};
  44     int16_t telemTemperature1 = 0;
  45     baro_t baro = { .baroTemperature = 50 };
  46     telemetryConfig_t telemetryConfig_System;
  47 }
  48
  49
  50 bool telemetryCheckRxPortShared(const serialPortConfig_t *portConfig)
  51 {
  52     //TODO: implement
  53     (void) portConfig;
  54     return false;
  55 }
  56
  57 serialPort_t * telemetrySharedPort = NULL;
  58
  59 static uint16_t vbat = 100;
  60 uint16_t getVbat(void)
  61 {
  62     return vbat;
  63 }
  64
  65 uint32_t microseconds_stub_value = 0;
  66 uint32_t micros(void)
  67 {
  68     return microseconds_stub_value;
  69 }
  70 uint32_t microsISR(void)
  71 {
  72     return micros();
  73 }
  74
  75 #define SERIAL_BUFFER_SIZE 256
  76 #define SERIAL_PORT_DUMMY_IDENTIFIER  (serialPortIdentifier_e)0x1234
  77
  78 typedef struct serialPortStub_s {
  79     uint8_t buffer[SERIAL_BUFFER_SIZE];
  80     int pos = 0;
  81     int end = 0;
  82 } serialPortStub_t;
  83
  84 static serialPort_t serialTestInstance;
  85 static serialPortConfig_t serialTestInstanceConfig = {
  86     .identifier = SERIAL_PORT_DUMMY_IDENTIFIER,
  87     .functionMask = 0
  88 };
  89
  90 static serialReceiveCallbackPtr stub_serialRxCallback;
  91 static serialPortConfig_t *findSerialPortConfig_stub_retval;
  92 static bool openSerial_called = false;
  93 static serialPortStub_t serialWriteStub;
  94 static bool portIsShared = false;
  95
  96 bool isSerialPortShared(const serialPortConfig_t *portConfig,
  97                         uint16_t functionMask,
  98                         serialPortFunction_e sharedWithFunction)
  99 {
 100     EXPECT_EQ(portConfig, findSerialPortConfig_stub_retval);
 101     EXPECT_EQ(functionMask, FUNCTION_RX_SERIAL);
 102     EXPECT_EQ(sharedWithFunction, FUNCTION_TELEMETRY_IBUS);
 103     return portIsShared;
 104 }
 105
 106 serialPortConfig_t *findSerialPortConfig(serialPortFunction_e function)
 107 {
 108     EXPECT_EQ(function, FUNCTION_RX_SERIAL);
 109     return findSerialPortConfig_stub_retval;
 110 }
 111
 112 static portMode_e serialExpectedMode = MODE_RX;
 113 static portOptions_e serialExpectedOptions = SERIAL_UNIDIR;
 114
 115 serialPort_t *openSerialPort(
 116     serialPortIdentifier_e identifier,
 117     serialPortFunction_e function,
 118     serialReceiveCallbackPtr callback,
 119     void *callbackData,
 120     uint32_t baudrate,
 121     portMode_e mode,
 122     portOptions_e options
 123 )
 124 {
 125     openSerial_called = true;
 126     EXPECT_FALSE(NULL == callback);
 127     EXPECT_TRUE(NULL == callbackData);
 128     EXPECT_EQ(identifier, SERIAL_PORT_DUMMY_IDENTIFIER);
 129     EXPECT_EQ(options, serialExpectedOptions);
 130     EXPECT_EQ(function, FUNCTION_RX_SERIAL);
 131     EXPECT_EQ(baudrate, 115200);
 132     EXPECT_EQ(mode, serialExpectedMode);
 133     stub_serialRxCallback = callback;
 134     return &serialTestInstance;
 135 }
 136
 137 void serialWrite(serialPort_t *instance, uint8_t ch)
 138 {
 139     EXPECT_EQ(instance, &serialTestInstance);
 140     EXPECT_LT(serialWriteStub.pos, sizeof(serialWriteStub.buffer));
 141     serialWriteStub.buffer[serialWriteStub.pos++] = ch;
 142     //TODO serialReadStub.buffer[serialReadStub.end++] = ch; //characters echoes back on the shared wire
 143     //printf("w: %02d 0x%02x\n", serialWriteStub.pos, ch);
 144 }
 145
 146
 147 void serialTestResetPort()
 148 {
 149     openSerial_called = false;
 150     stub_serialRxCallback = NULL;
 151     portIsShared = false;
 152     serialExpectedMode = MODE_RX;
 153     serialExpectedOptions = SERIAL_UNIDIR;
 154 }
 155
 156
 157 static bool isChecksumOkReturnValue = true;
 158 bool isChecksumOkIa6b(const uint8_t *ibusPacket, const uint8_t length)
 159 {
 160     (void) ibusPacket;
 161     (void) length;
 162     return isChecksumOkReturnValue;
 163 }
 164
 165
 166 static bool initSharedIbusTelemetryCalled = false;
 167 void initSharedIbusTelemetry(serialPort_t * port)
 168 {
 169     EXPECT_EQ(port, &serialTestInstance);
 170     initSharedIbusTelemetryCalled = true;
 171 }
 172
 173 static bool    stubTelemetryCalled = false;
 174 static uint8_t stubTelemetryPacket[100];
 175 static uint8_t stubTelemetryIgnoreRxChars = 0;
 176
 177 uint8_t respondToIbusRequest(uint8_t const * const ibusPacket) {
 178     uint8_t len = ibusPacket[0];
 179     EXPECT_LT(len, sizeof(stubTelemetryPacket));
 180     memcpy(stubTelemetryPacket, ibusPacket, len);
 181     stubTelemetryCalled = true;
 182     return stubTelemetryIgnoreRxChars;
 183 }
 184
 185 void resetStubTelemetry(void)
 186 {
 187     memset(stubTelemetryPacket, 0, sizeof(stubTelemetryPacket));
 188     stubTelemetryCalled = false;
 189     stubTelemetryIgnoreRxChars = 0;
 190     initSharedIbusTelemetryCalled = false;
 191     isChecksumOkReturnValue = true;
 192 }
 193
 194
 195 class IbusRxInitUnitTest : public ::testing::Test
 196 {
 197 protected:
 198     virtual void SetUp()
 199     {
 200         serialTestResetPort();
 201     }
 202 };
 203
 204
 205 TEST_F(IbusRxInitUnitTest, Test_IbusRxNotEnabled)
 206 {
 207     const rxConfig_t initialRxConfig = {};
 208     rxRuntimeState_t rxRuntimeState = {};
 209     findSerialPortConfig_stub_retval = NULL;
 210
 211     EXPECT_FALSE(ibusInit(&initialRxConfig, &rxRuntimeState));
 212
 213     //TODO: Question: I'd expect that runtime conf was not initialized unless there was a serial port to run but the implementation states otherwise
 214     // EXPECT_EQ(0, rxRuntimeState.channelCount);
 215     // EXPECT_EQ(0, rxRuntimeState.rxRefreshRate);
 216     // EXPECT_EQ(NULL, rxRuntimeState.rcReadRawFn);
 217     // EXPECT_EQ(NULL, rxRuntimeState.rcFrameStatusFn);
 218
 219     EXPECT_EQ(18, rxRuntimeState.channelCount);
 220     EXPECT_EQ(20000, rxRuntimeState.rxRefreshRate);
 221     EXPECT_FALSE(NULL == rxRuntimeState.rcReadRawFn);
 222     EXPECT_FALSE(NULL == rxRuntimeState.rcFrameStatusFn);
 223 }
 224
 225
 226 TEST_F(IbusRxInitUnitTest, Test_IbusRxEnabled)
 227 {
 228     const rxConfig_t initialRxConfig = {};
 229     rxRuntimeState_t rxRuntimeState = {};
 230     findSerialPortConfig_stub_retval = &serialTestInstanceConfig;
 231
 232     EXPECT_TRUE(ibusInit(&initialRxConfig, &rxRuntimeState));
 233
 234     EXPECT_EQ(18, rxRuntimeState.channelCount);
 235     EXPECT_EQ(20000, rxRuntimeState.rxRefreshRate);
 236     EXPECT_FALSE(NULL == rxRuntimeState.rcReadRawFn);
 237     EXPECT_FALSE(NULL == rxRuntimeState.rcFrameStatusFn);
 238
 239     EXPECT_TRUE(openSerial_called);
 240 }
 241
 242
 243
 244 class IbusRxProtocollUnitTest : public ::testing::Test
 245 {
 246 protected:
 247     rxRuntimeState_t rxRuntimeState = {};
 248     virtual void SetUp()
 249     {
 250         serialTestResetPort();
 251         resetStubTelemetry();
 252         portIsShared = true;
 253         serialExpectedOptions = SERIAL_BIDIR;
 254         serialExpectedMode = MODE_RXTX;
 255
 256         const rxConfig_t initialRxConfig = {};
 257         findSerialPortConfig_stub_retval = &serialTestInstanceConfig;
 258
 259         EXPECT_TRUE(ibusInit(&initialRxConfig, &rxRuntimeState));
 260
 261         EXPECT_TRUE(initSharedIbusTelemetryCalled);
 262
 263         //handle that internal ibus position is not set to zero at init
 264         microseconds_stub_value += 5000;
 265         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 266     }
 267
 268     virtual void receivePacket(uint8_t const * const packet, const size_t length)
 269     {
 270         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 271         for (size_t i=0; i < length; i++) {
 272             EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 273             stub_serialRxCallback(packet[i], NULL);
 274         }
 275     }
 276 };
 277
 278
 279 TEST_F(IbusRxProtocollUnitTest, Test_InitialFrameState)
 280 {
 281     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 282
 283     //TODO: is it ok to have undefined channel values after init?
 284 }
 285
 286
 287 TEST_F(IbusRxProtocollUnitTest, Test_IA6B_OnePacketReceived)
 288 {
 289     uint8_t packet[] = {0x20, 0x00, //length and reserved (unknown) bits
 290                         0x00, 0xE0, 0x01, 0x00, 0x02, 0x00, 0x03, 0xF0, 0x04, 0x00, //channel 1..5  + 15 + 16
 291                         0x05, 0x00, 0x06, 0x00, 0x07, 0x10, 0x08, 0x00, 0x09, 0x10, //channel 6..10 + 17 + 18(lsb)
 292                         0x0a, 0x10, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00,             //channel 11..14 + 18
 293                         0x84, 0xfd}; //checksum
 294
 295     for (size_t i=0; i < sizeof(packet); i++) {
 296         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 297         stub_serialRxCallback(packet[i], NULL);
 298     }
 299
 300     //report frame complete once
 301     EXPECT_EQ(RX_FRAME_COMPLETE, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 302     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 303
 304     //check that channel values have been updated
 305     for (int i=0; i<18; i++) {
 306         ASSERT_EQ(i, rxRuntimeState.rcReadRawFn(&rxRuntimeState, i));
 307     }
 308 }
 309
 310
 311 TEST_F(IbusRxProtocollUnitTest, Test_IA6B_OnePacketReceivedWithBadCrc)
 312 {
 313     uint8_t packet[] = {0x20, 0x00, //length and reserved (unknown) bits
 314                         0x00, 0x33, 0x01, 0x33, 0x02, 0x33, 0x03, 0x33, 0x04, 0x33, //channel 1..5
 315                         0x05, 0x33, 0x06, 0x33, 0x07, 0x33, 0x08, 0x33, 0x09, 0x33, //channel 6..10
 316                         0x0a, 0x33, 0x0b, 0x33, 0x0c, 0x33, 0x0d, 0x33,             //channel 11..14
 317                         0x00, 0x00}; //checksum
 318
 319     isChecksumOkReturnValue = false;
 320     for (size_t i=0; i < sizeof(packet); i++) {
 321         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 322         stub_serialRxCallback(packet[i], NULL);
 323     }
 324
 325     //no frame complete
 326     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 327
 328     //check that channel values have not been updated
 329     for (int i=0; i<14; i++) {
 330         ASSERT_NE(i + (0x33 << 8), rxRuntimeState.rcReadRawFn(&rxRuntimeState, i));
 331     }
 332 }
 333
 334
 335 TEST_F(IbusRxProtocollUnitTest, Test_IA6B_HalfPacketReceived_then_interPacketGapReset)
 336 {
 337     const uint8_t packet_half[] = {0x20, 0x00, //length and reserved (unknown) bits
 338                                     0x00, 0xab, 0x01, 0xab, 0x02, 0xab, 0x03, 0xab, 0x04, 0xab, //channel 1..5
 339                                     0x05, 0xab};
 340     const uint8_t packet_full[] = {0x20, 0x00, //length and reserved (unknown) bits
 341                                     0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, //channel 1..5
 342                                     0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, //channel 6..10
 343                                     0x0a, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00,             //channel 11..14
 344                                     0x84, 0xff}; //checksum
 345
 346     for (size_t i=0; i < sizeof(packet_half); i++) {
 347         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 348         stub_serialRxCallback(packet_half[i], NULL);
 349     }
 350
 351     microseconds_stub_value += 5000;
 352     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 353
 354     for (size_t i=0; i < sizeof(packet_full); i++) {
 355         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 356         stub_serialRxCallback(packet_full[i], NULL);
 357     }
 358
 359     //report frame complete once
 360     EXPECT_EQ(RX_FRAME_COMPLETE, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 361     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 362
 363     //check that channel values have been updated
 364     for (int i=0; i<14; i++) {
 365         ASSERT_EQ(i, rxRuntimeState.rcReadRawFn(&rxRuntimeState, i));
 366     }
 367 }
 368
 369
 370 TEST_F(IbusRxProtocollUnitTest, Test_IA6_OnePacketReceived)
 371 {
 372     uint8_t packet[] = {0x55, //sync character
 373                         0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, //channel 1..5
 374                         0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, //channel 6..10
 375                         0x0a, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00,             //channel 11..14
 376                         0x5b, 0x00}; //checksum
 377
 378     for (size_t i=0; i < sizeof(packet); i++) {
 379         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 380         stub_serialRxCallback(packet[i], NULL);
 381     }
 382
 383     //report frame complete once
 384     EXPECT_EQ(RX_FRAME_COMPLETE, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 385     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 386
 387     //check that channel values have been updated
 388     for (int i=0; i<14; i++) {
 389         ASSERT_EQ(i, rxRuntimeState.rcReadRawFn(&rxRuntimeState, i));
 390     }
 391 }
 392
 393
 394 TEST_F(IbusRxProtocollUnitTest, Test_IA6_OnePacketReceivedBadCrc)
 395 {
 396     uint8_t packet[] = {0x55, //sync character
 397                         0x00, 0x33, 0x01, 0x33, 0x02, 0x33, 0x03, 0x33, 0x04, 0x33, //channel 1..5
 398                         0x05, 0x33, 0x06, 0x33, 0x07, 0x33, 0x08, 0x33, 0x09, 0x33, //channel 6..10
 399                         0x0a, 0x33, 0x0b, 0x33, 0x0c, 0x33, 0x0d, 0x33,             //channel 11..14
 400                         0x00, 0x00}; //checksum
 401
 402     for (size_t i=0; i < sizeof(packet); i++) {
 403         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 404         stub_serialRxCallback(packet[i], NULL);
 405     }
 406
 407     //no frame complete
 408     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 409
 410     //check that channel values have not been updated
 411     for (int i=0; i<14; i++) {
 412         ASSERT_NE(i + (0x33 << 8), rxRuntimeState.rcReadRawFn(&rxRuntimeState, i));
 413     }
 414 }
 415
 416
 417 TEST_F(IbusRxProtocollUnitTest, Test_IA6B_OnePacketReceived_not_shared_port)
 418 {
 419     uint8_t packet[] = {0x20, 0x00, //length and reserved (unknown) bits
 420                         0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, //channel 1..5
 421                         0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, //channel 6..10
 422                         0x0a, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00,             //channel 11..14
 423                         0x84, 0xff}; //checksum
 424
 425     {
 426
 427         serialTestResetPort();
 428         resetStubTelemetry();
 429         portIsShared = false;
 430         serialExpectedOptions = SERIAL_NOT_INVERTED;
 431         serialExpectedMode = MODE_RX;
 432
 433         const rxConfig_t initialRxConfig = {};
 434         findSerialPortConfig_stub_retval = &serialTestInstanceConfig;
 435
 436         EXPECT_TRUE(ibusInit(&initialRxConfig, &rxRuntimeState));
 437         EXPECT_FALSE(initSharedIbusTelemetryCalled);
 438
 439         //handle that internal ibus position is not set to zero at init
 440         microseconds_stub_value += 5000;
 441         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 442     }
 443
 444     for (size_t i=0; i < sizeof(packet); i++) {
 445         EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 446         stub_serialRxCallback(packet[i], NULL);
 447     }
 448
 449     //report frame complete once
 450     EXPECT_EQ(RX_FRAME_COMPLETE, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 451     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 452
 453     //check that channel values have been updated
 454     for (int i=0; i<14; i++) {
 455         ASSERT_EQ(i, rxRuntimeState.rcReadRawFn(&rxRuntimeState, i));
 456     }
 457 }
 458
 459
 460 TEST_F(IbusRxProtocollUnitTest, Test_OneTelemetryPacketReceived)
 461 {
 462     uint8_t packet[] = {0x04, 0x81, 0x7a, 0xff}; //ibus sensor discovery
 463     resetStubTelemetry();
 464
 465     receivePacket(packet, sizeof(packet));
 466
 467     //no frame complete signal to rx system, but telemetry system is called
 468     EXPECT_EQ(RX_FRAME_PENDING, rxRuntimeState.rcFrameStatusFn(&rxRuntimeState));
 469     EXPECT_TRUE(stubTelemetryCalled);
 470     EXPECT_TRUE( 0 == memcmp( stubTelemetryPacket, packet, sizeof(packet)));
 471 }
 472
 473
 474 TEST_F(IbusRxProtocollUnitTest, Test_OneTelemetryIgnoreTxEchoToRx)
 475 {
 476     uint8_t packet[] = {0x04, 0x81, 0x7a, 0xff}; //ibus sensor discovery
 477     resetStubTelemetry();
 478     stubTelemetryIgnoreRxChars = 4;
 479
 480     //given one packet received, that will respond with four characters to be ignored
 481     receivePacket(packet, sizeof(packet));
 482     rxRuntimeState.rcFrameStatusFn(&rxRuntimeState);
 483     EXPECT_TRUE(stubTelemetryCalled);
 484
 485     //when those four bytes are sent and looped back
 486     resetStubTelemetry();
 487     rxRuntimeState.rcFrameStatusFn(&rxRuntimeState);
 488     receivePacket(packet, sizeof(packet));
 489
 490     //then they are ignored
 491     EXPECT_FALSE(stubTelemetryCalled);
 492
 493     //and then next packet can be received
 494     receivePacket(packet, sizeof(packet));
 495     rxRuntimeState.rcFrameStatusFn(&rxRuntimeState);
 496     EXPECT_TRUE(stubTelemetryCalled);
 497 }
 498
 499
 500 TEST_F(IbusRxProtocollUnitTest, Test_OneTelemetryShouldNotIgnoreTxEchoAfterInterFrameGap)
 501 {
 502     uint8_t packet[] = {0x04, 0x81, 0x7a, 0xff}; //ibus sensor discovery
 503     resetStubTelemetry();
 504     stubTelemetryIgnoreRxChars = 4;
 505
 506     //given one packet received, that will respond with four characters to be ignored
 507     receivePacket(packet, sizeof(packet));
 508     rxRuntimeState.rcFrameStatusFn(&rxRuntimeState);
 509     EXPECT_TRUE(stubTelemetryCalled);
 510
 511     //when there is an interPacketGap
 512     microseconds_stub_value += 5000;
 513     resetStubTelemetry();
 514     rxRuntimeState.rcFrameStatusFn(&rxRuntimeState);
 515
 516     //then next packet can be received
 517     receivePacket(packet, sizeof(packet));
 518     rxRuntimeState.rcFrameStatusFn(&rxRuntimeState);
 519     EXPECT_TRUE(stubTelemetryCalled);
 520 }