src/main/rx/cc2500_frsky_x.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 #include <string.h>
  22
  23 #include "platform.h"
  24
  25 #ifdef USE_RX_FRSKY_SPI_X
  26
  27 #include "build/build_config.h"
  28 #include "build/debug.h"
  29
  30 #include "common/maths.h"
  31 #include "common/utils.h"
  32
  33 #include "config/feature.h"
  34
  35 #include "drivers/adc.h"
  36 #include "drivers/io.h"
  37 #include "drivers/io_def.h"
  38 #include "drivers/io_types.h"
  39 #include "drivers/resource.h"
  40 #include "drivers/rx/rx_cc2500.h"
  41 #include "drivers/rx/rx_spi.h"
  42 #include "drivers/system.h"
  43 #include "drivers/time.h"
  44
  45 #include "config/config.h"
  46
  47 #include "pg/rx.h"
  48 #include "pg/rx_spi.h"
  49 #include "pg/rx_spi_cc2500.h"
  50
  51 #include "rx/rx_spi_common.h"
  52 #include "rx/cc2500_common.h"
  53 #include "rx/cc2500_frsky_common.h"
  54 #include "rx/cc2500_frsky_shared.h"
  55
  56 #include "sensors/battery.h"
  57
  58 #include "telemetry/smartport.h"
  59
  60 #include "cc2500_frsky_x.h"
  61
  62 const uint16_t crcTable_Short[] = {
  63         0x0000,0x1189,0x2312,0x329b,0x4624,0x57ad,0x6536,0x74bf,
  64         0x8c48,0x9dc1,0xaf5a,0xbed3,0xca6c,0xdbe5,0xe97e,0xf8f7,
  65 };
  66
  67 #define TELEMETRY_OUT_BUFFER_SIZE  64
  68
  69 #define TELEMETRY_SEQUENCE_LENGTH 4
  70
  71 #define A1_CONST_X 50
  72
  73 typedef struct telemetrySequenceMarkerData_s {
  74     unsigned int packetSequenceId: 2;
  75     unsigned int unused: 1;
  76     unsigned int initRequest: 1;
  77     unsigned int ackSequenceId: 2;
  78     unsigned int retransmissionRequested: 1;
  79     unsigned int initResponse: 1;
  80 } __attribute__ ((__packed__)) telemetrySequenceMarkerData_t;
  81
  82 typedef union telemetrySequenceMarker_s {
  83     uint8_t raw;
  84     telemetrySequenceMarkerData_t data;
  85 } __attribute__ ((__packed__)) telemetrySequenceMarker_t;
  86
  87 #define SEQUENCE_MARKER_REMOTE_PART 0xf0
  88
  89 #define TELEMETRY_DATA_SIZE 5
  90
  91 typedef struct telemetryData_s {
  92     uint8_t dataLength;
  93     uint8_t data[TELEMETRY_DATA_SIZE];
  94 } __attribute__ ((__packed__)) telemetryData_t;
  95
  96 typedef struct telemetryBuffer_s {
  97     telemetryData_t data;
  98     uint8_t needsProcessing;
  99 } telemetryBuffer_t;
 100
 101 #define TELEMETRY_FRAME_SIZE  sizeof(telemetryData_t)
 102
 103 typedef struct telemetryPayload_s {
 104     uint8_t packetConst;
 105     uint8_t rssiA1;
 106     telemetrySequenceMarker_t sequence;
 107     telemetryData_t data;
 108     uint8_t crc[2];
 109 } __attribute__ ((__packed__)) telemetryPayload_t;
 110
 111 #if defined(USE_RX_FRSKY_SPI_TELEMETRY)
 112 static telemetryData_t telemetryTxBuffer[TELEMETRY_SEQUENCE_LENGTH];
 113 #endif
 114
 115 static telemetryBuffer_t telemetryRxBuffer[TELEMETRY_SEQUENCE_LENGTH];
 116
 117 static telemetrySequenceMarker_t responseToSend;
 118
 119 #if defined(USE_RX_FRSKY_SPI_TELEMETRY)
 120 static uint8_t frame[20];
 121
 122 #if defined(USE_TELEMETRY_SMARTPORT)
 123 static uint8_t telemetryOutWriter;
 124
 125 static uint8_t telemetryOutBuffer[TELEMETRY_OUT_BUFFER_SIZE];
 126
 127 static bool telemetryEnabled = false;
 128
 129 static uint8_t remoteToProcessId = 0;
 130 static uint8_t remoteToProcessIndex = 0;
 131 #endif
 132 #endif // USE_RX_FRSKY_SPI_TELEMETRY
 133
 134 static uint8_t packetLength;
 135 static uint16_t telemetryDelayUs;
 136
 137 static uint16_t crcTable(uint8_t val)
 138 {
 139     uint16_t word;
 140     word = (*(&crcTable_Short[val & 0x0f]));
 141     val /= 16;
 142     return word ^ (0x1081 * val);
 143 }
 144
 145 static uint16_t calculateCrc(const uint8_t *data, uint8_t len)
 146 {
 147     uint16_t crc = 0;
 148     for (unsigned i = 0; i < len; i++) {
 149         crc = (crc << 8) ^ crcTable((uint8_t)(crc >> 8) ^ *data++);
 150     }
 151     return crc;
 152 }
 153
 154 #if defined(USE_RX_FRSKY_SPI_TELEMETRY)
 155 #if defined(USE_TELEMETRY_SMARTPORT)
 156 static uint8_t appendSmartPortData(uint8_t *buf)
 157 {
 158     static uint8_t telemetryOutReader = 0;
 159
 160     uint8_t index;
 161     for (index = 0; index < TELEMETRY_DATA_SIZE; index++) { // max 5 bytes in a frame
 162         if (telemetryOutReader == telemetryOutWriter) { // no new data
 163             break;
 164         }
 165         buf[index] = telemetryOutBuffer[telemetryOutReader];
 166         telemetryOutReader = (telemetryOutReader + 1) % TELEMETRY_OUT_BUFFER_SIZE;
 167     }
 168
 169     return index;
 170 }
 171 #endif
 172
 173 static void buildTelemetryFrame(uint8_t *packet)
 174 {
 175     static uint8_t localPacketId;
 176
 177     static bool evenRun = false;
 178
 179     frame[0] = 0x0E;//length
 180     frame[1] = rxCc2500SpiConfig()->bindTxId[0];
 181     frame[2] = rxCc2500SpiConfig()->bindTxId[1];
 182
 183     if (spiProtocol == RX_SPI_FRSKY_X_V2 || spiProtocol == RX_SPI_FRSKY_X_LBT_V2) {
 184         frame[3] = rxCc2500SpiConfig()->bindTxId[2];
 185     } else {
 186         frame[3] = packet[3];
 187     }
 188
 189     if (evenRun) {
 190         frame[4] = (uint8_t)cc2500getRssiDbm() | 0x80;
 191     } else {
 192         uint8_t a1Value;
 193         switch (rxCc2500SpiConfig()->a1Source) {
 194         case FRSKY_SPI_A1_SOURCE_EXTADC:
 195             a1Value = (uint8_t)((adcGetChannel(ADC_EXTERNAL1) & 0xfe0) >> 5);
 196             break;
 197         case FRSKY_SPI_A1_SOURCE_CONST:
 198             a1Value = A1_CONST_X & 0x7f;
 199             break;
 200         case FRSKY_SPI_A1_SOURCE_VBAT:
 201         default:
 202             a1Value = getLegacyBatteryVoltage() & 0x7f;
 203             break;
 204         }
 205         frame[4] = a1Value;
 206     }
 207     evenRun = !evenRun;
 208
 209     telemetrySequenceMarker_t *inFrameMarker = (telemetrySequenceMarker_t *)&packet[21];
 210     telemetrySequenceMarker_t *outFrameMarker = (telemetrySequenceMarker_t *)&frame[5];
 211     if (inFrameMarker->data.initRequest) { // check syncronization at startup ok if not no sport telemetry
 212         outFrameMarker-> raw = 0;
 213         outFrameMarker->data.initRequest = 1;
 214         outFrameMarker->data.initResponse = 1;
 215
 216         localPacketId = 0;
 217     } else {
 218         if (inFrameMarker->data.retransmissionRequested) {
 219             uint8_t retransmissionFrameId = inFrameMarker->data.ackSequenceId;
 220             outFrameMarker->raw = responseToSend.raw & SEQUENCE_MARKER_REMOTE_PART;
 221             outFrameMarker->data.packetSequenceId = retransmissionFrameId;
 222
 223             memcpy(&frame[6], &telemetryTxBuffer[retransmissionFrameId], TELEMETRY_FRAME_SIZE);
 224         } else {
 225             uint8_t localAckId = inFrameMarker->data.ackSequenceId;
 226             if (localPacketId != (localAckId + 1) % TELEMETRY_SEQUENCE_LENGTH) {
 227                 outFrameMarker->raw = responseToSend.raw & SEQUENCE_MARKER_REMOTE_PART;
 228                 outFrameMarker->data.packetSequenceId = localPacketId;
 229
 230                 frame[6] = appendSmartPortData(&frame[7]);
 231                 memcpy(&telemetryTxBuffer[localPacketId], &frame[6], TELEMETRY_FRAME_SIZE);
 232
 233                 localPacketId = (localPacketId + 1) % TELEMETRY_SEQUENCE_LENGTH;
 234             }
 235         }
 236     }
 237
 238     uint16_t lcrc = calculateCrc(&frame[3], 10);
 239     frame[13]=lcrc>>8;
 240     frame[14]=lcrc;
 241 }
 242
 243 static bool frSkyXReadyToSend(void)
 244 {
 245     return true;
 246 }
 247
 248 #if defined(USE_TELEMETRY_SMARTPORT)
 249 static void frSkyXTelemetrySendByte(uint8_t c)
 250 {
 251     if (c == FSSP_DLE || c == FSSP_START_STOP) {
 252         telemetryOutBuffer[telemetryOutWriter] = FSSP_DLE;
 253         telemetryOutWriter = (telemetryOutWriter + 1) % TELEMETRY_OUT_BUFFER_SIZE;
 254         telemetryOutBuffer[telemetryOutWriter] = c ^ FSSP_DLE_XOR;
 255         telemetryOutWriter = (telemetryOutWriter + 1) % TELEMETRY_OUT_BUFFER_SIZE;
 256     } else {
 257         telemetryOutBuffer[telemetryOutWriter] = c;
 258         telemetryOutWriter = (telemetryOutWriter + 1) % TELEMETRY_OUT_BUFFER_SIZE;
 259     }
 260 }
 261
 262 static void frSkyXTelemetryWriteFrame(const smartPortPayload_t *payload)
 263 {
 264     telemetryOutBuffer[telemetryOutWriter] = FSSP_START_STOP;
 265     telemetryOutWriter = (telemetryOutWriter + 1) % TELEMETRY_OUT_BUFFER_SIZE;
 266     telemetryOutBuffer[telemetryOutWriter] = FSSP_SENSOR_ID1 & 0x1f;
 267     telemetryOutWriter = (telemetryOutWriter + 1) % TELEMETRY_OUT_BUFFER_SIZE;
 268     uint8_t *data = (uint8_t *)payload;
 269     for (unsigned i = 0; i < sizeof(smartPortPayload_t); i++) {
 270         frSkyXTelemetrySendByte(*data++);
 271     }
 272 }
 273 #endif
 274 #endif // USE_RX_FRSKY_SPI_TELEMETRY
 275
 276
 277 void frSkyXSetRcData(uint16_t *rcData, const uint8_t *packet)
 278 {
 279     uint16_t c[8];
 280     // ignore failsafe packet
 281     if (packet[7] != 0) {
 282         return;
 283     }
 284     c[0] = (uint16_t)((packet[10] << 8) & 0xF00) | packet[9];
 285     c[1] = (uint16_t)((packet[11] << 4) & 0xFF0) | (packet[10] >> 4);
 286     c[2] = (uint16_t)((packet[13] << 8) & 0xF00) | packet[12];
 287     c[3] = (uint16_t)((packet[14] << 4) & 0xFF0) | (packet[13] >> 4);
 288     c[4] = (uint16_t)((packet[16] << 8) & 0xF00) | packet[15];
 289     c[5] = (uint16_t)((packet[17] << 4) & 0xFF0) | (packet[16] >> 4);
 290     c[6] = (uint16_t)((packet[19] << 8) & 0xF00) | packet[18];
 291     c[7] = (uint16_t)((packet[20] << 4) & 0xFF0) | (packet[19] >> 4);
 292
 293     for (unsigned i = 0; i < 8; i++) {
 294         const bool channelIsShifted = c[i] & 0x800;
 295         const uint16_t channelValue = c[i] & 0x7FF;
 296         rcData[channelIsShifted ? i + 8 : i] = ((channelValue - 64) * 2 + 860 * 3) / 3;
 297     }
 298 }
 299
 300 bool isValidPacket(const uint8_t *packet)
 301 {
 302     bool useBindTxId2 = false;
 303
 304     if (spiProtocol == RX_SPI_FRSKY_X_V2 || spiProtocol == RX_SPI_FRSKY_X_LBT_V2) {
 305         useBindTxId2 = true;
 306         if (!(packet[packetLength - 1] & 0x80)) {
 307             return false;
 308         }
 309     }
 310
 311     uint16_t lcrc = calculateCrc(&packet[3], (packetLength - 7));
 312
 313     if ((lcrc >> 8) == packet[packetLength - 4] && (lcrc & 0x00FF) == packet[packetLength - 3] &&
 314         (packet[0] == packetLength - 3) &&
 315         (packet[1] == rxCc2500SpiConfig()->bindTxId[0]) &&
 316         (packet[2] == rxCc2500SpiConfig()->bindTxId[1]) &&
 317         (!useBindTxId2 || (packet[3] == rxCc2500SpiConfig()->bindTxId[2])) &&
 318         (rxCc2500SpiConfig()->rxNum == 0 || packet[6] == 0 || packet[6] == rxCc2500SpiConfig()->rxNum)) {
 319         return true;
 320     }
 321     return false;
 322 }
 323
 324 rx_spi_received_e frSkyXHandlePacket(uint8_t * const packet, uint8_t * const protocolState)
 325 {
 326     static unsigned receiveTelemetryRetryCount = 0;
 327     static bool skipChannels = true;
 328
 329     static uint8_t remoteAckId = 0;
 330
 331     static timeUs_t packetTimerUs;
 332
 333     static bool frameReceived;
 334     static timeDelta_t receiveDelayUs;
 335     static uint8_t channelsToSkip = 1;
 336     static uint32_t packetErrors = 0;
 337
 338 #if defined(USE_RX_FRSKY_SPI_TELEMETRY)
 339     static bool telemetryReceived = false;
 340 #endif
 341
 342     rx_spi_received_e ret = RX_SPI_RECEIVED_NONE;
 343
 344     switch (*protocolState) {
 345     case STATE_STARTING:
 346         listLength = 47;
 347         initialiseData(false);
 348         *protocolState = STATE_UPDATE;
 349         nextChannel(1);
 350         cc2500Strobe(CC2500_SRX);
 351         break;
 352     case STATE_UPDATE:
 353         packetTimerUs = micros();
 354         *protocolState = STATE_DATA;
 355         frameReceived = false; // again set for receive
 356         receiveDelayUs = 5300;
 357         if (rxSpiCheckBindRequested(false)) {
 358             packetTimerUs = 0;
 359             timeoutUs = 50;
 360             missingPackets = 0;
 361             *protocolState = STATE_INIT;
 362
 363             break;
 364         }
 365
 366         FALLTHROUGH;
 367         // here FS code could be
 368     case STATE_DATA:
 369         if (rxSpiGetExtiState() && (!frameReceived)) {
 370             uint8_t ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
 371             if (ccLen >= packetLength) {
 372                 cc2500ReadFifo(packet, packetLength);
 373                 if (isValidPacket(packet)) {
 374                     missingPackets = 0;
 375                     timeoutUs = 1;
 376                     receiveDelayUs = 0;
 377                     rxSpiLedOn();
 378                     if (skipChannels) {
 379                         channelsToSkip = (packet[5] << 2) | (packet[4] >> 6);
 380                         telemetryReceived = true; // now telemetry can be sent
 381                         skipChannels = false;
 382                     }
 383                     cc2500setRssiDbm(packet[packetLength - 2]);
 384
 385                     telemetrySequenceMarker_t *inFrameMarker = (telemetrySequenceMarker_t *)&packet[21];
 386
 387                     uint8_t remoteNewPacketId = inFrameMarker->data.packetSequenceId;
 388                     memcpy(&telemetryRxBuffer[remoteNewPacketId].data, &packet[22], TELEMETRY_FRAME_SIZE);
 389                     telemetryRxBuffer[remoteNewPacketId].needsProcessing = true;
 390
 391                     responseToSend.raw = 0;
 392                     uint8_t remoteToAckId = (remoteAckId + 1) % TELEMETRY_SEQUENCE_LENGTH;
 393                     if (remoteNewPacketId != remoteToAckId) {
 394                         while (remoteToAckId != remoteNewPacketId) {
 395                             if (!telemetryRxBuffer[remoteToAckId].needsProcessing) {
 396                                 responseToSend.data.ackSequenceId = remoteToAckId;
 397                                 responseToSend.data.retransmissionRequested = 1;
 398
 399                                 receiveTelemetryRetryCount++;
 400
 401                                 break;
 402                             }
 403
 404                             remoteToAckId = (remoteToAckId + 1) % TELEMETRY_SEQUENCE_LENGTH;
 405                         }
 406                     }
 407
 408                     if (!responseToSend.data.retransmissionRequested) {
 409                         receiveTelemetryRetryCount = 0;
 410
 411                         remoteToAckId = (remoteAckId + 1) % TELEMETRY_SEQUENCE_LENGTH;
 412                         uint8_t remoteNextAckId = remoteToAckId;
 413                         while (telemetryRxBuffer[remoteToAckId].needsProcessing && remoteToAckId != remoteAckId) {
 414                             remoteNextAckId = remoteToAckId;
 415                             remoteToAckId = (remoteToAckId + 1) % TELEMETRY_SEQUENCE_LENGTH;
 416                         }
 417                         remoteAckId = remoteNextAckId;
 418                         responseToSend.data.ackSequenceId = remoteAckId;
 419                     }
 420
 421                     if (receiveTelemetryRetryCount >= 5) {
 422 #if defined(USE_RX_FRSKY_SPI_TELEMETRY) && defined(USE_TELEMETRY_SMARTPORT)
 423                          remoteToProcessId = 0;
 424                          remoteToProcessIndex = 0;
 425 #endif
 426                          remoteAckId = TELEMETRY_SEQUENCE_LENGTH - 1;
 427                          for (unsigned i = 0; i < TELEMETRY_SEQUENCE_LENGTH; i++) {
 428                              telemetryRxBuffer[i].needsProcessing = false;
 429                          }
 430
 431                          receiveTelemetryRetryCount = 0;
 432                      }
 433
 434                     packetTimerUs = micros();
 435                     frameReceived = true; // no need to process frame again.
 436                 }
 437                 if (!frameReceived) {
 438                     packetErrors++;
 439                     DEBUG_SET(DEBUG_RX_FRSKY_SPI, DEBUG_DATA_BAD_FRAME, packetErrors);
 440                     cc2500Strobe(CC2500_SFRX);
 441                 }
 442             }
 443         }
 444         if (telemetryReceived) {
 445             if (cmpTimeUs(micros(), packetTimerUs) > receiveDelayUs) { // if received or not received in this time sent telemetry data
 446                 *protocolState = STATE_TELEMETRY;
 447                 buildTelemetryFrame(packet);
 448             }
 449         }
 450         if (cmpTimeUs(micros(), packetTimerUs) > timeoutUs * SYNC_DELAY_MAX) {
 451             rxSpiLedToggle();
 452
 453             setRssiDirect(0, RSSI_SOURCE_RX_PROTOCOL);
 454             nextChannel(1);
 455             cc2500Strobe(CC2500_SRX);
 456             *protocolState = STATE_UPDATE;
 457         }
 458         if (frameReceived) {
 459             ret |= RX_SPI_RECEIVED_DATA;
 460
 461             frameReceived = false;
 462         }
 463
 464         break;
 465 #ifdef USE_RX_FRSKY_SPI_TELEMETRY
 466     case STATE_TELEMETRY:
 467         if (cmpTimeUs(micros(), packetTimerUs) >= receiveDelayUs + telemetryDelayUs) { // if received or not received in this time sent telemetry data
 468             cc2500Strobe(CC2500_SIDLE);
 469             cc2500SetPower(6);
 470             cc2500Strobe(CC2500_SFRX);
 471             delayMicroseconds(30);
 472 #if defined(USE_RX_CC2500_SPI_PA_LNA)
 473             cc2500TxEnable();
 474 #endif
 475             cc2500Strobe(CC2500_SIDLE);
 476             cc2500WriteFifo(frame, frame[0] + 1);
 477
 478 #if defined(USE_TELEMETRY_SMARTPORT)
 479             if (telemetryEnabled) {
 480                 ret |= RX_SPI_ROCESSING_REQUIRED;
 481             }
 482 #endif
 483             *protocolState = STATE_RESUME;
 484         }
 485
 486         break;
 487 #endif // USE_RX_FRSKY_SPI_TELEMETRY
 488     case STATE_RESUME:
 489         if (cmpTimeUs(micros(), packetTimerUs) > receiveDelayUs + 3700) {
 490             packetTimerUs = micros();
 491             receiveDelayUs = 5300;
 492             frameReceived = false; // again set for receive
 493             nextChannel(channelsToSkip);
 494             cc2500Strobe(CC2500_SRX);
 495 #ifdef USE_RX_CC2500_SPI_PA_LNA
 496             cc2500TxDisable();
 497 #if defined(USE_RX_CC2500_SPI_DIVERSITY)
 498             if (missingPackets >= 2) {
 499                 cc2500switchAntennae();
 500             }
 501 #endif
 502 #endif // USE_RX_CC2500_SPI_PA_LNA
 503             if (missingPackets > MAX_MISSING_PKT) {
 504                 timeoutUs = 50;
 505                 skipChannels = true;
 506                 telemetryReceived = false;
 507                 *protocolState = STATE_UPDATE;
 508                 break;
 509             }
 510             missingPackets++;
 511             DEBUG_SET(DEBUG_RX_FRSKY_SPI, DEBUG_DATA_MISSING_PACKETS, missingPackets);
 512             *protocolState = STATE_DATA;
 513         }
 514         break;
 515     }
 516
 517     return ret;
 518 }
 519
 520 #if defined(USE_RX_FRSKY_SPI_TELEMETRY) && defined(USE_TELEMETRY_SMARTPORT)
 521 rx_spi_received_e frSkyXProcessFrame(uint8_t * const packet)
 522 {
 523     static timeMs_t pollingTimeMs = 0;
 524
 525     UNUSED(packet);
 526
 527     bool clearToSend = false;
 528     timeMs_t now = millis();
 529     smartPortPayload_t *payload = NULL;
 530     if ((now - pollingTimeMs) > 24) {
 531         pollingTimeMs = now;
 532
 533         clearToSend = true;
 534     } else {
 535         while (telemetryRxBuffer[remoteToProcessId].needsProcessing && !payload) {
 536             if (remoteToProcessIndex >= telemetryRxBuffer[remoteToProcessId].data.dataLength) {
 537                 remoteToProcessIndex = 0;
 538                 telemetryRxBuffer[remoteToProcessId].needsProcessing = false;
 539                 remoteToProcessId = (remoteToProcessId + 1) % TELEMETRY_SEQUENCE_LENGTH;
 540
 541                 if (!telemetryRxBuffer[remoteToProcessId].needsProcessing) {
 542                     break;
 543                 }
 544             }
 545
 546             while (remoteToProcessIndex < telemetryRxBuffer[remoteToProcessId].data.dataLength && !payload) {
 547                 payload = smartPortDataReceive(telemetryRxBuffer[remoteToProcessId].data.data[remoteToProcessIndex], &clearToSend, frSkyXReadyToSend, false);
 548                 remoteToProcessIndex = remoteToProcessIndex + 1;
 549             }
 550         }
 551     }
 552
 553     processSmartPortTelemetry(payload, &clearToSend, NULL);
 554
 555     return RX_SPI_RECEIVED_NONE;
 556 }
 557 #endif
 558
 559 uint8_t frSkyXInit(void)
 560 {
 561     switch(spiProtocol) {
 562     case RX_SPI_FRSKY_X:
 563         packetLength = FRSKY_RX_D16FCC_LENGTH;
 564         telemetryDelayUs = 400;
 565         break;
 566     case RX_SPI_FRSKY_X_LBT:
 567         packetLength = FRSKY_RX_D16LBT_LENGTH;
 568         telemetryDelayUs = 1400;
 569         break;
 570     case RX_SPI_FRSKY_X_V2:
 571         packetLength = FRSKY_RX_D16v2_LENGTH;
 572         telemetryDelayUs = 400;
 573         break;
 574     case RX_SPI_FRSKY_X_LBT_V2:
 575         packetLength = FRSKY_RX_D16v2_LENGTH;
 576         telemetryDelayUs = 1500;
 577         break;
 578     default:
 579         break;
 580     }
 581 #if defined(USE_TELEMETRY_SMARTPORT)
 582      if (featureIsEnabled(FEATURE_TELEMETRY)) {
 583          telemetryEnabled = initSmartPortTelemetryExternal(frSkyXTelemetryWriteFrame);
 584      }
 585 #endif
 586      return packetLength;
 587 }
 588
 589 #endif