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
  95 // Jeti Ex Bus CRC calculations for a frame
  96 uint16_t jetiExBusCalcCRC16(uint8_t *pt, uint8_t msgLen)
  97 {
  98     uint16_t crc16_data = 0;
  99     uint8_t data=0;
 100
 101     for (uint8_t mlen = 0; mlen < msgLen; mlen++) {
 102         data = pt[mlen] ^ ((uint8_t)(crc16_data) & (uint8_t)(0xFF));
 103         data ^= data << 4;
 104         crc16_data = ((((uint16_t)data << 8) | ((crc16_data & 0xFF00) >> 8))
 105                       ^ (uint8_t)(data >> 4)
 106                       ^ ((uint16_t)data << 3));
 107     }
 108     return(crc16_data);
 109 }
 110
 111 void jetiExBusDecodeChannelFrame(uint8_t *exBusFrame)
 112 {
 113     uint16_t value;
 114     uint8_t frameAddr;
 115
 116     // Decode header
 117     switch (((uint16_t)exBusFrame[EXBUS_HEADER_SYNC] << 8) | ((uint16_t)exBusFrame[EXBUS_HEADER_REQ])) {
 118
 119     case EXBUS_CHANNELDATA_DATA_REQUEST:                   // not yet specified
 120     case EXBUS_CHANNELDATA:
 121         for (uint8_t i = 0; i < JETIEXBUS_CHANNEL_COUNT; i++) {
 122             frameAddr = EXBUS_HEADER_LEN + i * 2;
 123             value = ((uint16_t)exBusFrame[frameAddr + 1]) << 8;
 124             value += (uint16_t)exBusFrame[frameAddr];
 125             // Convert to internal format
 126             jetiExBusChannelData[i] = value >> 3;
 127         }
 128         break;
 129     }
 130 }
 131
 132 void jetiExBusFrameReset(void)
 133 {
 134     jetiExBusFramePosition = 0;
 135     jetiExBusFrameLength = EXBUS_MAX_CHANNEL_FRAME_SIZE;
 136 }
 137
 138 /*
 139   supported:
 140   0x3E 0x01 LEN Packet_ID 0x31 SUB_LEN Data_array CRC16      // Channel Data with telemetry request (2nd byte 0x01)
 141   0x3E 0x03 LEN Packet_ID 0x31 SUB_LEN Data_array CRC16      // Channel Data forbids answering (2nd byte 0x03)
 142   0x3D 0x01 0x08 Packet_ID 0x3A 0x00 CRC16                   // Telemetry Request EX telemetry (5th byte 0x3A)
 143
 144   other messages - not supported:
 145   0x3D 0x01 0x09 Packet_ID 0x3B 0x01 0xF0 CRC16              // Jetibox request (5th byte 0x3B)
 146   ...
 147 */
 148
 149 // Receive ISR callback
 150 static void jetiExBusDataReceive(uint16_t c, void *data)
 151 {
 152     UNUSED(data);
 153
 154     static timeUs_t jetiExBusTimeLast = 0;
 155     static uint8_t *jetiExBusFrame;
 156     const timeUs_t now = microsISR();
 157
 158     // Check if we shall reset frame position due to time
 159     if (cmpTimeUs(now, jetiExBusTimeLast) > JETIEXBUS_MIN_FRAME_GAP) {
 160         jetiExBusFrameReset();
 161         jetiExBusFrameState = EXBUS_STATE_ZERO;
 162         jetiExBusRequestState = EXBUS_STATE_ZERO;
 163     }
 164     jetiExBusTimeLast = now;
 165
 166     // Check if we shall start a frame?
 167     if (jetiExBusFramePosition == 0) {
 168         switch (c) {
 169         case EXBUS_START_CHANNEL_FRAME:
 170             jetiExBusFrameState = EXBUS_STATE_IN_PROGRESS;
 171             jetiExBusFrame = jetiExBusChannelFrame;
 172             break;
 173
 174         case EXBUS_START_REQUEST_FRAME:
 175             jetiExBusRequestState = EXBUS_STATE_IN_PROGRESS;
 176             jetiExBusFrame = jetiExBusRequestFrame;
 177             break;
 178
 179         default:
 180             return;
 181         }
 182     }
 183
 184     // Store in frame copy
 185     jetiExBusFrame[jetiExBusFramePosition] = (uint8_t)c;
 186     jetiExBusFramePosition++;
 187
 188     // Check the header for the message length
 189     if (jetiExBusFramePosition == EXBUS_HEADER_LEN) {
 190
 191         if ((jetiExBusFrameState == EXBUS_STATE_IN_PROGRESS) && (jetiExBusFrame[EXBUS_HEADER_MSG_LEN] <= EXBUS_MAX_CHANNEL_FRAME_SIZE)) {
 192             jetiExBusFrameLength = jetiExBusFrame[EXBUS_HEADER_MSG_LEN];
 193             return;
 194         }
 195
 196         if ((jetiExBusRequestState == EXBUS_STATE_IN_PROGRESS) && (jetiExBusFrame[EXBUS_HEADER_MSG_LEN] <= EXBUS_MAX_REQUEST_FRAME_SIZE)) {
 197             jetiExBusFrameLength = jetiExBusFrame[EXBUS_HEADER_MSG_LEN];
 198             return;
 199         }
 200
 201         jetiExBusFrameReset();                  // not a valid frame
 202         jetiExBusFrameState = EXBUS_STATE_ZERO;
 203         jetiExBusRequestState = EXBUS_STATE_ZERO;
 204         return;
 205     }
 206
 207     // Done?
 208     if (jetiExBusFrameLength == jetiExBusFramePosition) {
 209         if (jetiExBusFrameState == EXBUS_STATE_IN_PROGRESS)
 210             jetiExBusFrameState = EXBUS_STATE_RECEIVED;
 211         if (jetiExBusRequestState == EXBUS_STATE_IN_PROGRESS) {
 212             jetiExBusRequestState = EXBUS_STATE_RECEIVED;
 213             jetiTimeStampRequest = now;
 214         }
 215
 216         jetiExBusFrameReset();
 217     }
 218 }
 219
 220 // Check if it is time to read a frame from the data...
 221 static uint8_t jetiExBusFrameStatus(rxRuntimeConfig_t *rxRuntimeConfig)
 222 {
 223     UNUSED(rxRuntimeConfig);
 224
 225     uint8_t frameStatus = RX_FRAME_PENDING;
 226
 227     if (jetiExBusFrameState == EXBUS_STATE_RECEIVED) {
 228         if (jetiExBusCalcCRC16(jetiExBusChannelFrame, jetiExBusChannelFrame[EXBUS_HEADER_MSG_LEN]) == 0) {
 229             jetiExBusDecodeChannelFrame(jetiExBusChannelFrame);
 230             frameStatus = RX_FRAME_COMPLETE;
 231         }
 232         jetiExBusFrameState = EXBUS_STATE_ZERO;
 233     }
 234
 235     return frameStatus;
 236 }
 237
 238 static uint16_t jetiExBusReadRawRC(const rxRuntimeConfig_t *rxRuntimeConfig, uint8_t chan)
 239 {
 240     if (chan >= rxRuntimeConfig->channelCount)
 241         return 0;
 242
 243     return (jetiExBusChannelData[chan]);
 244 }
 245
 246 bool jetiExBusInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig)
 247 {
 248     UNUSED(rxConfig);
 249
 250     rxRuntimeConfig->channelCount = JETIEXBUS_CHANNEL_COUNT;
 251     rxRuntimeConfig->rcReadRawFn = jetiExBusReadRawRC;
 252     rxRuntimeConfig->rcFrameStatusFn = jetiExBusFrameStatus;
 253
 254     jetiExBusFrameReset();
 255
 256     const serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL);
 257
 258     if (!portConfig) {
 259         return false;
 260     }
 261
 262     jetiExBusPort = openSerialPort(portConfig->identifier,
 263         FUNCTION_RX_SERIAL,
 264         jetiExBusDataReceive,
 265         NULL,
 266         JETIEXBUS_BAUDRATE,
 267         MODE_RXTX,
 268         JETIEXBUS_OPTIONS | (rxConfig->serialrx_inverted ? SERIAL_INVERTED : 0) | SERIAL_BIDIR
 269         );
 270     return jetiExBusPort != NULL;
 271 }
 272 #endif // SERIAL_RX