Mirror/betaflight
1
0
Fork 0
mirror of https://github.com/betaflight/betaflight.git synced 2025-07-24 00:35:39 +03:00
Code Issues Wiki Activity

Merge branch 'serial-port-options'

Browse source
This commit is contained in:
Dominic Clifton 2015-03-26 01:42:42 +00:00
commit f9d22ab212
17 changed files with 180 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/main/blackbox/blackbox_io.c
View file

@ -62,6 +62,8 @@
#ifdef BLACKBOX #ifdef BLACKBOX
#define BLACKBOX_SERIAL_PORT_MODE MODE_TX
// How many bytes should we transmit per loop iteration? // How many bytes should we transmit per loop iteration?
uint8_t blackboxWriteChunkSize = 16; uint8_t blackboxWriteChunkSize = 16;
@ -446,7 +448,7 @@ bool blackboxDeviceOpen(void)
{ {
serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_BLACKBOX); serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_BLACKBOX);
baudRate_e baudRateIndex; baudRate_e baudRateIndex;
portMode_t portMode; portOptions_t portOptions = SERIAL_PARITY_NO | SERIAL_NOT_INVERTED;
if (!portConfig) { if (!portConfig) {
return false; return false;
@ -455,18 +457,18 @@ bool blackboxDeviceOpen(void)
blackboxPortSharing = determinePortSharing(portConfig, FUNCTION_BLACKBOX); blackboxPortSharing = determinePortSharing(portConfig, FUNCTION_BLACKBOX);
baudRateIndex = portConfig->blackbox_baudrateIndex; baudRateIndex = portConfig->blackbox_baudrateIndex;
portMode = MODE_TX;
if (baudRates[baudRateIndex] == 230400) { if (baudRates[baudRateIndex] == 230400) {
/* /*
* OpenLog's 230400 baud rate is very inaccurate, so it requires a larger inter-character gap in * OpenLog's 230400 baud rate is very inaccurate, so it requires a larger inter-character gap in
* order to maintain synchronization. * order to maintain synchronization.
*/ */
portMode |= MODE_STOPBITS2; portOptions |= SERIAL_STOPBITS_2;
} else {
portOptions |= SERIAL_STOPBITS_1;
} }
blackboxPort = openSerialPort(portConfig->identifier, FUNCTION_BLACKBOX, NULL, baudRates[baudRateIndex], blackboxPort = openSerialPort(portConfig->identifier, FUNCTION_BLACKBOX, NULL, baudRates[baudRateIndex],
portMode, SERIAL_NOT_INVERTED); BLACKBOX_SERIAL_PORT_MODE, portOptions);
return blackboxPort != NULL; return blackboxPort != NULL;
} }

2
src/main/config/config.c
View file

