src/test/unit/rx_ranges_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 #include <stdbool.h>
  20
  21 #include <limits.h>
  22
  23 extern "C" {
  24     #include "platform.h"
  25     #include "build/debug.h"
  26     #include "drivers/io.h"
  27     #include "common/maths.h"
  28     #include "flight/failsafe.h"
  29     #include "pg/pg.h"
  30     #include "pg/pg_ids.h"
  31     #include "pg/rx.h"
  32     #include "fc/rc_controls.h"
  33     #include "fc/rc_modes.h"
  34     #include "fc/runtime_config.h"
  35     #include "rx/rx.h"
  36 }
  37
  38 #include "unittest_macros.h"
  39 #include "gtest/gtest.h"
  40
  41 extern "C" {
  42
  43 PG_REGISTER(flight3DConfig_t, flight3DConfig, PG_MOTOR_3D_CONFIG, 0);
  44 PG_REGISTER(failsafeConfig_t, failsafeConfig, PG_FAILSAFE_CONFIG, 0);
  45
  46 extern boxBitmask_t rcModeActivationMask;
  47 int16_t debug[DEBUG16_VALUE_COUNT];
  48 uint8_t debugMode = 0;
  49 uint8_t armingFlags = 0;
  50
  51 extern float applyRxChannelRangeConfiguraton(float sample, const rxChannelRangeConfig_t *range);
  52 }
  53
  54 #define RANGE_CONFIGURATION(min, max) new (rxChannelRangeConfig_t) {min, max}
  55
  56 TEST(RxChannelRangeTest, TestRxChannelRanges)
  57 {
  58     memset(&rcModeActivationMask, 0, sizeof(rcModeActivationMask)); // BOXFAILSAFE must be OFF
  59
  60     // No signal, special condition
  61     EXPECT_EQ(0, applyRxChannelRangeConfiguraton(0, RANGE_CONFIGURATION(1000, 2000)));
  62     EXPECT_EQ(0, applyRxChannelRangeConfiguraton(0, RANGE_CONFIGURATION(1300, 1700)));
  63     EXPECT_EQ(0, applyRxChannelRangeConfiguraton(0, RANGE_CONFIGURATION(900, 2100)));
  64
  65     // Exact mapping
  66     EXPECT_EQ(1000, applyRxChannelRangeConfiguraton(1000, RANGE_CONFIGURATION(1000, 2000)));
  67     EXPECT_EQ(1500, applyRxChannelRangeConfiguraton(1500, RANGE_CONFIGURATION(1000, 2000)));
  68     EXPECT_EQ(2000, applyRxChannelRangeConfiguraton(2000, RANGE_CONFIGURATION(1000, 2000)));
  69     EXPECT_EQ(700, applyRxChannelRangeConfiguraton(700, RANGE_CONFIGURATION(1000, 2000)));
  70     EXPECT_EQ(2500, applyRxChannelRangeConfiguraton(2500, RANGE_CONFIGURATION(1000, 2000)));
  71
  72     // Reversed channel
  73     EXPECT_EQ(2000, applyRxChannelRangeConfiguraton(1000, RANGE_CONFIGURATION(2000, 1000)));
  74     EXPECT_EQ(1500, applyRxChannelRangeConfiguraton(1500, RANGE_CONFIGURATION(2000, 1000)));
  75     EXPECT_EQ(1000, applyRxChannelRangeConfiguraton(2000, RANGE_CONFIGURATION(2000, 1000)));
  76
  77     // Shifted range
  78     EXPECT_EQ(1000, applyRxChannelRangeConfiguraton(900, RANGE_CONFIGURATION(900, 1900)));
  79     EXPECT_EQ(1500, applyRxChannelRangeConfiguraton(1400, RANGE_CONFIGURATION(900, 1900)));
  80     EXPECT_EQ(2000, applyRxChannelRangeConfiguraton(1900, RANGE_CONFIGURATION(900, 1900)));
  81     EXPECT_EQ(700, applyRxChannelRangeConfiguraton(600, RANGE_CONFIGURATION(900, 1900)));
  82     EXPECT_EQ(2600, applyRxChannelRangeConfiguraton(2500, RANGE_CONFIGURATION(900, 1900)));
  83
  84     // Narrower range than expected
  85     EXPECT_EQ(1000, applyRxChannelRangeConfiguraton(1300, RANGE_CONFIGURATION(1300, 1700)));
  86     EXPECT_EQ(1500, applyRxChannelRangeConfiguraton(1500, RANGE_CONFIGURATION(1300, 1700)));
  87     EXPECT_EQ(2000, applyRxChannelRangeConfiguraton(1700, RANGE_CONFIGURATION(1300, 1700)));
  88     EXPECT_EQ(-500, applyRxChannelRangeConfiguraton(700, RANGE_CONFIGURATION(1300, 1700)));
  89     EXPECT_EQ(4000, applyRxChannelRangeConfiguraton(2500, RANGE_CONFIGURATION(1300, 1700)));
  90
  91     // Wider range than expected
  92     EXPECT_EQ(1000, applyRxChannelRangeConfiguraton(900, RANGE_CONFIGURATION(900, 2100)));
  93     EXPECT_EQ(1500, applyRxChannelRangeConfiguraton(1500, RANGE_CONFIGURATION(900, 2100)));
  94     EXPECT_EQ(2000, applyRxChannelRangeConfiguraton(2100, RANGE_CONFIGURATION(900, 2100)));
  95     EXPECT_EQ(750, applyRxChannelRangeConfiguraton(600, RANGE_CONFIGURATION(900, 2100)));
  96     EXPECT_EQ(2500, applyRxChannelRangeConfiguraton(2700, RANGE_CONFIGURATION(900, 2100)));
  97
  98     // extreme out of range
  99     EXPECT_EQ(1, applyRxChannelRangeConfiguraton(1, RANGE_CONFIGURATION(1000, 2000)));
 100     EXPECT_EQ(-2245, applyRxChannelRangeConfiguraton(2, RANGE_CONFIGURATION(1300, 1700)));
 101     EXPECT_EQ(252.5, applyRxChannelRangeConfiguraton(3, RANGE_CONFIGURATION(900, 2100)));
 102
 103     EXPECT_EQ(10000, applyRxChannelRangeConfiguraton(10000, RANGE_CONFIGURATION(1000, 2000)));
 104     EXPECT_EQ(22750, applyRxChannelRangeConfiguraton(10000, RANGE_CONFIGURATION(1300, 1700)));
 105     EXPECT_EQ(25250, applyRxChannelRangeConfiguraton(30000, RANGE_CONFIGURATION(900, 2100)));
 106 }
 107
 108
 109 // stubs
 110 extern "C" {
 111
 112 void failsafeOnRxSuspend(uint32_t ) {}
 113 void failsafeOnRxResume(void) {}
 114 bool failsafeIsActive(void) { return false; }
 115 bool failsafeIsReceivingRxData(void) { return true; }
 116 bool taskUpdateRxMainInProgress(void) { return true; }
 117 void setArmingDisabled(armingDisableFlags_e flag) { UNUSED(flag); }
 118 void unsetArmingDisabled(armingDisableFlags_e flag) { UNUSED(flag); }
 119 uint16_t flightModeFlags = 0;
 120
 121 uint32_t micros(void) { return 0; }
 122 uint32_t millis(void) { return 0; }
 123
 124 void rxPwmInit(rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 125 {
 126     UNUSED(rxRuntimeState);
 127     UNUSED(callback);
 128 }
 129
 130 bool sbusInit(rxConfig_t *initialRxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 131 {
 132     UNUSED(initialRxConfig);
 133     UNUSED(rxRuntimeState);
 134     UNUSED(callback);
 135     return true;
 136 }
 137
 138 bool spektrumInit(rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 139 {
 140     UNUSED(rxConfig);
 141     UNUSED(rxRuntimeState);
 142     UNUSED(callback);
 143     return true;
 144 }
 145
 146 bool sumdInit(rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 147 {
 148     UNUSED(rxConfig);
 149     UNUSED(rxRuntimeState);
 150     UNUSED(callback);
 151     return true;
 152 }
 153
 154 bool sumhInit(rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 155 {
 156     UNUSED(rxConfig);
 157     UNUSED(rxRuntimeState);
 158     UNUSED(callback);
 159     return true;
 160 }
 161
 162 bool crsfRxInit(rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 163 {
 164     UNUSED(rxConfig);
 165     UNUSED(rxRuntimeState);
 166     UNUSED(callback);
 167     return true;
 168 }
 169
 170 bool jetiExBusInit(rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 171 {
 172     UNUSED(rxConfig);
 173     UNUSED(rxRuntimeState);
 174     UNUSED(callback);
 175     return true;
 176 }
 177
 178 bool ibusInit(rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 179 {
 180     UNUSED(rxConfig);
 181     UNUSED(rxRuntimeState);
 182     UNUSED(callback);
 183     return true;
 184 }
 185
 186 bool xBusInit(rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 187 {
 188     UNUSED(rxConfig);
 189     UNUSED(rxRuntimeState);
 190     UNUSED(callback);
 191     return true;
 192 }
 193
 194 bool rxMspInit(rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState, rcReadRawDataFnPtr *callback)
 195 {
 196     UNUSED(rxConfig);
 197     UNUSED(rxRuntimeState);
 198     UNUSED(callback);
 199     return true;
 200 }
 201
 202 bool featureIsEnabled(uint32_t)
 203 {
 204     return false;
 205 }
 206
 207 void featureDisableImmediate(uint32_t)
 208 {
 209 }
 210
 211 bool rxMspFrameComplete(void)
 212 {
 213     return false;
 214 }
 215
 216 bool isPPMDataBeingReceived(void)
 217 {
 218     return false;
 219 }
 220
 221 bool isPWMDataBeingReceived(void)
 222 {
 223     return false;
 224 }
 225
 226 void resetPPMDataReceivedState(void)
 227 {
 228 }
 229
 230 void failsafeOnValidDataReceived(void)
 231 {
 232 }
 233
 234 void failsafeOnValidDataFailed(void)
 235 {
 236 }
 237
 238 uint32_t failsafeFailurePeriodMs(void)
 239 {
 240     return 400;
 241 }
 242
 243 float pt1FilterGain(float f_cut, float dT)
 244 {
 245     UNUSED(f_cut);
 246     UNUSED(dT);
 247     return 0.0;
 248 }
 249
 250 void pt1FilterInit(pt1Filter_t *filter, float k)
 251 {
 252     UNUSED(filter);
 253     UNUSED(k);
 254 }
 255
 256 void pt1FilterUpdateCutoff(pt1Filter_t *filter, float k)
 257 {
 258     UNUSED(filter);
 259     UNUSED(k);
 260 }
 261
 262 float pt1FilterApply(pt1Filter_t *filter, float input)
 263 {
 264     UNUSED(filter);
 265     UNUSED(input);
 266     return 0.0;
 267 }
 268
 269 void pinioBoxTaskControl(void) {}
 270
 271 }