rx.h

Go to the documentation of this file.

/*
 * This file is part of Ninjaflight.
 *
 * Ninjaflight is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Ninjaflight is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Ninjaflight.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#include <stdbool.h>
#include "../config/rc_controls.h"
#include "target.h"
#include "system_calls.h"

#include "../config/rx.h"

#ifndef DEFAULT_RX_FEATURE
#define DEFAULT_RX_FEATURE FEATURE_RX_PARALLEL_PWM
#endif

#define STICK_CHANNEL_COUNT 4

typedef enum {
    SERIAL_RX_FRAME_PENDING = 0,
    SERIAL_RX_FRAME_COMPLETE = (1 << 0),
    SERIAL_RX_FRAME_FAILSAFE = (1 << 1)
} serialrxFrameState_t;

typedef enum {
    SERIALRX_SPEKTRUM1024 = 0,
    SERIALRX_SPEKTRUM2048 = 1,
    SERIALRX_SBUS = 2,
    SERIALRX_SUMD = 3,
    SERIALRX_SUMH = 4,
    SERIALRX_XBUS_MODE_B = 5,
    SERIALRX_XBUS_MODE_B_RJ01 = 6,
    SERIALRX_IBUS = 7,
    SERIALRX_PROVIDER_MAX = SERIALRX_IBUS
} SerialRXType;

#define SERIALRX_PROVIDER_COUNT (SERIALRX_PROVIDER_MAX + 1)

#define RX_MAX_PPM_CHANNELS 12
#define MAX_SUPPORTED_RC_PARALLEL_PWM_CHANNEL_COUNT 8

#define MAX_AUX_CHANNEL_COUNT (RX_MAX_SUPPORTED_RC_CHANNELS - RX_NON_AUX_CHANNEL_COUNT)

#if MAX_SUPPORTED_RC_PARALLEL_PWM_CHANNEL_COUNT > RX_MAX_PPM_CHANNELS
#define MAX_SUPPORTED_RX_PARALLEL_PWM_OR_PPM_CHANNEL_COUNT MAX_SUPPORTED_RC_PARALLEL_PWM_CHANNEL_COUNT
#else
#define MAX_SUPPORTED_RX_PARALLEL_PWM_OR_PPM_CHANNEL_COUNT RX_MAX_PPM_CHANNELS
#endif
#define RX_FAILSAFE_MODE_COUNT 3

typedef enum {
    RX_FAILSAFE_TYPE_FLIGHT = 0,
    RX_FAILSAFE_TYPE_AUX,
} rxFailsafeChannelType_e;

#define RX_FAILSAFE_TYPE_COUNT 2
typedef struct rxRuntimeConfig_s {
    uint8_t channelCount;                  // number of rc channels as reported by current input driver
} rxRuntimeConfig_t;

#define RSSI_ADC_SAMPLE_COUNT 16
#define RX_CHANNEL_TIMEOUT    300
#define PPM_AND_PWM_SAMPLE_COUNT 3

typedef uint16_t (*rcReadRawDataPtr)(rxRuntimeConfig_t *rxRuntimeConfig, uint8_t chan);        // used by receiver driver to return channel data

typedef enum {
    RX_PWM,
    RX_PPM,
    RX_MSP,
    RX_SERIAL,
    RX_SERIAL_SPEKTRUM1024 = RX_SERIAL,
    RX_SERIAL_SPEKTRUM2048,
    RX_SERIAL_SBUS,
    RX_SERIAL_SUMD,
    RX_SERIAL_SUMH,
    RX_SERIAL_XBUS_MODE_B,
    RX_SERIAL_XBUS_MODE_B_RJ01,
    RX_SERIAL_IBUS
} rx_type_t;

struct config;
struct rx {
    rx_type_t rx_type;

    uint16_t rssi;                  

    sys_micros_t rxUpdateAt;

    sys_micros_t suspendRxSignalUntil;
    uint8_t  skipRxSamples;

    uint16_t rcSamples[MAX_SUPPORTED_RX_PARALLEL_PWM_OR_PPM_CHANNEL_COUNT][PPM_AND_PWM_SAMPLE_COUNT];
    bool rxSamplesCollected;
    uint8_t rcSampleIndex;

    sys_micros_t rcInvalidPulsPeriod[RX_MAX_SUPPORTED_RC_CHANNELS];
    int16_t rcData[RX_MAX_SUPPORTED_RC_CHANNELS];     
    uint32_t active_channels;
    uint32_t used_channels;

    uint16_t (*rcReadRawFunc)(rxRuntimeConfig_t *rxRuntimeConfig, uint8_t chan);        // used by receiver driver to return channel data

    uint16_t rxRefreshRate;

    #if defined(USE_ADC)
    uint8_t adcRssiSamples[RSSI_ADC_SAMPLE_COUNT];
    uint8_t adcRssiSampleIndex;
    uint32_t rssiUpdateAt;
    #endif

    rxRuntimeConfig_t rxRuntimeConfig;

    const struct system_calls *system;
    const struct config *config;
};

void rx_update(struct rx *self);

bool rx_has_signal(struct rx *self);

bool rx_is_healthy(struct rx *self);

bool rx_flight_channels_valid(struct rx *self);

void rx_init(struct rx *self, const struct system_calls *system, const struct config *config);

// TODO: make it possible to switch type at runtime (involves sorting out some init things)
// currently it is only possible to set the type once
void rx_set_type(struct rx *self, rx_type_t type);

void rx_update_rssi(struct rx *self);

void rx_suspend_signal(struct rx *self);
void rx_resume_signal(struct rx *self);

uint16_t rx_get_refresh_rate(struct rx *self);

uint16_t rx_get_rssi(struct rx *self);

char rx_get_channel_letter(uint8_t ch);
uint8_t rx_get_channel_count(struct rx *self);
int16_t rx_get_channel(struct rx *self, uint8_t chan);

//void rx_set_channel(struct rx *self, uint8_t chan, int16_t value);