src/main/rx/rx.h

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #pragma once
  22
  23 #include "common/time.h"
  24
  25 #include "pg/pg.h"
  26 #include "pg/rx.h"
  27
  28 #include "drivers/io_types.h"
  29
  30 #define STICK_CHANNEL_COUNT 4
  31
  32 #define PWM_RANGE_MIN 1000
  33 #define PWM_RANGE_MAX 2000
  34 #define PWM_RANGE (PWM_RANGE_MAX - PWM_RANGE_MIN)
  35 #define PWM_RANGE_MIDDLE (PWM_RANGE_MIN + (PWM_RANGE / 2))
  36
  37 #define PWM_PULSE_MIN   750       // minimum PWM pulse width which is considered valid
  38 #define PWM_PULSE_MAX   2250      // maximum PWM pulse width which is considered valid
  39
  40 #define RXFAIL_STEP_TO_CHANNEL_VALUE(step) (PWM_PULSE_MIN + 25 * step)
  41 #define CHANNEL_VALUE_TO_RXFAIL_STEP(channelValue) ((constrain(channelValue, PWM_PULSE_MIN, PWM_PULSE_MAX) - PWM_PULSE_MIN) / 25)
  42 #define MAX_RXFAIL_RANGE_STEP ((PWM_PULSE_MAX - PWM_PULSE_MIN) / 25)
  43
  44
  45 typedef enum {
  46     RX_FRAME_PENDING = 0,
  47     RX_FRAME_COMPLETE = (1 << 0),
  48     RX_FRAME_FAILSAFE = (1 << 1),
  49     RX_FRAME_PROCESSING_REQUIRED = (1 << 2),
  50     RX_FRAME_DROPPED = (1 << 3)
  51 } rxFrameState_e;
  52
  53 typedef enum {
  54     SERIALRX_NONE = 0,
  55     SERIALRX_SPEKTRUM2048 = 1,
  56     SERIALRX_SBUS = 2,
  57     SERIALRX_SUMD = 3,
  58     SERIALRX_SUMH = 4,
  59     SERIALRX_XBUS_MODE_B = 5,
  60     SERIALRX_XBUS_MODE_B_RJ01 = 6,
  61     SERIALRX_IBUS = 7,
  62     SERIALRX_JETIEXBUS = 8,
  63     SERIALRX_CRSF = 9,
  64     SERIALRX_SRXL = 10,
  65     SERIALRX_TARGET_CUSTOM = 11,
  66     SERIALRX_FPORT = 12,
  67     SERIALRX_SRXL2 = 13,
  68     SERIALRX_GHST = 14,
  69     SERIALRX_SPEKTRUM1024 = 15
  70 } SerialRXType;
  71
  72 #define MAX_SUPPORTED_RC_PPM_CHANNEL_COUNT          12
  73 #define MAX_SUPPORTED_RC_PARALLEL_PWM_CHANNEL_COUNT  8
  74 #define MAX_SUPPORTED_RC_CHANNEL_COUNT              18
  75
  76 #define NON_AUX_CHANNEL_COUNT 4
  77 #define MAX_AUX_CHANNEL_COUNT (MAX_SUPPORTED_RC_CHANNEL_COUNT - NON_AUX_CHANNEL_COUNT)
  78
  79 #if MAX_SUPPORTED_RC_PARALLEL_PWM_CHANNEL_COUNT > MAX_SUPPORTED_RC_PPM_CHANNEL_COUNT
  80 #define MAX_SUPPORTED_RX_PARALLEL_PWM_OR_PPM_CHANNEL_COUNT MAX_SUPPORTED_RC_PARALLEL_PWM_CHANNEL_COUNT
  81 #else
  82 #define MAX_SUPPORTED_RX_PARALLEL_PWM_OR_PPM_CHANNEL_COUNT MAX_SUPPORTED_RC_PPM_CHANNEL_COUNT
  83 #endif
  84
  85 extern const char rcChannelLetters[];
  86
  87 extern float rcData[MAX_SUPPORTED_RC_CHANNEL_COUNT];       // interval [1000;2000]
  88
  89 #define RSSI_SCALE_MIN 1
  90 #define RSSI_SCALE_MAX 255
  91
  92 #define RSSI_SCALE_DEFAULT 100
  93
  94 typedef enum {
  95     RX_FAILSAFE_MODE_AUTO = 0,
  96     RX_FAILSAFE_MODE_HOLD,
  97     RX_FAILSAFE_MODE_SET,
  98     RX_FAILSAFE_MODE_INVALID
  99 } rxFailsafeChannelMode_e;
 100
 101 #define RX_FAILSAFE_MODE_COUNT 3
 102
 103 typedef enum {
 104     RX_FAILSAFE_TYPE_FLIGHT = 0,
 105     RX_FAILSAFE_TYPE_AUX
 106 } rxFailsafeChannelType_e;
 107
 108 #define RX_FAILSAFE_TYPE_COUNT 2
 109
 110 typedef struct rxFailsafeChannelConfig_s {
 111     uint8_t mode; // See rxFailsafeChannelMode_e
 112     uint8_t step;
 113 } rxFailsafeChannelConfig_t;
 114
 115 PG_DECLARE_ARRAY(rxFailsafeChannelConfig_t, MAX_SUPPORTED_RC_CHANNEL_COUNT, rxFailsafeChannelConfigs);
 116
 117 typedef struct rxChannelRangeConfig_s {
 118     uint16_t min;
 119     uint16_t max;
 120 } rxChannelRangeConfig_t;
 121
 122 PG_DECLARE_ARRAY(rxChannelRangeConfig_t, NON_AUX_CHANNEL_COUNT, rxChannelRangeConfigs);
 123
 124 struct rxRuntimeState_s;
 125 typedef float (*rcReadRawDataFnPtr)(const struct rxRuntimeState_s *rxRuntimeState, uint8_t chan); // used by receiver driver to return channel data
 126 typedef uint8_t (*rcFrameStatusFnPtr)(struct rxRuntimeState_s *rxRuntimeState);
 127 typedef bool (*rcProcessFrameFnPtr)(const struct rxRuntimeState_s *rxRuntimeState);
 128 typedef timeUs_t rcGetFrameTimeUsFn(void);  // used to retrieve the timestamp in microseconds for the last channel data frame
 129
 130 typedef enum {
 131     RX_PROVIDER_NONE = 0,
 132     RX_PROVIDER_PARALLEL_PWM,
 133     RX_PROVIDER_PPM,
 134     RX_PROVIDER_SERIAL,
 135     RX_PROVIDER_MSP,
 136     RX_PROVIDER_SPI,
 137     RX_PROVIDER_UDP,
 138 } rxProvider_t;
 139
 140 typedef struct rxRuntimeState_s {
 141     rxProvider_t        rxProvider;
 142     SerialRXType        serialrxProvider;
 143     uint8_t             channelCount; // number of RC channels as reported by current input driver
 144     rcReadRawDataFnPtr  rcReadRawFn;
 145     rcFrameStatusFnPtr  rcFrameStatusFn;
 146     rcProcessFrameFnPtr rcProcessFrameFn;
 147     rcGetFrameTimeUsFn *rcFrameTimeUsFn;
 148     uint16_t            *channelData;
 149     void                *frameData;
 150     timeUs_t            lastRcFrameTimeUs;
 151 } rxRuntimeState_t;
 152
 153 typedef enum {
 154     RSSI_SOURCE_NONE = 0,
 155     RSSI_SOURCE_ADC,
 156     RSSI_SOURCE_RX_CHANNEL,
 157     RSSI_SOURCE_RX_PROTOCOL,
 158     RSSI_SOURCE_MSP,
 159     RSSI_SOURCE_FRAME_ERRORS,
 160     RSSI_SOURCE_RX_PROTOCOL_CRSF,
 161 } rssiSource_e;
 162
 163 extern rssiSource_e rssiSource;
 164
 165 typedef enum {
 166     LQ_SOURCE_NONE = 0,
 167     LQ_SOURCE_RX_PROTOCOL_CRSF,
 168     LQ_SOURCE_RX_PROTOCOL_GHST,
 169 } linkQualitySource_e;
 170
 171 extern linkQualitySource_e linkQualitySource;
 172
 173 extern rxRuntimeState_t rxRuntimeState; //!!TODO remove this extern, only needed once for channelCount
 174
 175 void rxInit(void);
 176 void rxProcessPending(bool state);
 177 bool rxUpdateCheck(timeUs_t currentTimeUs, timeDelta_t currentDeltaTimeUs);
 178 void rxFrameCheck(timeUs_t currentTimeUs, timeDelta_t currentDeltaTimeUs);
 179 bool rxIsReceivingSignal(void);
 180 bool rxAreFlightChannelsValid(void);
 181 bool calculateRxChannelsAndUpdateFailsafe(timeUs_t currentTimeUs);
 182
 183 struct rxConfig_s;
 184
 185 void parseRcChannels(const char *input, struct rxConfig_s *rxConfig);
 186
 187 #define RSSI_MAX_VALUE 1023
 188
 189 void setRssiDirect(uint16_t newRssi, rssiSource_e source);
 190 void setRssi(uint16_t rssiValue, rssiSource_e source);
 191 void setRssiMsp(uint8_t newMspRssi);
 192 void updateRSSI(timeUs_t currentTimeUs);
 193 uint16_t getRssi(void);
 194 uint8_t getRssiPercent(void);
 195 bool isRssiConfigured(void);
 196
 197 #define LINK_QUALITY_MAX_VALUE 1023
 198
 199 uint16_t rxGetLinkQuality(void);
 200 void setLinkQualityDirect(uint16_t linkqualityValue);
 201 uint16_t rxGetLinkQualityPercent(void);
 202
 203 #ifdef USE_RX_RSSI_DBM
 204 int16_t getRssiDbm(void);
 205 void setRssiDbm(int16_t newRssiDbm, rssiSource_e source);
 206 void setRssiDbmDirect(int16_t newRssiDbm, rssiSource_e source);
 207 int8_t getActiveAntenna(void);
 208 void setActiveAntenna(int8_t antenna);
 209 #endif //USE_RX_RSSI_DBM
 210
 211 #ifdef USE_RX_RSNR
 212 int16_t getRsnr(void);
 213 void setRsnr(int16_t newRsnr);
 214 void setRsnrDirect(int16_t newRsnr);
 215 #endif //USE_RX_RSNR
 216
 217 void rxSetRfMode(uint8_t rfModeValue);
 218 uint8_t rxGetRfMode(void);
 219
 220 void rxSetUplinkTxPwrMw(uint16_t uplinkTxPwrMwValue);
 221 uint16_t rxGetUplinkTxPwrMw(void);
 222
 223 void resetAllRxChannelRangeConfigurations(rxChannelRangeConfig_t *rxChannelRangeConfig);
 224
 225 void suspendRxSignal(void);
 226 void resumeRxSignal(void);
 227
 228 timeDelta_t rxGetFrameDelta(timeDelta_t *frameAgeUs);
 229
 230 timeUs_t rxFrameTimeUs(void);