mirror of
https://bitbucket.org/librepilot/librepilot.git
synced 2024-12-05 13:24:11 +01:00
458 lines
14 KiB
C
458 lines
14 KiB
C
/**
|
|
******************************************************************************
|
|
* @file pios_exbus.c
|
|
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2015.
|
|
* Tau Labs, http://taulabs.org, Copyright (C) 2013
|
|
* @addtogroup PIOS PIOS Core hardware abstraction layer
|
|
* @{
|
|
* @addtogroup PIOS_EXBUS Jeti EX Bus receiver functions
|
|
* @{
|
|
* @brief Jeti EX Bus receiver functions
|
|
*****************************************************************************/
|
|
/*
|
|
* This program 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.
|
|
*
|
|
* This program 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 this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
/* Project Includes */
|
|
#include "pios_exbus_priv.h"
|
|
|
|
#if defined(PIOS_INCLUDE_EXBUS)
|
|
|
|
#if !defined(PIOS_INCLUDE_RTC)
|
|
#error PIOS_INCLUDE_RTC must be used to use EXBUS
|
|
#endif
|
|
|
|
/**
|
|
* Based on Jeti EX Bus protocol version 1.21
|
|
* Available at http://www.jetimodel.com/en/Telemetry-Protocol/
|
|
*/
|
|
|
|
/* EXBUS frame size and contents definitions */
|
|
#define EXBUS_HEADER_LENGTH 4
|
|
#define EXBUS_CRC_LENGTH 2
|
|
#define EXBUS_MAX_CHANNELS 16
|
|
#define EXBUS_OVERHEAD_LENGTH (EXBUS_HEADER_LENGTH + EXBUS_CRC_LENGTH)
|
|
#define EXBUS_MAX_FRAME_LENGTH (EXBUS_MAX_CHANNELS * 2 + 10 + EXBUS_OVERHEAD_LENGTH)
|
|
|
|
#define EXBUS_SYNC_CHANNEL 0x3E
|
|
#define EXBUS_SYNC_TELEMETRY 0x3D
|
|
#define EXBUS_BYTE_REQ 0x01
|
|
#define EXBUS_BYTE_NOREQ 0x03
|
|
|
|
#define EXBUS_DATA_CHANNEL 0x31
|
|
#define EXBUS_DATA_TELEMETRY 0x3A
|
|
#define EXBUS_DATA_JETIBOX 0x3B
|
|
|
|
#define EXBUS_LOW_BAUD_RATE 125000
|
|
#define EXBUS_HIGH_BAUD_RATE 250000
|
|
#define EXBUS_BAUD_RATE_LIMIT 64
|
|
#define EXBUS_FRAME_TIMEOUT 4
|
|
#define EXBUS_FAILSAFE_TIMEOUT 64
|
|
|
|
/* With an Ex.Bus frame rate of 10ms (100Hz) averaging over 20 samples
|
|
* gives about a 200ms response.
|
|
*/
|
|
#define EXBUS_FL_WEIGHTED_AVERAGE 20
|
|
|
|
/* Forward Declarations */
|
|
static int32_t PIOS_EXBUS_Get(uint32_t rcvr_id, uint8_t channel);
|
|
static uint16_t PIOS_EXBUS_RxInCallback(uint32_t context,
|
|
uint8_t *buf,
|
|
uint16_t buf_len,
|
|
uint16_t *headroom,
|
|
bool *need_yield);
|
|
static void PIOS_EXBUS_Supervisor(uint32_t exbus_id);
|
|
static uint16_t PIOS_EXBUS_CRC_Update(uint16_t crc, uint8_t data);
|
|
static uint8_t PIOS_EXBUS_Quality_Get(uint32_t rcvr_id);
|
|
|
|
/* Local Variables */
|
|
const struct pios_rcvr_driver pios_exbus_rcvr_driver = {
|
|
.read = PIOS_EXBUS_Get,
|
|
.get_quality = PIOS_EXBUS_Quality_Get,
|
|
};
|
|
|
|
enum pios_exbus_dev_magic {
|
|
PIOS_EXBUS_DEV_MAGIC = 0x485355FF,
|
|
};
|
|
|
|
enum pios_exbus_frame_state {
|
|
EXBUS_STATE_SYNC,
|
|
EXBUS_STATE_REQ,
|
|
EXBUS_STATE_LEN,
|
|
EXBUS_STATE_PACKET_ID,
|
|
EXBUS_STATE_DATA_ID,
|
|
EXBUS_STATE_SUBLEN,
|
|
EXBUS_STATE_DATA
|
|
};
|
|
|
|
struct pios_exbus_state {
|
|
uint16_t channel_data[PIOS_EXBUS_NUM_INPUTS];
|
|
uint8_t received_data[EXBUS_MAX_FRAME_LENGTH];
|
|
uint8_t receive_timer;
|
|
uint8_t failsafe_timer;
|
|
uint8_t failsafe_count;
|
|
uint8_t byte_count;
|
|
uint8_t frame_length;
|
|
uint16_t crc;
|
|
bool high_baud_rate;
|
|
bool frame_found;
|
|
float quality;
|
|
};
|
|
|
|
struct pios_exbus_dev {
|
|
enum pios_exbus_dev_magic magic;
|
|
uint32_t com_port_id;
|
|
const struct pios_com_driver *driver;
|
|
struct pios_exbus_state state;
|
|
};
|
|
|
|
/* Allocate EXBUS device descriptor */
|
|
static struct pios_exbus_dev *PIOS_EXBUS_Alloc(void)
|
|
{
|
|
struct pios_exbus_dev *exbus_dev;
|
|
|
|
exbus_dev = (struct pios_exbus_dev *)pios_malloc(sizeof(*exbus_dev));
|
|
if (!exbus_dev) {
|
|
return NULL;
|
|
}
|
|
|
|
exbus_dev->magic = PIOS_EXBUS_DEV_MAGIC;
|
|
return exbus_dev;
|
|
}
|
|
|
|
/* Validate EXBUS device descriptor */
|
|
static bool PIOS_EXBUS_Validate(struct pios_exbus_dev *exbus_dev)
|
|
{
|
|
return exbus_dev->magic == PIOS_EXBUS_DEV_MAGIC;
|
|
}
|
|
|
|
/* Reset channels in case of lost signal or explicit failsafe receiver flag */
|
|
static void PIOS_EXBUS_ResetChannels(struct pios_exbus_dev *exbus_dev)
|
|
{
|
|
struct pios_exbus_state *state = &(exbus_dev->state);
|
|
|
|
for (int i = 0; i < PIOS_EXBUS_NUM_INPUTS; i++) {
|
|
state->channel_data[i] = PIOS_RCVR_TIMEOUT;
|
|
}
|
|
}
|
|
|
|
/* Reset EXBUS receiver state */
|
|
static void PIOS_EXBUS_ResetState(struct pios_exbus_dev *exbus_dev)
|
|
{
|
|
struct pios_exbus_state *state = &(exbus_dev->state);
|
|
|
|
state->receive_timer = 0;
|
|
state->failsafe_timer = 0;
|
|
state->failsafe_count = 0;
|
|
state->high_baud_rate = false;
|
|
state->frame_found = false;
|
|
state->quality = 0.0f;
|
|
PIOS_EXBUS_ResetChannels(exbus_dev);
|
|
}
|
|
|
|
/**
|
|
* Check and unroll complete frame data.
|
|
* \output 0 frame data accepted
|
|
* \output -1 frame error found
|
|
*/
|
|
static int PIOS_EXBUS_UnrollChannels(struct pios_exbus_dev *exbus_dev)
|
|
{
|
|
struct pios_exbus_state *state = &(exbus_dev->state);
|
|
|
|
if (state->crc != 0) {
|
|
/* crc failed */
|
|
return -1;
|
|
}
|
|
|
|
enum pios_exbus_frame_state exbus_state = EXBUS_STATE_SYNC;
|
|
uint8_t *byte = state->received_data;
|
|
uint8_t sub_length;
|
|
uint8_t n_channels = 0;
|
|
uint8_t channel = 0;
|
|
|
|
while ((byte - state->received_data) < state->frame_length) {
|
|
switch (exbus_state) {
|
|
case EXBUS_STATE_SYNC:
|
|
/* sync byte */
|
|
if (*byte == EXBUS_SYNC_CHANNEL) {
|
|
exbus_state = EXBUS_STATE_REQ;
|
|
} else {
|
|
return -1;
|
|
}
|
|
byte += sizeof(uint8_t);
|
|
break;
|
|
|
|
case EXBUS_STATE_REQ:
|
|
/*
|
|
* tells us whether the rx is requesting a reply or not,
|
|
* currently nothing is actually done with this information...
|
|
*/
|
|
if (*byte == EXBUS_BYTE_REQ) {
|
|
exbus_state = EXBUS_STATE_LEN;
|
|
} else if (*byte == EXBUS_BYTE_NOREQ) {
|
|
exbus_state = EXBUS_STATE_LEN;
|
|
} else {
|
|
return -1;
|
|
}
|
|
byte += sizeof(uint8_t);
|
|
break;
|
|
|
|
case EXBUS_STATE_LEN:
|
|
/* total frame length */
|
|
exbus_state = EXBUS_STATE_PACKET_ID;
|
|
byte += sizeof(uint8_t);
|
|
break;
|
|
|
|
case EXBUS_STATE_PACKET_ID:
|
|
/* packet id */
|
|
exbus_state = EXBUS_STATE_DATA_ID;
|
|
byte += sizeof(uint8_t);
|
|
break;
|
|
|
|
case EXBUS_STATE_DATA_ID:
|
|
/* checks the type of data, ignore non-rc data */
|
|
if (*byte == EXBUS_DATA_CHANNEL) {
|
|
exbus_state = EXBUS_STATE_SUBLEN;
|
|
} else {
|
|
return -1;
|
|
}
|
|
byte += sizeof(uint8_t);
|
|
break;
|
|
|
|
case EXBUS_STATE_SUBLEN:
|
|
sub_length = *byte;
|
|
n_channels = sub_length / 2;
|
|
exbus_state = EXBUS_STATE_DATA;
|
|
byte += sizeof(uint8_t);
|
|
break;
|
|
|
|
case EXBUS_STATE_DATA:
|
|
if (channel < n_channels) {
|
|
/* 1 lsb = 1/8 us */
|
|
state->channel_data[channel++] = (byte[1] << 8 | byte[0]) / 8;
|
|
}
|
|
byte += sizeof(uint16_t);
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Update decoder state processing input byte from the stream */
|
|
static void PIOS_EXBUS_UpdateState(struct pios_exbus_dev *exbus_dev, uint8_t byte)
|
|
{
|
|
struct pios_exbus_state *state = &(exbus_dev->state);
|
|
|
|
if (!state->frame_found) {
|
|
if (byte == EXBUS_SYNC_CHANNEL) {
|
|
state->frame_found = true;
|
|
state->byte_count = 0;
|
|
state->frame_length = EXBUS_MAX_FRAME_LENGTH;
|
|
state->crc = PIOS_EXBUS_CRC_Update(0, byte);
|
|
state->received_data[state->byte_count++] = byte;
|
|
}
|
|
} else if (state->byte_count < EXBUS_MAX_FRAME_LENGTH) {
|
|
state->crc = PIOS_EXBUS_CRC_Update(state->crc, byte);
|
|
state->received_data[state->byte_count++] = byte;
|
|
|
|
if (state->byte_count == 3) {
|
|
state->frame_length = byte;
|
|
}
|
|
if (state->byte_count == state->frame_length) {
|
|
uint8_t quality_trend = 0;
|
|
if (!PIOS_EXBUS_UnrollChannels(exbus_dev)) {
|
|
/* data looking good */
|
|
state->failsafe_timer = 0;
|
|
state->failsafe_count = 0;
|
|
quality_trend = 100;
|
|
}
|
|
// Calculate quality trend using weighted average of good frames
|
|
state->quality = ((state->quality * (EXBUS_FL_WEIGHTED_AVERAGE - 1)) +
|
|
quality_trend) / EXBUS_FL_WEIGHTED_AVERAGE;
|
|
/* get ready for the next frame */
|
|
state->frame_found = false;
|
|
}
|
|
} else {
|
|
state->frame_found = false;
|
|
}
|
|
}
|
|
|
|
/* Initialise EX Bus receiver interface */
|
|
int32_t PIOS_EXBUS_Init(uint32_t *exbus_id,
|
|
const struct pios_com_driver *driver,
|
|
uint32_t lower_id)
|
|
{
|
|
PIOS_DEBUG_Assert(exbus_id);
|
|
PIOS_DEBUG_Assert(driver);
|
|
|
|
struct pios_exbus_dev *exbus_dev;
|
|
|
|
exbus_dev = (struct pios_exbus_dev *)PIOS_EXBUS_Alloc();
|
|
if (!exbus_dev) {
|
|
return -1;
|
|
}
|
|
|
|
PIOS_EXBUS_ResetState(exbus_dev);
|
|
|
|
*exbus_id = (uint32_t)exbus_dev;
|
|
|
|
/* Set comm driver callback */
|
|
(driver->bind_rx_cb)(lower_id, PIOS_EXBUS_RxInCallback, *exbus_id);
|
|
|
|
if (!PIOS_RTC_RegisterTickCallback(PIOS_EXBUS_Supervisor, *exbus_id)) {
|
|
PIOS_DEBUG_Assert(0);
|
|
}
|
|
|
|
exbus_dev->driver = driver;
|
|
exbus_dev->com_port_id = lower_id;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Comm byte received callback */
|
|
static uint16_t PIOS_EXBUS_RxInCallback(uint32_t context,
|
|
uint8_t *buf,
|
|
uint16_t buf_len,
|
|
uint16_t *headroom,
|
|
bool *need_yield)
|
|
{
|
|
struct pios_exbus_dev *exbus_dev = (struct pios_exbus_dev *)context;
|
|
|
|
bool valid = PIOS_EXBUS_Validate(exbus_dev);
|
|
|
|
PIOS_Assert(valid);
|
|
|
|
/* process byte(s) and clear receive timer */
|
|
for (uint8_t i = 0; i < buf_len; i++) {
|
|
PIOS_EXBUS_UpdateState(exbus_dev, buf[i]);
|
|
exbus_dev->state.receive_timer = 0;
|
|
}
|
|
|
|
/* Always signal that we can accept more data */
|
|
if (headroom) {
|
|
*headroom = EXBUS_MAX_FRAME_LENGTH;
|
|
}
|
|
|
|
/* We never need a yield */
|
|
*need_yield = false;
|
|
|
|
/* Always indicate that all bytes were consumed */
|
|
return buf_len;
|
|
}
|
|
|
|
/**
|
|
* Get the value of an input channel
|
|
* \param[in] channel Number of the channel desired (zero based)
|
|
* \output PIOS_RCVR_INVALID channel not available
|
|
* \output PIOS_RCVR_TIMEOUT failsafe condition or missing receiver
|
|
* \output >=0 channel value
|
|
*/
|
|
static int32_t PIOS_EXBUS_Get(uint32_t rcvr_id, uint8_t channel)
|
|
{
|
|
struct pios_exbus_dev *exbus_dev = (struct pios_exbus_dev *)rcvr_id;
|
|
|
|
if (!PIOS_EXBUS_Validate(exbus_dev)) {
|
|
return PIOS_RCVR_INVALID;
|
|
}
|
|
|
|
/* return error if channel is not available */
|
|
if (channel >= PIOS_EXBUS_NUM_INPUTS) {
|
|
return PIOS_RCVR_INVALID;
|
|
}
|
|
|
|
/* may also be PIOS_RCVR_TIMEOUT set by other function */
|
|
return exbus_dev->state.channel_data[channel];
|
|
}
|
|
|
|
static void PIOS_EXBUS_Change_BaudRate(struct pios_exbus_dev *device)
|
|
{
|
|
struct pios_exbus_state *state = &(device->state);
|
|
|
|
if (++state->failsafe_count >= EXBUS_BAUD_RATE_LIMIT) {
|
|
state->high_baud_rate = !state->high_baud_rate;
|
|
(device->driver->set_baud)(device->com_port_id,
|
|
state->high_baud_rate ? EXBUS_HIGH_BAUD_RATE : EXBUS_LOW_BAUD_RATE);
|
|
state->failsafe_count = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Input data supervisor is called periodically and provides
|
|
* two functions: frame syncing and failsafe triggering.
|
|
*
|
|
* EX.Bus frames come at 20ms or 10ms rate at 125 or 250 kbaud.
|
|
* RTC timer is running at 625Hz (1.6ms). So with divider 5 it gives
|
|
* 8ms pause between frames which is good for both EX.Bus frame rates.
|
|
*
|
|
* Data receive function must clear the receive_timer to confirm new
|
|
* data reception. If no new data received in 100ms, we must call the
|
|
* failsafe function which clears all channels.
|
|
*/
|
|
static void PIOS_EXBUS_Supervisor(uint32_t exbus_id)
|
|
{
|
|
struct pios_exbus_dev *exbus_dev = (struct pios_exbus_dev *)exbus_id;
|
|
|
|
bool valid = PIOS_EXBUS_Validate(exbus_dev);
|
|
|
|
PIOS_Assert(valid);
|
|
|
|
struct pios_exbus_state *state = &(exbus_dev->state);
|
|
|
|
/* waiting for new frame if no bytes were received in 8ms */
|
|
if (++state->receive_timer > EXBUS_FRAME_TIMEOUT) {
|
|
state->frame_found = false;
|
|
state->byte_count = 0;
|
|
state->receive_timer = 0;
|
|
state->frame_length = EXBUS_MAX_FRAME_LENGTH;
|
|
}
|
|
|
|
/* activate failsafe if no frames have arrived in 102.4ms */
|
|
if (++state->failsafe_timer > EXBUS_FAILSAFE_TIMEOUT) {
|
|
PIOS_EXBUS_ResetChannels(exbus_dev);
|
|
state->failsafe_timer = 0;
|
|
state->quality = 0.0f;
|
|
PIOS_EXBUS_Change_BaudRate(exbus_dev);
|
|
}
|
|
}
|
|
|
|
static uint8_t PIOS_EXBUS_Quality_Get(uint32_t exbus_id)
|
|
{
|
|
struct pios_exbus_dev *exbus_dev = (struct pios_exbus_dev *)exbus_id;
|
|
|
|
bool valid = PIOS_EXBUS_Validate(exbus_dev);
|
|
|
|
PIOS_Assert(valid);
|
|
|
|
struct pios_exbus_state *state = &(exbus_dev->state);
|
|
|
|
return (uint8_t)(state->quality + 0.5f);
|
|
}
|
|
|
|
static uint16_t PIOS_EXBUS_CRC_Update(uint16_t crc, uint8_t data)
|
|
{
|
|
data ^= (uint8_t)crc & (uint8_t)0xFF;
|
|
data ^= data << 4;
|
|
crc = ((((uint16_t)data << 8) | ((crc & 0xFF00) >> 8))
|
|
^ (uint8_t)(data >> 4) ^ ((uint16_t)data << 3));
|
|
|
|
return crc;
|
|
}
|
|
|
|
#endif /* PIOS_INCLUDE_EXBUS */
|
|
|
|
/**
|
|
* @}
|
|
* @}
|
|
*/
|