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