src/main/rx/jetiexbus.c

   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 /*
  22  * Authors:
  23  * Thomas Miric - marv-t
  24  *
  25  * Jeti EX Bus Communication Protocol:
  26  * http://www.jetimodel.com/en/show-file/642/
  27  *
  28  * JETI Telemetry Communication Protocol:
  29  * http://www.jetimodel.com/en/show-file/26/
  30  *
  31  * Following restrictions:
  32  * Communication speed: 125000 bps
  33  * Number of channels: 16
  34  *
  35  * Connect as follows:
  36  * Jeti EX Bus -> Serial TX (connect directly)
  37  */
  38
  39
  40 #include <stdbool.h>
  41 #include <stdint.h>
  42
  43 #include "platform.h"
  44
  45 #ifdef USE_SERIALRX_JETIEXBUS
  46
  47 #include "build/build_config.h"
  48 #include "build/debug.h"
  49
  50 #include "common/utils.h"
  51
  52 #include "drivers/time.h"
  53
  54 #include "io/serial.h"
  55
  56 #include "rx/rx.h"
  57 #include "rx/jetiexbus.h"
  58
  59
  60 //
  61 // Serial driver for Jeti EX Bus receiver
  62 //
  63 #define JETIEXBUS_BAUDRATE 125000                       // EX Bus 125000; EX Bus HS 250000 not supported
  64 #define JETIEXBUS_OPTIONS (SERIAL_STOPBITS_1 | SERIAL_PARITY_NO)
  65 #define JETIEXBUS_MIN_FRAME_GAP     1000
  66 #define JETIEXBUS_CHANNEL_COUNT     16                  // most Jeti TX transmit 16 channels
  67
  68
  69 #define EXBUS_START_CHANNEL_FRAME       (0x3E)
  70 #define EXBUS_START_REQUEST_FRAME       (0x3D)
  71 #define EXBUS_JETIBOX_REQUEST           (0x3B)
  72
  73 #define EXBUS_CHANNELDATA               (0x3E03)        // Frame contains Channel Data
  74 #define EXBUS_CHANNELDATA_DATA_REQUEST  (0x3E01)        // Frame contains Channel Data, but with a request for data
  75 #define EXBUS_TELEMETRY_REQUEST         (0x3D01)        // Frame is a request Frame
  76
  77
  78
  79 serialPort_t *jetiExBusPort;
  80
  81 uint32_t jetiTimeStampRequest = 0;
  82
  83 static uint8_t jetiExBusFramePosition;
  84 static uint8_t jetiExBusFrameLength;
  85
  86 static uint8_t jetiExBusFrameState = EXBUS_STATE_ZERO;
  87 uint8_t jetiExBusRequestState = EXBUS_STATE_ZERO;
  88
  89 // Use max values for ram areas
  90 static uint8_t jetiExBusChannelFrame[EXBUS_MAX_CHANNEL_FRAME_SIZE];
  91 uint8_t jetiExBusRequestFrame[EXBUS_MAX_REQUEST_FRAME_SIZE];
  92
  93 static uint16_t jetiExBusChannelData[JETIEXBUS_CHANNEL_COUNT];
  94 static timeUs_t lastRcFrameTimeUs = 0;
  95
  96 // Jeti Ex Bus CRC calculations for a frame
  97 uint16_t jetiExBusCalcCRC16(uint8_t *pt, uint8_t msgLen)
  98 {
  99     uint16_t crc16_data = 0;
 100     uint8_t data=0;
 101
 102     for (uint8_t mlen = 0; mlen < msgLen; mlen++) {
 103         data = pt[mlen] ^ ((uint8_t)(crc16_data) & (uint8_t)(0xFF));
 104         data ^= data << 4;
 105         crc16_data = ((((uint16_t)data << 8) | ((crc16_data & 0xFF00) >> 8))
 106                       ^ (uint8_t)(data >> 4)
 107                       ^ ((uint16_t)data << 3));
 108     }
 109     return(crc16_data);
 110 }
 111
 112 void jetiExBusDecodeChannelFrame(uint8_t *exBusFrame)
 113 {
 114     uint16_t value;
 115     uint8_t frameAddr;
 116
 117     // Decode header
 118     switch (((uint16_t)exBusFrame[EXBUS_HEADER_SYNC] << 8) | ((uint16_t)exBusFrame[EXBUS_HEADER_REQ])) {
 119
 120     case EXBUS_CHANNELDATA_DATA_REQUEST:                   // not yet specified
 121     case EXBUS_CHANNELDATA:
 122         for (uint8_t i = 0; i < JETIEXBUS_CHANNEL_COUNT; i++) {
 123             frameAddr = EXBUS_HEADER_LEN + i * 2;
 124             value = ((uint16_t)exBusFrame[frameAddr + 1]) << 8;
 125             value += (uint16_t)exBusFrame[frameAddr];
 126             // Convert to internal format
 127             jetiExBusChannelData[i] = value >> 3;
 128         }
 129         break;
 130     }
 131 }
 132
 133 void jetiExBusFrameReset(void)
 134 {
 135     jetiExBusFramePosition = 0;
 136     jetiExBusFrameLength = EXBUS_MAX_CHANNEL_FRAME_SIZE;
 137 }
 138
 139 /*
 140   supported:
 141   0x3E 0x01 LEN Packet_ID 0x31 SUB_LEN Data_array CRC16      // Channel Data with telemetry request (2nd byte 0x01)
 142   0x3E 0x03 LEN Packet_ID 0x31 SUB_LEN Data_array CRC16      // Channel Data forbids answering (2nd byte 0x03)
 143   0x3D 0x01 0x08 Packet_ID 0x3A 0x00 CRC16                   // Telemetry Request EX telemetry (5th byte 0x3A)
 144
 145   other messages - not supported:
 146   0x3D 0x01 0x09 Packet_ID 0x3B 0x01 0xF0 CRC16              // Jetibox request (5th byte 0x3B)
 147   ...
 148 */
 149
 150 // Receive ISR callback
 151 static void jetiExBusDataReceive(uint16_t c, void *data)
 152 {
 153     UNUSED(data);
 154
 155     static timeUs_t jetiExBusTimeLast = 0;
 156     static uint8_t *jetiExBusFrame;
 157     const timeUs_t now = microsISR();
 158
 159     // Check if we shall reset frame position due to time
 160     if (cmpTimeUs(now, jetiExBusTimeLast) > JETIEXBUS_MIN_FRAME_GAP) {
 161         jetiExBusFrameReset();
 162         jetiExBusFrameState = EXBUS_STATE_ZERO;
 163         jetiExBusRequestState = EXBUS_STATE_ZERO;
 164     }
 165     jetiExBusTimeLast = now;
 166
 167     // Check if we shall start a frame?
 168     if (jetiExBusFramePosition == 0) {
 169         switch (c) {
 170         case EXBUS_START_CHANNEL_FRAME:
 171             jetiExBusFrameState = EXBUS_STATE_IN_PROGRESS;
 172             jetiExBusFrame = jetiExBusChannelFrame;
 173             break;
 174
 175         case EXBUS_START_REQUEST_FRAME:
 176             jetiExBusRequestState = EXBUS_STATE_IN_PROGRESS;
 177             jetiExBusFrame = jetiExBusRequestFrame;
 178             break;
 179
 180         default:
 181             return;
 182         }
 183     }
 184
 185     // Store in frame copy
 186     jetiExBusFrame[jetiExBusFramePosition] = (uint8_t)c;
 187     jetiExBusFramePosition++;
 188
 189     // Check the header for the message length
 190     if (jetiExBusFramePosition == EXBUS_HEADER_LEN) {
 191
 192         if ((jetiExBusFrameState == EXBUS_STATE_IN_PROGRESS) && (jetiExBusFrame[EXBUS_HEADER_MSG_LEN] <= EXBUS_MAX_CHANNEL_FRAME_SIZE)) {
 193             jetiExBusFrameLength = jetiExBusFrame[EXBUS_HEADER_MSG_LEN];
 194             return;
 195         }
 196
 197         if ((jetiExBusRequestState == EXBUS_STATE_IN_PROGRESS) && (jetiExBusFrame[EXBUS_HEADER_MSG_LEN] <= EXBUS_MAX_REQUEST_FRAME_SIZE)) {
 198             jetiExBusFrameLength = jetiExBusFrame[EXBUS_HEADER_MSG_LEN];
 199             return;
 200         }
 201
 202         jetiExBusFrameReset();                  // not a valid frame
 203         jetiExBusFrameState = EXBUS_STATE_ZERO;
 204         jetiExBusRequestState = EXBUS_STATE_ZERO;
 205         return;
 206     }
 207
 208     // Done?
 209     if (jetiExBusFrameLength == jetiExBusFramePosition) {
 210         if (jetiExBusFrameState == EXBUS_STATE_IN_PROGRESS)
 211             jetiExBusFrameState = EXBUS_STATE_RECEIVED;
 212         if (jetiExBusRequestState == EXBUS_STATE_IN_PROGRESS) {
 213             jetiExBusRequestState = EXBUS_STATE_RECEIVED;
 214             jetiTimeStampRequest = now;
 215         }
 216
 217         jetiExBusFrameReset();
 218     }
 219 }
 220
 221 // Check if it is time to read a frame from the data...
 222 static uint8_t jetiExBusFrameStatus(rxRuntimeState_t *rxRuntimeState)
 223 {
 224     UNUSED(rxRuntimeState);
 225
 226     uint8_t frameStatus = RX_FRAME_PENDING;
 227
 228     if (jetiExBusFrameState == EXBUS_STATE_RECEIVED) {
 229         if (jetiExBusCalcCRC16(jetiExBusChannelFrame, jetiExBusChannelFrame[EXBUS_HEADER_MSG_LEN]) == 0) {
 230             jetiExBusDecodeChannelFrame(jetiExBusChannelFrame);
 231             frameStatus = RX_FRAME_COMPLETE;
 232             lastRcFrameTimeUs = jetiTimeStampRequest;
 233         }
 234         jetiExBusFrameState = EXBUS_STATE_ZERO;
 235     }
 236
 237     return frameStatus;
 238 }
 239
 240 static float jetiExBusReadRawRC(const rxRuntimeState_t *rxRuntimeState, uint8_t chan)
 241 {
 242     if (chan >= rxRuntimeState->channelCount)
 243         return 0;
 244
 245     return (jetiExBusChannelData[chan]);
 246 }
 247
 248 static timeUs_t jetiExBusFrameTimeUsFn(void)
 249 {
 250     return lastRcFrameTimeUs;
 251 }
 252
 253 bool jetiExBusInit(const rxConfig_t *rxConfig, rxRuntimeState_t *rxRuntimeState)
 254 {
 255     UNUSED(rxConfig);
 256
 257     rxRuntimeState->channelCount = JETIEXBUS_CHANNEL_COUNT;
 258     rxRuntimeState->rxRefreshRate = 5500;
 259
 260     rxRuntimeState->rcReadRawFn = jetiExBusReadRawRC;
 261     rxRuntimeState->rcFrameStatusFn = jetiExBusFrameStatus;
 262     rxRuntimeState->rcFrameTimeUsFn = jetiExBusFrameTimeUsFn;
 263
 264     jetiExBusFrameReset();
 265
 266     const serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL);
 267
 268     if (!portConfig) {
 269         return false;
 270     }
 271
 272     jetiExBusPort = openSerialPort(portConfig->identifier,
 273         FUNCTION_RX_SERIAL,
 274         jetiExBusDataReceive,
 275         NULL,
 276         JETIEXBUS_BAUDRATE,
 277         MODE_RXTX,
 278         JETIEXBUS_OPTIONS | (rxConfig->serialrx_inverted ? SERIAL_INVERTED : 0) | SERIAL_BIDIR
 279         );
 280     return jetiExBusPort != NULL;
 281 }
 282 #endif // SERIAL_RX