@ -240,7 +240,7 @@ void resetFlight3DConfig(flight3DConfig_t *flight3DConfig)
void resetTelemetryConfig(telemetryConfig_t *telemetryConfig) void resetTelemetryConfig(telemetryConfig_t *telemetryConfig)
{ {
telemetryConfig->telemetry_inversion = SERIAL_NOT_INVERTED; telemetryConfig->telemetry_inversion = 0;
telemetryConfig->telemetry_switch = 0; telemetryConfig->telemetry_switch = 0;
telemetryConfig->gpsNoFixLatitude = 0; telemetryConfig->gpsNoFixLatitude = 0;
telemetryConfig->gpsNoFixLongitude = 0; telemetryConfig->gpsNoFixLongitude = 0;

24
src/main/drivers/serial.h
View file

@ -17,20 +17,23 @@
#pragma once #pragma once
typedef enum {
SERIAL_NOT_INVERTED = 0,
SERIAL_INVERTED
} serialInversion_e;
typedef enum portMode_t { typedef enum portMode_t {
MODE_RX = 1 << 0, MODE_RX = 1 << 0,
MODE_TX = 1 << 1, MODE_TX = 1 << 1,
MODE_RXTX = MODE_RX | MODE_TX, MODE_RXTX = MODE_RX | MODE_TX
MODE_SBUS = 1 << 2,
MODE_BIDIR = 1 << 3,
MODE_STOPBITS2 = 1 << 4,
} portMode_t; } portMode_t;
typedef enum portOptions_t {
SERIAL_NOT_INVERTED = 0 << 0,
SERIAL_INVERTED = 1 << 0,
SERIAL_STOPBITS_1 = 0 << 1,
SERIAL_STOPBITS_2 = 1 << 1,
SERIAL_PARITY_NO = 0 << 2,
SERIAL_PARITY_EVEN = 1 << 2,
SERIAL_UNIDIR = 0 << 3,
SERIAL_BIDIR = 1 << 3
} portOptions_t;
typedef void (*serialReceiveCallbackPtr)(uint16_t data); // used by serial drivers to return frames to app typedef void (*serialReceiveCallbackPtr)(uint16_t data); // used by serial drivers to return frames to app
typedef struct serialPort { typedef struct serialPort {
@ -39,7 +42,8 @@ typedef struct serialPort {
uint8_t identifier; uint8_t identifier;
portMode_t mode; portMode_t mode;
serialInversion_e inversion; portOptions_t options;
uint32_t baudRate; uint32_t baudRate;
uint32_t rxBufferSize; uint32_t rxBufferSize;

23
src/main/drivers/serial_softserial.c
View file

@ -52,7 +52,7 @@ void onSerialRxPinChange(timerCCHandlerRec_t *cbRec, captureCompare_t capture);
void setTxSignal(softSerial_t *softSerial, uint8_t state) void setTxSignal(softSerial_t *softSerial, uint8_t state)
{ {
if (softSerial->port.inversion == SERIAL_INVERTED) { if (softSerial->port.options & SERIAL_INVERTED) {
state = !state; state = !state;
} }
@ -119,10 +119,10 @@ static void serialICConfig(TIM_TypeDef *tim, uint8_t channel, uint16_t polarity)
TIM_ICInit(tim, &TIM_ICInitStructure); TIM_ICInit(tim, &TIM_ICInitStructure);
} }
static void serialTimerRxConfig(const timerHardware_t *timerHardwarePtr, uint8_t reference, serialInversion_e inversion) static void serialTimerRxConfig(const timerHardware_t *timerHardwarePtr, uint8_t reference, portOptions_t options)
{ {
// start bit is usually a FALLING signal // start bit is usually a FALLING signal
serialICConfig(timerHardwarePtr->tim, timerHardwarePtr->channel, inversion == SERIAL_INVERTED ? TIM_ICPolarity_Rising : TIM_ICPolarity_Falling); serialICConfig(timerHardwarePtr->tim, timerHardwarePtr->channel, (options & SERIAL_INVERTED) ? TIM_ICPolarity_Rising : TIM_ICPolarity_Falling);
timerChCCHandlerInit(&softSerialPorts[reference].edgeCb, onSerialRxPinChange); timerChCCHandlerInit(&softSerialPorts[reference].edgeCb, onSerialRxPinChange);
timerChConfigCallbacks(timerHardwarePtr, &softSerialPorts[reference].edgeCb, NULL); timerChConfigCallbacks(timerHardwarePtr, &softSerialPorts[reference].edgeCb, NULL);
} }
@ -145,7 +145,7 @@ static void resetBuffers(softSerial_t *softSerial)
softSerial->port.txBufferHead = 0; softSerial->port.txBufferHead = 0;
} }
serialPort_t *openSoftSerial(softSerialPortIndex_e portIndex, serialReceiveCallbackPtr callback, uint32_t baud, serialInversion_e inversion) serialPort_t *openSoftSerial(softSerialPortIndex_e portIndex, serialReceiveCallbackPtr callback, uint32_t baud, portOptions_t options)
{ {
softSerial_t *softSerial = &(softSerialPorts[portIndex]); softSerial_t *softSerial = &(softSerialPorts[portIndex]);
@ -166,7 +166,7 @@ serialPort_t *openSoftSerial(softSerialPortIndex_e portIndex, serialReceiveCallb
softSerial->port.vTable = softSerialVTable; softSerial->port.vTable = softSerialVTable;
softSerial->port.baudRate = baud; softSerial->port.baudRate = baud;
softSerial->port.mode = MODE_RXTX; softSerial->port.mode = MODE_RXTX;
softSerial->port.inversion = inversion; softSerial->port.options = options;
softSerial->port.callback = callback; softSerial->port.callback = callback;
resetBuffers(softSerial); resetBuffers(softSerial);
@ -188,7 +188,7 @@ serialPort_t *openSoftSerial(softSerialPortIndex_e portIndex, serialReceiveCallb
delay(50); delay(50);
serialTimerTxConfig(softSerial->txTimerHardware, portIndex, baud); serialTimerTxConfig(softSerial->txTimerHardware, portIndex, baud);
serialTimerRxConfig(softSerial->rxTimerHardware, portIndex, inversion); serialTimerRxConfig(softSerial->rxTimerHardware, portIndex, options);
return &softSerial->port; return &softSerial->port;
} }
@ -258,7 +258,7 @@ void prepareForNextRxByte(softSerial_t *softSerial)
serialICConfig( serialICConfig(
softSerial->rxTimerHardware->tim, softSerial->rxTimerHardware->tim,
softSerial->rxTimerHardware->channel, softSerial->rxTimerHardware->channel,
softSerial->port.inversion == SERIAL_INVERTED ? TIM_ICPolarity_Rising : TIM_ICPolarity_Falling (softSerial->port.options & SERIAL_INVERTED) ? TIM_ICPolarity_Rising : TIM_ICPolarity_Falling
); );
} }
} }
@ -328,6 +328,7 @@ void onSerialRxPinChange(timerCCHandlerRec_t *cbRec, captureCompare_t capture)
UNUSED(capture); UNUSED(capture);
softSerial_t *softSerial = container_of(cbRec, softSerial_t, edgeCb); softSerial_t *softSerial = container_of(cbRec, softSerial_t, edgeCb);
bool inverted = softSerial->port.options & SERIAL_INVERTED;
if ((softSerial->port.mode & MODE_RX) == 0) { if ((softSerial->port.mode & MODE_RX) == 0) {
return; return;
@ -342,7 +343,7 @@ void onSerialRxPinChange(timerCCHandlerRec_t *cbRec, captureCompare_t capture)
softSerial->transmissionErrors++; softSerial->transmissionErrors++;
} }
serialICConfig(softSerial->rxTimerHardware->tim, softSerial->rxTimerHardware->channel, softSerial->port.inversion == SERIAL_INVERTED ? TIM_ICPolarity_Falling : TIM_ICPolarity_Rising); serialICConfig(softSerial->rxTimerHardware->tim, softSerial->rxTimerHardware->channel, inverted ? TIM_ICPolarity_Falling : TIM_ICPolarity_Rising);
softSerial->rxEdge = LEADING; softSerial->rxEdge = LEADING;
softSerial->rxBitIndex = 0; softSerial->rxBitIndex = 0;
@ -360,10 +361,10 @@ void onSerialRxPinChange(timerCCHandlerRec_t *cbRec, captureCompare_t capture)
if (softSerial->rxEdge == TRAILING) { if (softSerial->rxEdge == TRAILING) {
softSerial->rxEdge = LEADING; softSerial->rxEdge = LEADING;
serialICConfig(softSerial->rxTimerHardware->tim, softSerial->rxTimerHardware->channel, softSerial->port.inversion == SERIAL_INVERTED ? TIM_ICPolarity_Falling : TIM_ICPolarity_Rising); serialICConfig(softSerial->rxTimerHardware->tim, softSerial->rxTimerHardware->channel, inverted ? TIM_ICPolarity_Falling : TIM_ICPolarity_Rising);
} else { } else {
softSerial->rxEdge = TRAILING; softSerial->rxEdge = TRAILING;
serialICConfig(softSerial->rxTimerHardware->tim, softSerial->rxTimerHardware->channel, softSerial->port.inversion == SERIAL_INVERTED ? TIM_ICPolarity_Rising : TIM_ICPolarity_Falling); serialICConfig(softSerial->rxTimerHardware->tim, softSerial->rxTimerHardware->channel, inverted ? TIM_ICPolarity_Rising : TIM_ICPolarity_Falling);
} }
} }
@ -408,7 +409,7 @@ void softSerialWriteByte(serialPort_t *s, uint8_t ch)
void softSerialSetBaudRate(serialPort_t *s, uint32_t baudRate) void softSerialSetBaudRate(serialPort_t *s, uint32_t baudRate)
{ {
softSerial_t *softSerial = (softSerial_t *)s; softSerial_t *softSerial = (softSerial_t *)s;
openSoftSerial(softSerial->softSerialPortIndex, s->callback, baudRate, softSerial->port.inversion); openSoftSerial(softSerial->softSerialPortIndex, s->callback, baudRate, softSerial->port.options);
} }
void softSerialSetMode(serialPort_t *instance, portMode_t mode) void softSerialSetMode(serialPort_t *instance, portMode_t mode)

