src/main/drivers/serial_softserial.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  * Cleanflight (or Baseflight): original
  23  * jflyper: Mono-timer and single-wire half-duplex
  24  */
  25
  26 #include <stdbool.h>
  27 #include <stdint.h>
  28
  29 #include "platform.h"
  30
  31 #if defined(USE_SOFTSERIAL1) || defined(USE_SOFTSERIAL2)
  32
  33 #include "build/build_config.h"
  34 #include "build/atomic.h"
  35
  36 #include "build/debug.h"
  37
  38 #include "common/utils.h"
  39
  40 #include "drivers/nvic.h"
  41 #include "drivers/io.h"
  42 #include "drivers/serial.h"
  43 #include "drivers/timer.h"
  44
  45 #include "serial_softserial.h"
  46
  47 #define RX_TOTAL_BITS 10
  48 #define TX_TOTAL_BITS 10
  49
  50 #if defined(USE_SOFTSERIAL1) && defined(USE_SOFTSERIAL2)
  51 #define MAX_SOFTSERIAL_PORTS 2
  52 #else
  53 #define MAX_SOFTSERIAL_PORTS 1
  54 #endif
  55
  56 typedef enum {
  57     TIMER_MODE_SINGLE,
  58     TIMER_MODE_DUAL,
  59 } timerMode_e;
  60
  61 #define ICPOLARITY_RISING true
  62 #define ICPOLARITY_FALLING false
  63
  64 typedef struct softSerial_s {
  65     serialPort_t     port;
  66
  67     IO_t rxIO;
  68     IO_t txIO;
  69
  70     const timerHardware_t *timerHardware;
  71 #ifdef USE_HAL_DRIVER
  72     const TIM_HandleTypeDef *timerHandle;
  73 #endif
  74     const timerHardware_t *exTimerHardware;
  75
  76     volatile uint8_t rxBuffer[SOFTSERIAL_BUFFER_SIZE];
  77     volatile uint8_t txBuffer[SOFTSERIAL_BUFFER_SIZE];
  78
  79     uint8_t          isSearchingForStartBit;
  80     uint8_t          rxBitIndex;
  81     uint8_t          rxLastLeadingEdgeAtBitIndex;
  82     uint8_t          rxEdge;
  83     uint8_t          rxActive;
  84
  85     uint8_t          isTransmittingData;
  86     int8_t           bitsLeftToTransmit;
  87
  88     uint16_t         internalTxBuffer;  // includes start and stop bits
  89     uint16_t         internalRxBuffer;  // includes start and stop bits
  90
  91     uint16_t         transmissionErrors;
  92     uint16_t         receiveErrors;
  93
  94     uint8_t          softSerialPortIndex;
  95     timerMode_e      timerMode;
  96
  97     timerOvrHandlerRec_t overCb;
  98     timerCCHandlerRec_t edgeCb;
  99 } softSerial_t;
 100
 101 static const struct serialPortVTable softSerialVTable; // Forward
 102
 103 static softSerial_t softSerialPorts[MAX_SOFTSERIAL_PORTS];
 104
 105 void onSerialTimerOverflow(timerOvrHandlerRec_t *cbRec, captureCompare_t capture);
 106 void onSerialRxPinChange(timerCCHandlerRec_t *cbRec, captureCompare_t capture);
 107
 108 static void setTxSignal(softSerial_t *softSerial, uint8_t state)
 109 {
 110     if (softSerial->port.options & SERIAL_INVERTED) {
 111         state = !state;
 112     }
 113
 114     if (state) {
 115         IOHi(softSerial->txIO);
 116     } else {
 117         IOLo(softSerial->txIO);
 118     }
 119 }
 120
 121 static void serialEnableCC(softSerial_t *softSerial)
 122 {
 123 #ifdef USE_HAL_DRIVER
 124     TIM_CCxChannelCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_ENABLE);
 125 #else
 126     TIM_CCxCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_Enable);
 127 #endif
 128 }
 129
 130 static void serialInputPortActivate(softSerial_t *softSerial)
 131 {
 132     if (softSerial->port.options & SERIAL_INVERTED) {
 133 #ifdef STM32F1
 134         IOConfigGPIO(softSerial->rxIO, IOCFG_IPD);
 135 #else
 136         const uint8_t pinConfig = (softSerial->port.options & SERIAL_BIDIR_NOPULL) ? IOCFG_AF_PP : IOCFG_AF_PP_PD;
 137         IOConfigGPIOAF(softSerial->rxIO, pinConfig, softSerial->timerHardware->alternateFunction);
 138 #endif
 139     } else {
 140 #ifdef STM32F1
 141         IOConfigGPIO(softSerial->rxIO, IOCFG_IPU);
 142 #else
 143         const uint8_t pinConfig = (softSerial->port.options & SERIAL_BIDIR_NOPULL) ? IOCFG_AF_PP : IOCFG_AF_PP_UP;
 144         IOConfigGPIOAF(softSerial->rxIO, pinConfig, softSerial->timerHardware->alternateFunction);
 145 #endif
 146     }
 147
 148     softSerial->rxActive = true;
 149     softSerial->isSearchingForStartBit = true;
 150     softSerial->rxBitIndex = 0;
 151
 152     // Enable input capture
 153
 154     serialEnableCC(softSerial);
 155 }
 156
 157 static void serialInputPortDeActivate(softSerial_t *softSerial)
 158 {
 159     // Disable input capture
 160
 161 #ifdef USE_HAL_DRIVER
 162     TIM_CCxChannelCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_DISABLE);
 163 #else
 164     TIM_CCxCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_Disable);
 165 #endif
 166
 167     IOConfigGPIO(softSerial->rxIO, IOCFG_IN_FLOATING);
 168     softSerial->rxActive = false;
 169 }
 170
 171 static void serialOutputPortActivate(softSerial_t *softSerial)
 172 {
 173 #ifdef STM32F1
 174     IOConfigGPIO(softSerial->txIO, IOCFG_OUT_PP);
 175 #else
 176     if (softSerial->exTimerHardware)
 177         IOConfigGPIOAF(softSerial->txIO, IOCFG_OUT_PP, softSerial->exTimerHardware->alternateFunction);
 178     else
 179         IOConfigGPIO(softSerial->txIO, IOCFG_OUT_PP);
 180 #endif
 181 }
 182
 183 static void serialOutputPortDeActivate(softSerial_t *softSerial)
 184 {
 185 #ifdef STM32F1
 186     IOConfigGPIO(softSerial->txIO, IOCFG_IN_FLOATING);
 187 #else
 188     if (softSerial->exTimerHardware)
 189         IOConfigGPIOAF(softSerial->txIO, IOCFG_IN_FLOATING, softSerial->exTimerHardware->alternateFunction);
 190     else
 191         IOConfigGPIO(softSerial->txIO, IOCFG_IN_FLOATING);
 192 #endif
 193 }
 194
 195 static bool isTimerPeriodTooLarge(uint32_t timerPeriod)
 196 {
 197     return timerPeriod > 0xFFFF;
 198 }
 199
 200 static void serialTimerConfigureTimebase(const timerHardware_t *timerHardwarePtr, uint32_t baud)
 201 {
 202     uint32_t baseClock = timerClock(timerHardwarePtr->tim);
 203     uint32_t clock = baseClock;
 204     uint32_t timerPeriod;
 205
 206     do {
 207         timerPeriod = clock / baud;
 208         if (isTimerPeriodTooLarge(timerPeriod)) {
 209             if (clock > 1) {
 210                 clock = clock / 2;   // this is wrong - mhz stays the same ... This will double baudrate until ok (but minimum baudrate is < 1200)
 211             } else {
 212                 // TODO unable to continue, unable to determine clock and timerPeriods for the given baud
 213             }
 214
 215         }
 216     } while (isTimerPeriodTooLarge(timerPeriod));
 217
 218     timerConfigure(timerHardwarePtr, timerPeriod, baseClock);
 219 }
 220
 221 static void resetBuffers(softSerial_t *softSerial)
 222 {
 223     softSerial->port.rxBufferSize = SOFTSERIAL_BUFFER_SIZE;
 224     softSerial->port.rxBuffer = softSerial->rxBuffer;
 225     softSerial->port.rxBufferTail = 0;
 226     softSerial->port.rxBufferHead = 0;
 227
 228     softSerial->port.txBuffer = softSerial->txBuffer;
 229     softSerial->port.txBufferSize = SOFTSERIAL_BUFFER_SIZE;
 230     softSerial->port.txBufferTail = 0;
 231     softSerial->port.txBufferHead = 0;
 232 }
 233
 234 serialPort_t *openSoftSerial(softSerialPortIndex_e portIndex, serialReceiveCallbackPtr rxCallback, void *rxCallbackData, uint32_t baud, portMode_e mode, portOptions_e options)
 235 {
 236     softSerial_t *softSerial = &(softSerialPorts[portIndex]);
 237
 238     int pinCfgIndex = portIndex + RESOURCE_SOFT_OFFSET;
 239
 240     ioTag_t tagRx = serialPinConfig()->ioTagRx[pinCfgIndex];
 241     ioTag_t tagTx = serialPinConfig()->ioTagTx[pinCfgIndex];
 242
 243     const timerHardware_t *timerTx = timerAllocate(tagTx, OWNER_SERIAL_TX, RESOURCE_INDEX(portIndex + RESOURCE_SOFT_OFFSET));
 244     const timerHardware_t *timerRx = (tagTx == tagRx) ? timerTx : timerAllocate(tagRx, OWNER_SERIAL_RX, RESOURCE_INDEX(portIndex + RESOURCE_SOFT_OFFSET));
 245
 246     IO_t rxIO = IOGetByTag(tagRx);
 247     IO_t txIO = IOGetByTag(tagTx);
 248
 249     if (options & SERIAL_BIDIR) {
 250         // If RX and TX pins are both assigned, we CAN use either with a timer.
 251         // However, for consistency with hardware UARTs, we only use TX pin,
 252         // and this pin must have a timer, and it should not be N-Channel.
 253         if (!timerTx || (timerTx->output & TIMER_OUTPUT_N_CHANNEL)) {
 254             return NULL;
 255         }
 256
 257         softSerial->timerHardware = timerTx;
 258         softSerial->txIO = txIO;
 259         softSerial->rxIO = txIO;
 260         IOInit(txIO, OWNER_SERIAL_TX, RESOURCE_INDEX(portIndex + RESOURCE_SOFT_OFFSET));
 261     } else {
 262         if (mode & MODE_RX) {
 263             // Need a pin & a timer on RX. Channel should not be N-Channel.
 264             if (!timerRx || (timerRx->output & TIMER_OUTPUT_N_CHANNEL)) {
 265                 return NULL;
 266             }
 267
 268             softSerial->rxIO = rxIO;
 269             softSerial->timerHardware = timerRx;
 270             if (!((mode & MODE_TX) && rxIO == txIO)) {
 271                 IOInit(rxIO, OWNER_SERIAL_RX, RESOURCE_INDEX(portIndex + RESOURCE_SOFT_OFFSET));
 272             }
 273         }
 274
 275         if (mode & MODE_TX) {
 276             // Need a pin on TX
 277             if (!tagTx)
 278                 return NULL;
 279
 280             softSerial->txIO = txIO;
 281
 282             if (!(mode & MODE_RX)) {
 283                 // TX Simplex, must have a timer
 284                 if (!timerTx)
 285                     return NULL;
 286                 softSerial->timerHardware = timerTx;
 287             } else {
 288                 // Duplex
 289                 softSerial->exTimerHardware = timerTx;
 290             }
 291             IOInit(txIO, OWNER_SERIAL_TX, RESOURCE_INDEX(portIndex + RESOURCE_SOFT_OFFSET));
 292         }
 293     }
 294
 295     softSerial->port.vTable = &softSerialVTable;
 296     softSerial->port.baudRate = baud;
 297     softSerial->port.mode = mode;
 298     softSerial->port.options = options;
 299     softSerial->port.rxCallback = rxCallback;
 300     softSerial->port.rxCallbackData = rxCallbackData;
 301
 302     resetBuffers(softSerial);
 303
 304     softSerial->softSerialPortIndex = portIndex;
 305
 306     softSerial->transmissionErrors = 0;
 307     softSerial->receiveErrors = 0;
 308
 309     softSerial->rxActive = false;
 310     softSerial->isTransmittingData = false;
 311
 312     // Configure master timer (on RX); time base and input capture
 313
 314     serialTimerConfigureTimebase(softSerial->timerHardware, baud);
 315     timerChConfigIC(softSerial->timerHardware, (options & SERIAL_INVERTED) ? ICPOLARITY_RISING : ICPOLARITY_FALLING, 0);
 316
 317     // Initialize callbacks
 318     timerChCCHandlerInit(&softSerial->edgeCb, onSerialRxPinChange);
 319     timerChOvrHandlerInit(&softSerial->overCb, onSerialTimerOverflow);
 320
 321     // Configure bit clock interrupt & handler.
 322     // If we have an extra timer (on TX), it is initialized and configured
 323     // for overflow interrupt.
 324     // Receiver input capture is configured when input is activated.
 325
 326     if ((mode & MODE_TX) && softSerial->exTimerHardware && softSerial->exTimerHardware->tim != softSerial->timerHardware->tim) {
 327         softSerial->timerMode = TIMER_MODE_DUAL;
 328         serialTimerConfigureTimebase(softSerial->exTimerHardware, baud);
 329         timerChConfigCallbacks(softSerial->exTimerHardware, NULL, &softSerial->overCb);
 330         timerChConfigCallbacks(softSerial->timerHardware, &softSerial->edgeCb, NULL);
 331     } else {
 332         softSerial->timerMode = TIMER_MODE_SINGLE;
 333         timerChConfigCallbacks(softSerial->timerHardware, &softSerial->edgeCb, &softSerial->overCb);
 334     }
 335
 336 #ifdef USE_HAL_DRIVER
 337     softSerial->timerHandle = timerFindTimerHandle(softSerial->timerHardware->tim);
 338 #endif
 339
 340     if (!(options & SERIAL_BIDIR)) {
 341         serialOutputPortActivate(softSerial);
 342         setTxSignal(softSerial, ENABLE);
 343     }
 344
 345     serialInputPortActivate(softSerial);
 346
 347     return &softSerial->port;
 348 }
 349
 350
 351 /*
 352  * Serial Engine
 353  */
 354
 355 void processTxState(softSerial_t *softSerial)
 356 {
 357     uint8_t mask;
 358
 359     if (!softSerial->isTransmittingData) {
 360         if (isSoftSerialTransmitBufferEmpty((serialPort_t *)softSerial)) {
 361             // Transmit buffer empty.
 362             // Start listening if not already in if half-duplex
 363             if (!softSerial->rxActive && softSerial->port.options & SERIAL_BIDIR) {
 364                 serialOutputPortDeActivate(softSerial);
 365                 serialInputPortActivate(softSerial);
 366             }
 367             return;
 368         }
 369
 370         // data to send
 371         uint8_t byteToSend = softSerial->port.txBuffer[softSerial->port.txBufferTail++];
 372         if (softSerial->port.txBufferTail >= softSerial->port.txBufferSize) {
 373             softSerial->port.txBufferTail = 0;
 374         }
 375
 376         // build internal buffer, MSB = Stop Bit (1) + data bits (MSB to LSB) + start bit(0) LSB
 377         softSerial->internalTxBuffer = (1 << (TX_TOTAL_BITS - 1)) | (byteToSend << 1);
 378         softSerial->bitsLeftToTransmit = TX_TOTAL_BITS;
 379         softSerial->isTransmittingData = true;
 380
 381         if (softSerial->rxActive && (softSerial->port.options & SERIAL_BIDIR)) {
 382             // Half-duplex: Deactivate receiver, activate transmitter
 383             serialInputPortDeActivate(softSerial);
 384             serialOutputPortActivate(softSerial);
 385
 386             // Start sending on next bit timing, as port manipulation takes time,
 387             // and continuing here may cause bit period to decrease causing sampling errors
 388             // at the receiver under high rates.
 389             // Note that there will be (little less than) 1-bit delay; take it as "turn around time".
 390             // XXX We may be able to reload counter and continue. (Future work.)
 391             return;
 392         }
 393     }
 394
 395     if (softSerial->bitsLeftToTransmit) {
 396         mask = softSerial->internalTxBuffer & 1;
 397         softSerial->internalTxBuffer >>= 1;
 398
 399         setTxSignal(softSerial, mask);
 400         softSerial->bitsLeftToTransmit--;
 401         return;
 402     }
 403
 404     softSerial->isTransmittingData = false;
 405 }
 406
 407 enum {
 408     TRAILING,
 409     LEADING
 410 };
 411
 412 void applyChangedBits(softSerial_t *softSerial)
 413 {
 414     if (softSerial->rxEdge == TRAILING) {
 415         uint8_t bitToSet;
 416         for (bitToSet = softSerial->rxLastLeadingEdgeAtBitIndex; bitToSet < softSerial->rxBitIndex; bitToSet++) {
 417             softSerial->internalRxBuffer |= 1 << bitToSet;
 418         }
 419     }
 420 }
 421
 422 void prepareForNextRxByte(softSerial_t *softSerial)
 423 {
 424     // prepare for next byte
 425     softSerial->rxBitIndex = 0;
 426     softSerial->isSearchingForStartBit = true;
 427     if (softSerial->rxEdge == LEADING) {
 428         softSerial->rxEdge = TRAILING;
 429         timerChConfigIC(softSerial->timerHardware, (softSerial->port.options & SERIAL_INVERTED) ? ICPOLARITY_RISING : ICPOLARITY_FALLING, 0);
 430         serialEnableCC(softSerial);
 431     }
 432 }
 433
 434 #define STOP_BIT_MASK (1 << 0)
 435 #define START_BIT_MASK (1 << (RX_TOTAL_BITS - 1))
 436
 437 void extractAndStoreRxByte(softSerial_t *softSerial)
 438 {
 439     if ((softSerial->port.mode & MODE_RX) == 0) {
 440         return;
 441     }
 442
 443     uint8_t haveStartBit = (softSerial->internalRxBuffer & START_BIT_MASK) == 0;
 444     uint8_t haveStopBit = (softSerial->internalRxBuffer & STOP_BIT_MASK) == 1;
 445
 446     if (!haveStartBit || !haveStopBit) {
 447         softSerial->receiveErrors++;
 448         return;
 449     }
 450
 451     uint8_t rxByte = (softSerial->internalRxBuffer >> 1) & 0xFF;
 452
 453     if (softSerial->port.rxCallback) {
 454         softSerial->port.rxCallback(rxByte, softSerial->port.rxCallbackData);
 455     } else {
 456         softSerial->port.rxBuffer[softSerial->port.rxBufferHead] = rxByte;
 457         softSerial->port.rxBufferHead = (softSerial->port.rxBufferHead + 1) % softSerial->port.rxBufferSize;
 458     }
 459 }
 460
 461 void processRxState(softSerial_t *softSerial)
 462 {
 463     if (softSerial->isSearchingForStartBit) {
 464         return;
 465     }
 466
 467     softSerial->rxBitIndex++;
 468
 469     if (softSerial->rxBitIndex == RX_TOTAL_BITS - 1) {
 470         applyChangedBits(softSerial);
 471         return;
 472     }
 473
 474     if (softSerial->rxBitIndex == RX_TOTAL_BITS) {
 475
 476         if (softSerial->rxEdge == TRAILING) {
 477             softSerial->internalRxBuffer |= STOP_BIT_MASK;
 478         }
 479
 480         extractAndStoreRxByte(softSerial);
 481         prepareForNextRxByte(softSerial);
 482     }
 483 }
 484
 485 void onSerialTimerOverflow(timerOvrHandlerRec_t *cbRec, captureCompare_t capture)
 486 {
 487     UNUSED(capture);
 488     softSerial_t *self = container_of(cbRec, softSerial_t, overCb);
 489
 490     if (self->port.mode & MODE_TX)
 491         processTxState(self);
 492
 493     if (self->port.mode & MODE_RX)
 494         processRxState(self);
 495 }
 496
 497 void onSerialRxPinChange(timerCCHandlerRec_t *cbRec, captureCompare_t capture)
 498 {
 499     UNUSED(capture);
 500
 501     softSerial_t *self = container_of(cbRec, softSerial_t, edgeCb);
 502     bool inverted = self->port.options & SERIAL_INVERTED;
 503
 504     if ((self->port.mode & MODE_RX) == 0) {
 505         return;
 506     }
 507
 508     if (self->isSearchingForStartBit) {
 509         // Synchronize the bit timing so that it will interrupt at the center
 510         // of the bit period.
 511
 512 #ifdef USE_HAL_DRIVER
 513         __HAL_TIM_SetCounter(self->timerHandle, __HAL_TIM_GetAutoreload(self->timerHandle) / 2);
 514 #else
 515         TIM_SetCounter(self->timerHardware->tim, self->timerHardware->tim->ARR / 2);
 516 #endif
 517
 518         // For a mono-timer full duplex configuration, this may clobber the
 519         // transmission because the next callback to the onSerialTimerOverflow
 520         // will happen too early causing transmission errors.
 521         // For a dual-timer configuration, there is no problem.
 522
 523         if ((self->timerMode != TIMER_MODE_DUAL) && self->isTransmittingData) {
 524             self->transmissionErrors++;
 525         }
 526
 527         timerChConfigIC(self->timerHardware, inverted ? ICPOLARITY_FALLING : ICPOLARITY_RISING, 0);
 528 #if defined(STM32F7) || defined(STM32H7) || defined(STM32G4)
 529         serialEnableCC(self);
 530 #endif
 531         self->rxEdge = LEADING;
 532
 533         self->rxBitIndex = 0;
 534         self->rxLastLeadingEdgeAtBitIndex = 0;
 535         self->internalRxBuffer = 0;
 536         self->isSearchingForStartBit = false;
 537         return;
 538     }
 539
 540     if (self->rxEdge == LEADING) {
 541         self->rxLastLeadingEdgeAtBitIndex = self->rxBitIndex;
 542     }
 543
 544     applyChangedBits(self);
 545
 546     if (self->rxEdge == TRAILING) {
 547         self->rxEdge = LEADING;
 548         timerChConfigIC(self->timerHardware, inverted ? ICPOLARITY_FALLING : ICPOLARITY_RISING, 0);
 549     } else {
 550         self->rxEdge = TRAILING;
 551         timerChConfigIC(self->timerHardware, inverted ? ICPOLARITY_RISING : ICPOLARITY_FALLING, 0);
 552     }
 553 #if defined(STM32F7) || defined(STM32H7) || defined(STM32G4)
 554     serialEnableCC(self);
 555 #endif
 556 }
 557
 558
 559 /*
 560  * Standard serial driver API
 561  */
 562
 563 uint32_t softSerialRxBytesWaiting(const serialPort_t *instance)
 564 {
 565     if ((instance->mode & MODE_RX) == 0) {
 566         return 0;
 567     }
 568
 569     softSerial_t *s = (softSerial_t *)instance;
 570
 571     return (s->port.rxBufferHead - s->port.rxBufferTail) & (s->port.rxBufferSize - 1);
 572 }
 573
 574 uint32_t softSerialTxBytesFree(const serialPort_t *instance)
 575 {
 576     if ((instance->mode & MODE_TX) == 0) {
 577         return 0;
 578     }
 579
 580     softSerial_t *s = (softSerial_t *)instance;
 581
 582     uint8_t bytesUsed = (s->port.txBufferHead - s->port.txBufferTail) & (s->port.txBufferSize - 1);
 583
 584     return (s->port.txBufferSize - 1) - bytesUsed;
 585 }
 586
 587 uint8_t softSerialReadByte(serialPort_t *instance)
 588 {
 589     uint8_t ch;
 590
 591     if ((instance->mode & MODE_RX) == 0) {
 592         return 0;
 593     }
 594
 595     if (softSerialRxBytesWaiting(instance) == 0) {
 596         return 0;
 597     }
 598
 599     ch = instance->rxBuffer[instance->rxBufferTail];
 600     instance->rxBufferTail = (instance->rxBufferTail + 1) % instance->rxBufferSize;
 601     return ch;
 602 }
 603
 604 void softSerialWriteByte(serialPort_t *s, uint8_t ch)
 605 {
 606     if ((s->mode & MODE_TX) == 0) {
 607         return;
 608     }
 609
 610     s->txBuffer[s->txBufferHead] = ch;
 611     s->txBufferHead = (s->txBufferHead + 1) % s->txBufferSize;
 612 }
 613
 614 void softSerialSetBaudRate(serialPort_t *s, uint32_t baudRate)
 615 {
 616     softSerial_t *softSerial = (softSerial_t *)s;
 617
 618     softSerial->port.baudRate = baudRate;
 619
 620     serialTimerConfigureTimebase(softSerial->timerHardware, baudRate);
 621 }
 622
 623 void softSerialSetMode(serialPort_t *instance, portMode_e mode)
 624 {
 625     instance->mode = mode;
 626 }
 627
 628 bool isSoftSerialTransmitBufferEmpty(const serialPort_t *instance)
 629 {
 630     return instance->txBufferHead == instance->txBufferTail;
 631 }
 632
 633 static const struct serialPortVTable softSerialVTable = {
 634     .serialWrite = softSerialWriteByte,
 635     .serialTotalRxWaiting = softSerialRxBytesWaiting,
 636     .serialTotalTxFree = softSerialTxBytesFree,
 637     .serialRead = softSerialReadByte,
 638     .serialSetBaudRate = softSerialSetBaudRate,
 639     .isSerialTransmitBufferEmpty = isSoftSerialTransmitBufferEmpty,
 640     .setMode = softSerialSetMode,
 641     .setCtrlLineStateCb = NULL,
 642     .setBaudRateCb = NULL,
 643     .writeBuf = NULL,
 644     .beginWrite = NULL,
 645     .endWrite = NULL
 646 };
 647
 648 #endif