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