2
src/main/drivers/serial_softserial.h
View file

@ -58,7 +58,7 @@ extern softSerial_t softSerialPorts[];
extern const struct serialPortVTable softSerialVTable[]; extern const struct serialPortVTable softSerialVTable[];
serialPort_t *openSoftSerial(softSerialPortIndex_e portIndex, serialReceiveCallbackPtr callback, uint32_t baud, serialInversion_e inversion); serialPort_t *openSoftSerial(softSerialPortIndex_e portIndex, serialReceiveCallbackPtr callback, uint32_t baud, portOptions_t options);
// serialPort API // serialPort API
void softSerialWriteByte(serialPort_t *instance, uint8_t ch); void softSerialWriteByte(serialPort_t *instance, uint8_t ch);

59
src/main/drivers/serial_uart.c
View file

@ -39,10 +39,11 @@
static void usartConfigurePinInversion(uartPort_t *uartPort) { static void usartConfigurePinInversion(uartPort_t *uartPort) {
#if !defined(INVERTER) && !defined(STM32F303xC) #if !defined(INVERTER) && !defined(STM32F303xC)
UNUSED(uartPort); UNUSED(uartPort);
#endif #else
bool inverted = uartPort->port.options & SERIAL_INVERTED;
#ifdef INVERTER #ifdef INVERTER
if (uartPort->port.inversion == SERIAL_INVERTED && uartPort->USARTx == INVERTER_USART) { if (inverted && uartPort->USARTx == INVERTER_USART) {
// Enable hardware inverter if available. // Enable hardware inverter if available.
INVERTER_ON; INVERTER_ON;
} }
@ -51,18 +52,23 @@ static void usartConfigurePinInversion(uartPort_t *uartPort) {
#ifdef STM32F303xC #ifdef STM32F303xC
uint32_t inversionPins = 0; uint32_t inversionPins = 0;
if (uartPort->port.mode & MODE_TX) { // Inversion when using OPTION_BIDIR not supported yet.
inversionPins |= USART_InvPin_Tx; if (uartPort->port.options & SERIAL_BIDIR) {
} // Clear inversion on both Tx and Rx
if (uartPort->port.mode & MODE_RX) { inversionPins |= USART_InvPin_Tx | USART_InvPin_Rx;
inversionPins |= USART_InvPin_Rx; inverted = false;
} else {
if (uartPort->port.mode & MODE_TX) {
inversionPins |= USART_InvPin_Tx;
}
if (uartPort->port.mode & MODE_RX) {
inversionPins |= USART_InvPin_Rx;
}
} }
// Note: inversion when using MODE_BIDIR not supported yet. USART_InvPinCmd(uartPort->USARTx, inversionPins, inverted ? ENABLE : DISABLE);
#endif
USART_InvPinCmd(uartPort->USARTx, inversionPins, uartPort->port.inversion == SERIAL_INVERTED ? ENABLE : DISABLE);
#endif #endif
} }
static void uartReconfigure(uartPort_t *uartPort) static void uartReconfigure(uartPort_t *uartPort)
@ -72,25 +78,16 @@ static void uartReconfigure(uartPort_t *uartPort)
USART_InitStructure.USART_BaudRate = uartPort->port.baudRate; USART_InitStructure.USART_BaudRate = uartPort->port.baudRate;
USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_WordLength = USART_WordLength_8b;
if (uartPort->port.mode & MODE_SBUS) {
USART_InitStructure.USART_StopBits = USART_StopBits_2;
USART_InitStructure.USART_Parity = USART_Parity_Even;
} else {
if (uartPort->port.mode & MODE_STOPBITS2)
USART_InitStructure.USART_StopBits = USART_StopBits_2;
else
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_StopBits = (uartPort->port.options & SERIAL_STOPBITS_2) ? USART_StopBits_2 : USART_StopBits_1;
} USART_InitStructure.USART_Parity = (uartPort->port.options & SERIAL_PARITY_EVEN) ? USART_Parity_Even : USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = 0; USART_InitStructure.USART_Mode = 0;
if (uartPort->port.mode & MODE_RX) if (uartPort->port.mode & MODE_RX)
USART_InitStructure.USART_Mode |= USART_Mode_Rx; USART_InitStructure.USART_Mode |= USART_Mode_Rx;
if (uartPort->port.mode & MODE_TX) if (uartPort->port.mode & MODE_TX)
USART_InitStructure.USART_Mode |= USART_Mode_Tx; USART_InitStructure.USART_Mode |= USART_Mode_Tx;
if (uartPort->port.mode & MODE_BIDIR)
USART_InitStructure.USART_Mode |= USART_Mode_Tx | USART_Mode_Rx;
USART_Init(uartPort->USARTx, &USART_InitStructure); USART_Init(uartPort->USARTx, &USART_InitStructure);
@ -99,19 +96,19 @@ static void uartReconfigure(uartPort_t *uartPort)
USART_Cmd(uartPort->USARTx, ENABLE); USART_Cmd(uartPort->USARTx, ENABLE);
} }
serialPort_t *uartOpen(USART_TypeDef *USARTx, serialReceiveCallbackPtr callback, uint32_t baudRate, portMode_t mode, serialInversion_e inversion) serialPort_t *uartOpen(USART_TypeDef *USARTx, serialReceiveCallbackPtr callback, uint32_t baudRate, portMode_t mode, portOptions_t options)
{ {
uartPort_t *s = NULL; uartPort_t *s = NULL;
if (USARTx == USART1) { if (USARTx == USART1) {
s = serialUSART1(baudRate, mode); s = serialUSART1(baudRate, mode, options);
#ifdef USE_USART2 #ifdef USE_USART2
} else if (USARTx == USART2) { } else if (USARTx == USART2) {
s = serialUSART2(baudRate, mode); s = serialUSART2(baudRate, mode, options);
#endif #endif
#ifdef USE_USART3 #ifdef USE_USART3
} else if (USARTx == USART3) { } else if (USARTx == USART3) {
s = serialUSART3(baudRate, mode); s = serialUSART3(baudRate, mode, options);
#endif #endif
} else { } else {
return (serialPort_t *)s; return (serialPort_t *)s;
@ -125,13 +122,13 @@ serialPort_t *uartOpen(USART_TypeDef *USARTx, serialReceiveCallbackPtr callback,
s->port.callback = callback; s->port.callback = callback;
s->port.mode = mode; s->port.mode = mode;
s->port.baudRate = baudRate; s->port.baudRate = baudRate;
s->port.inversion = inversion; s->port.options = options;
uartReconfigure(s); uartReconfigure(s);
// Receive DMA or IRQ // Receive DMA or IRQ
DMA_InitTypeDef DMA_InitStructure; DMA_InitTypeDef DMA_InitStructure;
if ((mode & MODE_RX) || (mode & MODE_BIDIR)) { if (mode & MODE_RX) {
if (s->rxDMAChannel) { if (s->rxDMAChannel) {
DMA_StructInit(&DMA_InitStructure); DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = s->rxDMAPeripheralBaseAddr; DMA_InitStructure.DMA_PeripheralBaseAddr = s->rxDMAPeripheralBaseAddr;
@ -158,7 +155,7 @@ serialPort_t *uartOpen(USART_TypeDef *USARTx, serialReceiveCallbackPtr callback,
} }
// Transmit DMA or IRQ // Transmit DMA or IRQ
if ((mode & MODE_TX) || (mode & MODE_BIDIR)) { if (mode & MODE_TX) {
if (s->txDMAChannel) { if (s->txDMAChannel) {
DMA_StructInit(&DMA_InitStructure); DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = s->txDMAPeripheralBaseAddr; DMA_InitStructure.DMA_PeripheralBaseAddr = s->txDMAPeripheralBaseAddr;
@ -185,7 +182,7 @@ serialPort_t *uartOpen(USART_TypeDef *USARTx, serialReceiveCallbackPtr callback,
USART_Cmd(s->USARTx, ENABLE); USART_Cmd(s->USARTx, ENABLE);
if (mode & MODE_BIDIR) if (options & SERIAL_BIDIR)
USART_HalfDuplexCmd(s->USARTx, ENABLE); USART_HalfDuplexCmd(s->USARTx, ENABLE);
else else
USART_HalfDuplexCmd(s->USARTx, DISABLE); USART_HalfDuplexCmd(s->USARTx, DISABLE);

2
src/main/drivers/serial_uart.h
View file

@ -44,7 +44,7 @@ typedef struct {
USART_TypeDef *USARTx; USART_TypeDef *USARTx;
} uartPort_t; } uartPort_t;
serialPort_t *uartOpen(USART_TypeDef *USARTx, serialReceiveCallbackPtr callback, uint32_t baudRate, portMode_t mode, serialInversion_e inversion); serialPort_t *uartOpen(USART_TypeDef *USARTx, serialReceiveCallbackPtr callback, uint32_t baudRate, portMode_t mode, portOptions_t options);
// serialPort API // serialPort API
void uartWrite(serialPort_t *instance, uint8_t ch); void uartWrite(serialPort_t *instance, uint8_t ch);

6
src/main/drivers/serial_uart_impl.h
View file

@ -23,7 +23,7 @@ extern const struct serialPortVTable uartVTable[];
void uartStartTxDMA(uartPort_t *s); void uartStartTxDMA(uartPort_t *s);
uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode); uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode, portOptions_t options);
uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode); uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode, portOptions_t options);
uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode); uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode, portOptions_t options);

78
src/main/drivers/serial_uart_stm32f10x.c
View file

@ -84,7 +84,7 @@ void usartIrqCallback(uartPort_t *s)
#ifdef USE_USART1 #ifdef USE_USART1
// USART1 - Telemetry (RX/TX by DMA) // USART1 - Telemetry (RX/TX by DMA)
uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode) uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode, portOptions_t options)
{ {
uartPort_t *s; uartPort_t *s;
static volatile uint8_t rx1Buffer[UART1_RX_BUFFER_SIZE]; static volatile uint8_t rx1Buffer[UART1_RX_BUFFER_SIZE];
@ -118,17 +118,23 @@ uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode)
// USART1_TX PA9 // USART1_TX PA9
// USART1_RX PA10 // USART1_RX PA10
gpio.speed = Speed_2MHz; gpio.speed = Speed_2MHz;
gpio.pin = Pin_9; gpio.pin = Pin_9;
gpio.mode = Mode_AF_PP; if (options & SERIAL_BIDIR) {
if (mode & MODE_TX) gpio.mode = Mode_AF_OD;
gpioInit(GPIOA, &gpio);
gpio.mode = Mode_AF_OD;
if (mode & MODE_BIDIR)
gpioInit(GPIOA, &gpio);
gpio.pin = Pin_10;
gpio.mode = Mode_IPU;
if (mode & MODE_RX)
gpioInit(GPIOA, &gpio); gpioInit(GPIOA, &gpio);
} else {
if (mode & MODE_TX) {
gpio.mode = Mode_AF_PP;
gpioInit(GPIOA, &gpio);
}
if (mode & MODE_RX) {
gpio.pin = Pin_10;
gpio.mode = Mode_IPU;
gpioInit(GPIOA, &gpio);
}
}
// DMA TX Interrupt // DMA TX Interrupt
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn; NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
@ -174,7 +180,7 @@ void USART1_IRQHandler(void)
#ifdef USE_USART2 #ifdef USE_USART2
// USART2 - GPS or Spektrum or ?? (RX + TX by IRQ) // USART2 - GPS or Spektrum or ?? (RX + TX by IRQ)
uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode) uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode, portOptions_t options)
{ {
uartPort_t *s; uartPort_t *s;
static volatile uint8_t rx2Buffer[UART2_RX_BUFFER_SIZE]; static volatile uint8_t rx2Buffer[UART2_RX_BUFFER_SIZE];
@ -203,17 +209,23 @@ uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode)
// USART2_TX PA2 // USART2_TX PA2
// USART2_RX PA3 // USART2_RX PA3
gpio.speed = Speed_2MHz; gpio.speed = Speed_2MHz;
gpio.pin = Pin_2; gpio.pin = Pin_2;
gpio.mode = Mode_AF_PP; if (options & SERIAL_BIDIR) {
if (mode & MODE_TX) gpio.mode = Mode_AF_OD;
gpioInit(GPIOA, &gpio);
gpio.mode = Mode_AF_OD;
if (mode & MODE_BIDIR)
gpioInit(GPIOA, &gpio);
gpio.pin = Pin_3;
gpio.mode = Mode_IPU;
if (mode & MODE_RX)
gpioInit(GPIOA, &gpio); gpioInit(GPIOA, &gpio);
} else {
if (mode & MODE_TX) {
gpio.mode = Mode_AF_PP;
gpioInit(GPIOA, &gpio);
}
if (mode & MODE_RX) {
gpio.pin = Pin_3;
gpio.mode = Mode_IPU;
gpioInit(GPIOA, &gpio);
}
}
// RX/TX Interrupt // RX/TX Interrupt
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
@ -237,7 +249,7 @@ void USART2_IRQHandler(void)
#ifdef USE_USART3 #ifdef USE_USART3
// USART3 // USART3
uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode) uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode, portOptions_t options)
{ {
uartPort_t *s; uartPort_t *s;
static volatile uint8_t rx3Buffer[UART3_RX_BUFFER_SIZE]; static volatile uint8_t rx3Buffer[UART3_RX_BUFFER_SIZE];
@ -268,17 +280,23 @@ uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode)
#endif #endif
gpio.speed = Speed_2MHz; gpio.speed = Speed_2MHz;
gpio.pin = USART3_TX_PIN; gpio.pin = USART3_TX_PIN;
gpio.mode = Mode_AF_PP; if (options & SERIAL_BIDIR) {
if (mode & MODE_TX) gpio.mode = Mode_AF_OD;
gpioInit(USART3_GPIO, &gpio);
gpio.mode = Mode_AF_OD;
if (mode & MODE_BIDIR)
gpioInit(USART3_GPIO, &gpio);
gpio.pin = USART3_RX_PIN;
gpio.mode = Mode_IPU;
if (mode & MODE_RX)
gpioInit(USART3_GPIO, &gpio); gpioInit(USART3_GPIO, &gpio);
} else {
if (mode & MODE_TX) {
gpio.mode = Mode_AF_PP;
gpioInit(USART3_GPIO, &gpio);
}
if (mode & MODE_RX) {
gpio.pin = USART3_RX_PIN;
gpio.mode = Mode_IPU;
gpioInit(USART3_GPIO, &gpio);
}
}
// RX/TX Interrupt // RX/TX Interrupt
NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn; NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;

84
src/main/drivers/serial_uart_stm32f30x.c
View file

@ -82,7 +82,7 @@ static uartPort_t uartPort3;
#endif #endif
#ifdef USE_USART1 #ifdef USE_USART1
uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode) uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode, portOptions_t options)
{ {
uartPort_t *s; uartPort_t *s;
static volatile uint8_t rx1Buffer[UART1_RX_BUFFER_SIZE]; static volatile uint8_t rx1Buffer[UART1_RX_BUFFER_SIZE];
@ -118,23 +118,23 @@ uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode)
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
if (mode & MODE_TX) { if (options & SERIAL_BIDIR) {
GPIO_InitStructure.GPIO_Pin = UART1_TX_PIN;
GPIO_PinAFConfig(UART1_GPIO, UART1_TX_PINSOURCE, UART1_GPIO_AF);
GPIO_Init(UART1_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_RX) {
GPIO_InitStructure.GPIO_Pin = UART1_RX_PIN;
GPIO_PinAFConfig(UART1_GPIO, UART1_RX_PINSOURCE, UART1_GPIO_AF);
GPIO_Init(UART1_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_BIDIR) {
GPIO_InitStructure.GPIO_Pin = UART1_TX_PIN; GPIO_InitStructure.GPIO_Pin = UART1_TX_PIN;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_PinAFConfig(UART1_GPIO, UART1_TX_PINSOURCE, UART1_GPIO_AF); GPIO_PinAFConfig(UART1_GPIO, UART1_TX_PINSOURCE, UART1_GPIO_AF);
GPIO_Init(UART1_GPIO, &GPIO_InitStructure); GPIO_Init(UART1_GPIO, &GPIO_InitStructure);
} else {
if (mode & MODE_TX) {
GPIO_InitStructure.GPIO_Pin = UART1_TX_PIN;
GPIO_PinAFConfig(UART1_GPIO, UART1_TX_PINSOURCE, UART1_GPIO_AF);
GPIO_Init(UART1_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_RX) {
GPIO_InitStructure.GPIO_Pin = UART1_RX_PIN;
GPIO_PinAFConfig(UART1_GPIO, UART1_RX_PINSOURCE, UART1_GPIO_AF);
GPIO_Init(UART1_GPIO, &GPIO_InitStructure);
}
} }
// DMA TX Interrupt // DMA TX Interrupt
@ -157,7 +157,7 @@ uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode)
#endif #endif
#ifdef USE_USART2 #ifdef USE_USART2
uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode) uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode, portOptions_t options)
{ {
uartPort_t *s; uartPort_t *s;
static volatile uint8_t rx2Buffer[UART2_RX_BUFFER_SIZE]; static volatile uint8_t rx2Buffer[UART2_RX_BUFFER_SIZE];
@ -197,23 +197,23 @@ uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode)
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
if (mode & MODE_TX) { if (options & SERIAL_BIDIR) {
GPIO_InitStructure.GPIO_Pin = UART2_TX_PIN;
GPIO_PinAFConfig(UART2_GPIO, UART2_TX_PINSOURCE, UART2_GPIO_AF);
GPIO_Init(UART2_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_RX) {
GPIO_InitStructure.GPIO_Pin = UART2_RX_PIN;
GPIO_PinAFConfig(UART2_GPIO, UART2_RX_PINSOURCE, UART2_GPIO_AF);
GPIO_Init(UART2_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_BIDIR) {
GPIO_InitStructure.GPIO_Pin = UART2_TX_PIN; GPIO_InitStructure.GPIO_Pin = UART2_TX_PIN;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_PinAFConfig(UART2_GPIO, UART2_TX_PINSOURCE, UART2_GPIO_AF); GPIO_PinAFConfig(UART2_GPIO, UART2_TX_PINSOURCE, UART2_GPIO_AF);
GPIO_Init(UART2_GPIO, &GPIO_InitStructure); GPIO_Init(UART2_GPIO, &GPIO_InitStructure);
} else {
if (mode & MODE_TX) {
GPIO_InitStructure.GPIO_Pin = UART2_TX_PIN;
GPIO_PinAFConfig(UART2_GPIO, UART2_TX_PINSOURCE, UART2_GPIO_AF);
GPIO_Init(UART2_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_RX) {
GPIO_InitStructure.GPIO_Pin = UART2_RX_PIN;
GPIO_PinAFConfig(UART2_GPIO, UART2_RX_PINSOURCE, UART2_GPIO_AF);
GPIO_Init(UART2_GPIO, &GPIO_InitStructure);
}
} }
#ifdef USE_USART2_TX_DMA #ifdef USE_USART2_TX_DMA
@ -238,7 +238,7 @@ uartPort_t *serialUSART2(uint32_t baudRate, portMode_t mode)
#endif #endif
#ifdef USE_USART3 #ifdef USE_USART3
uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode) uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode, portOptions_t options)
{ {
uartPort_t *s; uartPort_t *s;
static volatile uint8_t rx3Buffer[UART3_RX_BUFFER_SIZE]; static volatile uint8_t rx3Buffer[UART3_RX_BUFFER_SIZE];
@ -278,23 +278,23 @@ uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode)
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
if (mode & MODE_TX) { if (options & SERIAL_BIDIR) {
GPIO_InitStructure.GPIO_Pin = UART3_TX_PIN;
GPIO_PinAFConfig(UART3_GPIO, UART3_TX_PINSOURCE, UART3_GPIO_AF);
GPIO_Init(UART3_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_RX) {
GPIO_InitStructure.GPIO_Pin = UART3_RX_PIN;
GPIO_PinAFConfig(UART3_GPIO, UART3_RX_PINSOURCE, UART3_GPIO_AF);
GPIO_Init(UART3_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_BIDIR) {
GPIO_InitStructure.GPIO_Pin = UART3_TX_PIN; GPIO_InitStructure.GPIO_Pin = UART3_TX_PIN;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_PinAFConfig(UART3_GPIO, UART3_TX_PINSOURCE, UART3_GPIO_AF); GPIO_PinAFConfig(UART3_GPIO, UART3_TX_PINSOURCE, UART3_GPIO_AF);
GPIO_Init(UART3_GPIO, &GPIO_InitStructure); GPIO_Init(UART3_GPIO, &GPIO_InitStructure);
} else {
if (mode & MODE_TX) {
GPIO_InitStructure.GPIO_Pin = UART3_TX_PIN;
GPIO_PinAFConfig(UART3_GPIO, UART3_TX_PINSOURCE, UART3_GPIO_AF);
GPIO_Init(UART3_GPIO, &GPIO_InitStructure);
}
if (mode & MODE_RX) {
GPIO_InitStructure.GPIO_Pin = UART3_RX_PIN;
GPIO_PinAFConfig(UART3_GPIO, UART3_RX_PINSOURCE, UART3_GPIO_AF);
GPIO_Init(UART3_GPIO, &GPIO_InitStructure);
}
} }
#ifdef USE_USART3_TX_DMA #ifdef USE_USART3_TX_DMA

12
src/main/io/serial.c
View file

@ -238,7 +238,7 @@ serialPort_t *openSerialPort(
serialReceiveCallbackPtr callback, serialReceiveCallbackPtr callback,
uint32_t baudRate, uint32_t baudRate,
portMode_t mode, portMode_t mode,
serialInversion_e inversion) portOptions_t options)
{ {
serialPortUsage_t *serialPortUsage = findSerialPortUsageByIdentifier(identifier); serialPortUsage_t *serialPortUsage = findSerialPortUsageByIdentifier(identifier);
if (serialPortUsage->function != FUNCTION_NONE) { if (serialPortUsage->function != FUNCTION_NONE) {
@ -256,28 +256,28 @@ serialPort_t *openSerialPort(
#endif #endif
#ifdef USE_USART1 #ifdef USE_USART1
case SERIAL_PORT_USART1: case SERIAL_PORT_USART1:
serialPort = uartOpen(USART1, callback, baudRate, mode, inversion); serialPort = uartOpen(USART1, callback, baudRate, mode, options);
break; break;
#endif #endif
#ifdef USE_USART2 #ifdef USE_USART2
case SERIAL_PORT_USART2: case SERIAL_PORT_USART2:
serialPort = uartOpen(USART2, callback, baudRate, mode, inversion); serialPort = uartOpen(USART2, callback, baudRate, mode, options);
break; break;
#endif #endif
#ifdef USE_USART3 #ifdef USE_USART3
case SERIAL_PORT_USART3: case SERIAL_PORT_USART3:
serialPort = uartOpen(USART3, callback, baudRate, mode, inversion); serialPort = uartOpen(USART3, callback, baudRate, mode, options);
break; break;
#endif #endif
#ifdef USE_SOFTSERIAL1 #ifdef USE_SOFTSERIAL1
case SERIAL_PORT_SOFTSERIAL1: case SERIAL_PORT_SOFTSERIAL1:
serialPort = openSoftSerial(SOFTSERIAL1, callback, baudRate, inversion); serialPort = openSoftSerial(SOFTSERIAL1, callback, baudRate, options);
serialSetMode(serialPort, mode); serialSetMode(serialPort, mode);
break; break;
#endif #endif
#ifdef USE_SOFTSERIAL2 #ifdef USE_SOFTSERIAL2
case SERIAL_PORT_SOFTSERIAL2: case SERIAL_PORT_SOFTSERIAL2:
serialPort = openSoftSerial(SOFTSERIAL2, callback, baudRate, inversion); serialPort = openSoftSerial(SOFTSERIAL2, callback, baudRate, options);
serialSetMode(serialPort, mode); serialSetMode(serialPort, mode);
break; break;
#endif #endif

2
src/main/io/serial.h
View file

@ -114,7 +114,7 @@ serialPort_t *openSerialPort(
serialReceiveCallbackPtr callback, serialReceiveCallbackPtr callback,
uint32_t baudrate, uint32_t baudrate,
portMode_t mode, portMode_t mode,
serialInversion_e inversion portOptions_t options
); );
void closeSerialPort(serialPort_t *serialPort); void closeSerialPort(serialPort_t *serialPort);

3
src/main/rx/sbus.c
View file

@ -68,6 +68,7 @@ static uint16_t sbusStateFlags = 0;
#define SBUS_FRAME_END_BYTE 0x00 #define SBUS_FRAME_END_BYTE 0x00
#define SBUS_BAUDRATE 100000 #define SBUS_BAUDRATE 100000
#define SBUS_PORT_OPTIONS (SERIAL_STOPBITS_2 | SERIAL_PARITY_EVEN | SERIAL_INVERTED)
#define SBUS_DIGITAL_CHANNEL_MIN 173 #define SBUS_DIGITAL_CHANNEL_MIN 173
#define SBUS_DIGITAL_CHANNEL_MAX 1812 #define SBUS_DIGITAL_CHANNEL_MAX 1812
@ -92,7 +93,7 @@ bool sbusInit(rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig, rcReadRa
return false; return false;
} }
serialPort_t *sBusPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, sbusDataReceive, SBUS_BAUDRATE, (portMode_t)(MODE_RX | MODE_SBUS), SERIAL_INVERTED); serialPort_t *sBusPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, sbusDataReceive, SBUS_BAUDRATE, MODE_RX, SBUS_PORT_OPTIONS);
return sBusPort != NULL; return sBusPort != NULL;
} }

2
src/main/telemetry/frsky.c
View file

@ -433,7 +433,7 @@ void configureFrSkyTelemetryPort(void)
return; return;
} }
frskyPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_FRSKY, NULL, FRSKY_BAUDRATE, FRSKY_INITIAL_PORT_MODE, telemetryConfig->telemetry_inversion); frskyPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_FRSKY, NULL, FRSKY_BAUDRATE, FRSKY_INITIAL_PORT_MODE, telemetryConfig->telemetry_inversion ? SERIAL_INVERTED : SERIAL_NOT_INVERTED);
if (!frskyPort) { if (!frskyPort) {
return; return;
} }

12
src/main/telemetry/smartport.c
View file

@ -134,7 +134,7 @@ const uint16_t frSkyDataIdTable[] = {
#define __USE_C99_MATH // for roundf() #define __USE_C99_MATH // for roundf()
#define SMARTPORT_BAUD 57600 #define SMARTPORT_BAUD 57600
#define SMARTPORT_UART_MODE MODE_BIDIR #define SMARTPORT_UART_MODE MODE_RXTX
#define SMARTPORT_SERVICE_DELAY_MS 5 // telemetry requests comes in at roughly 12 ms intervals, keep this under that #define SMARTPORT_SERVICE_DELAY_MS 5 // telemetry requests comes in at roughly 12 ms intervals, keep this under that
#define SMARTPORT_NOT_CONNECTED_TIMEOUT_MS 7000 #define SMARTPORT_NOT_CONNECTED_TIMEOUT_MS 7000
@ -229,11 +229,19 @@ void freeSmartPortTelemetryPort(void)
void configureSmartPortTelemetryPort(void) void configureSmartPortTelemetryPort(void)
{ {
portOptions_t portOptions;
if (!portConfig) { if (!portConfig) {
return; return;
} }
smartPortSerialPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_SMARTPORT, NULL, SMARTPORT_BAUD, SMARTPORT_UART_MODE, telemetryConfig->telemetry_inversion); portOptions = SERIAL_BIDIR;
if (telemetryConfig->telemetry_inversion) {
portOptions |= SERIAL_INVERTED;
}
smartPortSerialPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_SMARTPORT, NULL, SMARTPORT_BAUD, SMARTPORT_UART_MODE, portOptions);
if (!smartPortSerialPort) { if (!smartPortSerialPort) {
return; return;

2
src/main/telemetry/telemetry.h
View file

@ -37,7 +37,7 @@ typedef enum {
typedef struct telemetryConfig_s { typedef struct telemetryConfig_s {
uint8_t telemetry_switch; // Use aux channel to change serial output & baudrate( MSP / Telemetry ). It disables automatic switching to Telemetry when armed. uint8_t telemetry_switch; // Use aux channel to change serial output & baudrate( MSP / Telemetry ). It disables automatic switching to Telemetry when armed.
serialInversion_e telemetry_inversion; // also shared with smartport inversion uint8_t telemetry_inversion; // also shared with smartport inversion
float gpsNoFixLatitude; float gpsNoFixLatitude;
float gpsNoFixLongitude; float gpsNoFixLongitude;
frskyGpsCoordFormat_e frsky_coordinate_format; frskyGpsCoordFormat_e frsky_coordinate_format;

4
src/test/unit/telemetry_hott_unittest.cc
View file

@ -187,13 +187,13 @@ void serialSetMode(serialPort_t *instance, portMode_t mode) {
} }
serialPort_t *openSerialPort(serialPortIdentifier_e identifier, serialPortFunction_e functionMask, serialReceiveCallbackPtr callback, uint32_t baudRate, portMode_t mode, serialInversion_e inversion) { serialPort_t *openSerialPort(serialPortIdentifier_e identifier, serialPortFunction_e functionMask, serialReceiveCallbackPtr callback, uint32_t baudRate, portMode_t mode, portOptions_t options) {
UNUSED(identifier); UNUSED(identifier);
UNUSED(functionMask); UNUSED(functionMask);
UNUSED(baudRate); UNUSED(baudRate);
UNUSED(callback); UNUSED(callback);
UNUSED(mode); UNUSED(mode);
UNUSED(inversion); UNUSED(options);
return NULL; return NULL;
} }