feat: Major serial driver re-write - see #1089 for details

Serial refactor
This commit is contained in:
Peter Feerick
2022-03-21 19:58:26 +10:00
committed by GitHub
717 changed files with 942251 additions and 4095 deletions
+2 -1
View File
@@ -164,7 +164,7 @@ endif()
if(HAPTIC)
add_definitions(-DHAPTIC)
set(SRC ${SRC} haptic.cpp)
set(TARGET_SRC ${TARGET_SRC} haptic_driver.cpp)
set(FIRMWARE_TARGET_SRC ${FIRMWARE_TARGET_SRC} haptic_driver.cpp)
endif()
# Protocols supported
@@ -268,6 +268,7 @@ add_definitions(-g)
add_definitions(-DCPUARM)
add_definitions(-DGPS)
add_definitions(-DBATTGRAPH -DTHRTRACE)
add_definitions(-DSBUS_TRAINER)
include_directories(${RTOS_DIR}/include)
@@ -29,7 +29,6 @@ set(STM32USB_SRC
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
../common/arm/stm32/rtc_driver.cpp
${AUX_SERIAL_DRIVER}
../common/arm/stm32/delays_driver.cpp
../common/arm/stm32/usb_bsp.c
../common/arm/stm32/usbd_desc.c
@@ -40,6 +39,18 @@ set(FIRMWARE_TARGET_SRC
../common/arm/stm32/usbd_hid_joystick.c
)
if(AUX_SERIAL OR AUX2_SERIAL)
set(FIRMWARE_TARGET_SRC ${FIRMWARE_TARGET_SRC}
../common/arm/stm32/aux_serial_driver.cpp
)
if(AUX_SERIAL)
add_definitions(-DAUX_SERIAL)
endif()
if(AUX2_SERIAL)
add_definitions(-DAUX2_SERIAL)
endif()
endif()
if(DEBUG OR CLI OR USB_SERIAL)
set(STM32USB_SRC
${STM32USB_SRC}
@@ -70,7 +81,6 @@ endif()
set(FIRMWARE_SRC
${FIRMWARE_SRC}
serial.cpp
syscalls.c
)
@@ -19,415 +19,259 @@
* GNU General Public License for more details.
*/
#include "stm32_hal_ll.h"
#include "stm32_usart_driver.h"
#include "opentx.h"
#include "targets/horus/board.h"
#include "aux_serial_driver.h"
#include "fifo.h"
#include "dmafifo.h"
#define AUX_SERIAL_TX_BUFFER 512
#if defined(SDRAM)
#define AUX_SERIAL_RX_BUFFER 128
#else
#define AUX_SERIAL_RX_BUFFER 32
#endif
typedef Fifo<uint8_t, AUX_SERIAL_TX_BUFFER> TxFifo;
typedef DMAFifo<AUX_SERIAL_RX_BUFFER> RxFifo;
struct SerialState
{
TxFifo* txFifo;
RxFifo* rxFifo;
const stm32_usart_t* usart;
};
static void* aux_serial_init(const SerialState* st, const etx_serial_init* params)
{
stm32_usart_init(st->usart, params);
if (params->rx_enable && st->usart->rxDMA && !params->on_receive) {
st->rxFifo->clear();
stm32_usart_init_rx_dma(st->usart, st->rxFifo->buffer(), st->rxFifo->size());
}
return (void*)st;
}
static void aux_serial_putc(void* ctx, uint8_t c)
{
auto st = (const SerialState*)ctx;
if (st->txFifo->isFull()) return;
st->txFifo->push(c);
// Send is based on IRQ, so that this
// only enables the corresponding IRQ
stm32_usart_send_buffer(st->usart, &c, 1);
}
static void aux_serial_send_buffer(void* ctx, const uint8_t* data, uint8_t size)
{
while(size > 0) {
aux_serial_putc(ctx, *data++);
size--;
}
}
static void aux_wait_tx_completed(void* ctx)
{
// TODO
(void)ctx;
}
static int aux_get_byte(void* ctx, uint8_t* data)
{
auto st = (const SerialState*)ctx;
if (!st->rxFifo) return -1;
return st->rxFifo->pop(*data);
}
void aux_serial_deinit(void* ctx)
{
auto st = (const SerialState*)ctx;
stm32_usart_deinit(st->usart);
}
#if defined(AUX_SERIAL)
uint8_t auxSerialMode = UART_MODE_COUNT; // Prevent debug output before port is setup
Fifo<uint8_t, 512> auxSerialTxFifo;
#if defined(AUX_SERIAL_DMA_Stream_RX)
AuxSerialRxFifo auxSerialRxFifo __DMA (AUX_SERIAL_DMA_Stream_RX);
#else
AuxSerialRxFifo auxSerialRxFifo;
#endif
static TxFifo auxSerialTxFifo;
static RxFifo auxSerialRxFifo __DMA (AUX_SERIAL_DMA_Stream_RX);
void auxSerialSetup(unsigned int baudrate, bool dma, uint16_t length, uint16_t parity, uint16_t stop)
static const LL_GPIO_InitTypeDef auxUSARTPinInit = {
.Pin = AUX_SERIAL_GPIO_PIN_TX | AUX_SERIAL_GPIO_PIN_RX,
.Mode = LL_GPIO_MODE_ALTERNATE,
.Speed = LL_GPIO_SPEED_FREQ_LOW,
.OutputType = LL_GPIO_OUTPUT_PUSHPULL,
.Pull = LL_GPIO_PULL_UP,
.Alternate = AUX_SERIAL_GPIO_AF_LL,
};
static const stm32_usart_t auxUSART = {
.USARTx = AUX_SERIAL_USART,
.GPIOx = AUX_SERIAL_GPIO,
.pinInit = &auxUSARTPinInit,
.IRQn = AUX_SERIAL_USART_IRQn,
.IRQ_Prio = 7, // TODO: define constant
.txDMA = nullptr,
.txDMA_Stream = 0,
.txDMA_Channel = 0,
.rxDMA = AUX_SERIAL_DMA_RX,
.rxDMA_Stream = AUX_SERIAL_DMA_Stream_RX_LL,
.rxDMA_Channel = AUX_SERIAL_DMA_Channel_RX,
};
static const SerialState auxSerialState = {
.txFifo = &auxSerialTxFifo,
.rxFifo = &auxSerialRxFifo,
.usart = &auxUSART,
};
// TODO: grab context to get buffer
static uint8_t auxSerialOnSend(uint8_t* data)
{
USART_InitTypeDef USART_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_PinAFConfig(AUX_SERIAL_GPIO, AUX_SERIAL_GPIO_PinSource_RX, AUX_SERIAL_GPIO_AF);
GPIO_PinAFConfig(AUX_SERIAL_GPIO, AUX_SERIAL_GPIO_PinSource_TX, AUX_SERIAL_GPIO_AF);
GPIO_InitStructure.GPIO_Pin = AUX_SERIAL_GPIO_PIN_TX | AUX_SERIAL_GPIO_PIN_RX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(AUX_SERIAL_GPIO, &GPIO_InitStructure);
#if defined(AUX_SERIAL_PWR_GPIO)
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = AUX_SERIAL_PWR_GPIO_PIN;
GPIO_Init(AUX_SERIAL_PWR_GPIO, &GPIO_InitStructure);
#endif
USART_InitStructure.USART_BaudRate = baudrate;
USART_InitStructure.USART_WordLength = length;
USART_InitStructure.USART_StopBits = stop;
USART_InitStructure.USART_Parity = parity;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_Init(AUX_SERIAL_USART, &USART_InitStructure);
#if defined(AUX_SERIAL_TX_INVERT_GPIO_PIN)
GPIO_InitStructure.GPIO_Pin = AUX_SERIAL_TX_INVERT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_Init(AUX_SERIAL_TX_INVERT_GPIO, &GPIO_InitStructure);
GPIO_ResetBits(AUX_SERIAL_TX_INVERT_GPIO, AUX_SERIAL_TX_INVERT_GPIO_PIN);
#endif
#if defined(AUX_SERIAL_RX_INVERT_GPIO_PIN)
GPIO_InitStructure.GPIO_Pin = AUX_SERIAL_RX_INVERT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_Init(AUX_SERIAL_RX_INVERT_GPIO, &GPIO_InitStructure);
GPIO_ResetBits(AUX_SERIAL_RX_INVERT_GPIO, AUX_SERIAL_RX_INVERT_GPIO_PIN);
#endif
#if defined(AUX_SERIAL_DMA_Stream_RX)
if (dma) {
DMA_InitTypeDef DMA_InitStructure;
auxSerialRxFifo.clear();
USART_ITConfig(AUX_SERIAL_USART, USART_IT_RXNE, DISABLE);
USART_ITConfig(AUX_SERIAL_USART, USART_IT_TXE, DISABLE);
DMA_InitStructure.DMA_Channel = AUX_SERIAL_DMA_Channel_RX;
DMA_InitStructure.DMA_PeripheralBaseAddr = CONVERT_PTR_UINT(&AUX_SERIAL_USART->DR);
DMA_InitStructure.DMA_Memory0BaseAddr = CONVERT_PTR_UINT(auxSerialRxFifo.buffer());
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_BufferSize = auxSerialRxFifo.size();
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(AUX_SERIAL_DMA_Stream_RX, &DMA_InitStructure);
USART_DMACmd(AUX_SERIAL_USART, USART_DMAReq_Rx, ENABLE);
USART_Cmd(AUX_SERIAL_USART, ENABLE);
DMA_Cmd(AUX_SERIAL_DMA_Stream_RX, ENABLE);
return;
}
#endif
// no DMA ...
USART_Cmd(AUX_SERIAL_USART, ENABLE);
USART_ITConfig(AUX_SERIAL_USART, USART_IT_RXNE, ENABLE);
USART_ITConfig(AUX_SERIAL_USART, USART_IT_TXE, DISABLE);
NVIC_SetPriority(AUX_SERIAL_USART_IRQn, 7);
NVIC_EnableIRQ(AUX_SERIAL_USART_IRQn);
return auxSerialTxFifo.pop(*data);
}
void auxSerialInit(unsigned int mode, unsigned int protocol)
// TODO: add to state
static etx_serial_callbacks_t auxSerialCb = {
.on_send = auxSerialOnSend,
.on_receive = nullptr,
.on_error = nullptr,
};
static void* auxSerialInit(const etx_serial_init* params)
{
auxSerialStop();
return aux_serial_init(&auxSerialState, params);
}
auxSerialMode = mode;
static void (*aux1RxCb)(uint8_t*, uint32_t);
switch (mode) {
case UART_MODE_TELEMETRY_MIRROR:
#if defined(CROSSFIRE)
if (protocol == PROTOCOL_TELEMETRY_CROSSFIRE) {
auxSerialSetup(CROSSFIRE_TELEM_MIRROR_BAUDRATE, false);
AUX_SERIAL_POWER_ON();
break;
}
#endif
auxSerialSetup(FRSKY_TELEM_MIRROR_BAUDRATE, false);
AUX_SERIAL_POWER_ON();
break;
static void aux1_on_rx_byte(uint8_t data)
{
if (aux1RxCb) aux1RxCb(&data, 1);
}
#if defined(DEBUG) || defined(CLI)
case UART_MODE_DEBUG:
auxSerialSetup(DEBUG_BAUDRATE, false);
AUX_SERIAL_POWER_OFF();
break;
#endif
case UART_MODE_TELEMETRY:
if (protocol == PROTOCOL_TELEMETRY_FRSKY_D_SECONDARY) {
auxSerialSetup(FRSKY_D_BAUDRATE, true);
AUX_SERIAL_POWER_ON();
}
break;
case UART_MODE_SBUS_TRAINER:
auxSerialSetup(SBUS_BAUDRATE, true, USART_WordLength_9b, USART_Parity_Even, USART_StopBits_2); // USART_WordLength_9b due to parity bit
AUX_SERIAL_POWER_ON();
break;
case UART_MODE_LUA:
auxSerialSetup(LUA_DEFAULT_BAUDRATE, false);
AUX_SERIAL_POWER_ON();
static void aux1SetRxCb(void*, void (*cb)(uint8_t*, uint32_t))
{
aux1RxCb = cb;
if (aux1RxCb) {
auxSerialCb.on_receive = aux1_on_rx_byte;
stm32_usart_deinit_rx_dma(&auxUSART);
} else {
auxSerialCb.on_receive = nullptr;
}
}
void auxSerialPutc(char c)
{
#if !defined(SIMU)
if (auxSerialTxFifo.isFull()) return;
auxSerialTxFifo.push(c);
USART_ITConfig(AUX_SERIAL_USART, USART_IT_TXE, ENABLE);
#endif
}
void auxSerialSbusInit()
{
auxSerialInit(UART_MODE_SBUS_TRAINER, 0);
}
void auxSerialStop()
{
#if defined(AUX_SERIAL_DMA_Stream_RX)
DMA_DeInit(AUX_SERIAL_DMA_Stream_RX);
#endif
USART_DeInit(AUX_SERIAL_USART);
}
uint8_t auxSerialTracesEnabled()
{
#if defined(DEBUG)
return (auxSerialMode == UART_MODE_DEBUG);
#else
return false;
#endif
}
const etx_serial_driver_t AuxSerialDriver = {
.init = auxSerialInit,
.deinit = aux_serial_deinit,
.sendByte = aux_serial_putc,
.sendBuffer = aux_serial_send_buffer,
.waitForTxCompleted = aux_wait_tx_completed,
.getByte = aux_get_byte,
.getBaudrate = nullptr,
.setReceiveCb = aux1SetRxCb,
.setBaudrateCb = nullptr,
};
extern "C" void AUX_SERIAL_USART_IRQHandler(void)
{
DEBUG_INTERRUPT(INT_SER2);
// Send
if (USART_GetITStatus(AUX_SERIAL_USART, USART_IT_TXE) != RESET) {
uint8_t txchar;
if (auxSerialTxFifo.pop(txchar)) {
/* Write one byte to the transmit data register */
USART_SendData(AUX_SERIAL_USART, txchar);
}
else {
USART_ITConfig(AUX_SERIAL_USART, USART_IT_TXE, DISABLE);
}
}
#if defined(CLI)
if (getSelectedUsbMode() != USB_SERIAL_MODE) {
// Receive
uint32_t status = AUX_SERIAL_USART->SR;
while (status & (USART_FLAG_RXNE | USART_FLAG_ERRORS)) {
uint8_t data = AUX_SERIAL_USART->DR;
if (!(status & USART_FLAG_ERRORS)) {
switch (auxSerialMode) {
case UART_MODE_DEBUG:
cliReceiveData(&data, 1);
break;
}
}
status = AUX_SERIAL_USART->SR;
}
}
#endif
// Receive
uint32_t status = AUX_SERIAL_USART->SR;
while (status & (USART_FLAG_RXNE | USART_FLAG_ERRORS)) {
uint8_t data = AUX_SERIAL_USART->DR;
UNUSED(data);
if (!(status & USART_FLAG_ERRORS)) {
#if defined(LUA) & !defined(CLI)
if (luaRxFifo && auxSerialMode == UART_MODE_LUA)
luaRxFifo->push(data);
#endif
}
status = AUX_SERIAL_USART->SR;
}
stm32_usart_isr(&auxUSART, &auxSerialCb);
}
#endif // AUX_SERIAL
#if defined(AUX2_SERIAL)
uint8_t aux2SerialMode = UART_MODE_COUNT; // Prevent debug output before port is setup
Fifo<uint8_t, 512> aux2SerialTxFifo;
AuxSerialRxFifo aux2SerialRxFifo __DMA (AUX2_SERIAL_DMA_Stream_RX);
void aux2SerialSetup(unsigned int baudrate, bool dma, uint16_t length, uint16_t parity, uint16_t stop)
static TxFifo aux2SerialTxFifo;
static RxFifo aux2SerialRxFifo __DMA (AUX2_SERIAL_DMA_Stream_RX);
static const LL_GPIO_InitTypeDef aux2USARTPinInit = {
.Pin = AUX2_SERIAL_GPIO_PIN_TX | AUX2_SERIAL_GPIO_PIN_RX,
.Mode = LL_GPIO_MODE_ALTERNATE,
.Speed = LL_GPIO_SPEED_FREQ_LOW,
.OutputType = LL_GPIO_OUTPUT_PUSHPULL,
.Pull = LL_GPIO_PULL_UP,
.Alternate = AUX2_SERIAL_GPIO_AF_LL,
};
static const stm32_usart_t aux2USART = {
.USARTx = AUX2_SERIAL_USART,
.GPIOx = AUX2_SERIAL_GPIO,
.pinInit = &aux2USARTPinInit,
.IRQn = AUX2_SERIAL_USART_IRQn,
.IRQ_Prio = 7, // TODO: define constant
.txDMA = nullptr,
.txDMA_Stream = 0,
.txDMA_Channel = 0,
.rxDMA = AUX2_SERIAL_DMA_RX,
.rxDMA_Stream = AUX2_SERIAL_DMA_Stream_RX_LL,
.rxDMA_Channel = AUX2_SERIAL_DMA_Channel_RX,
};
static const SerialState aux2SerialState = {
.txFifo = &aux2SerialTxFifo,
.rxFifo = &aux2SerialRxFifo,
.usart = &aux2USART,
};
static uint8_t aux2SerialOnSend(uint8_t* data)
{
USART_InitTypeDef USART_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
return aux2SerialTxFifo.pop(*data);
}
GPIO_PinAFConfig(AUX2_SERIAL_GPIO, AUX2_SERIAL_GPIO_PinSource_RX, AUX2_SERIAL_GPIO_AF);
GPIO_PinAFConfig(AUX2_SERIAL_GPIO, AUX2_SERIAL_GPIO_PinSource_TX, AUX2_SERIAL_GPIO_AF);
static etx_serial_callbacks_t aux2SerialCb = {
.on_send = aux2SerialOnSend,
.on_receive = nullptr,
.on_error = nullptr,
};
GPIO_InitStructure.GPIO_Pin = AUX2_SERIAL_GPIO_PIN_TX | AUX2_SERIAL_GPIO_PIN_RX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(AUX2_SERIAL_GPIO, &GPIO_InitStructure);
static void* aux2SerialInit(const etx_serial_init* params)
{
return aux_serial_init(&aux2SerialState, params);
}
#if defined(AUX2_SERIAL_PWR_GPIO)
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = AUX2_SERIAL_PWR_GPIO_PIN;
GPIO_Init(AUX2_SERIAL_PWR_GPIO, &GPIO_InitStructure);
#endif
static void (*aux2RxCb)(uint8_t*, uint32_t);
USART_InitStructure.USART_BaudRate = baudrate;
USART_InitStructure.USART_WordLength = length;
USART_InitStructure.USART_StopBits = stop;
USART_InitStructure.USART_Parity = parity;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_Init(AUX2_SERIAL_USART, &USART_InitStructure);
static void aux2_on_rx_byte(uint8_t data)
{
if (aux2RxCb) aux2RxCb(&data, 1);
}
if (dma) {
DMA_InitTypeDef DMA_InitStructure;
aux2SerialRxFifo.clear();
USART_ITConfig(AUX2_SERIAL_USART, USART_IT_RXNE, DISABLE);
USART_ITConfig(AUX2_SERIAL_USART, USART_IT_TXE, DISABLE);
DMA_InitStructure.DMA_Channel = AUX2_SERIAL_DMA_Channel_RX;
DMA_InitStructure.DMA_PeripheralBaseAddr = CONVERT_PTR_UINT(&AUX2_SERIAL_USART->DR);
DMA_InitStructure.DMA_Memory0BaseAddr = CONVERT_PTR_UINT(aux2SerialRxFifo.buffer());
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_BufferSize = aux2SerialRxFifo.size();
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(AUX2_SERIAL_DMA_Stream_RX, &DMA_InitStructure);
USART_DMACmd(AUX2_SERIAL_USART, USART_DMAReq_Rx, ENABLE);
USART_Cmd(AUX2_SERIAL_USART, ENABLE);
DMA_Cmd(AUX2_SERIAL_DMA_Stream_RX, ENABLE);
static void aux2SetRxCb(void*, void (*cb)(uint8_t*, uint32_t))
{
aux2RxCb = cb;
if (aux2RxCb) {
aux2SerialCb.on_receive = aux2_on_rx_byte;
stm32_usart_deinit_rx_dma(&aux2USART);
} else {
aux2SerialCb.on_receive = nullptr;
}
else {
USART_Cmd(AUX2_SERIAL_USART, ENABLE);
USART_ITConfig(AUX2_SERIAL_USART, USART_IT_RXNE, ENABLE);
USART_ITConfig(AUX2_SERIAL_USART, USART_IT_TXE, DISABLE);
NVIC_SetPriority(AUX2_SERIAL_USART_IRQn, 7);
NVIC_EnableIRQ(AUX2_SERIAL_USART_IRQn);
}
}
void aux2SerialInit(unsigned int mode, unsigned int protocol)
{
aux2SerialStop();
aux2SerialMode = mode;
switch (mode) {
case UART_MODE_TELEMETRY_MIRROR:
#if defined(CROSSFIRE)
if (protocol == PROTOCOL_TELEMETRY_CROSSFIRE) {
aux2SerialSetup(CROSSFIRE_TELEM_MIRROR_BAUDRATE, false);
AUX2_SERIAL_POWER_ON();
break;
}
#endif
aux2SerialSetup(FRSKY_TELEM_MIRROR_BAUDRATE, false);
AUX2_SERIAL_POWER_ON();
break;
#if defined(DEBUG) || defined(CLI)
case UART_MODE_DEBUG:
aux2SerialSetup(DEBUG_BAUDRATE, false);
AUX2_SERIAL_POWER_OFF();
break;
#endif
case UART_MODE_TELEMETRY:
if (protocol == PROTOCOL_TELEMETRY_FRSKY_D_SECONDARY) {
aux2SerialSetup(FRSKY_D_BAUDRATE, true);
AUX2_SERIAL_POWER_ON();
}
break;
case UART_MODE_SBUS_TRAINER:
aux2SerialSetup(SBUS_BAUDRATE, true, USART_WordLength_9b, USART_Parity_Even, USART_StopBits_2); // 2 stop bits requires USART_WordLength_9b
AUX2_SERIAL_POWER_ON();
break;
case UART_MODE_LUA:
aux2SerialSetup(LUA_DEFAULT_BAUDRATE, false);
AUX2_SERIAL_POWER_ON();
}
}
void aux2SerialPutc(char c)
{
#if !defined(SIMU)
if (aux2SerialTxFifo.isFull()) return;
aux2SerialTxFifo.push(c);
USART_ITConfig(AUX2_SERIAL_USART, USART_IT_TXE, ENABLE);
#endif
}
void aux2SerialSbusInit()
{
aux2SerialInit(UART_MODE_SBUS_TRAINER, 0);
}
void aux2SerialStop()
{
DMA_DeInit(AUX2_SERIAL_DMA_Stream_RX);
USART_DeInit(AUX2_SERIAL_USART);
}
uint8_t aux2SerialTracesEnabled()
{
#if defined(DEBUG)
return (aux2SerialMode == UART_MODE_DEBUG);
#else
return false;
#endif
}
extern "C" void AUX2_SERIAL_USART_IRQHandler(void)
{
DEBUG_INTERRUPT(INT_SER2);
// Send
if (USART_GetITStatus(AUX2_SERIAL_USART, USART_IT_TXE) != RESET) {
uint8_t txchar;
if (aux2SerialTxFifo.pop(txchar)) {
/* Write one byte to the transmit data register */
USART_SendData(AUX2_SERIAL_USART, txchar);
}
else {
USART_ITConfig(AUX2_SERIAL_USART, USART_IT_TXE, DISABLE);
}
}
#if defined(CLI)
if (getSelectedUsbMode() != USB_SERIAL_MODE) {
// Receive
uint32_t status = AUX2_SERIAL_USART->SR;
while (status & (USART_FLAG_RXNE | USART_FLAG_ERRORS)) {
uint8_t data = AUX2_SERIAL_USART->DR;
if (!(status & USART_FLAG_ERRORS)) {
switch (aux2SerialMode) {
case UART_MODE_DEBUG:
cliReceiveData(&data, 1);
break;
}
}
status = AUX2_SERIAL_USART->SR;
}
}
#endif
// Receive
uint32_t status = AUX2_SERIAL_USART->SR;
while (status & (USART_FLAG_RXNE | USART_FLAG_ERRORS)) {
uint8_t data = AUX2_SERIAL_USART->DR;
UNUSED(data);
if (!(status & USART_FLAG_ERRORS)) {
#if defined(LUA) & !defined(CLI)
if (luaRxFifo && aux2SerialMode == UART_MODE_LUA) {
luaRxFifo->push(data);
}
#endif
}
status = AUX2_SERIAL_USART->SR;
}
stm32_usart_isr(&aux2USART, &aux2SerialCb);
}
const etx_serial_driver_t Aux2SerialDriver = {
.init = aux2SerialInit,
.deinit = aux_serial_deinit,
.sendByte = aux_serial_putc,
.sendBuffer = aux_serial_send_buffer,
.waitForTxCompleted = aux_wait_tx_completed,
.getByte = aux_get_byte,
.getBaudrate = nullptr,
.setReceiveCb = aux2SetRxCb,
.setBaudrateCb = nullptr,
};
#endif // AUX2_SERIAL
@@ -0,0 +1,33 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdint.h>
#include "hal/serial_driver.h"
#if defined(AUX_SERIAL)
extern const etx_serial_driver_t AuxSerialDriver;
#endif
#if defined(AUX2_SERIAL)
extern const etx_serial_driver_t Aux2SerialDriver;
#endif
@@ -80,26 +80,8 @@
#endif
#if defined(__cplusplus) && !defined(SIMU)
extern "C" {
#endif
#include "usb_driver.h"
#if !defined(SIMU)
#include "usbd_cdc_core.h"
#include "usbd_msc_core.h"
#include "usbd_hid_core.h"
#include "usbd_usr.h"
#include "usbd_desc.h"
#include "usb_conf.h"
#include "usbd_conf.h"
#endif
#if defined(__cplusplus) && !defined(SIMU)
}
#endif
#if defined(SIMU)
#include "../simu/simpgmspace.h"
#endif
@@ -144,6 +144,7 @@ if(PCB STREQUAL X10 OR PCB STREQUAL X12S OR PCB STREQUAL NV14)
../../../../../${STM32LIB_DIR}/STM32F4xx_StdPeriph_Driver/src/stm32f4xx_usart.c
../../../../../serial.cpp
../../../../../targets/common/arm/stm32/aux_serial_driver.cpp
../../../../../targets/common/arm/stm32/stm32_usart_driver.cpp
)
endif()
else()
@@ -244,12 +244,9 @@ int main()
#endif
delaysInit(); // needed for lcdInit()
#if defined(DEBUG) && defined(AUX_SERIAL)
auxSerialInit(UART_MODE_DEBUG, 0); // default serial mode (None if DEBUG not defined)
#endif
#if defined(DEBUG) && defined(AUX2_SERIAL)
aux2SerialInit(UART_MODE_DEBUG, 0); // default serial mode (None if DEBUG not defined)
#if defined(DEBUG)
initSerialPorts();
#endif
__enable_irq();
+3 -2
View File
@@ -20,8 +20,9 @@
*/
#include <inttypes.h>
#include "definitions.h"
void getCPUUniqueID(char * s);
EXTERN_C(void getCPUUniqueID(char * s));
#define LEN_CPU_UID (3*8+2)
@@ -29,4 +30,4 @@ void getCPUUniqueID(char * s);
extern const uint32_t cpu_uid[3];
#else
extern const uint32_t * cpu_uid;
#endif
#endif
@@ -0,0 +1,178 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "extmodule_driver.h"
#include "stm32_pulse_driver.h"
#include "hal.h"
#include "timers_driver.h"
static const stm32_pulse_timer_t extmoduleTimer = {
.GPIOx = EXTMODULE_TX_GPIO,
.GPIO_Pin = EXTMODULE_TX_GPIO_PIN,
.GPIO_Alternate = EXTMODULE_TIMER_TX_GPIO_AF,
.TIMx = EXTMODULE_TIMER,
.TIM_Prescaler = __LL_TIM_CALC_PSC(EXTMODULE_TIMER_FREQ, 2000000),
.TIM_Channel = EXTMODULE_TIMER_Channel,
.TIM_IRQn = EXTMODULE_TIMER_IRQn,
.DMAx = EXTMODULE_TIMER_DMA,
.DMA_Stream = EXTMODULE_TIMER_DMA_STREAM_LL,
.DMA_Channel = EXTMODULE_TIMER_DMA_CHANNEL,
.DMA_IRQn = EXTMODULE_TIMER_DMA_STREAM_IRQn,
};
// Make sure the timer channel is supported
static_assert(__STM32_PULSE_IS_TIMER_CHANNEL_SUPPORTED(EXTMODULE_TIMER_Channel),
"Unsupported timer channel");
// Make sure the DMA channel is supported
static_assert(__STM32_PULSE_IS_DMA_STREAM_SUPPORTED(EXTMODULE_TIMER_DMA_STREAM_LL),
"Unsupported DMA stream");
#if !defined(EXTMODULE_TIMER_DMA_IRQHandler)
#error "Missing EXTMODULE_TIMER_DMA_IRQHandler definition"
#endif
extern "C" void EXTMODULE_TIMER_DMA_IRQHandler()
{
stm32_pulse_dma_tc_isr(&extmoduleTimer);
}
#if !defined(EXTMODULE_TIMER_IRQHandler)
#error "Missing EXTMODULE_TIMER_IRQHandler definition"
#endif
extern "C" void EXTMODULE_TIMER_IRQHandler()
{
stm32_pulse_tim_update_isr(&extmoduleTimer);
}
void extmoduleStop()
{
EXTERNAL_MODULE_OFF();
stm32_pulse_deinit(&extmoduleTimer);
}
static void config_ppm_output(uint16_t ppm_delay, bool polarity)
{
// PPM generation principle:
//
// Hardware timer in PWM mode is used for PPM generation
// Output is OFF if CNT<CCR1(delay) and ON if bigger
// CCR1 register defines duration of pulse length and is constant
// AAR register defines duration of each pulse, it is
// updated after every pulse in Update interrupt handler.
stm32_pulse_config_output(&extmoduleTimer, !polarity, LL_TIM_OCMODE_PWM1,
ppm_delay * 2);
}
void extmodulePpmStart(uint16_t ppm_delay, bool polarity)
{
EXTERNAL_MODULE_ON();
stm32_pulse_init(&extmoduleTimer);
config_ppm_output(ppm_delay, polarity);
}
void extmoduleSendNextFramePpm(void* pulses, uint16_t length,
uint16_t ppm_delay, bool polarity)
{
if (!stm32_pulse_if_not_running_disable(&extmoduleTimer))
return;
// Set polarity
stm32_pulse_set_polarity(&extmoduleTimer, !polarity);
// Start DMA request and re-enable timer
stm32_pulse_start_dma_req(&extmoduleTimer, pulses, length,
LL_TIM_OCMODE_PWM1, ppm_delay * 2);
}
#if defined(PXX1)
void extmodulePxx1PulsesStart()
{
EXTERNAL_MODULE_ON();
stm32_pulse_config_output(&extmoduleTimer, false, LL_TIM_OCMODE_PWM1, 9 * 2);
stm32_pulse_init(&extmoduleTimer);
}
void extmoduleSendNextFramePxx1(const void* pulses, uint16_t length)
{
if (!stm32_pulse_if_not_running_disable(&extmoduleTimer)) return;
// Start DMA request and re-enable timer
stm32_pulse_start_dma_req(&extmoduleTimer, pulses, length, LL_TIM_OCMODE_PWM1,
9 * 2);
}
#endif
// TODO: polarity?
void extmoduleSerialStart()
{
EXTERNAL_MODULE_ON();
stm32_pulse_init(&extmoduleTimer);
stm32_pulse_config_output(&extmoduleTimer, true, LL_TIM_OCMODE_TOGGLE, 0);
}
void extmoduleSendNextFrameSoftSerial(const void* pulses, uint16_t length, bool polarity)
{
if (!stm32_pulse_if_not_running_disable(&extmoduleTimer))
return;
// Set polarity
stm32_pulse_set_polarity(&extmoduleTimer, polarity);
// Start DMA request and re-enable timer
stm32_pulse_start_dma_req(&extmoduleTimer, pulses, length, LL_TIM_OCMODE_TOGGLE, 0);
}
// Delay based byte sending @ 57600 bps
void extmoduleSendInvertedByte(uint8_t byte)
{
uint16_t time;
uint32_t i;
__disable_irq();
time = getTmr2MHz();
LL_GPIO_SetOutputPin(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
while ((uint16_t) (getTmr2MHz() - time) < 34) {
// wait
}
time += 34;
for (i = 0; i < 8; i++) {
if (byte & 1) {
LL_GPIO_ResetOutputPin(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
}
else {
LL_GPIO_SetOutputPin(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
}
byte >>= 1 ;
while ((uint16_t) (getTmr2MHz() - time) < 35) {
// wait
}
time += 35 ;
}
LL_GPIO_ResetOutputPin(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
__enable_irq(); // No need to wait for the stop bit to complete
while ((uint16_t) (getTmr2MHz() - time) < 34) {
// wait
}
}
@@ -0,0 +1,44 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#include <stdint.h>
void extmoduleStop();
void extmodulePpmStart(uint16_t ppm_delay, bool polarity);
#if defined(PXX1)
void extmodulePxx1PulsesStart();
void extmoduleSendNextFramePxx1(const void* pulses, uint16_t length);
#endif
// Soft serial on PPM pin
void extmoduleSerialStart();
void extmoduleSendNextFramePpm(void* pulses, uint16_t length,
uint16_t ppm_delay, bool polarity);
void extmoduleSendNextFrameSoftSerial(const void* pulses, uint16_t length,
bool polarity = true);
// Bitbang serial
void extmoduleSendInvertedByte(uint8_t byte);
@@ -0,0 +1,153 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "stm32_hal_ll.h"
#include "extmodule_serial_driver.h"
#include "board.h"
#if defined(EXTMODULE_USART)
#include "stm32_usart_driver.h"
#include "io/frsky_pxx2.h"
ModuleFifo extmoduleFifo;
static etx_serial_callbacks_t extmodule_driver = {
nullptr, nullptr, nullptr
};
void extmoduleFifoReceive(uint8_t data)
{
extmoduleFifo.push(data);
}
void extmoduleFifoError()
{
extmoduleFifo.errors++;
}
static const etx_serial_init extmoduleSerialParams = {
.baudrate = 0,
.parity = ETX_Parity_None,
.stop_bits = ETX_StopBits_One,
.word_length = ETX_WordLength_8,
.rx_enable = true,
.on_receive = extmoduleFifoReceive,
.on_error = extmoduleFifoError,
};
static const LL_GPIO_InitTypeDef extmoduleUSART_PinDef = {
.Pin = EXTMODULE_TX_GPIO_PIN | EXTMODULE_RX_GPIO_PIN,
.Mode = LL_GPIO_MODE_ALTERNATE,
.Speed = LL_GPIO_SPEED_FREQ_LOW,
.OutputType = LL_GPIO_OUTPUT_PUSHPULL,
.Pull = LL_GPIO_PULL_UP,
.Alternate = EXTMODULE_USART_GPIO_AF_LL,
};
static const stm32_usart_t extmoduleUSART = {
.USARTx = EXTMODULE_USART,
.GPIOx = EXTMODULE_TX_GPIO,
.pinInit = &extmoduleUSART_PinDef,
.IRQn = EXTMODULE_USART_IRQn,
.IRQ_Prio = EXTMODULE_USART_IRQ_PRIORITY,
.txDMA = EXTMODULE_USART_TX_DMA,
.txDMA_Stream = EXTMODULE_USART_TX_DMA_STREAM_LL,
.txDMA_Channel = EXTMODULE_USART_TX_DMA_CHANNEL,
.rxDMA = nullptr,
.rxDMA_Stream = 0,
.rxDMA_Channel = 0,
};
static void* extmoduleSerialStart(const etx_serial_init* params)
{
if (!params) return nullptr;
extmodule_driver.on_receive = params->on_receive;
extmodule_driver.on_error = params->on_error;
// UART config
stm32_usart_init(&extmoduleUSART, params);
extmoduleFifo.clear();
return nullptr;
}
void extmoduleInvertedSerialStart(uint32_t baudrate)
{
EXTERNAL_MODULE_ON();
etx_serial_init params(extmoduleSerialParams);
params.baudrate = baudrate;
extmoduleSerialStart(&params);
}
#if defined(PXX1)
void extmodulePxx1SerialStart()
{
EXTERNAL_MODULE_ON();
etx_serial_init params(extmoduleSerialParams);
params.baudrate = EXTMODULE_PXX1_SERIAL_BAUDRATE;
ExtmoduleSerialDriver.init(&params);
}
#endif
void extmoduleSerialStop(void*)
{
stm32_usart_deinit(&extmoduleUSART);
// reset callbacks
extmodule_driver.on_receive = nullptr;
extmodule_driver.on_error = nullptr;
}
static void extmoduleSendByte(void*, uint8_t byte)
{
stm32_usart_send_byte(&extmoduleUSART, byte);
}
static void extmoduleSendBuffer(void*, const uint8_t * data, uint8_t size)
{
if (size == 0) return;
stm32_usart_send_buffer(&extmoduleUSART, data, size);
}
static void extmoduleWaitForTxCompleted(void*)
{
stm32_usart_wait_for_tx_dma(&extmoduleUSART);
}
const etx_serial_driver_t ExtmoduleSerialDriver = {
.init = extmoduleSerialStart,
.deinit = extmoduleSerialStop,
.sendByte = extmoduleSendByte,
.sendBuffer = extmoduleSendBuffer,
.waitForTxCompleted = extmoduleWaitForTxCompleted,
.getByte = nullptr,
.getBaudrate = nullptr,
.setReceiveCb = nullptr,
.setBaudrateCb = nullptr,
};
extern "C" void EXTMODULE_USART_IRQHandler(void)
{
stm32_usart_isr(&extmoduleUSART, &extmodule_driver);
}
#endif // defined(EXTMODULE_USART)
@@ -0,0 +1,42 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#include <stdint.h>
#include "hal/serial_driver.h"
#define EXTMODULE_USART_IRQ_PRIORITY 6
// Callbacks using intmoduleFifo
void extmoduleFifoReceive(uint8_t data);
void extmoduleFifoError();
// void extmoduleSerialStart();
// void extmoduleInvertedSerialStart(uint32_t baudrate);
// void extmoduleSendBuffer(const uint8_t * data, uint8_t size);
// void extmoduleSendNextFrame();
#if defined(PXX1)
void extmodulePxx1SerialStart();
#endif
extern const etx_serial_driver_t ExtmoduleSerialDriver;
@@ -1,11 +1,31 @@
set(CPU_FAMILY STM32)
set(MCU cortex-m3)
set(FPU_FLAGS "")
set(STM32LIB_DIR ${THIRDPARTY_DIR}/STM32F2xx_StdPeriph_Lib_V1.1.0/Libraries)
# STM32 HAL/LL library
set(STM32CUBE_DIR ${THIRDPARTY_DIR}/STM32F2xx_HAL_Driver)
add_library(stm32cube_ll OBJECT EXCLUDE_FROM_ALL
${STM32CUBE_DIR}/Src/stm32f2xx_ll_gpio.c
${STM32CUBE_DIR}/Src/stm32f2xx_ll_tim.c
${STM32CUBE_DIR}/Src/stm32f2xx_ll_dma.c
${STM32CUBE_DIR}/Src/stm32f2xx_ll_usart.c
${STM32CUBE_DIR}/Src/stm32f2xx_ll_rcc.c
)
target_compile_options(stm32cube_ll PRIVATE -DUSE_FULL_LL_DRIVER)
target_include_directories(stm32cube_ll PRIVATE
${STM32CUBE_DIR}/Inc
${THIRDPARTY_DIR}/CMSIS/Device/ST/STM32F2xx/Include
${THIRDPARTY_DIR}/CMSIS/Include)
set(FIRMWARE_SRC ${FIRMWARE_SRC} $<TARGET_OBJECTS:stm32cube_ll>)
# StdPeriph library
set(STM32LIB_DIR ${THIRDPARTY_DIR}/STM32F2xx_StdPeriph_Lib_V1.1.0/Libraries)
include_directories(${STM32LIB_DIR}/STM32F2xx_StdPeriph_Driver/inc)
include_directories(${STM32LIB_DIR}/CMSIS/Device/ST/STM32F2xx/Include)
include_directories(${STM32LIB_DIR}/CMSIS/include)
include_directories(${STM32LIB_DIR}/CMSIS/Include)
add_definitions(-DSTM32F2)
@@ -88,6 +88,7 @@
uint32_t SystemCoreClock = 120000000;
__I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
__I uint8_t APBPrescTable[8] = {0, 0, 0, 0, 1, 2, 3, 4};
/**
* @}
@@ -1,8 +1,29 @@
set(CPU_FAMILY STM32)
set(MCU cortex-m4)
set(FPU_FLAGS "-mfloat-abi=hard -mfpu=fpv4-sp-d16")
set(STM32LIB_DIR ${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries)
# STM32 HAL/LL library
set(STM32CUBE_DIR ${THIRDPARTY_DIR}/STM32F4xx_HAL_Driver)
add_library(stm32cube_ll OBJECT EXCLUDE_FROM_ALL
${STM32CUBE_DIR}/Src/stm32f4xx_ll_gpio.c
${STM32CUBE_DIR}/Src/stm32f4xx_ll_tim.c
${STM32CUBE_DIR}/Src/stm32f4xx_ll_dma.c
${STM32CUBE_DIR}/Src/stm32f4xx_ll_usart.c
${STM32CUBE_DIR}/Src/stm32f4xx_ll_rcc.c
)
target_compile_options(stm32cube_ll PRIVATE -DUSE_FULL_LL_DRIVER)
target_include_directories(stm32cube_ll PRIVATE
${STM32CUBE_DIR}/Inc
${THIRDPARTY_DIR}/CMSIS/Device/ST/STM32F4xx/Include
${THIRDPARTY_DIR}/CMSIS/Include)
set(FIRMWARE_SRC ${FIRMWARE_SRC} $<TARGET_OBJECTS:stm32cube_ll>)
set(BOOTLOADER_SRC ${BOOTLOADER_SRC} $<TARGET_OBJECTS:stm32cube_ll>)
# StdPeriph library
set(STM32LIB_DIR ${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries)
include_directories(${STM32LIB_DIR}/STM32F4xx_StdPeriph_Driver/inc)
include_directories(${STM32LIB_DIR}/CMSIS/Device/ST/STM32F4xx/Include)
include_directories(${STM32LIB_DIR}/CMSIS/Include)
@@ -182,6 +182,7 @@
uint32_t SystemCoreClock = 168000000;
__I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
__I uint8_t APBPrescTable[8] = {0, 0, 0, 0, 1, 2, 3, 4};
/**
* @}
@@ -19,8 +19,12 @@
* GNU General Public License for more details.
*/
#include "opentx.h"
#include "mixer_scheduler.h"
#include "board.h"
#include "debug.h"
#include "heartbeat_driver.h"
#include "timers_driver.h"
#if defined(INTMODULE_HEARTBEAT_GPIO)
@@ -79,9 +83,7 @@ void stop_intmodule_heartbeat()
void check_intmodule_heartbeat()
{
if (EXTI_GetITStatus(INTMODULE_HEARTBEAT_EXTI_LINE) != RESET) {
#if !defined(INTMODULE_USART)
heartbeatCapture.timestamp = getTmr2MHz();
#endif
#if defined(DEBUG_LATENCY)
heartbeatCapture.count++;
#endif
@@ -0,0 +1,36 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
struct HeartbeatCapture {
uint32_t timestamp;
uint8_t valid;
#if defined(DEBUG_LATENCY)
uint32_t count;
#endif
};
extern volatile HeartbeatCapture heartbeatCapture;
void init_intmodule_heartbeat();
void check_intmodule_heartbeat();
void stop_intmodule_heartbeat();
@@ -19,217 +19,147 @@
* GNU General Public License for more details.
*/
#include "opentx.h"
#include "stm32_hal_ll.h"
#include "intmodule_serial_driver.h"
#include "stm32_usart_driver.h"
#include "board.h"
#include "io/frsky_pxx2.h"
ModuleFifo intmoduleFifo;
#if !defined(INTMODULE_DMA_STREAM)
uint8_t * intmoduleTxBufferData;
volatile uint8_t intmoduleTxBufferRemaining;
static uint8_t * intmoduleTxBufferData;
static volatile uint8_t intmoduleTxBufferRemaining;
uint8_t intmoduleTxBufferSend(uint8_t* data)
{
if (intmoduleTxBufferRemaining) {
*data = *(intmoduleTxBufferData++);
intmoduleTxBufferRemaining--;
return true;
}
// buffer is empty
return false;
}
#endif
struct etx_serial_driver {
void (*on_receive)(uint8_t data);
void (*on_error)();
static etx_serial_callbacks_t intmodule_driver = {
#if !defined(INTMODULE_DMA_STREAM)
intmoduleTxBufferSend,
#else
nullptr,
#endif
nullptr, nullptr
};
static etx_serial_driver intmodule_driver = { nullptr, nullptr };
// TODO: move this somewhere else
static void intmoduleFifoReceive(uint8_t data)
void intmoduleFifoReceive(uint8_t data)
{
intmoduleFifo.push(data);
}
static void intmoduleFifoError()
void intmoduleFifoError()
{
intmoduleFifo.errors++;
}
etx_serial_init::etx_serial_init():
baudrate(0),
parity(USART_Parity_No),
stop_bits(USART_StopBits_1),
word_length(USART_WordLength_8b),
rx_enable(false),
// TODO: this should not be needed
on_receive(intmoduleFifoReceive),
on_error(intmoduleFifoError)
{
}
static const LL_GPIO_InitTypeDef intmoduleUSART_PinDef = {
.Pin = INTMODULE_TX_GPIO_PIN | INTMODULE_RX_GPIO_PIN,
.Mode = LL_GPIO_MODE_ALTERNATE,
.Speed = LL_GPIO_SPEED_FREQ_LOW,
.OutputType = LL_GPIO_OUTPUT_PUSHPULL,
.Pull = LL_GPIO_PULL_UP,
.Alternate = INTMODULE_GPIO_AF_LL,
};
static const stm32_usart_t intmoduleUSART = {
.USARTx = INTMODULE_USART,
.GPIOx = INTMODULE_GPIO,
.pinInit = &intmoduleUSART_PinDef,
.IRQn = INTMODULE_USART_IRQn,
.IRQ_Prio = INTMODULE_USART_IRQ_PRIORITY,
.txDMA = INTMODULE_DMA,
.txDMA_Stream = INTMODULE_DMA_STREAM_LL,
.txDMA_Channel = INTMODULE_DMA_CHANNEL,
.rxDMA = nullptr,
.rxDMA_Stream = 0,
.rxDMA_Channel = 0,
};
void intmoduleStop()
{
GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN);
#if defined(INTMODULE_DMA_STREAM)
INTMODULE_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
#endif
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = INTMODULE_TX_GPIO_PIN | INTMODULE_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(INTMODULE_GPIO, &GPIO_InitStructure);
USART_DeInit(INTMODULE_USART);
GPIO_ResetBits(INTMODULE_GPIO, INTMODULE_TX_GPIO_PIN | INTMODULE_RX_GPIO_PIN);
stm32_usart_deinit(&intmoduleUSART);
// reset callbacks
intmodule_driver.on_receive = nullptr;
intmodule_driver.on_error = nullptr;
}
void intmodulePxx1SerialStart()
static void intmoduleStop(void* ctx)
{
etx_serial_init params;
params.baudrate = INTMODULE_PXX1_SERIAL_BAUDRATE;
intmoduleSerialStart(&params);
(void)ctx;
intmoduleStop();
}
void intmoduleSerialStart(const etx_serial_init* params)
void* intmoduleSerialStart(const etx_serial_init* params)
{
if (!params) return;
INTERNAL_MODULE_ON();
if (!params) return nullptr;
// TODO: sanity check parameters
// - the UART seems to block when initialised with baudrate = 0
// init callbacks
intmodule_driver.on_receive = params->on_receive;
intmodule_driver.on_error = params->on_error;
uint32_t baudrate = params->baudrate;
#if !defined(INTMODULE_DMA_STREAM)
// IRQ based TX
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = INTMODULE_USART_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// rco: workaround for high baudrate not supported with
// IRQ based TX.
if (baudrate > 1870000) {
TRACE("limiting baudrate to 1.87 MBit/s");
baudrate = 1870000;
}
#endif
GPIO_PinAFConfig(INTMODULE_GPIO, INTMODULE_GPIO_PinSource_TX, INTMODULE_GPIO_AF);
GPIO_PinAFConfig(INTMODULE_GPIO, INTMODULE_GPIO_PinSource_RX, INTMODULE_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = INTMODULE_TX_GPIO_PIN | INTMODULE_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(INTMODULE_GPIO, &GPIO_InitStructure);
USART_DeInit(INTMODULE_USART);
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = baudrate;
USART_InitStructure.USART_Parity = params->parity;
USART_InitStructure.USART_StopBits = params->stop_bits;
USART_InitStructure.USART_WordLength = params->word_length;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_Init(INTMODULE_USART, &USART_InitStructure);
USART_Cmd(INTMODULE_USART, ENABLE);
if (params->rx_enable) {
USART_ITConfig(INTMODULE_USART, USART_IT_RXNE, ENABLE);
NVIC_SetPriority(INTMODULE_USART_IRQn, 6);
NVIC_EnableIRQ(INTMODULE_USART_IRQn);
}
stm32_usart_init(&intmoduleUSART, params);
return nullptr;
}
#define USART_FLAG_ERRORS (USART_FLAG_ORE | USART_FLAG_NE | USART_FLAG_FE | USART_FLAG_PE)
extern "C" void INTMODULE_USART_IRQHandler(void)
{
#if !defined(INTMODULE_DMA_STREAM)
// Send
if (USART_GetITStatus(INTMODULE_USART, USART_IT_TXE) != RESET) {
if (intmoduleTxBufferRemaining) {
USART_SendData(INTMODULE_USART, intmoduleTxBufferData[0]);
intmoduleTxBufferData++;
intmoduleTxBufferRemaining--;
}
else {
USART_ITConfig(INTMODULE_USART, USART_IT_TXE, DISABLE);
}
}
#endif
// Receive
uint32_t status = INTMODULE_USART->SR;
while (status & (USART_FLAG_RXNE | USART_FLAG_ERRORS)) {
uint8_t data = INTMODULE_USART->DR;
if (status & USART_FLAG_ERRORS) {
if (intmodule_driver.on_error)
intmodule_driver.on_error();
}
else {
if (intmodule_driver.on_receive)
intmodule_driver.on_receive(data);
}
status = INTMODULE_USART->SR;
}
stm32_usart_isr(&intmoduleUSART, &intmodule_driver);
}
void intmoduleSendByte(uint8_t byte)
void intmoduleSendByte(void* ctx, uint8_t byte)
{
while (!(INTMODULE_USART->SR & USART_SR_TXE));
USART_SendData(INTMODULE_USART, byte);
(void)ctx;
stm32_usart_send_byte(&intmoduleUSART, byte);
}
void intmoduleSendBuffer(const uint8_t * data, uint8_t size)
void intmoduleSendBuffer(void* ctx, const uint8_t * data, uint8_t size)
{
(void)ctx;
if (size == 0)
return;
#if defined(INTMODULE_DMA_STREAM)
DMA_InitTypeDef DMA_InitStructure;
DMA_DeInit(INTMODULE_DMA_STREAM);
DMA_InitStructure.DMA_Channel = INTMODULE_DMA_CHANNEL;
DMA_InitStructure.DMA_PeripheralBaseAddr = CONVERT_PTR_UINT(&INTMODULE_USART->DR);
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
DMA_InitStructure.DMA_Memory0BaseAddr = CONVERT_PTR_UINT(data);
DMA_InitStructure.DMA_BufferSize = size;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(INTMODULE_DMA_STREAM, &DMA_InitStructure);
DMA_Cmd(INTMODULE_DMA_STREAM, ENABLE);
USART_DMACmd(INTMODULE_USART, USART_DMAReq_Tx, ENABLE);
#else
#if !defined(INTMODULE_DMA_STREAM)
intmoduleTxBufferData = (uint8_t *)data;
intmoduleTxBufferRemaining = size;
USART_ITConfig(INTMODULE_USART, USART_IT_TXE, ENABLE);
#endif
stm32_usart_send_buffer(&intmoduleUSART, data, size);
}
void intmoduleWaitForTxCompleted()
void intmoduleWaitForTxCompleted(void* ctx)
{
#if !defined(SIMU)
(void)ctx;
#if defined(INTMODULE_DMA_STREAM)
if (DMA_GetCmdStatus(INTMODULE_DMA_STREAM) == ENABLE) {
while(DMA_GetFlagStatus(INTMODULE_DMA_STREAM, INTMODULE_DMA_FLAG_TC) == RESET);
DMA_ClearFlag(INTMODULE_DMA_STREAM, INTMODULE_DMA_FLAG_TC);
}
stm32_usart_wait_for_tx_dma(&intmoduleUSART);
#else
while (intmoduleTxBufferRemaining > 0);
#endif
#endif
}
const etx_serial_driver_t IntmoduleSerialDriver = {
.init = intmoduleSerialStart,
.deinit = intmoduleStop,
.sendByte = intmoduleSendByte,
.sendBuffer = intmoduleSendBuffer,
.waitForTxCompleted = intmoduleWaitForTxCompleted,
.getByte = nullptr,
.getBaudrate = nullptr,
.setReceiveCb = nullptr,
.setBaudrateCb = nullptr,
};
@@ -22,22 +22,12 @@
#pragma once
#include <stdint.h>
#include "hal/serial_driver.h"
struct etx_serial_init {
uint32_t baudrate;
uint16_t parity;
uint16_t stop_bits;
uint16_t word_length;
bool rx_enable;
void (*on_receive)(uint8_t data);
void (*on_error)();
#define INTMODULE_USART_IRQ_PRIORITY 6
etx_serial_init();
};
// Callbacks using intmoduleFifo
void intmoduleFifoReceive(uint8_t data);
void intmoduleFifoError();
void intmoduleSerialStart(const etx_serial_init* params);
void intmoduleSerialStop();
void intmoduleSendByte(uint8_t byte);
void intmoduleSendBuffer(const uint8_t* data, uint8_t size);
void intmoduleWaitForTxCompleted();
extern const etx_serial_driver_t IntmoduleSerialDriver;
@@ -20,6 +20,7 @@
*/
#include "opentx.h"
#include "heartbeat_driver.h"
uint8_t rotencPosition;
@@ -0,0 +1,45 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
extern "C" {
#define USE_FULL_LL_DRIVER
#if defined(STM32F4)
#include "CMSIS/Device/ST/STM32F4xx/Include/stm32f4xx.h"
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_gpio.h"
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_tim.h"
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_dma.h"
#include "STM32F4xx_HAL_Driver/Inc/stm32f4xx_ll_usart.h"
#elif defined(STM32F2)
// Workaround to prevent the other CMSIS header to be included
// and fix some missing items in the old one
#include "thirdparty/CMSIS/Include/cmsis_compiler.h"
#define __CORE_CM3_H_GENERIC
#include "CMSIS/Device/ST/STM32F2xx/Include/stm32f2xx.h"
#include "STM32F2xx_HAL_Driver/Inc/stm32f2xx_ll_gpio.h"
#include "STM32F2xx_HAL_Driver/Inc/stm32f2xx_ll_tim.h"
#include "STM32F2xx_HAL_Driver/Inc/stm32f2xx_ll_dma.h"
#include "STM32F2xx_HAL_Driver/Inc/stm32f2xx_ll_usart.h"
#endif
}
@@ -0,0 +1,257 @@
/*
* Copyright (C) EdgeTx
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "stm32_pulse_driver.h"
#include "definitions.h"
void stm32_pulse_init(const stm32_pulse_timer_t* tim)
{
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = tim->GPIO_Pin;
pinInit.Mode = LL_GPIO_MODE_ALTERNATE;
pinInit.Alternate = tim->GPIO_Alternate;
LL_GPIO_Init(tim->GPIOx, &pinInit);
LL_TIM_InitTypeDef timInit;
LL_TIM_StructInit(&timInit);
// 0.5uS (2Mhz)
timInit.Prescaler = tim->TIM_Prescaler;
timInit.Autoreload = 65535;
LL_TIM_Init(tim->TIMx, &timInit);
// Enable DMA IRQ
NVIC_EnableIRQ(tim->DMA_IRQn);
NVIC_SetPriority(tim->DMA_IRQn, 7);
// Enable timer IRQ
NVIC_EnableIRQ(tim->TIM_IRQn);
NVIC_SetPriority(tim->TIM_IRQn, 7);
}
void stm32_pulse_deinit(const stm32_pulse_timer_t* tim)
{
// Disable IRQs
NVIC_DisableIRQ(tim->DMA_IRQn);
NVIC_DisableIRQ(tim->TIM_IRQn);
// De-init DMA & timer
LL_DMA_DeInit(tim->DMAx, tim->DMA_Stream);
LL_TIM_DeInit(tim->TIMx);
// Reconfigure pin as output
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = tim->GPIO_Pin;
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
LL_GPIO_Init(tim->GPIOx, &pinInit);
}
void stm32_pulse_config_output(const stm32_pulse_timer_t* tim, bool polarity,
uint32_t ocmode, uint32_t cmp_val)
{
LL_TIM_OC_InitTypeDef ocInit;
LL_TIM_OC_StructInit(&ocInit);
ocInit.OCMode = ocmode;
ocInit.CompareValue = cmp_val;
uint32_t channel = tim->TIM_Channel;
if (tim->TIM_Channel != LL_TIM_CHANNEL_CH1N) {
ocInit.OCState = LL_TIM_OCSTATE_ENABLE;
ocInit.OCNState = LL_TIM_OCSTATE_DISABLE;
} else {
ocInit.OCState = LL_TIM_OCSTATE_DISABLE;
ocInit.OCNState = LL_TIM_OCSTATE_ENABLE;
channel = LL_TIM_CHANNEL_CH1;
}
uint32_t ll_polarity;
if (polarity) {
ll_polarity = LL_TIM_OCPOLARITY_HIGH;
} else {
ll_polarity = LL_TIM_OCPOLARITY_LOW;
}
if (tim->TIM_Channel != LL_TIM_CHANNEL_CH1N) {
ocInit.OCPolarity = ll_polarity;
} else {
ocInit.OCNPolarity = ll_polarity;
}
LL_TIM_OC_Init(tim->TIMx, channel, &ocInit);
LL_TIM_OC_EnablePreload(tim->TIMx, channel);
if (IS_TIM_BREAK_INSTANCE(tim->TIMx)) {
LL_TIM_EnableAllOutputs(tim->TIMx);
}
LL_TIM_EnableDMAReq_UPDATE(tim->TIMx);
}
void stm32_pulse_set_polarity(const stm32_pulse_timer_t* tim, bool polarity)
{
uint32_t ll_polarity;
if (polarity) {
ll_polarity = LL_TIM_OCPOLARITY_HIGH;
} else {
ll_polarity = LL_TIM_OCPOLARITY_LOW;
}
LL_TIM_OC_SetPolarity(tim->TIMx, tim->TIM_Channel, ll_polarity);
}
// return true if stopped, false otherwise
bool stm32_pulse_if_not_running_disable(const stm32_pulse_timer_t* tim)
{
if (LL_DMA_IsEnabledStream(tim->DMAx, tim->DMA_Stream))
return false;
// disable timer
LL_TIM_DisableCounter(tim->TIMx);
LL_TIM_DisableIT_UPDATE(tim->TIMx);
return true;
}
static void set_compare_reg(const stm32_pulse_timer_t* tim, uint32_t val)
{
switch(tim->TIM_Channel){
case LL_TIM_CHANNEL_CH1:
case LL_TIM_CHANNEL_CH1N:
LL_TIM_OC_SetCompareCH1(tim->TIMx, val);
break;
case LL_TIM_CHANNEL_CH3:
LL_TIM_OC_SetCompareCH3(tim->TIMx, val);
break;
}
}
static void set_oc_mode(const stm32_pulse_timer_t* tim, uint32_t ocmode)
{
uint32_t channel = tim->TIM_Channel;
if (channel == LL_TIM_CHANNEL_CH1N)
channel = LL_TIM_CHANNEL_CH1;
LL_TIM_OC_SetMode(tim->TIMx, channel, ocmode);
}
void stm32_pulse_start_dma_req(const stm32_pulse_timer_t* tim,
const void* pulses, uint16_t length,
uint32_t ocmode, uint32_t cmp_val)
{
// Re-configure timer output
set_compare_reg(tim, cmp_val);
set_oc_mode(tim, ocmode);
// re-init DMA stream
LL_DMA_DeInit(tim->DMAx, tim->DMA_Stream);
LL_DMA_InitTypeDef dmaInit;
LL_DMA_StructInit(&dmaInit);
// Direction
dmaInit.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
// Source
dmaInit.MemoryOrM2MDstAddress = CONVERT_PTR_UINT(pulses);
dmaInit.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
// Destination
dmaInit.PeriphOrM2MSrcAddress = CONVERT_PTR_UINT(&tim->TIMx->ARR);
dmaInit.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
// Data width
if (IS_TIM_32B_COUNTER_INSTANCE(tim->TIMx)) {
// TODO: try using 16-bit source as well
dmaInit.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
dmaInit.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
} else {
dmaInit.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_HALFWORD;
dmaInit.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_HALFWORD;
}
dmaInit.NbData = length;
dmaInit.Channel = tim->DMA_Channel;
dmaInit.Priority = LL_DMA_PRIORITY_VERYHIGH;
LL_DMA_Init(tim->DMAx, tim->DMA_Stream, &dmaInit);
// Enable TC IRQ
LL_DMA_EnableIT_TC(tim->DMAx, tim->DMA_Stream);
// Enable DMA
LL_TIM_ClearFlag_UPDATE(tim->TIMx);
LL_TIM_DisableDMAReq_UPDATE(tim->TIMx);
LL_TIM_SetCounter(tim->TIMx, 0);
LL_DMA_EnableStream(tim->DMAx, tim->DMA_Stream);
// Trigger update to effect the first DMA transation
// and thus load ARR with the first duration
LL_TIM_EnableDMAReq_UPDATE(tim->TIMx);
LL_TIM_GenerateEvent_UPDATE(tim->TIMx);
// start timer
LL_TIM_EnableCounter(tim->TIMx);
}
static bool check_and_clean_dma_tc_flag(const stm32_pulse_timer_t* tim)
{
switch(tim->DMA_Stream) {
case LL_DMA_STREAM_1:
if (!LL_DMA_IsActiveFlag_TC1(tim->DMAx)) return false;
LL_DMA_ClearFlag_TC1(tim->DMAx);
break;
case LL_DMA_STREAM_5:
if (!LL_DMA_IsActiveFlag_TC5(tim->DMAx)) return false;
LL_DMA_ClearFlag_TC5(tim->DMAx);
break;
case LL_DMA_STREAM_7:
if (!LL_DMA_IsActiveFlag_TC7(tim->DMAx)) return false;
LL_DMA_ClearFlag_TC7(tim->DMAx);
break;
}
return true;
}
void stm32_pulse_dma_tc_isr(const stm32_pulse_timer_t* tim)
{
if (!check_and_clean_dma_tc_flag(tim)) return;
LL_TIM_ClearFlag_UPDATE(tim->TIMx);
LL_TIM_EnableIT_UPDATE(tim->TIMx);
set_compare_reg(tim, 0);
set_oc_mode(tim, LL_TIM_OCMODE_PWM1);
}
void stm32_pulse_tim_update_isr(const stm32_pulse_timer_t* tim)
{
if (!LL_TIM_IsActiveFlag_UPDATE(tim->TIMx))
return;
LL_TIM_ClearFlag_UPDATE(tim->TIMx);
LL_TIM_DisableIT_UPDATE(tim->TIMx);
// Halt pulses by forcing to inactive level
set_oc_mode(tim, LL_TIM_OCMODE_FORCED_INACTIVE);
}
@@ -0,0 +1,71 @@
/*
* Copyright (C) EdgeTx
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#include <stdint.h>
#include "stm32_hal_ll.h"
struct stm32_pulse_timer_t {
GPIO_TypeDef* GPIOx;
uint32_t GPIO_Pin;
uint32_t GPIO_Alternate;
TIM_TypeDef* TIMx;
uint16_t TIM_Prescaler;
uint32_t TIM_Channel;
IRQn_Type TIM_IRQn;
DMA_TypeDef* DMAx;
uint32_t DMA_Stream;
uint32_t DMA_Channel;
IRQn_Type DMA_IRQn;
};
void stm32_pulse_init(const stm32_pulse_timer_t* tim);
void stm32_pulse_deinit(const stm32_pulse_timer_t* tim);
void stm32_pulse_config_output(const stm32_pulse_timer_t* tim, bool polarity,
uint32_t ocmode, uint32_t cmp_val);
void stm32_pulse_set_polarity(const stm32_pulse_timer_t* tim, bool polarity);
// return true if it could be disabled without interrupting a pulse train, false otherwise
bool stm32_pulse_if_not_running_disable(const stm32_pulse_timer_t* tim);
void stm32_pulse_start_dma_req(const stm32_pulse_timer_t* tim,
const void* pulses, uint16_t length,
uint32_t ocmode, uint32_t cmp_val);
// Must be called from DMA TC IRQ handler
void stm32_pulse_dma_tc_isr(const stm32_pulse_timer_t* tim);
// Must be called from timer UPDATE IRQ handler
void stm32_pulse_tim_update_isr(const stm32_pulse_timer_t* tim);
#define __STM32_PULSE_IS_TIMER_CHANNEL_SUPPORTED(ch) \
((ch) == LL_TIM_CHANNEL_CH1 || (ch) == LL_TIM_CHANNEL_CH1N || \
(ch) == LL_TIM_CHANNEL_CH3)
#define __STM32_PULSE_IS_DMA_STREAM_SUPPORTED(stream) \
((stream) == LL_DMA_STREAM_1 || (stream) == LL_DMA_STREAM_5 || \
(stream) == LL_DMA_STREAM_7)
@@ -0,0 +1,259 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "stm32_usart_driver.h"
#include <string.h>
void stm32_usart_init_rx_dma(const stm32_usart_t* usart, void* buffer, uint32_t length)
{
if (!usart->rxDMA) return;
// Disable IRQ based RX
LL_USART_DisableIT_RXNE(usart->USARTx);
// In case TX DMA is used, disable the ISR completely
if (usart->txDMA) {
NVIC_DisableIRQ(usart->IRQn);
}
LL_DMA_InitTypeDef dmaInit;
LL_DMA_StructInit(&dmaInit);
dmaInit.Channel = usart->rxDMA_Channel;
dmaInit.PeriphOrM2MSrcAddress = (uint32_t)&usart->USARTx->DR;
dmaInit.Direction = LL_DMA_DIRECTION_PERIPH_TO_MEMORY;
dmaInit.MemoryOrM2MDstAddress = (uint32_t)buffer;
dmaInit.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
dmaInit.Mode = LL_DMA_MODE_CIRCULAR;
dmaInit.NbData = length;
dmaInit.Priority = LL_DMA_PRIORITY_LOW; // TODO: make it configurable
LL_DMA_Init(usart->rxDMA, usart->rxDMA_Stream, &dmaInit);
LL_USART_EnableDMAReq_RX(usart->USARTx);
// Stream can be enable as the USART has alread been enabled
LL_DMA_EnableStream(usart->rxDMA, usart->rxDMA_Stream);
}
void stm32_usart_deinit_rx_dma(const stm32_usart_t* usart)
{
if (!usart->rxDMA) return;
LL_DMA_DeInit(usart->rxDMA, usart->rxDMA_Stream);
// Enable IRQ based RX
LL_USART_EnableIT_RXNE(usart->USARTx);
NVIC_SetPriority(usart->IRQn, usart->IRQ_Prio);
NVIC_EnableIRQ(usart->IRQn);
}
void stm32_usart_init(const stm32_usart_t* usart, const etx_serial_init* params)
{
LL_USART_DeInit(usart->USARTx);
LL_GPIO_Init(usart->GPIOx, (LL_GPIO_InitTypeDef*)usart->pinInit);
LL_USART_InitTypeDef usartInit;
LL_USART_StructInit(&usartInit);
usartInit.BaudRate = params->baudrate;
uint32_t parity = LL_USART_PARITY_NONE;
switch(params->parity){
case ETX_Parity_None:
parity = LL_USART_PARITY_NONE;
break;
case ETX_Parity_Even:
parity = LL_USART_PARITY_EVEN;
break;
case ETX_Parity_Odd:
parity = LL_USART_PARITY_ODD;
break;
}
usartInit.Parity = parity;
uint16_t stop_bits = LL_USART_STOPBITS_1;
switch(params->stop_bits) {
case ETX_StopBits_One:
stop_bits = LL_USART_STOPBITS_1;
break;
case ETX_StopBits_OneAndHalf:
stop_bits = LL_USART_STOPBITS_1_5;
break;
case ETX_StopBits_Two:
stop_bits = LL_USART_STOPBITS_2;
break;
}
usartInit.StopBits = stop_bits;
if (params->word_length == ETX_WordLength_9) {
usartInit.DataWidth = LL_USART_DATAWIDTH_9B;
} else {
usartInit.DataWidth = LL_USART_DATAWIDTH_8B;
}
usartInit.HardwareFlowControl = LL_USART_HWCONTROL_NONE;
usartInit.TransferDirection = LL_USART_DIRECTION_TX_RX;
LL_USART_Init(usart->USARTx, &usartInit);
LL_USART_Enable(usart->USARTx);
// Enable TX DMA request
if (usart->txDMA) {
LL_USART_EnableDMAReq_TX(usart->USARTx);
}
// Enable RX IRQ
if (params->rx_enable) {
// IRQ based RX
LL_USART_EnableIT_RXNE(usart->USARTx);
}
if (!usart->txDMA || (params->rx_enable && !usart->rxDMA)) {
NVIC_SetPriority(usart->IRQn, usart->IRQ_Prio);
NVIC_EnableIRQ(usart->IRQn);
}
}
void stm32_usart_deinit(const stm32_usart_t* usart)
{
if (usart->rxDMA) {
LL_DMA_DeInit(usart->rxDMA, usart->rxDMA_Stream);
}
if (usart->txDMA) {
LL_DMA_DeInit(usart->txDMA, usart->txDMA_Stream);
}
NVIC_DisableIRQ(usart->IRQn);
LL_USART_DeInit(usart->USARTx);
// Reconfigure pin as output
LL_GPIO_InitTypeDef pinInit;
memcpy(&pinInit, usart->pinInit, sizeof(LL_GPIO_InitTypeDef));
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
pinInit.Pull = LL_GPIO_PULL_NO;
pinInit.Alternate = LL_GPIO_AF_0;
LL_GPIO_Init(usart->GPIOx, &pinInit);
LL_GPIO_ResetOutputPin(usart->GPIOx, pinInit.Pin);
}
void stm32_usart_send_byte(const stm32_usart_t* usart, uint8_t byte)
{
// TODO: split into 2 steps to avoid blocking on send
while (!LL_USART_IsActiveFlag_TXE(usart->USARTx));
LL_USART_TransmitData8(usart->USARTx, byte);
}
void stm32_usart_send_buffer(const stm32_usart_t* usart, const uint8_t * data, uint32_t size)
{
if (usart->txDMA) {
LL_DMA_DeInit(usart->txDMA, usart->txDMA_Stream);
LL_DMA_InitTypeDef dmaInit;
LL_DMA_StructInit(&dmaInit);
dmaInit.Channel = usart->txDMA_Channel;
dmaInit.PeriphOrM2MSrcAddress = (uint32_t)&usart->USARTx->DR;
dmaInit.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
dmaInit.MemoryOrM2MDstAddress = (uint32_t)data;
dmaInit.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
dmaInit.NbData = size;
dmaInit.Priority = LL_DMA_PRIORITY_VERYHIGH; // TODO: make it configurable
LL_DMA_Init(usart->txDMA, usart->txDMA_Stream, &dmaInit);
LL_DMA_EnableStream(usart->txDMA, usart->txDMA_Stream);
return;
} else {
// Please note that we don't use the buffer:
// it should be set internally by the driver user
// and each byte is returned individually by on_send()
LL_USART_EnableIT_TXE(usart->USARTx);
}
}
void stm32_usart_wait_for_tx_dma(const stm32_usart_t* usart)
{
// TODO: check if everything is properly initialised, this seems to block when
// the port has been initialised with a zero baudrate
if (LL_DMA_IsEnabledStream(usart->txDMA, usart->txDMA_Stream)) {
switch(usart->txDMA_Stream) {
case LL_DMA_STREAM_1:
while (LL_DMA_IsActiveFlag_TC1(usart->txDMA));
LL_DMA_ClearFlag_TC1(usart->txDMA);
break;
case LL_DMA_STREAM_3:
while (LL_DMA_IsActiveFlag_TC3(usart->txDMA));
LL_DMA_ClearFlag_TC3(usart->txDMA);
break;
case LL_DMA_STREAM_5:
while (LL_DMA_IsActiveFlag_TC5(usart->txDMA));
LL_DMA_ClearFlag_TC5(usart->txDMA);
break;
case LL_DMA_STREAM_6:
while (LL_DMA_IsActiveFlag_TC6(usart->txDMA));
LL_DMA_ClearFlag_TC6(usart->txDMA);
break;
case LL_DMA_STREAM_7:
while (LL_DMA_IsActiveFlag_TC7(usart->txDMA));
LL_DMA_ClearFlag_TC7(usart->txDMA);
break;
}
}
}
#define USART_FLAG_ERRORS \
(LL_USART_SR_ORE | LL_USART_SR_NE | LL_USART_SR_FE | LL_USART_SR_PE)
void stm32_usart_isr(const stm32_usart_t* usart, etx_serial_callbacks_t* cb)
{
uint32_t status = LL_USART_ReadReg(usart->USARTx, SR);
// Receive: do it first as it is more time critical
if (LL_USART_IsEnabledIT_RXNE(usart->USARTx)) {
// Drain RX
while (status & (LL_USART_SR_RXNE | USART_FLAG_ERRORS)) {
// This will clear the RXNE bit in USART_DR register
uint8_t data = LL_USART_ReadReg(usart->USARTx, DR);
if (status & USART_FLAG_ERRORS) {
if (cb->on_error)
cb->on_error();
}
else {
if (cb->on_receive)
cb->on_receive(data);
}
status = LL_USART_ReadReg(usart->USARTx, SR);
}
}
// IRQ based send: TXE IRQ is enabled only during transfer
if (LL_USART_IsEnabledIT_TXE(usart->USARTx) && (status & LL_USART_SR_TXE)) {
uint8_t data;
if (cb->on_send && cb->on_send(&data)) {
LL_USART_TransmitData8(usart->USARTx, data);
} else {
LL_USART_DisableIT_TXE(usart->USARTx);
}
}
}
@@ -0,0 +1,58 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#include <stdint.h>
#include "hal/serial_driver.h"
#include "stm32_hal_ll.h"
struct stm32_usart_t {
// USART defs
USART_TypeDef* USARTx;
GPIO_TypeDef* GPIOx;
const LL_GPIO_InitTypeDef* pinInit;
// USART IRQ
IRQn_Type IRQn;
uint8_t IRQ_Prio;
// TX DMA defs
DMA_TypeDef* txDMA;
uint32_t txDMA_Stream;
uint32_t txDMA_Channel;
// RX DMA defs
DMA_TypeDef* rxDMA;
uint32_t rxDMA_Stream;
uint32_t rxDMA_Channel;
};
void stm32_usart_init(const stm32_usart_t* usart, const etx_serial_init* params);
void stm32_usart_init_rx_dma(const stm32_usart_t* usart, void* buffer, uint32_t length);
void stm32_usart_deinit(const stm32_usart_t* usart);
void stm32_usart_deinit_rx_dma(const stm32_usart_t* usart);
void stm32_usart_send_byte(const stm32_usart_t* usart, uint8_t byte);
void stm32_usart_send_buffer(const stm32_usart_t* usart, const uint8_t * data, uint32_t size);
void stm32_usart_wait_for_tx_dma(const stm32_usart_t* usart);
void stm32_usart_isr(const stm32_usart_t* usart, etx_serial_callbacks_t* cb);
@@ -52,8 +52,7 @@ void stop1msTimer()
NVIC_DisableIRQ(INTERRUPT_xMS_IRQn);
}
// TODO use the same than board_sky9x.cpp
void interrupt1ms()
static void interrupt1ms()
{
static uint8_t pre_scale; // Used to get 10 Hz counter
@@ -0,0 +1,38 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#if defined(SIMU)
uint16_t getTmr2MHz();
#elif defined(STM32)
#include "board.h"
void init2MhzTimer();
void init1msTimer();
void stop1msTimer();
static inline uint16_t getTmr2MHz() { return TIMER_2MHz_TIMER->CNT; }
#endif
@@ -19,18 +19,24 @@
* GNU General Public License for more details.
*/
#if defined(__cplusplus)
extern "C" {
#endif
#include "usb_dcd_int.h"
#include "usb_bsp.h"
#if defined(__cplusplus)
}
#endif
#include "opentx.h"
#include "debug.h"
#include "usb_driver.h"
extern "C" {
#include "usb_conf.h"
#include "usb_dcd_int.h"
#include "usb_bsp.h"
#include "usbd_cdc_core.h"
#include "usbd_msc_core.h"
#include "usbd_hid_core.h"
#include "usbd_usr.h"
#include "usbd_desc.h"
#include "usbd_conf.h"
}
static bool usbDriverStarted = false;
#if defined(BOOT)
static usbMode selectedUsbMode = USB_MASS_STORAGE_MODE;
@@ -21,6 +21,9 @@
#pragma once
#include "hal/serial_port.h"
#include "definitions.h"
#include <stdbool.h>
#include <stdint.h>
@@ -37,20 +40,19 @@ enum usbMode {
#endif
};
// Control line state bits
#define CTRL_LINE_STATE_DTR (1 << 0)
#define CTRL_LINE_STATE_RTS (1 << 1)
int usbPlugged();
void usbInit();
void usbStart();
void usbStop();
bool usbStarted();
int getSelectedUsbMode();
EXTERN_C(int getSelectedUsbMode());
void setSelectedUsbMode(int mode);
uint32_t usbSerialFreeSpace();
void usbSerialPutc(uint8_t c);
EXTERN_C(uint32_t usbSerialFreeSpace());
uint32_t usbSerialBaudRate(void);
void usbSerialSetReceiveDataCb(void (*cb)(uint8_t* buf, uint32_t len));
void usbSerialSetCtrlLineStateCb(void (*cb)(uint16_t ctrlLineState));
void usbSerialSetBaudRateCb(void (*cb)(uint32_t baud));
extern const etx_serial_port_t UsbSerialPort;
+57 -34
View File
@@ -25,11 +25,13 @@
// include STM32 headers and generic board defs
#include "board_common.h"
#include "usb_driver.h"
extern "C" {
/* Includes ------------------------------------------------------------------*/
#include "usb_conf.h"
#include "usbd_cdc_core.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
@@ -76,9 +78,13 @@ extern "C" const CDC_IF_Prop_TypeDef VCP_fops =
} // extern "C"
static void (*receiveDataCb)(uint8_t* buf, uint32_t len);
static void (*ctrlLineStateCb)(uint16_t ctrlLineState);
static void (*baudRateCb)(uint32_t baud);
static void (*receiveDataCb)(uint8_t*, uint32_t) = nullptr;
// static void* receiveDataCbCtx;
//static void (*ctrlLineStateCb)(uint16_t ctrlLineState);
static void (*baudRateCb)(uint32_t) = nullptr;
// static void* baudRateCbCtx;
bool cdcConnected = false;
@@ -92,8 +98,9 @@ bool cdcConnected = false;
static uint16_t VCP_Init(void)
{
cdcConnected = true;
ctrlLineStateCb = NULL;
baudRateCb = NULL;
// receiveDataCb = nullptr;
// baudRateCb = nullptr;
return USBD_OK;
}
@@ -106,6 +113,9 @@ static uint16_t VCP_Init(void)
static uint16_t VCP_DeInit(void)
{
cdcConnected = false;
receiveDataCb = nullptr;
baudRateCb = nullptr;
return USBD_OK;
}
@@ -156,8 +166,10 @@ static uint16_t VCP_Ctrl (uint32_t Cmd, uint8_t* Buf, uint32_t Len)
case SET_LINE_CODING:
if (plc && (Len == sizeof (*plc))) {
// If a callback is provided, tell the upper driver of changes in baud rate
if (baudRateCb) {
baudRateCb(plc->bitrate);
auto _cb = baudRateCb;
// auto _ctx = baudRateCbCtx;
if (_cb) {
_cb(/*_ctx,*/ plc->bitrate);
}
// Copy into structure to save for later
ust_cpy(&g_lc, plc);
@@ -172,11 +184,11 @@ static uint16_t VCP_Ctrl (uint32_t Cmd, uint8_t* Buf, uint32_t Len)
case SET_CONTROL_LINE_STATE:
// If a callback is provided, tell the upper driver of changes in DTR/RTS state
if (plc && (Len == sizeof (uint16_t))) {
if (ctrlLineStateCb) {
ctrlLineStateCb(*((uint16_t *)Buf));
}
}
// if (plc && (Len == sizeof (uint16_t))) {
// if (ctrlLineStateCb) {
// ctrlLineStateCb(*((uint16_t *)Buf));
// }
// }
break;
case SEND_BREAK:
@@ -205,7 +217,7 @@ uint32_t usbSerialFreeSpace()
1;
}
void usbSerialPutc(uint8_t c)
void usbSerialPutc(void*, uint8_t c)
{
/*
Apparently there is no reliable way to tell if the
@@ -253,42 +265,53 @@ void usbSerialPutc(uint8_t c)
*/
static uint16_t VCP_DataRx (uint8_t* Buf, uint32_t Len)
{
if (receiveDataCb)
receiveDataCb(Buf, Len);
// #if defined(CLI)
// // pass data to CLI
// cliReceiveData(Buf, Len);
// #elif defined(LUA)
// // copy data to the LUA FIFO
// if (luaRxFifo) {
// for (uint32_t i = 0; i < Len; i++) {
// luaRxFifo->push(Buf[i]);
// }
// }
// #endif
auto _rxCb = receiveDataCb;
// auto _ctx = receiveDataCbCtx;
if (_rxCb) _rxCb(/*_ctx,*/ Buf, Len);
return USBD_OK;
}
uint32_t usbSerialBaudRate(void)
uint32_t usbSerialBaudRate(void*)
{
return g_lc.bitrate;
}
void usbSerialSetReceiveDataCb(void (*cb)(uint8_t* buf, uint32_t len))
void usbSerialSetReceiveDataCb(void*, void (*cb)(uint8_t*, uint32_t))
{
// receiveDataCb = nullptr;
// receiveDataCbCtx = cb_ctx;
receiveDataCb = cb;
}
void usbSerialSetBaudRateCb(void (*cb)(uint32_t baud))
void usbSerialSetBaudRateCb(void*, void (*cb)(uint32_t))
{
// baudRateCb = nullptr;
// baudRateCbCtx = cb_ctx;
baudRateCb = cb;
}
void usbSerialSetCtrlLineStateCb(void (*cb)(uint16_t ctrlLineState))
{
ctrlLineStateCb = cb;
}
// void usbSerialSetCtrlLineStateCb(void (*cb)(uint16_t ctrlLineState))
// {
// ctrlLineStateCb = cb;
// }
static const etx_serial_driver_t usbSerialDriver = {
nullptr,
nullptr,
usbSerialPutc,
nullptr,
nullptr,
nullptr,
usbSerialBaudRate,
usbSerialSetReceiveDataCb,
usbSerialSetBaudRateCb,
};
const etx_serial_port_t UsbSerialPort = {
"VCP",
&usbSerialDriver,
nullptr,
};
// /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
@@ -0,0 +1,43 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#define WDG_DURATION 500 /*ms*/
void watchdogInit(unsigned int duration);
#if defined(SIMU)
#define WAS_RESET_BY_WATCHDOG() (false)
#define WAS_RESET_BY_SOFTWARE() (false)
#define WAS_RESET_BY_WATCHDOG_OR_SOFTWARE() (false)
#define WDG_ENABLE(x)
#define WDG_RESET()
#else
#if defined(WATCHDOG)
#define WDG_ENABLE(x) watchdogInit(x)
#define WDG_RESET() IWDG->KR = 0xAAAA
#else
#define WDG_ENABLE(x)
#define WDG_RESET()
#endif
#define WAS_RESET_BY_WATCHDOG() (RCC->CSR & (RCC_CSR_WDGRSTF | RCC_CSR_WWDGRSTF))
#define WAS_RESET_BY_SOFTWARE() (RCC->CSR & RCC_CSR_SFTRSTF)
#define WAS_RESET_BY_WATCHDOG_OR_SOFTWARE() (RCC->CSR & (RCC_CSR_WDGRSTF | RCC_CSR_WWDGRSTF | RCC_CSR_SFTRSTF))
#endif
+44 -67
View File
@@ -54,26 +54,22 @@ set(INTERNAL_MODULES PXX1;PXX2;MULTI;CRSF CACHE STRING "Internal modules")
# VCP CLI
set(ENABLE_SERIAL_PASSTHROUGH ON CACHE BOOL "Enable serial passthrough")
set(CLI ON CACHE BOOL "Enable CLI")
set(AUX_SERIAL ON)
if (PCB STREQUAL X10)
set(PCBREV "STD" CACHE STRING "PCB Revision")
add_definitions(-DPCBX10)
add_definitions(-DSOFTWARE_VOLUME)
set(TARGET_SRC
${TARGET_SRC}
../common/arm/stm32/audio_dac_driver.cpp
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/stm32_hal_adc.cpp
targets/common/arm/stm32/audio_dac_driver.cpp
)
if (NOT PCBREV STREQUAL TX16S)
set(TARGET_SRC
${TARGET_SRC}
../common/arm/stm32/sticks_pwm_driver.cpp
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/sticks_pwm_driver.cpp
)
endif()
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
../common/arm/stm32/stm32_hal_adc.cpp
../../hal/adc_driver.cpp
)
set(BITMAPS_TARGET x10_bitmaps)
set(FONTS_TARGET x10_fonts)
set(LCD_DRIVER lcd_driver.cpp)
@@ -82,6 +78,7 @@ if (PCB STREQUAL X10)
set(FLAVOUR x10express)
set(DEFAULT_INTERNAL_MODULE ISRM_PXX2 CACHE STRING "Default internal module")
set(BLUETOOTH ON)
set(AUX_SERIAL OFF)
add_definitions(-DHARDWARE_POWER_MANAGEMENT_UNIT)
add_definitions(-DRADIO_X10E)
add_definitions(-DMANUFACTURER_FRSKY)
@@ -100,14 +97,12 @@ if (PCB STREQUAL X10)
add_definitions(-DRADIO_FAMILY_T16)
set(DEFAULT_INTERNAL_MODULE MULTIMODULE CACHE STRING "Default internal module")
option(BLUETOOTH "Support for bluetooth module" OFF)
option(INTERNAL_GPS "Support for internal ublox GPS" OFF)
option(INTERNAL_GPS "Support for internal ublox GPS" ON)
set(HARDWARE_TOUCH YES)
set(USB_CHARGER YES)
set(DEFAULT_THEME "DARKBLUE")
set(SBUS_TRAINER ON)
set(AUX_SERIAL ON)
add_definitions(-DMANUFACTURER_RADIOMASTER)
if (NOT BLUETOOTH AND NOT INTERNAL_GPS)
if (NOT BLUETOOTH)
set(AUX2_SERIAL ON)
endif()
set(INTERNAL_GPS_BAUDRATE "9600" CACHE STRING "Baud rate for internal GPS")
@@ -140,14 +135,10 @@ elseif (PCB STREQUAL X12S)
endif()
endif()
set(INTERNAL_GPS_BAUDRATE "9600" CACHE STRING "Baud rate for internal GPS")
add_definitions(-DPCBX12S)
set(TARGET_SRC
${TARGET_SRC}
audio_spi_driver.cpp
)
set(AUX2_SERIAL ON) # wire to GPS
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
../../hal/adc_driver.cpp
audio_spi_driver.cpp
x12s_adc_driver.cpp
)
set(BITMAPS_TARGET x12s_bitmaps)
@@ -157,6 +148,7 @@ elseif (PCB STREQUAL X12S)
add_definitions(-DMANUFACTURER_FRSKY)
endif()
add_definitions(-DPCB${PCB})
add_definitions(-DPCBREV=${PCBREV})
add_definitions(-DPCBREV_${PCBREV})
@@ -166,13 +158,9 @@ set(RADIO_DEPENDENCIES
truetype_fonts
)
if(HARDWARE_EXTERNAL_MODULE)
set(TARGET_SRC ${TARGET_SRC} extmodule_driver.cpp)
endif()
set(FIRMWARE_DEPENDENCIES datacopy)
add_definitions(-DPCBHORUS -DSTM32F429_439xx -DSDRAM -DCCMRAM -DCOLORLCD -DHARDWARE_KEYS)
add_definitions(-DPCBHORUS -DSTM32F429_439xx -DSTM32F429xx -DSDRAM -DCCMRAM -DCOLORLCD -DHARDWARE_KEYS)
add_definitions(-DEEPROM_VARIANT=0 -DAUDIO -DVOICE -DRTCLOCK)
add_definitions(-DGPS_USART_BAUDRATE=${INTERNAL_GPS_BAUDRATE})
add_definitions(-DPWR_BUTTON_${PWR_BUTTON})
@@ -228,23 +216,12 @@ endif()
if(INTERNAL_GPS)
set(SRC ${SRC} gps.cpp)
set(TARGET_SRC ${TARGET_SRC} gps_driver.cpp)
add_definitions(-DINTERNAL_GPS)
message("Horus: Internal GPS enabled")
message("-- Internal GPS enabled")
endif()
set(GVAR_SCREEN model_gvars.cpp)
set(TARGET_SRC
${TARGET_SRC}
led_driver.cpp
trainer_driver.cpp
../common/arm/stm32/mixer_scheduler_driver.cpp
../common/arm/stm32/timers_driver.cpp
../common/arm/stm32/intmodule_serial_driver.cpp
../common/arm/stm32/rotary_encoder_driver.cpp
)
if(HARDWARE_TOUCH)
set(TOUCH_DRIVER tp_gt911.cpp i2c_driver.cpp)
add_definitions(-DHARDWARE_TOUCH)
@@ -252,55 +229,55 @@ if(HARDWARE_TOUCH)
endif()
if(USB_CHARGER)
set(TARGET_SRC ${TARGET_SRC} usb_charger_driver.cpp)
set(FIRMWARE_TARGET_SRC ${FIRMWARE_TARGET_SRC} usb_charger_driver.cpp)
add_definitions(-DUSB_CHARGER)
endif()
if(BLUETOOTH)
add_definitions(-DBLUETOOTH)
set(TARGET_SRC ${TARGET_SRC} ../common/arm/stm32/bluetooth_driver.cpp)
set(SRC ${SRC} bluetooth.cpp)
add_definitions(-DHARDWARE_TRAINER_BLUETOOTH)
endif()
if (AUX_SERIAL)
add_definitions(-DAUX_SERIAL)
set(AUX_SERIAL_DRIVER ../common/arm/stm32/aux_serial_driver.cpp)
endif()
if (AUX2_SERIAL)
add_definitions(-DAUX2_SERIAL)
set(AUX_SERIAL_DRIVER ../common/arm/stm32/aux_serial_driver.cpp)
endif()
if (SBUS_TRAINER)
add_definitions(-DSBUS_TRAINER)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/bluetooth_driver.cpp)
set(SRC
${SRC}
sbus.cpp
)
bluetooth.cpp)
add_definitions(-DHARDWARE_TRAINER_BLUETOOTH)
endif()
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
${LCD_DRIVER}
${AUX_SERIAL_DRIVER}
${FLYSKY_HALL_STICKS_DRIVER}
${IMU_LSM6DS33_DRIVER}
${TOUCH_DRIVER}
board.cpp
backlight_driver.cpp
../common/arm/stm32/pwr_driver.cpp
led_driver.cpp
trainer_driver.cpp
sdram_driver.c
startup_stm32f42_43xxx.s
../common/arm/stm32/heartbeat_driver.cpp
../common/arm/stm32/sdio_sd.c
)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
hal/adc_driver.cpp
targets/common/arm/stm32/mixer_scheduler_driver.cpp
targets/common/arm/stm32/timers_driver.cpp
targets/common/arm/stm32/intmodule_serial_driver.cpp
targets/common/arm/stm32/extmodule_driver.cpp
targets/common/arm/stm32/stm32_pulse_driver.cpp
targets/common/arm/stm32/extmodule_serial_driver.cpp
targets/common/arm/stm32/stm32_usart_driver.cpp
targets/common/arm/stm32/rotary_encoder_driver.cpp
targets/common/arm/stm32/pwr_driver.cpp
targets/common/arm/stm32/heartbeat_driver.cpp
targets/common/arm/stm32/sdio_sd.c
)
if(BOOTLOADER)
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
../common/arm/loadboot.cpp
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/loadboot.cpp
)
endif()
@@ -366,7 +343,7 @@ if(PYTHONINTERP_FOUND)
add_custom_command(
OUTPUT ${PROJECT_BINARY_DIR}/radio/src/datacopy.cpp
WORKING_DIRECTORY ${RADIO_DIRECTORY}/src
COMMAND ${PYTHON_EXECUTABLE} ${RADIO_DIRECTORY}/util/generate_datacopy.py datastructs_private.h -DPCBHORUS -DPCBX10 -DCPUARM -DSTM32F4 -DSTM32F429_439xx -DCOLORLCD -DBACKUP -DSIMU -I. -Igui/colorlcd -Itargets/horus -Itargets/common/arm/stm32 -I${THIRDPARTY_DIR} -I${THIRDPARTY_DIR}/libopenui/src -I${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries/STM32F4xx_StdPeriph_Driver/inc -I${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries/CMSIS/Device/ST/STM32F4xx/Include -I${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries/CMSIS/Include ${gcc_include_path} -Wno-asm-operand-widths -Wno-pragma-once-outside-header ${SYSROOT_ARG} > ${PROJECT_BINARY_DIR}/radio/src/datacopy.cpp
COMMAND ${PYTHON_EXECUTABLE} ${RADIO_DIRECTORY}/util/generate_datacopy.py datastructs_private.h -DPCBHORUS -DPCB${PCB} -DCPUARM -DSTM32F4 -DSTM32F429_439xx -DCOLORLCD -DBACKUP -DSIMU -I. -Igui/colorlcd -Itargets/horus -Itargets/common/arm/stm32 -I${THIRDPARTY_DIR} -I${THIRDPARTY_DIR}/libopenui/src -I${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries/STM32F4xx_StdPeriph_Driver/inc -I${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries/CMSIS/Device/ST/STM32F4xx/Include -I${THIRDPARTY_DIR}/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries/CMSIS/Include ${gcc_include_path} -Wno-asm-operand-widths -Wno-pragma-once-outside-header ${SYSROOT_ARG} > ${PROJECT_BINARY_DIR}/radio/src/datacopy.cpp
DEPENDS ${RADIO_DIRECTORY}/src/datastructs.h ${RADIO_DIRECTORY}/util/generate_datacopy.py
)
+83 -45
View File
@@ -19,27 +19,27 @@
* GNU General Public License for more details.
*/
#include "stm32_hal_ll.h"
#include "opentx.h"
#include "hal/adc_driver.h"
#include "hal/serial_driver.h"
#include "hal/serial_port.h"
#include "timers_driver.h"
#if defined(AUX_SERIAL) || defined(AUX2_SERIAL)
#include "aux_serial_driver.h"
#endif
#if !defined(PCBX12S)
#include "../common/arm/stm32/stm32_hal_adc.h"
#include "stm32_hal_adc.h"
#define ADC_DRIVER stm32_hal_adc_driver
#else
#include "x12s_adc_driver.h"
#define ADC_DRIVER x12s_adc_driver
#endif
#if defined(__cplusplus)
extern "C" {
#endif
#include "usb_dcd_int.h"
#include "usb_bsp.h"
#if defined(__cplusplus)
}
#endif
extern void flysky_hall_stick_check_init(void);
extern void flysky_hall_stick_init(void);
extern void flysky_hall_stick_loop( void );
@@ -57,30 +57,6 @@ void watchdogInit(unsigned int duration)
IWDG->KR = 0xCCCC; // start
}
#if defined(AUX_SERIAL_PWR_GPIO)
void auxSerialPowerOn()
{
GPIO_SetBits(AUX_SERIAL_PWR_GPIO, AUX_SERIAL_PWR_GPIO_PIN);
}
void auxSerialPowerOff()
{
GPIO_ResetBits(AUX_SERIAL_PWR_GPIO, AUX_SERIAL_PWR_GPIO_PIN);
}
#endif
#if defined(AUX2_SERIAL_PWR_GPIO)
void aux2SerialPowerOn()
{
GPIO_SetBits(AUX2_SERIAL_PWR_GPIO, AUX2_SERIAL_PWR_GPIO_PIN);
}
void aux2SerialPowerOff()
{
GPIO_ResetBits(AUX2_SERIAL_PWR_GPIO, AUX2_SERIAL_PWR_GPIO_PIN);
}
#endif
#if HAS_SPORT_UPDATE_CONNECTOR()
void sportUpdateInit()
{
@@ -141,7 +117,6 @@ void boardInit()
INTMODULE_RCC_AHB1Periph |
EXTMODULE_RCC_AHB1Periph |
I2C_B1_RCC_AHB1Periph |
GPS_RCC_AHB1Periph |
SPORT_UPDATE_RCC_AHB1Periph |
TOUCH_INT_RCC_AHB1Periph |
TOUCH_RST_RCC_AHB1Periph,
@@ -168,7 +143,6 @@ void boardInit()
EXTMODULE_RCC_APB1Periph |
I2C_B1_RCC_APB1Periph |
MIXER_SCHEDULER_TIMER_RCC_APB1Periph |
GPS_RCC_APB1Periph |
BACKLIGHT_RCC_APB1Periph,
ENABLE);
@@ -182,7 +156,6 @@ void boardInit()
BT_RCC_APB2Periph |
AUX_SERIAL_RCC_APB2Periph |
AUX2_SERIAL_RCC_APB2Periph |
GPS_RCC_APB2Periph |
BACKLIGHT_RCC_APB2Periph,
ENABLE);
@@ -192,11 +165,8 @@ void boardInit()
__enable_irq();
#if defined(DEBUG) && defined(AUX_SERIAL)
auxSerialInit(UART_MODE_DEBUG, 0); // default serial mode (None if DEBUG not defined)
#endif
#if defined(DEBUG) && defined(AUX2_SERIAL)
aux2SerialInit(UART_MODE_DEBUG, 0); // default serial mode (None if DEBUG not defined)
#if defined(DEBUG)
serialInit(SP_AUX1, UART_MODE_DEBUG);
#endif
TRACE("\nHorus board started :)");
@@ -260,9 +230,6 @@ void boardInit()
bluetoothInit(BLUETOOTH_DEFAULT_BAUDRATE, true);
#endif
#if defined(INTERNAL_GPS)
gpsInit(GPS_USART_BAUDRATE);
#endif
#if defined(DEBUG)
DBGMCU_APB1PeriphConfig(DBGMCU_IWDG_STOP|DBGMCU_TIM1_STOP|DBGMCU_TIM2_STOP|DBGMCU_TIM3_STOP|DBGMCU_TIM4_STOP|DBGMCU_TIM5_STOP|DBGMCU_TIM6_STOP|DBGMCU_TIM7_STOP|DBGMCU_TIM8_STOP|DBGMCU_TIM9_STOP|DBGMCU_TIM10_STOP|DBGMCU_TIM11_STOP|DBGMCU_TIM12_STOP|DBGMCU_TIM13_STOP|DBGMCU_TIM14_STOP, ENABLE);
@@ -358,3 +325,74 @@ bool isBacklightEnabled()
return true;
return boardBacklightOn;
}
#if defined(AUX_SERIAL_PWR_GPIO) || defined(AUX2_SERIAL_PWR_GPIO)
static void _aux_pwr(GPIO_TypeDef *GPIOx, uint32_t pin, uint8_t on)
{
LL_GPIO_InitTypeDef pinInit;
LL_GPIO_StructInit(&pinInit);
pinInit.Pin = pin;
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
pinInit.Pull = LL_GPIO_PULL_UP;
LL_GPIO_Init(GPIOx, &pinInit);
if (on) {
LL_GPIO_SetOutputPin(GPIOx, pin);
} else {
LL_GPIO_ResetOutputPin(GPIOx, pin);
}
}
#endif
#if defined(AUX_SERIAL)
void set_aux_pwr(uint8_t on)
{
#if defined(AUX_SERIAL_PWR_GPIO)
_aux_pwr(AUX_SERIAL_PWR_GPIO, AUX_SERIAL_PWR_GPIO_PIN, on);
#endif
}
const etx_serial_port_t auxSerialPort = {
"AUX1",
&AuxSerialDriver,
set_aux_pwr,
};
#define AUX_SERIAL_PORT &auxSerialPort
#else
#define AUX_SERIAL_PORT nullptr
#endif
#if defined(AUX2_SERIAL)
void set_aux2_pwr(uint8_t on)
{
#if defined(AUX2_SERIAL_PWR_GPIO)
_aux_pwr(AUX2_SERIAL_PWR_GPIO, AUX2_SERIAL_PWR_GPIO_PIN, on);
#endif
}
const etx_serial_port_t aux2SerialPort = {
#if !defined(PCBX12S)
"AUX2",
#else
// AUX2 is hardwired to the internal GPS
// on the X12S, let's hide the setting
nullptr,
#endif
&Aux2SerialDriver,
set_aux2_pwr,
};
#define AUX2_SERIAL_PORT &aux2SerialPort
#else
#define AUX2_SERIAL_PORT nullptr
#endif // AUX2_SERIAL
static const etx_serial_port_t* serialPorts[MAX_AUX_SERIAL] = {
AUX_SERIAL_PORT,
AUX2_SERIAL_PORT,
};
const etx_serial_port_t* auxSerialGetPort(int port_nr)
{
if (port_nr >= MAX_AUX_SERIAL) return nullptr;
return serialPorts[port_nr];
}
+16 -115
View File
@@ -26,6 +26,9 @@
#include "opentx_constants.h"
#include "board_common.h"
#include "hal.h"
#include "hal/serial_port.h"
#include "watchdog_driver.h"
#if defined(HARDWARE_TOUCH)
#include "tp_gt911.h"
@@ -78,10 +81,6 @@ extern uint16_t sessionTimer;
void boardInit();
void boardOff();
// Timers driver
void init2MhzTimer();
void init1msTimer();
// PCBREV driver
enum {
// X12S
@@ -145,6 +144,10 @@ uint32_t isBootloaderStart(const uint8_t * buffer);
// SDRAM driver
void SDRAM_Init();
#if defined(INTERNAL_MODULE_PXX1) || defined(INTERNAL_MODULE_PXX2)
#define HARDWARE_INTERNAL_RAS
#endif
// Pulses driver
#if defined(RADIO_T18) || defined(RADIO_T16)
@@ -168,20 +171,14 @@ void SDRAM_Init();
#endif
#if defined(INTERNAL_MODULE_PXX1) || defined(INTERNAL_MODULE_PXX2)
#define HARDWARE_INTERNAL_RAS
#endif
#define INTERNAL_MODULE_OFF() GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_ON() GPIO_SetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_OFF() GPIO_ResetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#if defined(INTMODULE_USART)
#define INTERNAL_MODULE_OFF() intmoduleStop()
#else
#define INTERNAL_MODULE_OFF() GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#endif
#define EXTERNAL_MODULE_ON() GPIO_SetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define EXTERNAL_MODULE_OFF() GPIO_ResetBits(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN)
#define IS_INTERNAL_MODULE_ON() (GPIO_ReadInputDataBit(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN) == Bit_SET)
#define IS_EXTERNAL_MODULE_ON() (GPIO_ReadInputDataBit(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN) == Bit_SET)
#define IS_INTERNAL_MODULE_ON() \
(GPIO_ReadInputDataBit(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN) == Bit_SET)
#define IS_EXTERNAL_MODULE_ON() \
(GPIO_ReadInputDataBit(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN) == Bit_SET)
#if !defined(PXX2)
#define IS_PXX2_INTERNAL_ENABLED() (false)
@@ -196,24 +193,12 @@ void SDRAM_Init();
#define IS_PXX1_INTERNAL_ENABLED() (true)
#endif
void init_intmodule_heartbeat();
void check_intmodule_heartbeat();
void extmoduleSerialStart();
void extmoduleInvertedSerialStart(uint32_t baudrate);
void extmoduleSendBuffer(const uint8_t * data, uint8_t size);
void extmoduleSendNextFrame();
void extmoduleSendInvertedByte(uint8_t byte);
// Trainer driver
void init_trainer_ppm();
void stop_trainer_ppm();
void init_trainer_capture();
void stop_trainer_capture();
// SBUS
int sbusGetByte(uint8_t * byte);
// Keys driver
enum EnumKeys
{
@@ -329,29 +314,6 @@ uint32_t readTrims();
void rotaryEncoderInit();
void rotaryEncoderCheck();
// WDT driver
#define WDG_DURATION 500 /*ms*/
void watchdogInit(unsigned int duration);
#if defined(SIMU)
#define WAS_RESET_BY_WATCHDOG() (false)
#define WAS_RESET_BY_SOFTWARE() (false)
#define WAS_RESET_BY_WATCHDOG_OR_SOFTWARE() (false)
#define WDG_ENABLE(x)
#define WDG_RESET()
#else
#if defined(WATCHDOG)
#define WDG_ENABLE(x) watchdogInit(x)
#define WDG_RESET() IWDG->KR = 0xAAAA
#else
#define WDG_ENABLE(x)
#define WDG_RESET()
#endif
#define WAS_RESET_BY_WATCHDOG() (RCC->CSR & (RCC_CSR_WDGRSTF | RCC_CSR_WWDGRSTF))
#define WAS_RESET_BY_SOFTWARE() (RCC->CSR & RCC_CSR_SFTRSTF)
#define WAS_RESET_BY_WATCHDOG_OR_SOFTWARE() (RCC->CSR & (RCC_CSR_WDGRSTF | RCC_CSR_WWDGRSTF | RCC_CSR_SFTRSTF))
#endif
// ADC driver
#if defined(PCBX10)
@@ -659,7 +621,7 @@ void telemetryPortSetDirectionInput();
void telemetryPortSetDirectionOutput();
void sportSendByte(uint8_t byte);
void sportSendBuffer(const uint8_t * buffer, uint32_t count);
bool telemetryGetByte(uint8_t * byte);
bool sportGetByte(uint8_t * byte);
void telemetryClearFifo();
extern uint32_t telemetryErrors;
@@ -690,48 +652,8 @@ void sportUpdatePowerInit();
#define DEBUG_BAUDRATE 115200
#define LUA_DEFAULT_BAUDRATE 115200
#endif
#if defined(AUX_SERIAL)
extern uint8_t auxSerialMode;
#if defined __cplusplus
void auxSerialSetup(unsigned int baudrate, bool dma, uint16_t length = USART_WordLength_8b, uint16_t parity = USART_Parity_No, uint16_t stop = USART_StopBits_1);
#endif
void auxSerialInit(unsigned int mode, unsigned int protocol);
void auxSerialPutc(char c);
#define auxSerialTelemetryInit(protocol) auxSerialInit(UART_MODE_TELEMETRY, protocol)
void auxSerialSbusInit();
void auxSerialStop();
void auxSerialPowerOn();
void auxSerialPowerOff();
#if defined(AUX_SERIAL_PWR_GPIO)
#define AUX_SERIAL_POWER_ON() auxSerialPowerOn()
#define AUX_SERIAL_POWER_OFF() auxSerialPowerOff()
#else
#define AUX_SERIAL_POWER_ON()
#define AUX_SERIAL_POWER_OFF()
#endif
#endif
// Aux2 serial port driver
#if defined(AUX2_SERIAL)
extern uint8_t aux2SerialMode;
#if defined __cplusplus
void aux2SerialSetup(unsigned int baudrate, bool dma, uint16_t length = USART_WordLength_8b, uint16_t parity = USART_Parity_No, uint16_t stop = USART_StopBits_1);
#endif
void aux2SerialInit(unsigned int mode, unsigned int protocol);
void aux2SerialPutc(char c);
#define aux2SerialTelemetryInit(protocol) aux2SerialInit(UART_MODE_TELEMETRY, protocol)
void aux2SerialSbusInit();
void aux2SerialStop();
void aux2SerialPowerOn();
void aux2SerialPowerOff();
#if defined(AUX2_SERIAL_PWR_GPIO)
#define AUX2_SERIAL_POWER_ON() aux2SerialPowerOn()
#define AUX2_SERIAL_POWER_OFF() aux2SerialPowerOff()
#else
#define AUX2_SERIAL_POWER_ON()
#define AUX2_SERIAL_POWER_OFF()
#endif
#endif
const etx_serial_port_t* auxSerialGetPort(int port_nr);
// Haptic driver
void hapticInit();
@@ -739,17 +661,6 @@ void hapticDone();
void hapticOff();
void hapticOn(uint32_t pwmPercent);
// GPS driver
void gpsInit(uint32_t baudrate);
uint8_t gpsGetByte(uint8_t * byte);
#if defined(DEBUG)
extern uint8_t gpsTraceEnabled;
#endif
void gpsSendByte(uint8_t byte);
#if defined(INTERNAL_GPS)
#define PILOTPOS_MIN_HDOP 500
#endif
#define USART_FLAG_ERRORS (USART_FLAG_ORE | USART_FLAG_NE | USART_FLAG_FE | USART_FLAG_PE)
// BT driver
@@ -763,14 +674,4 @@ void bluetoothWriteWakeup();
uint8_t bluetoothIsWriting();
void bluetoothDisable();
#if defined(__cplusplus)
#include "fifo.h"
#include "dmafifo.h"
extern DMAFifo<512> telemetryFifo;
typedef DMAFifo<32> AuxSerialRxFifo;
extern AuxSerialRxFifo auxSerialRxFifo;
extern AuxSerialRxFifo aux2SerialRxFifo;
extern volatile uint32_t externalModulePort;
#endif
#endif // _BOARD_H_
@@ -1,486 +0,0 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
void extmoduleStop()
{
EXTERNAL_MODULE_OFF();
NVIC_DisableIRQ(EXTMODULE_TIMER_DMA_STREAM_IRQn);
NVIC_DisableIRQ(EXTMODULE_TIMER_CC_IRQn);
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
EXTMODULE_TIMER->DIER &= ~(TIM_DIER_CC2IE | TIM_DIER_UDE);
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(EXTMODULE_TX_GPIO, &GPIO_InitStructure);
}
void extmodulePpmStart()
{
EXTERNAL_MODULE_ON();
GPIO_PinAFConfig(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PinSource, EXTMODULE_TIMER_TX_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(EXTMODULE_TX_GPIO, &GPIO_InitStructure);
// PPM generation principle:
//
// Hardware timer in PWM mode is used for PPM generation
// Output is OFF if CNT<CCR1(delay) and ON if bigger
// CCR1 register defines duration of pulse length and is constant
// AAR register defines duration of each pulse, it is
// updated after every pulse in Update interrupt handler.
// CCR2 register defines duration of no pulses (time between two pulse trains)
// it is calculated every round to have PPM period constant.
// CC2 interrupt is then used to setup new PPM values for the
// next PPM pulses train.
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN; // Stop timer
EXTMODULE_TIMER->PSC = EXTMODULE_TIMER_FREQ / 2000000 - 1; // 0.5uS (2Mhz)
#if defined(PCBX10) || PCBREV >= 13
EXTMODULE_TIMER->CCR3 = GET_MODULE_PPM_DELAY(EXTERNAL_MODULE)*2;
EXTMODULE_TIMER->CCER = TIM_CCER_CC3E | (GET_MODULE_PPM_POLARITY(EXTERNAL_MODULE) ? TIM_CCER_CC3P : 0);
EXTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_0; // Force O/P high
EXTMODULE_TIMER->BDTR = TIM_BDTR_MOE;
EXTMODULE_TIMER->EGR = 1; // Reloads register values now
EXTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_2; // PWM mode 1
#else
EXTMODULE_TIMER->CCR1 = GET_MODULE_PPM_DELAY(EXTERNAL_MODULE)*2;
EXTMODULE_TIMER->CCER = TIM_CCER_CC1E |
(GET_MODULE_PPM_POLARITY(EXTERNAL_MODULE) ?
#if defined(PCBNV14)
0 : TIM_CCER_CC1P
#else
TIM_CCER_CC1P : 0
#endif
);
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0; // Force O/P high
EXTMODULE_TIMER->EGR = 1; // Reloads register values now
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC2PE; // PWM mode 1
#endif
EXTMODULE_TIMER->ARR = 45000;
EXTMODULE_TIMER->CCR2 = 40000; // The first frame will be sent in 20ms
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
EXTMODULE_TIMER->DIER |= TIM_DIER_UDE | TIM_DIER_CC2IE; // Enable this interrupt
EXTMODULE_TIMER->CR1 = TIM_CR1_CEN; // Start timer
NVIC_EnableIRQ(EXTMODULE_TIMER_DMA_STREAM_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_DMA_STREAM_IRQn, 7);
NVIC_EnableIRQ(EXTMODULE_TIMER_CC_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_CC_IRQn, 7);
}
#if defined(PXX1)
void extmodulePxx1PulsesStart()
{
EXTERNAL_MODULE_ON();
GPIO_PinAFConfig(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PinSource, EXTMODULE_TIMER_TX_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(EXTMODULE_TX_GPIO, &GPIO_InitStructure);
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
EXTMODULE_TIMER->PSC = EXTMODULE_TIMER_FREQ / 2000000 - 1; // 0.5uS (2Mhz)
#if defined(PCBX10) || PCBREV >= 13
EXTMODULE_TIMER->CCR3 = 18;
EXTMODULE_TIMER->CCER = TIM_CCER_CC3E | TIM_CCER_CC3NE | TIM_CCER_CC3P | TIM_CCER_CC3NP;
EXTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3M_0; // Force O/P high
EXTMODULE_TIMER->BDTR = TIM_BDTR_MOE; // Enable outputs
EXTMODULE_TIMER->EGR = 1; // Restart
EXTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_2;
#else
EXTMODULE_TIMER->CCR1 = 18;
EXTMODULE_TIMER->CCER =
TIM_CCER_CC1E |
#if !defined(PCBNV14)
TIM_CCER_CC1P |
#endif
TIM_CCER_CC1NE | TIM_CCER_CC1NP;
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0; // Force O/P high
EXTMODULE_TIMER->BDTR = TIM_BDTR_MOE; // Enable outputs
EXTMODULE_TIMER->EGR = 1; // Restart
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2;
#endif
EXTMODULE_TIMER->ARR = 45000;
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
EXTMODULE_TIMER->DIER |= TIM_DIER_UDE; // Enable DMA on update
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
NVIC_EnableIRQ(EXTMODULE_TIMER_DMA_STREAM_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_DMA_STREAM_IRQn, 7);
NVIC_EnableIRQ(EXTMODULE_TIMER_CC_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_CC_IRQn, 7);
}
#endif
void extmoduleSerialStart()
{
EXTERNAL_MODULE_ON();
GPIO_PinAFConfig(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PinSource, EXTMODULE_TIMER_TX_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(EXTMODULE_TX_GPIO, &GPIO_InitStructure);
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
EXTMODULE_TIMER->PSC = EXTMODULE_TIMER_FREQ / 2000000 - 1; // 0.5uS (2Mhz)
#if defined(PCBX10) || PCBREV >= 13
EXTMODULE_TIMER->CCR3 = 0;
EXTMODULE_TIMER->CCER = TIM_CCER_CC3E | TIM_CCER_CC3P;
EXTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3M_0; // Force O/P high
EXTMODULE_TIMER->BDTR = TIM_BDTR_MOE; // Enable outputs
EXTMODULE_TIMER->EGR = 1; // Restart
EXTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_0;
#else
#if defined(PCBNV14)
EXTMODULE_TIMER->CCER = TIM_CCER_CC1E;
#else
EXTMODULE_TIMER->CCER = TIM_CCER_CC1E | TIM_CCER_CC1P;
#endif
EXTMODULE_TIMER->BDTR = TIM_BDTR_MOE; // Enable outputs
EXTMODULE_TIMER->CCR1 = 0;
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0; // Force O/P high
EXTMODULE_TIMER->EGR = 1; // Restart
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0;
#endif
EXTMODULE_TIMER->ARR = 40000; // dummy value until the DMA request kicks in
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
EXTMODULE_TIMER->DIER |= TIM_DIER_UDE;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
NVIC_EnableIRQ(EXTMODULE_TIMER_DMA_STREAM_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_DMA_STREAM_IRQn, 7);
}
#if defined(EXTMODULE_USART)
ModuleFifo extmoduleFifo;
void extmoduleInvertedSerialStart(uint32_t baudrate)
{
EXTERNAL_MODULE_ON();
// TX + RX Pins
GPIO_PinAFConfig(EXTMODULE_USART_GPIO, EXTMODULE_TX_GPIO_PinSource, EXTMODULE_USART_GPIO_AF);
GPIO_PinAFConfig(EXTMODULE_USART_GPIO, EXTMODULE_RX_GPIO_PinSource, EXTMODULE_USART_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN | EXTMODULE_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(EXTMODULE_USART_GPIO, &GPIO_InitStructure);
// UART config
USART_DeInit(EXTMODULE_USART);
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = baudrate;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_Init(EXTMODULE_USART, &USART_InitStructure);
USART_Cmd(EXTMODULE_USART, ENABLE);
extmoduleFifo.clear();
USART_ITConfig(EXTMODULE_USART, USART_IT_RXNE, ENABLE);
NVIC_SetPriority(EXTMODULE_USART_IRQn, 6);
NVIC_EnableIRQ(EXTMODULE_USART_IRQn);
}
void extmoduleSendBuffer(const uint8_t * data, uint8_t size)
{
DMA_InitTypeDef DMA_InitStructure;
DMA_DeInit(EXTMODULE_USART_TX_DMA_STREAM);
DMA_InitStructure.DMA_Channel = EXTMODULE_USART_TX_DMA_CHANNEL;
DMA_InitStructure.DMA_PeripheralBaseAddr = CONVERT_PTR_UINT(&EXTMODULE_USART->DR);
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
DMA_InitStructure.DMA_Memory0BaseAddr = CONVERT_PTR_UINT(data);
DMA_InitStructure.DMA_BufferSize = size;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(EXTMODULE_USART_TX_DMA_STREAM, &DMA_InitStructure);
DMA_Cmd(EXTMODULE_USART_TX_DMA_STREAM, ENABLE);
USART_DMACmd(EXTMODULE_USART, USART_DMAReq_Tx, ENABLE);
}
#define USART_FLAG_ERRORS (USART_FLAG_ORE | USART_FLAG_NE | USART_FLAG_FE | USART_FLAG_PE)
extern "C" void EXTMODULE_USART_IRQHandler(void)
{
uint32_t status = EXTMODULE_USART->SR;
while (status & (USART_FLAG_RXNE | USART_FLAG_ERRORS)) {
uint8_t data = EXTMODULE_USART->DR;
if (status & USART_FLAG_ERRORS) {
extmoduleFifo.errors++;
}
else {
extmoduleFifo.push(data);
}
status = EXTMODULE_USART->SR;
}
}
#endif
void extmoduleSendNextFrame()
{
switch (moduleState[EXTERNAL_MODULE].protocol) {
case PROTOCOL_CHANNELS_PPM:
#if defined(PCBX10) || PCBREV >= 13
EXTMODULE_TIMER->CCR3 = GET_MODULE_PPM_DELAY(EXTERNAL_MODULE)*2;
EXTMODULE_TIMER->CCER = TIM_CCER_CC3E | (GET_MODULE_PPM_POLARITY(EXTERNAL_MODULE) ? TIM_CCER_CC3P : 0);
EXTMODULE_TIMER->CCR2 = *(extmodulePulsesData.ppm.ptr - 1) - 4000; // 2mS in advance
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | EXTMODULE_TIMER_DMA_SIZE | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
#else
EXTMODULE_TIMER->CCR1 = GET_MODULE_PPM_DELAY(EXTERNAL_MODULE)*2;
EXTMODULE_TIMER->CCER = TIM_CCER_CC1E |
(GET_MODULE_PPM_POLARITY(EXTERNAL_MODULE) ?
#if defined(PCBNV14)
0 : TIM_CCER_CC1P
#else
TIM_CCER_CC1P : 0
#endif
);
EXTMODULE_TIMER->CCR2 = *(extmodulePulsesData.ppm.ptr - 1) - 4000; // 2mS in advance
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | EXTMODULE_TIMER_DMA_SIZE | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
#endif
EXTMODULE_TIMER_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
EXTMODULE_TIMER_DMA_STREAM->M0AR = CONVERT_PTR_UINT(extmodulePulsesData.ppm.pulses);
EXTMODULE_TIMER_DMA_STREAM->NDTR = extmodulePulsesData.ppm.ptr - extmodulePulsesData.ppm.pulses;
EXTMODULE_TIMER_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
break;
#if defined(PXX1)
case PROTOCOL_CHANNELS_PXX1_PULSES:
if (EXTMODULE_TIMER_DMA_STREAM->CR & DMA_SxCR_EN)
return;
// disable timer
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | EXTMODULE_TIMER_DMA_SIZE | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
EXTMODULE_TIMER_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
EXTMODULE_TIMER_DMA_STREAM->M0AR = CONVERT_PTR_UINT(extmodulePulsesData.pxx.getData());
EXTMODULE_TIMER_DMA_STREAM->NDTR = extmodulePulsesData.pxx.getSize();
EXTMODULE_TIMER_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
// re-init timer
EXTMODULE_TIMER->EGR = 1;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
break;
#endif
#if defined(PXX1) && defined(HARDWARE_EXTERNAL_MODULE_SIZE_SML)
case PROTOCOL_CHANNELS_PXX1_SERIAL:
extmoduleSendBuffer(extmodulePulsesData.pxx_uart.getData(), extmodulePulsesData.pxx_uart.getSize());
break;
#endif
#if defined(PXX2) && defined(EXTMODULE_USART)
case PROTOCOL_CHANNELS_PXX2_HIGHSPEED:
case PROTOCOL_CHANNELS_PXX2_LOWSPEED:
extmoduleSendBuffer(extmodulePulsesData.pxx2.getData(), extmodulePulsesData.pxx2.getSize());
break;
#endif
#if defined(AFHDS3)
case PROTOCOL_CHANNELS_AFHDS3:
{
#if defined(EXTMODULE_USART) && defined(EXTMODULE_TX_INVERT_GPIO)
extmoduleSendBuffer(extmodulePulsesData.afhds3.getData(), extmodulePulsesData.afhds3.getSize());
#else
if (EXTMODULE_TIMER_DMA_STREAM->CR & DMA_SxCR_EN)
return;
const uint16_t* dataPtr = extmodulePulsesData.afhds3.getData();
uint32_t dataSize = extmodulePulsesData.afhds3.getSize();
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | DMA_SxCR_PSIZE_0 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
EXTMODULE_TIMER_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
EXTMODULE_TIMER_DMA_STREAM->M0AR = CONVERT_PTR_UINT(dataPtr);
EXTMODULE_TIMER_DMA_STREAM->NDTR = dataSize;
EXTMODULE_TIMER_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
// re-init timer
EXTMODULE_TIMER->EGR = TIM_PSCReloadMode_Immediate;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
#endif
}
break;
#endif
#if defined(DSM2)
case PROTOCOL_CHANNELS_SBUS:
case PROTOCOL_CHANNELS_DSM2_LP45:
case PROTOCOL_CHANNELS_DSM2_DSM2:
case PROTOCOL_CHANNELS_DSM2_DSMX:
case PROTOCOL_CHANNELS_MULTIMODULE:
if (EXTMODULE_TIMER_DMA_STREAM->CR & DMA_SxCR_EN)
return;
if (PROTOCOL_CHANNELS_SBUS == moduleState[EXTERNAL_MODULE].protocol) {
// reverse polarity for Sbus if needed
EXTMODULE_TIMER->CCER =
#if defined(PCBX10) || PCBREV >= 13
TIM_CCER_CC3E | (GET_SBUS_POLARITY(EXTERNAL_MODULE) ? TIM_CCER_CC3P : 0)
#elif defined(PCBNV14)
TIM_CCER_CC1E | (GET_SBUS_POLARITY(EXTERNAL_MODULE) ? 0 : TIM_CCER_CC1P)
#else
TIM_CCER_CC1E | (GET_SBUS_POLARITY(EXTERNAL_MODULE) ? TIM_CCER_CC1P : 0)
#endif
; //
}
// disable timer
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
// send DMA request
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | EXTMODULE_TIMER_DMA_SIZE | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
EXTMODULE_TIMER_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
EXTMODULE_TIMER_DMA_STREAM->M0AR = CONVERT_PTR_UINT(extmodulePulsesData.dsm2.pulses);
EXTMODULE_TIMER_DMA_STREAM->NDTR = extmodulePulsesData.dsm2.ptr - extmodulePulsesData.dsm2.pulses;
EXTMODULE_TIMER_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
// re-init timer
EXTMODULE_TIMER->EGR = 1;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
break;
#endif
#if defined(CROSSFIRE)
case PROTOCOL_CHANNELS_CROSSFIRE:
sportSendBuffer(extmodulePulsesData.crossfire.pulses, extmodulePulsesData.crossfire.length);
break;
#endif
#if defined(GHOST)
case PROTOCOL_CHANNELS_GHOST:
sportSendBuffer(extmodulePulsesData.ghost.pulses, extmodulePulsesData.ghost.length);
break;
#endif
default:
EXTMODULE_TIMER->DIER |= TIM_DIER_CC2IE;
break;
}
}
void extmoduleSendInvertedByte(uint8_t byte)
{
uint16_t time;
uint32_t i;
__disable_irq();
time = getTmr2MHz();
GPIO_SetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
while ((uint16_t) (getTmr2MHz() - time) < 34) {
// wait
}
time += 34;
for (i = 0; i < 8; i++) {
if (byte & 1) {
GPIO_ResetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
}
else {
GPIO_SetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
}
byte >>= 1 ;
while ((uint16_t) (getTmr2MHz() - time) < 35) {
// wait
}
time += 35 ;
}
GPIO_ResetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
__enable_irq(); // No need to wait for the stop bit to complete
while ((uint16_t) (getTmr2MHz() - time) < 34) {
// wait
}
}
extern "C" void EXTMODULE_TIMER_DMA_IRQHandler()
{
if (!DMA_GetITStatus(EXTMODULE_TIMER_DMA_STREAM, EXTMODULE_TIMER_DMA_FLAG_TC))
return;
DMA_ClearITPendingBit(EXTMODULE_TIMER_DMA_STREAM, EXTMODULE_TIMER_DMA_FLAG_TC);
switch (moduleState[EXTERNAL_MODULE].protocol) {
case PROTOCOL_CHANNELS_PPM:
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
EXTMODULE_TIMER->DIER |= TIM_DIER_CC2IE; // Enable this interrupt
break;
}
}
extern "C" void EXTMODULE_TIMER_IRQHandler()
{
EXTMODULE_TIMER->DIER &= ~TIM_DIER_CC2IE; // Stop this interrupt
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF;
if (setupPulsesExternalModule())
extmoduleSendNextFrame();
}
@@ -22,6 +22,9 @@
#include "opentx.h"
#include "flyskyHallStick_driver.h"
#include "fifo.h"
#include "dmafifo.h"
DMAFifo<HALLSTICK_BUFF_SIZE> hallDMAFifo __DMA (FLYSKY_HALL_DMA_Stream_RX);
Fifo<uint8_t, HALLSTICK_BUFF_SIZE> hallStickTxFifo;
unsigned char HallCmd[264] __DMA;
-119
View File
@@ -1,119 +0,0 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
#if GPS_USART_BAUDRATE > 9600
Fifo<uint8_t, 256> gpsRxFifo;
#else
Fifo<uint8_t, 64> gpsRxFifo;
#endif
void gpsInit(uint32_t baudrate)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
// RX and TX pins
GPIO_PinAFConfig(GPS_UART_GPIO, GPS_TX_GPIO_PinSource, GPS_GPIO_AF);
GPIO_PinAFConfig(GPS_UART_GPIO, GPS_RX_GPIO_PinSource, GPS_GPIO_AF);
GPIO_InitStructure.GPIO_Pin = (GPS_TX_GPIO_PIN | GPS_RX_GPIO_PIN);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPS_UART_GPIO, &GPIO_InitStructure);
// UART config
USART_InitStructure.USART_BaudRate = baudrate;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(GPS_USART, &USART_InitStructure);
USART_Cmd(GPS_USART, ENABLE);
USART_ITConfig(GPS_USART, USART_IT_RXNE, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = GPS_USART_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x9;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
#if defined(GPS_PWR_GPIO)
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = GPS_PWR_GPIO_PIN;
GPIO_Init(GPS_PWR_GPIO, &GPIO_InitStructure);
GPIO_SetBits(GPS_PWR_GPIO, GPS_PWR_GPIO_PIN);
#endif
}
#if defined(DEBUG)
uint8_t gpsTraceEnabled = false;
#endif
Fifo<uint8_t, 64> gpsTxFifo;
void gpsSendByte(uint8_t byte)
{
while (gpsTxFifo.isFull());
gpsTxFifo.push(byte);
USART_ITConfig(GPS_USART, USART_IT_TXE, ENABLE);
}
extern "C" void GPS_USART_IRQHandler(void)
{
// Send
if (USART_GetITStatus(GPS_USART, USART_IT_TXE) != RESET) {
uint8_t txchar;
if (gpsTxFifo.pop(txchar)) {
/* Write one byte to the transmit data register */
USART_SendData(GPS_USART, txchar);
}
else {
USART_ITConfig(GPS_USART, USART_IT_TXE, DISABLE);
}
}
// Receive
uint32_t status = GPS_USART->SR;
while (status & (USART_FLAG_RXNE | USART_FLAG_ERRORS)) {
uint8_t data = GPS_USART->DR;
if (!(status & USART_FLAG_ERRORS)) {
gpsRxFifo.push(data);
}
status = GPS_USART->SR;
}
}
uint8_t gpsGetByte(uint8_t * byte)
{
uint8_t result = gpsRxFifo.pop(*byte);
#if defined(DEBUG)
if (gpsTraceEnabled) {
serialPutc(*byte);
}
#endif
return result;
}
+54 -56
View File
@@ -412,7 +412,7 @@
#endif
// Serial Port (DEBUG)
#if (defined(PCBX12S) || (defined(RADIO_TX16S)) && !defined(HARDWARE_EXTERNAL_ACCESS_MOD)) && !defined(IMU_LSM6DS33)
#if defined(AUX_SERIAL)
#define AUX_SERIAL_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_DMA1)
#define AUX_SERIAL_RCC_APB1Periph RCC_APB1Periph_USART3
#define AUX_SERIAL_RCC_APB2Periph 0
@@ -422,16 +422,18 @@
#define AUX_SERIAL_GPIO_PinSource_TX GPIO_PinSource10
#define AUX_SERIAL_GPIO_PinSource_RX GPIO_PinSource11
#define AUX_SERIAL_GPIO_AF GPIO_AF_USART3
#define AUX_SERIAL_GPIO_AF_LL LL_GPIO_AF_7
#define AUX_SERIAL_USART USART3
#define AUX_SERIAL_USART_IRQHandler USART3_IRQHandler
#define AUX_SERIAL_USART_IRQn USART3_IRQn
#define AUX_SERIAL_DMA_RX DMA1
#define AUX_SERIAL_DMA_Stream_RX DMA1_Stream1
#define AUX_SERIAL_DMA_Stream_RX_LL LL_DMA_STREAM_1
#define AUX_SERIAL_DMA_Channel_RX DMA_Channel_4
#if defined(RADIO_TX16S)
#define AUX_SERIAL_PWR_GPIO GPIOA
#define AUX_SERIAL_PWR_GPIO_PIN GPIO_Pin_15 // PA.15
#define TRAINER_BATTERY_COMPARTMENT // allows serial port TTL trainer
#endif
#if defined(RADIO_TX16S)
#define AUX_SERIAL_PWR_GPIO GPIOA
#define AUX_SERIAL_PWR_GPIO_PIN GPIO_Pin_15 // PA.15
#endif
#else
#define AUX_SERIAL_RCC_AHB1Periph 0
#define AUX_SERIAL_RCC_APB1Periph 0
@@ -439,44 +441,46 @@
#endif
#if defined(AUX2_SERIAL)
#if defined(PCBX12S)
#define AUX2_SERIAL_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define AUX2_SERIAL_RCC_APB1Periph RCC_APB1Periph_UART4
#define AUX2_SERIAL_RCC_APB2Periph 0
#define AUX2_SERIAL_USART UART4
#define AUX2_SERIAL_GPIO_AF GPIO_AF_UART4
#define AUX2_SERIAL_GPIO_AF_LL LL_GPIO_AF_8
#define AUX2_SERIAL_USART_IRQn UART4_IRQn
#define AUX2_SERIAL_USART_IRQHandler UART4_IRQHandler
#define AUX2_SERIAL_GPIO GPIOA
#define AUX2_SERIAL_GPIO_PIN_TX GPIO_Pin_0 // PA.00
#define AUX2_SERIAL_GPIO_PIN_RX GPIO_Pin_1 // PA.01
#define AUX2_SERIAL_GPIO_TX_PinSource GPIO_PinSource0
#define AUX2_SERIAL_GPIO_RX_PinSource GPIO_PinSource1
#define AUX2_SERIAL_DMA_RX DMA1
#define AUX2_SERIAL_DMA_Stream_RX DMA1_Stream2
#define AUX2_SERIAL_DMA_Channel_RX DMA_Channel_4
#define AUX2_SERIAL_DMA_Stream_RX_LL LL_DMA_STREAM_2
#else
#define AUX2_SERIAL_RCC_AHB1Periph (RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_DMA2)
#define AUX2_SERIAL_RCC_APB1Periph 0
#define AUX2_SERIAL_RCC_APB2Periph RCC_APB2Periph_USART6
#define AUX2_SERIAL_USART USART6
#define AUX2_SERIAL_GPIO_AF GPIO_AF_USART6
#define AUX2_SERIAL_GPIO_AF_LL LL_GPIO_AF_8
#define AUX2_SERIAL_USART_IRQn USART6_IRQn
#define AUX2_SERIAL_USART_IRQHandler USART6_IRQHandler
#define AUX2_SERIAL_GPIO GPIOG
#define AUX2_SERIAL_GPIO_PIN_TX GPIO_Pin_14 // PG.14
#define AUX2_SERIAL_GPIO_PIN_RX GPIO_Pin_9 // PG.09
#define AUX2_SERIAL_GPIO_PinSource_TX GPIO_PinSource14
#define AUX2_SERIAL_GPIO_PinSource_RX GPIO_PinSource9
#define AUX2_SERIAL_USART_IRQHandler USART6_IRQHandler
#define AUX2_SERIAL_DMA_RX DMA2
#define AUX2_SERIAL_DMA_Stream_RX DMA2_Stream1 // or DMA2_Stream2
#define AUX2_SERIAL_DMA_Channel_RX DMA_Channel_5
#define AUX2_SERIAL_DMA_Stream_RX_LL LL_DMA_STREAM_1
#define AUX2_SERIAL_PWR_GPIO GPIOB
#define AUX2_SERIAL_PWR_GPIO_PIN GPIO_Pin_0 // PB.00
#if defined(RADIO_TX16S)
#define TRAINER_BATTERY_COMPARTMENT // allows serial port TTL trainer
#endif
#elif defined(RADIO_TX16S) && defined(INTERNAL_GPS)
#define GPS_RCC_AHB1Periph (RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOG)
#define GPS_RCC_APB1Periph 0
#define GPS_RCC_APB2Periph RCC_APB2Periph_USART6
#define GPS_USART USART6
#define GPS_GPIO_AF GPIO_AF_USART6
#define GPS_USART_IRQn USART6_IRQn
#define GPS_USART_IRQHandler USART6_IRQHandler
#define GPS_UART_GPIO GPIOG
#define GPS_TX_GPIO_PIN GPIO_Pin_14 // PG.14
#define GPS_RX_GPIO_PIN GPIO_Pin_9 // PG.09
#define GPS_TX_GPIO_PinSource GPIO_PinSource14
#define GPS_RX_GPIO_PinSource GPIO_PinSource9
#define GPS_PWR_GPIO GPIOB
#define GPS_PWR_GPIO_PIN GPIO_Pin_0 // PB.00
#define AUX2_SERIAL_RCC_AHB1Periph 0
#define AUX2_SERIAL_RCC_APB1Periph 0
#define AUX2_SERIAL_RCC_APB2Periph 0
#else
#else // AUX2_SERIAL
#define AUX2_SERIAL_RCC_AHB1Periph 0
#define AUX2_SERIAL_RCC_APB1Periph 0
#define AUX2_SERIAL_RCC_APB2Periph 0
@@ -812,9 +816,12 @@
#define INTMODULE_GPIO_PinSource_RX GPIO_PinSource7
#define INTMODULE_USART USART1
#define INTMODULE_GPIO_AF GPIO_AF_USART1
#define INTMODULE_GPIO_AF_LL LL_GPIO_AF_7
#define INTMODULE_USART_IRQn USART1_IRQn
#define INTMODULE_USART_IRQHandler USART1_IRQHandler
#define INTMODULE_DMA DMA2
#define INTMODULE_DMA_STREAM DMA2_Stream7
#define INTMODULE_DMA_STREAM_LL LL_DMA_STREAM_7
#define INTMODULE_DMA_STREAM_IRQ DMA2_Stream7_IRQn
#define INTMODULE_DMA_STREAM_IRQHandler DMA2_Stream7_IRQHandler
#define INTMODULE_DMA_FLAG_TC DMA_FLAG_TCIF7
@@ -841,27 +848,36 @@
#define EXTMODULE_TX_GPIO GPIOB
#define EXTMODULE_USART_GPIO EXTMODULE_TX_GPIO
#define EXTMODULE_TX_GPIO_PIN GPIO_Pin_10 // PB.10 (TIM2_CH3)
#define EXTMODULE_TX_GPIO_PIN_LL LL_GPIO_PIN_10 // PB.10 (TIM2_CH3)
#define EXTMODULE_TX_GPIO_PinSource GPIO_PinSource10
#define EXTMODULE_RX_GPIO_PIN GPIO_Pin_11 // PB.11
#define EXTMODULE_RX_GPIO_PIN_LL LL_GPIO_PIN_11 // PB.11
#define EXTMODULE_RX_GPIO_PinSource GPIO_PinSource11
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM2
#define EXTMODULE_TIMER TIM2
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH3
#define EXTMODULE_TIMER_32BITS
#define EXTMODULE_TIMER_DMA_SIZE (DMA_SxCR_PSIZE_1 | DMA_SxCR_MSIZE_1)
#define EXTMODULE_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define EXTMODULE_TIMER_CC_IRQn TIM2_IRQn
#define EXTMODULE_TIMER_IRQn TIM2_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM2_IRQHandler
#define EXTMODULE_TIMER_DMA_CHANNEL DMA_Channel_3
#define EXTMODULE_TIMER_DMA_STREAM DMA1_Stream1
#define EXTMODULE_TIMER_DMA DMA1
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF1
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA1_Stream1_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA1_Stream1_IRQHandler
#define EXTMODULE_USART_GPIO_AF GPIO_AF_USART3
#define EXTMODULE_USART_GPIO_AF_LL LL_GPIO_AF_7
#define EXTMODULE_USART USART3
#define EXTMODULE_USART_IRQn USART3_IRQn
#define EXTMODULE_USART_IRQHandler USART3_IRQHandler
#define EXTMODULE_USART_TX_DMA DMA1
#define EXTMODULE_USART_TX_DMA_CHANNEL DMA_Channel_4
#define EXTMODULE_USART_TX_DMA_STREAM DMA1_Stream3
#define EXTMODULE_USART_TX_DMA_STREAM_LL LL_DMA_STREAM_3
#define EXTMODULE_USART_TX_DMA_FLAG_TC DMA_FLAG_TCIF3
#define EXTMODULE_USART_RX_DMA_CHANNEL DMA_Channel_4
#define EXTMODULE_USART_RX_DMA_STREAM DMA1_Stream1
#elif defined(PCBX10) || PCBREV >= 13
@@ -873,12 +889,15 @@
#define EXTMODULE_TX_GPIO_PinSource GPIO_PinSource10
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM1
#define EXTMODULE_TIMER TIM1
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH3
#define EXTMODULE_TIMER_DMA_SIZE (DMA_SxCR_PSIZE_0 | DMA_SxCR_MSIZE_0)
#define EXTMODULE_TIMER_CC_IRQn TIM1_CC_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM1_CC_IRQHandler
#define EXTMODULE_TIMER_IRQn TIM1_UP_TIM10_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM1_UP_TIM10_IRQHandler
#define EXTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#define EXTMODULE_TIMER_DMA_CHANNEL DMA_Channel_6
#define EXTMODULE_TIMER_DMA_STREAM DMA2_Stream5
#define EXTMODULE_TIMER_DMA DMA2
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_5
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream5_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA2_Stream5_IRQHandler
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF5
@@ -891,13 +910,16 @@
#define EXTMODULE_TX_GPIO_PinSource GPIO_PinSource15
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM2
#define EXTMODULE_TIMER TIM2
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH1
#define EXTMODULE_TIMER_32BITS
#define EXTMODULE_TIMER_DMA_SIZE (DMA_SxCR_PSIZE_1 | DMA_SxCR_MSIZE_1)
#define EXTMODULE_TIMER_CC_IRQn TIM2_IRQn
#define EXTMODULE_TIMER_IRQn TIM2_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM2_IRQHandler
#define EXTMODULE_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define EXTMODULE_TIMER_DMA_CHANNEL DMA_Channel_3
#define EXTMODULE_TIMER_DMA_STREAM DMA1_Stream7
#define EXTMODULE_TIMER_DMA DMA1
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_7
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA1_Stream7_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA1_Stream7_IRQHandler
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF7
@@ -936,10 +958,6 @@
#define TRAINER_GPIO_AF GPIO_AF_TIM3
#define TRAINER_DMA DMA1
#define TRAINER_DMA_CHANNEL DMA_Channel_5
#define TRAINER_DMA_STREAM DMA1_Stream2
#define TRAINER_DMA_IRQn DMA1_Stream2_IRQn
#define TRAINER_DMA_IRQHandler DMA1_Stream2_IRQHandler
#define TRAINER_DMA_FLAG_TC DMA_IT_TCIF2
#define TRAINER_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
// Xms Interrupt
@@ -995,24 +1013,4 @@
#define BT_EN_GPIO_PIN GPIO_Pin_10 // PG.10
#endif
// GPS
#if defined(PCBX12S)
#define GPS_RCC_AHB1Periph RCC_AHB1Periph_GPIOA
#define GPS_RCC_APB1Periph RCC_APB1Periph_UART4
#define GPS_RCC_APB2Periph 0
#define GPS_USART UART4
#define GPS_GPIO_AF GPIO_AF_UART4
#define GPS_USART_IRQn UART4_IRQn
#define GPS_USART_IRQHandler UART4_IRQHandler
#define GPS_UART_GPIO GPIOA
#define GPS_TX_GPIO_PIN GPIO_Pin_0 // PA.00
#define GPS_RX_GPIO_PIN GPIO_Pin_1 // PA.01
#define GPS_TX_GPIO_PinSource GPIO_PinSource0
#define GPS_RX_GPIO_PinSource GPIO_PinSource1
#elif !defined(INTERNAL_GPS)
#define GPS_RCC_AHB1Periph 0
#define GPS_RCC_APB1Periph 0
#define GPS_RCC_APB2Periph 0
#endif
#endif // _HAL_H_
+4 -1
View File
@@ -21,6 +21,9 @@
#include "opentx.h"
#include "fifo.h"
#include "dmafifo.h"
Fifo<uint8_t, TELEMETRY_FIFO_SIZE> telemetryNoDMAFifo;
uint32_t telemetryErrors = 0;
@@ -415,7 +418,7 @@ extern "C" void TELEMETRY_TIMER_IRQHandler()
}
// TODO we should have telemetry in an higher layer, functions above should move to a sport_driver.cpp
bool telemetryGetByte(uint8_t * byte)
bool sportGetByte(uint8_t * byte)
{
#if defined(PCBX12S)
if (telemetryFifoMode & TELEMETRY_SERIAL_WITHOUT_DMA)
+1 -19
View File
@@ -20,6 +20,7 @@
*/
#include "opentx.h"
#include "aux_serial_driver.h"
void trainerSendNextFrame();
@@ -141,22 +142,3 @@ extern "C" void TRAINER_TIMER_IRQHandler()
}
}
}
int sbusGetByte(uint8_t * byte)
{
switch (currentTrainerMode) {
#if defined(AUX_SERIAL) || defined(AUX2_SERIAL)
case TRAINER_MODE_MASTER_BATTERY_COMPARTMENT:
#if defined(AUX_SERIAL)
if (auxSerialMode == UART_MODE_SBUS_TRAINER)
return auxSerialRxFifo.pop(*byte);
#endif
#if defined(AUX2_SERIAL)
if (aux2SerialMode == UART_MODE_SBUS_TRAINER)
return aux2SerialRxFifo.pop(*byte);
#endif
#endif
default:
return false;
}
}
+39 -37
View File
@@ -54,21 +54,6 @@ add_definitions(-DINTERNAL_MODULE_AFHDS2A)
set(INTERNAL_MODULES AFHDS2A CACHE STRING "Internal modules")
set(DEFAULT_INTERNAL_MODULE FLYSKY CACHE STRING "Default internal module")
set(TARGET_SRC
${TARGET_SRC}
audio_spi_driver.cpp
../common/arm/stm32/mixer_scheduler_driver.cpp
../common/arm/stm32/timers_driver.cpp
)
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
battery_driver.cpp
../horus/flyskyHallStick_driver.cpp
../common/arm/stm32/stm32_hal_adc.cpp
../../hal/adc_driver.cpp
)
set(BITMAPS_TARGET nv14_bitmaps)
set(FONTS_TARGET x12_fonts)
set(LCD_DRIVER lcd_driver.cpp)
@@ -82,9 +67,12 @@ set(FIRMWARE_DEPENDENCIES datacopy)
set(HARDWARE_TOUCH ON)
set(SOFTWARE_KEYBOARD ON)
add_definitions(
-DSTM32F429_439xx -DSTM32F429xx
-DSDRAM -DCOLORLCD -DLIBOPENUI
-DHARDWARE_TOUCH -DHARDWARE_KEYS
-DSOFTWARE_KEYBOARD)
add_definitions(-DSTM32F429_439xx -DSDRAM -DCOLORLCD -DLIBOPENUI
-DHARDWARE_TOUCH -DHARDWARE_KEYS -DSOFTWARE_KEYBOARD)
add_definitions(-DEEPROM_VARIANT=0 -DAUDIO -DVOICE -DRTCLOCK)
add_definitions(-DGPS_USART_BAUDRATE=${INTERNAL_GPS_BAUDRATE})
add_definitions(-DPWR_BUTTON_${PWR_BUTTON})
@@ -107,6 +95,10 @@ set(AFHDS2 ON)
# disable for now as it crashes on radio
#set(AFHDS3 ON)
# VCP CLI
set(ENABLE_SERIAL_PASSTHROUGH ON CACHE BOOL "Enable serial passthrough")
set(CLI ON CACHE BOOL "Enable CLI")
include_directories(${RADIO_SRC_DIR}/fonts/colorlcd gui/${GUI_DIR} gui/${GUI_DIR}/layouts)
file(GLOB THEMES_SRC RELATIVE ${RADIO_SRC_DIR}/gui/colorlcd ${RADIO_SRC_DIR}/gui/colorlcd/themes/*.cpp)
@@ -127,26 +119,6 @@ set(SRC
set(GVAR_SCREEN model_gvars.cpp)
set(TARGET_SRC
${TARGET_SRC}
extmodule_helper.cpp
../horus/extmodule_driver.cpp
trainer_driver.cpp
../common/arm/stm32/intmodule_serial_driver.cpp
)
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
${LCD_DRIVER}
${TOUCH_DRIVER}
board.cpp
backlight_driver.cpp
sdram_driver.c
startup_stm32f42_43xxx.s
../common/arm/stm32/pwr_driver.cpp
../common/arm/stm32/sdio_sd.c
)
if(BOOTLOADER)
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
@@ -167,6 +139,36 @@ if (MULTIMODULE)
)
endif()
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
board.cpp
startup_stm32f42_43xxx.s
${LCD_DRIVER}
${TOUCH_DRIVER}
sdram_driver.c
trainer_driver.cpp
battery_driver.cpp
audio_spi_driver.cpp
backlight_driver.cpp
extmodule_helper.cpp
../horus/flyskyHallStick_driver.cpp
)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
hal/adc_driver.cpp
targets/common/arm/stm32/stm32_hal_adc.cpp
targets/common/arm/stm32/timers_driver.cpp
targets/common/arm/stm32/mixer_scheduler_driver.cpp
targets/common/arm/stm32/extmodule_driver.cpp
targets/common/arm/stm32/stm32_pulse_driver.cpp
targets/common/arm/stm32/extmodule_serial_driver.cpp
targets/common/arm/stm32/intmodule_serial_driver.cpp
targets/common/arm/stm32/stm32_usart_driver.cpp
targets/common/arm/stm32/pwr_driver.cpp
targets/common/arm/stm32/sdio_sd.c
)
# Make malloc() thread-safe
add_definitions(-DTHREADSAFE_MALLOC)
+9 -6
View File
@@ -23,7 +23,8 @@
#include "touch.h"
#include "hal/adc_driver.h"
#include "../common/arm/stm32/stm32_hal_adc.h"
#include "stm32_hal_adc.h"
#include "timers_driver.h"
#if defined(__cplusplus) && !defined(SIMU)
extern "C" {
@@ -119,11 +120,8 @@ void boardInit()
__enable_irq();
#endif
#if defined(DEBUG) && defined(AUX_SERIAL)
auxSerialInit(UART_MODE_DEBUG, 0); // default serial mode (None if DEBUG not defined)
#endif
#if defined(DEBUG) && defined(AUX2_SERIAL)
aux2SerialInit(UART_MODE_DEBUG, 0); // default serial mode (None if DEBUG not defined)
#if defined(DEBUG)
serialInit(SP_AUX1, UART_MODE_DEBUG);
#endif
TRACE("\nNV14 board started :)");
@@ -241,3 +239,8 @@ void boardOff()
}
}
const etx_serial_port_t* auxSerialGetPort(int port_nr)
{
return nullptr;
}
+22 -64
View File
@@ -26,6 +26,7 @@
#include "opentx_constants.h"
#include "board_common.h"
#include "hal.h"
#include "hal/serial_port.h"
#if !defined(LUA_EXPORT_GENERATION)
#include "stm32f4xx_sdio.h"
@@ -37,6 +38,7 @@
#include "touch_driver.h"
#include "lcd_driver.h"
#include "battery_driver.h"
#include "watchdog_driver.h"
#define FLASHSIZE 0x200000
#define BOOTLOADER_SIZE 0x20000
@@ -67,10 +69,6 @@ extern HardwareOptions hardwareOptions;
void boardInit();
void boardOff();
// Timers driver
void init2MhzTimer();
void init1msTimer();
// CPU Unique ID
#define LEN_CPU_UID (3*8+2)
void getCPUUniqueID(char * s);
@@ -109,27 +107,34 @@ uint32_t isBootloaderStart(const uint8_t * buffer);
// SDRAM driver
void SDRAM_Init();
// Pulses driver
#if !defined(SIMU)
#define INTERNAL_MODULE_OFF() GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define INTERNAL_MODULE_ON() GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
void EXTERNAL_MODULE_ON();
void EXTERNAL_MODULE_OFF();
#define EXTERNAL_MODULE_PWR_OFF EXTERNAL_MODULE_OFF
#define BLUETOOTH_MODULE_ON() GPIO_ResetBits(BLUETOOTH_ON_GPIO, BLUETOOTH_ON_GPIO_PIN)
#define BLUETOOTH_MODULE_OFF() GPIO_SetBits(BLUETOOTH_ON_GPIO, BLUETOOTH_ON_GPIO_PIN)
#define IS_INTERNAL_MODULE_ON() (GPIO_ReadInputDataBit(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN) == Bit_SET)
#define IS_EXTERNAL_MODULE_ON() (GPIO_ReadInputDataBit(EXTMODULE_PWR_GPIO, EXTMODULE_PWR_GPIO_PIN) == Bit_SET)
#else
#define INTERNAL_MODULE_OFF()
#define INTERNAL_MODULE_ON()
#define EXTERNAL_MODULE_ON()
#define EXTERNAL_MODULE_OFF()
#define BLUETOOTH_MODULE_ON()
#define BLUETOOTH_MODULE_OFF()
#define IS_INTERNAL_MODULE_ON() (false)
#define IS_EXTERNAL_MODULE_ON() (false)
#endif // defined(SIMU)
#define EXTERNAL_MODULE_PWR_OFF EXTERNAL_MODULE_OFF
#define IS_UART_MODULE(port) (port == INTERNAL_MODULE)
#define IS_PXX2_INTERNAL_ENABLED() (false)
void init_intmodule_heartbeat();
void check_intmodule_heartbeat();
//void extmoduleSerialStart(uint32_t baudrate, uint32_t period_half_us, bool inverted);
void extmoduleSerialStart();
void extmoduleSendNextFrame();
void extmoduleSendInvertedByte(uint8_t byte);
// Trainer driver
void init_trainer_ppm();
void stop_trainer_ppm();
@@ -256,27 +261,6 @@ bool getTrimsAsButtons();
#define DBLKEYS_PRESSED_RGT_UP(in) (false)
#define DBLKEYS_PRESSED_LFT_DWN(in) (false)
#define WDG_DURATION 500 /*ms*/
void watchdogInit(unsigned int duration);
#if defined(SIMU)
#define WAS_RESET_BY_WATCHDOG() (false)
#define WAS_RESET_BY_SOFTWARE() (false)
#define WAS_RESET_BY_WATCHDOG_OR_SOFTWARE() (false)
#define WDG_ENABLE(x)
#define WDG_RESET()
#else
#if defined(WATCHDOG)
#define WDG_ENABLE(x) watchdogInit(x)
#define WDG_RESET() IWDG->KR = 0xAAAA
#else
#define WDG_ENABLE(x)
#define WDG_RESET()
#endif
#define WAS_RESET_BY_WATCHDOG() (RCC->CSR & (RCC_CSR_WDGRSTF | RCC_CSR_WWDGRSTF))
#define WAS_RESET_BY_SOFTWARE() (RCC->CSR & RCC_CSR_SFTRSTF)
#define WAS_RESET_BY_WATCHDOG_OR_SOFTWARE() (RCC->CSR & (RCC_CSR_WDGRSTF | RCC_CSR_WWDGRSTF | RCC_CSR_SFTRSTF))
#endif
// ADC driver
#define NUM_POTS 2
#define NUM_XPOTS 0 // NUM_POTS
@@ -407,9 +391,8 @@ bool pwrPressed();
#endif
uint32_t pwrPressedDuration();;
#define AUX_SERIAL_POWER_ON()
#define AUX_SERIAL_POWER_OFF()
const etx_serial_port_t* auxSerialGetPort(int port_nr);
// LCD driver
#define LCD_W 320
#define LCD_H 480
@@ -500,7 +483,7 @@ void telemetryPortInit(uint32_t baudrate, uint8_t mode);
void telemetryPortSetDirectionOutput();
void telemetryPortSetDirectionInput();
void sportSendBuffer(const uint8_t * buffer, uint32_t count);
bool telemetryGetByte(uint8_t * byte);
bool sportGetByte(uint8_t * byte);
void telemetryClearFifo();
void sportSendByte(uint8_t byte);
extern uint32_t telemetryErrors;
@@ -524,35 +507,10 @@ void hapticOn(uint32_t pwmPercent);
//#define AUX_SERIAL
#define DEBUG_BAUDRATE 115200
#define LUA_DEFAULT_BAUDRATE 115200
extern uint8_t auxSerialMode;
#if defined __cplusplus
void auxSerialSetup(unsigned int baudrate, bool dma, uint16_t length = USART_WordLength_8b, uint16_t parity = USART_Parity_No, uint16_t stop = USART_StopBits_1);
#endif
void auxSerialInit(unsigned int mode, unsigned int protocol);
void auxSerialPutc(char c);
#define auxSerialTelemetryInit(protocol) auxSerialInit(UART_MODE_TELEMETRY, protocol)
void auxSerialSbusInit();
void auxSerialStop();
#if defined(AUX_SERIAL_PWR_GPIO)
#define AUX_SERIAL_POWER_ON() auxSerialPowerOn()
#define AUX_SERIAL__POWER_OFF() auxSerialPowerOff()
#else
#define AUX_SERIAL_POWER_ON()
#define AUX_SERIAL__POWER_OFF()
#endif
#define USART_FLAG_ERRORS (USART_FLAG_ORE | USART_FLAG_NE | USART_FLAG_FE | USART_FLAG_PE)
extern uint8_t currentTrainerMode;
void checkTrainerSettings();
#if defined(__cplusplus)
#include "fifo.h"
#include "dmafifo.h"
extern DMAFifo<512> telemetryFifo;
typedef Fifo<uint8_t, 32> AuxSerialRxFifo;
extern AuxSerialRxFifo auxSerialRxFifo;
#endif
// Touch panel driver
bool touchPanelEventOccured();
struct TouchState touchPanelRead();
+2 -2
View File
@@ -59,6 +59,6 @@ void extModuleInit()
GPIO_InitStructure.GPIO_Pin = EXTMODULE_RX_INVERT_GPIO_PIN;
GPIO_Init(EXTMODULE_RX_INVERT_GPIO, &GPIO_InitStructure);
GPIO_ResetBits(EXTMODULE_TX_INVERT_GPIO, EXTMODULE_TX_INVERT_GPIO_PIN);
GPIO_ResetBits(EXTMODULE_RX_INVERT_GPIO, EXTMODULE_RX_INVERT_GPIO_PIN);
EXTMODULE_TX_INVERTED();
EXTMODULE_RX_INVERTED();
}
+17 -8
View File
@@ -388,9 +388,12 @@
#define INTMODULE_GPIO_PinSource_RX GPIO_PinSource6
#define INTMODULE_USART UART7
#define INTMODULE_GPIO_AF GPIO_AF_UART7
#define INTMODULE_GPIO_AF_LL LL_GPIO_AF_8
#define INTMODULE_USART_IRQn UART7_IRQn
#define INTMODULE_USART_IRQHandler UART7_IRQHandler
#define INTMODULE_DMA DMA1
#define INTMODULE_DMA_STREAM DMA1_Stream1
#define INTMODULE_DMA_STREAM_LL LL_DMA_STREAM_1
#define INTMODULE_DMA_STREAM_IRQ DMA1_Stream1_IRQn
#define INTMODULE_DMA_FLAG_TC DMA_IT_TCIF1
#define INTMODULE_DMA_CHANNEL DMA_Channel_5
@@ -425,26 +428,30 @@
#define EXTMODULE_RCC_APB2Periph (RCC_APB2Periph_TIM8 | RCC_APB2Periph_USART6)
#define EXTMODULE_TX_GPIO GPIOC
#define EXTMODULE_TX_GPIO_PIN GPIO_Pin_6 // PC.06
#define EXTMODULE_TX_GPIO_PIN_LL LL_GPIO_PIN_6
#define EXTMODULE_TX_GPIO_PinSource GPIO_PinSource6
#define EXTMODULE_TX_GPIO_AF GPIO_AF_TIM8 // TIM8_CH1
#define EXTMODULE_TX_GPIO_AF_USART GPIO_AF_USART6
#define EXTMODULE_RX_GPIO GPIOC
#define EXTMODULE_RX_GPIO_PIN GPIO_Pin_7 // PC.07
#define EXTMODULE_RX_GPIO_PIN_LL LL_GPIO_PIN_7
#define EXTMODULE_RX_GPIO_PinSource GPIO_PinSource7
#define EXTMODULE_RX_GPIO_AF_USART GPIO_AF_USART6
#define EXTMODULE_TIMER TIM8
#define EXTMODULE_TIMER_IRQn TIM8_CC_IRQn
#define EXTMODULE_TIMER_CC_IRQn TIM8_CC_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM8_CC_IRQHandler
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH1
#define EXTMODULE_TIMER_IRQn TIM8_UP_TIM13_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM8_UP_TIM13_IRQHandler
#define EXTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM8
//USART
#define EXTMODULE_USART USART6
#define EXTMODULE_USART_GPIO GPIOC
#define EXTMODULE_USART_GPIO_AF GPIO_AF_USART6
#define EXTMODULE_USART_GPIO_AF_LL LL_GPIO_AF_8
#define EXTMODULE_USART_TX_DMA DMA2
#define EXTMODULE_USART_TX_DMA_CHANNEL DMA_Channel_5
#define EXTMODULE_USART_TX_DMA_STREAM DMA2_Stream7
#define EXTMODULE_USART_TX_DMA_STREAM_LL LL_DMA_STREAM_7
#define EXTMODULE_USART_TX_DMA_IRQn DMA2_Stream7_IRQn
#define EXTMODULE_USART_TX_DMA_IRQHandler DMA2_Stream7_IRQHandler
#define EXTMODULE_USART_TX_DMA_FLAG_TC DMA_IT_TCIF7
@@ -462,6 +469,8 @@
//TIMER
#define EXTMODULE_TIMER_DMA_CHANNEL DMA_Channel_7
#define EXTMODULE_TIMER_DMA_STREAM DMA2_Stream1
#define EXTMODULE_TIMER_DMA DMA2
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream1_IRQn
#define EXTMODULE_TIMER_DMA_IRQHandler DMA2_Stream1_IRQHandler
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF1
@@ -551,10 +560,10 @@
#define TIMER_2MHz_TIMER TIM7
// Mixer scheduler timer
#define MIXER_SCHEDULER_TIMER_RCC_APB1Periph RCC_APB1Periph_TIM13
#define MIXER_SCHEDULER_TIMER TIM13
#define MIXER_SCHEDULER_TIMER_RCC_APB1Periph RCC_APB1Periph_TIM12
#define MIXER_SCHEDULER_TIMER TIM12
#define MIXER_SCHEDULER_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define MIXER_SCHEDULER_TIMER_IRQn TIM8_UP_TIM13_IRQn
#define MIXER_SCHEDULER_TIMER_IRQHandler TIM8_UP_TIM13_IRQHandler
#define MIXER_SCHEDULER_TIMER_IRQn TIM8_BRK_TIM12_IRQn
#define MIXER_SCHEDULER_TIMER_IRQHandler TIM8_BRK_TIM12_IRQHandler
#endif // _HAL_H_
-130
View File
@@ -1,130 +0,0 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
void intmoduleStop(void);
void extmoduleStop(void);
void intmoduleNoneStart(void);
void intmodulePxxStart(void);
void extmoduleNoneStart(void);
void extmodulePpmStart(void);
void extmodulePxxStart(void);
#if defined(DSM2)
void extmoduleDsm2Start(void);
#endif
void extmoduleCrossfireStart(void);
void init_no_pulses(uint32_t port)
{
if (port == INTERNAL_MODULE)
intmoduleNoneStart();
else
extmoduleNoneStart();
}
void disable_no_pulses(uint32_t port)
{
if (port == INTERNAL_MODULE)
intmoduleStop();
else
extmoduleStop();
}
void init_ppm(uint32_t port)
{
if (port == EXTERNAL_MODULE) {
extmodulePpmStart();
}
}
void disable_ppm(uint32_t port)
{
if (port == EXTERNAL_MODULE) {
extmoduleStop();
}
}
void init_pxx(uint32_t port)
{
if (port == INTERNAL_MODULE)
intmodulePxxStart();
else
extmodulePxxStart();
}
void disable_pxx(uint32_t port)
{
if (port == INTERNAL_MODULE)
intmoduleStop();
else
extmoduleStop();
}
#if defined(DSM2)
void init_dsm2(uint32_t port)
{
if (port == EXTERNAL_MODULE) {
extmoduleDsm2Start();
}
}
void disable_dsm2(uint32_t port)
{
if (port == EXTERNAL_MODULE) {
extmoduleStop();
}
}
#endif
void init_sbusOut(uint32_t port)
{
init_dsm2(port);
}
void disable_sbusOut(uint32_t port)
{
disable_dsm2(port);
}
void init_crossfire(uint32_t port)
{
if (port == EXTERNAL_MODULE) {
extmoduleCrossfireStart();
}
}
void disable_crossfire(uint32_t port)
{
if (port == EXTERNAL_MODULE) {
extmoduleStop();
}
}
void init_serial(uint32_t module_index, uint32_t baudrate, uint32_t period_half_us)
{
}
void disable_serial(uint32_t port)
{
}
+1 -1
View File
@@ -215,7 +215,7 @@ extern "C" void TELEMETRY_USART_IRQHandler(void)
}
// TODO we should have telemetry in an higher layer, functions above should move to a sport_driver.cpp
bool telemetryGetByte(uint8_t * byte)
bool sportGetByte(uint8_t * byte)
{
#if defined(PCBX12S)
if (telemetryFifoMode & TELEMETRY_SERIAL_WITHOUT_DMA)
+5
View File
@@ -16,6 +16,11 @@ set(SIMU_SRC
simufatfs.cpp
simudisk.cpp
simulcd.cpp
module_drivers.cpp
led_driver.cpp
backlight_driver.cpp
gyro_driver.cpp
bt_driver.cpp
)
if(SIMU_DISKIO)
@@ -0,0 +1,25 @@
/*
* Copyright (C) EdgeTx
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
bool isBacklightEnabled() { return false; }
void backlightEnable(unsigned char) {}
void backlightEnable(unsigned char, unsigned char) {}
void backlightDisable() {}
+33
View File
@@ -0,0 +1,33 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "fifo.h"
//#define BT_TX_FIFO_SIZE 64
Fifo<uint8_t, 2> btTxFifo;
Fifo<uint8_t, 2> btRxFifo;
void bluetoothInit(unsigned int, bool) {}
void bluetoothDisable() {}
void bluetoothWriteWakeup() {}
bool bluetoothIsWriting() { return false; }
+23
View File
@@ -0,0 +1,23 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
void gyroRead() {}
void gyroRead(unsigned char*) {}
+30
View File
@@ -0,0 +1,30 @@
/*
* Copyright (C) EdgeTx
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdint.h>
void usbChargerLed() {}
void ledRed() {}
void ledGreen() {}
void ledBlue() {}
void ledOff() {}
void fsLedOn(uint8_t) {}
void fsLedOff(uint8_t) {}
+94
View File
@@ -0,0 +1,94 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "hal/serial_driver.h"
#include "intmodule_serial_driver.h"
#include "extmodule_serial_driver.h"
#include "io/frsky_pxx2.h"
ModuleFifo intmoduleFifo;
ModuleFifo extmoduleFifo;
void intmoduleStop() {}
void intmoduleFifoError() {}
void intmoduleFifoReceive(uint8_t){}
void intmodulePxx1PulsesStart() {}
void intmoduleSendNextFramePxx1(unsigned short const*, unsigned char) {}
void extmoduleStop() {}
void extmoduleFifoError() {}
void extmoduleFifoReceive(uint8_t){}
void extmodulePpmStart(unsigned short, bool) {}
void extmoduleSerialStart() {}
void extmodulePxx1SerialStart() {}
void extmodulePxx1PulsesStart() {}
void extmoduleSendInvertedByte(uint8_t) {}
void extmoduleSendNextFramePxx1(void const*, unsigned short) {}
void extmoduleSendNextFrameSoftSerial(void const*, unsigned short, bool) {}
void extmoduleSendNextFramePpm(void*, unsigned short, unsigned short, bool) {}
void init_trainer_ppm() {}
void stop_trainer_ppm() {}
void init_trainer_capture() {}
void stop_trainer_capture() {}
void init_trainer_module_cppm() {}
void stop_trainer_module_cppm() {}
void init_trainer_module_sbus() {}
void stop_trainer_module_sbus() {}
void init_intmodule_heartbeat() {}
void stop_intmodule_heartbeat() {}
static void* init(const etx_serial_init*) { return nullptr; }
static void deinit(void*) {}
static void sendByte(void*, uint8_t) {}
static void sendBuffer(void*, const uint8_t*, uint8_t) {}
static void waitForTxCompleted(void*) {}
static int getByte(void*,uint8_t*) { return -1; }
const etx_serial_driver_t IntmoduleSerialDriver = {
.init = init,
.deinit = deinit,
.sendByte = sendByte,
.sendBuffer = sendBuffer,
.waitForTxCompleted = waitForTxCompleted,
.getByte = getByte,
.getBaudrate = nullptr,
.setReceiveCb = nullptr,
.setBaudrateCb = nullptr,
};
const etx_serial_driver_t ExtmoduleSerialDriver = {
.init = init,
.deinit = deinit,
.sendByte = sendByte,
.sendBuffer = sendBuffer,
.waitForTxCompleted = waitForTxCompleted,
.getByte = getByte,
.getBaudrate = nullptr,
.setReceiveCb = nullptr,
.setBaudrateCb = nullptr,
};
+27 -125
View File
@@ -47,34 +47,13 @@ bool simu_running = false;
uint32_t telemetryErrors = 0;
// TODO: remove all STM32 defs
GPIO_TypeDef gpioa, gpiob, gpioc, gpiod, gpioe, gpiof, gpiog, gpioh, gpioi, gpioj;
TIM_TypeDef tim1, tim2, tim3, tim4, tim5, tim6, tim7, tim8, tim9, tim10;
RCC_TypeDef rcc;
DMA_Stream_TypeDef dma1_stream1, dma1_stream2, dma1_stream3, dma1_stream4, dma1_stream5, dma1_stream6, dma1_stream7, dma2_stream1, dma2_stream2, dma2_stream5, dma2_stream6, dma2_stream7;
DMA_TypeDef dma2;
USART_TypeDef Usart0, Usart1, Usart2, Usart3, Usart4;
SysTick_Type systick;
ADC_Common_TypeDef adc;
RTC_TypeDef rtc;
void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct) { }
void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct) { }
void SPI_CalculateCRC(SPI_TypeDef* SPIx, FunctionalState NewState) { }
void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState) { }
FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG) { return RESET; }
uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx) { return 0; }
void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data) { }
void DMA_DeInit(DMA_Stream_TypeDef* DMAy_Streamx) { }
void DMA_Init(DMA_Stream_TypeDef* DMAy_Streamx, DMA_InitTypeDef* DMA_InitStruct) { }
void DMA_ITConfig(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_IT, FunctionalState NewState) { }
void DMA_StructInit(DMA_InitTypeDef* DMA_InitStruct) { }
void DMA_Cmd(DMA_Stream_TypeDef* DMAy_Streamx, FunctionalState NewState) { }
void lcdCopy(void * dest, void * src);
FlagStatus DMA_GetFlagStatus(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_FLAG) { return RESET; }
ITStatus DMA_GetITStatus(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_IT) { return RESET; }
void DMA_ClearITPendingBit(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_IT) { }
void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState) { }
void UART3_Configure(uint32_t baudrate, uint32_t masterClock) { }
void NVIC_Init(NVIC_InitTypeDef * NVIC_InitStruct) { }
FATFS g_FATFS_Obj;
@@ -129,15 +108,6 @@ uint64_t CoGetOSTime(void)
void simuInit()
{
RCC->CSR = 0;
// set power button to "not pressed"
#if defined(PWR_SWITCH_GPIO) // STM32
GPIO_SetBits(PWR_SWITCH_GPIO, PWR_SWITCH_GPIO_PIN);
#elif defined(PIO_PC17) // AT91SAM3
PIOC->PIO_PDSR &= ~PIO_PC17;
#endif
#if defined(ROTARY_ENCODER_NAVIGATION)
rotencValue = 0;
#endif
@@ -459,7 +429,7 @@ void telemetryPortInit(uint32_t baudrate, uint8_t mode)
{
}
bool telemetryGetByte(uint8_t * byte)
bool sportGetByte(uint8_t * byte)
{
return false;
}
@@ -488,35 +458,11 @@ void boardInit()
{
}
uint32_t pwrCheck()
{
// TODO: ability to simulate shutdown warning for a "soft" simulator restart
return simu_shutdown ? e_power_off : e_power_on;
}
bool pwrPressed()
{
// TODO: simulate power button
#if defined(PWR_SWITCH_GPIO) // STM32
return GPIO_ReadInputDataBit(PWR_SWITCH_GPIO, PWR_SWITCH_GPIO_PIN) == Bit_RESET;
#elif defined(PIO_PC17) // AT91SAM3
return PIOC->PIO_PDSR & PIO_PC17;
#else
return false;
#endif
}
void pwrInit()
{
}
void pwrOn()
{
}
void pwrOff()
{
}
uint32_t pwrCheck() { return simu_shutdown ? e_power_off : e_power_on; }
bool pwrPressed() { return false; }
void pwrInit() {}
void pwrOn() {}
void pwrOff() {}
void readKeysAndTrims()
{
@@ -745,6 +691,8 @@ void boardOff()
{
}
void hapticOff() {}
#if defined(PCBFRSKY) || defined(PCBFLYSKY)
HardwareOptions hardwareOptions;
#endif
@@ -784,6 +732,7 @@ void disableSpeaker()
}
#endif
int trainerModuleSbusGetByte(unsigned char*) { return 0; }
void rtcInit()
{
@@ -798,81 +747,34 @@ void rtcSetTime(const struct gtm * t)
}
#if defined(USB_SERIAL)
void usbSerialPutc(uint8_t c)
{
}
const etx_serial_port_t UsbSerialPort = { "VCP", nullptr, nullptr };
#endif
#if defined(AUX_SERIAL)
#if defined(AUX_SERIAL_DMA_Stream_RX)
AuxSerialRxFifo auxSerialRxFifo(nullptr);
const etx_serial_port_t auxSerialPort = { "AUX1", nullptr, nullptr };
#define AUX_SERIAL_PORT &auxSerialPort
#else
AuxSerialRxFifo auxSerialRxFifo;
#endif
uint8_t auxSerialMode;
void auxSerialSetup(unsigned int baudrate, bool dma, uint16_t length, uint16_t parity, uint16_t stop)
{
}
void auxSerialInit(unsigned int mode, unsigned int protocol)
{
}
void auxSerialPutc(char c)
{
}
void auxSerialSbusInit()
{
}
void auxSerialStop()
{
}
#define AUX_SERIAL_PORT nullptr
#endif
#if defined(AUX2_SERIAL)
AuxSerialRxFifo aux2SerialRxFifo(nullptr);
uint8_t aux2SerialMode;
const etx_serial_port_t aux2SerialPort = { "AUX2", nullptr, nullptr };
#define AUX2_SERIAL_PORT &aux2SerialPort
#else
#define AUX2_SERIAL_PORT nullptr
#endif // AUX2_SERIAL
void aux2SerialSetup(unsigned int baudrate, bool dma, uint16_t length, uint16_t parity, uint16_t stop)
static const etx_serial_port_t* serialPorts[MAX_AUX_SERIAL] = {
AUX_SERIAL_PORT,
AUX2_SERIAL_PORT,
};
const etx_serial_port_t* auxSerialGetPort(int port_nr)
{
if (port_nr >= MAX_AUX_SERIAL) return nullptr;
return serialPorts[port_nr];
}
void aux2SerialInit(unsigned int mode, unsigned int protocol)
{
}
void aux2SerialPutc(char c)
{
}
void aux2SerialSbusInit()
{
}
void aux2SerialStop()
{
}
#endif
#if defined(INTMODULE_HEARTBEAT_GPIO)
volatile HeartbeatCapture heartbeatCapture;
void init_intmodule_heartbeat()
{
}
void stop_intmodule_heartbeat()
{
}
void check_intmodule_heartbeat()
{
}
#endif
#if defined(HARDWARE_TOUCH)
struct TouchState simTouchState = {};
bool simTouchOccured = false;
+72 -65
View File
@@ -19,7 +19,7 @@ if(PCB STREQUAL X9E)
set(CPU_TYPE STM32F4)
set(CPU_TYPE_FULL STM32F407xE) # for size report
set(LINKER_SCRIPT targets/taranis/stm32f4_flash.ld)
add_definitions(-DSTM32F40_41xxx)
add_definitions(-DSTM32F40_41xxx -DSTM32F407xx)
set(HAPTIC YES)
set(LUA_EXPORT lua_export_x9e)
set(FLAVOUR x9e)
@@ -31,7 +31,7 @@ if(PCB STREQUAL X9E)
top_lcd_driver.cpp
startup_stm32f40_41xxx.s
)
set(AUX_SERIAL_DRIVER ../common/arm/stm32/aux_serial_driver.cpp)
set(AUX_SERIAL ON)
if(STICKS STREQUAL HORUS)
add_definitions(-DHORUS_STICKS)
endif()
@@ -75,7 +75,7 @@ elseif(PCB STREQUAL X9D+)
startup_stm32f40_41xxx.s
)
add_definitions(-DRADIO_X9DP2019)
add_definitions(-DSTM32F40_41xxx)
add_definitions(-DSTM32F40_41xxx -DSTM32F407xx)
add_definitions(-DSOFTWARE_VOLUME -DPWR_BUTTON_${PWR_BUTTON} -DHARDWARE_POWER_MANAGEMENT_UNIT)
set(STATUS_LEDS YES)
set(PXX2 ON)
@@ -88,8 +88,9 @@ elseif(PCB STREQUAL X9D+)
set(FLAVOUR x9d+)
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(AUX_SERIAL_DRIVER ../common/arm/stm32/aux_serial_driver.cpp)
set(AUX_SERIAL ON)
set(STATUS_LEDS NO)
endif()
elseif(PCB STREQUAL X9D)
@@ -97,6 +98,7 @@ elseif(PCB STREQUAL X9D)
set(FLAVOUR x9d)
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
option(HAPTIC "Haptic support" OFF)
set(LUA_EXPORT lua_export_x9d)
@@ -108,7 +110,7 @@ elseif(PCB STREQUAL X9D)
set(BITMAPS_TARGET taranis_bitmaps)
set(FONTS_TARGET taranis_fonts)
set(LCD_DRIVER lcd_driver_aspi.cpp)
set(AUX_SERIAL_DRIVER ../common/arm/stm32/aux_serial_driver.cpp)
set(AUX_SERIAL ON)
set(GVAR_SCREEN model_gvars.cpp)
set(STATUS_LEDS NO)
add_definitions(-DMANUFACTURER_FRSKY)
@@ -132,6 +134,7 @@ elseif(PCB STREQUAL X7)
set(NAVIGATION_TYPE 9x)
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(LUA_EXPORT lua_export_t12)
add_definitions(-DRADIO_T12)
@@ -146,6 +149,7 @@ elseif(PCB STREQUAL X7)
set(CPU_TYPE STM32F2)
set(ROTARY_ENCODER YES)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(LUA_EXPORT lua_export_tpro)
add_definitions(-DFUNCTION_SWITCHES)
@@ -161,6 +165,7 @@ elseif(PCB STREQUAL X7)
set(NAVIGATION_TYPE 9x)
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(LUA_EXPORT lua_export_tlite)
add_definitions(-DRADIO_TLITE)
@@ -174,6 +179,7 @@ elseif(PCB STREQUAL X7)
set(NAVIGATION_TYPE x7)
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(ROTARY_ENCODER YES)
set(LUA_EXPORT lua_export_tx12)
@@ -189,18 +195,19 @@ elseif(PCB STREQUAL X7)
set(NAVIGATION_TYPE x7)
set(CPU_TYPE STM32F4)
set(CPU_TYPE_FULL STM32F407xE) # for size report
add_definitions(-DSTM32F407xx)
set(LINKER_SCRIPT targets/taranis/stm32f4_flash.ld)
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
startup_stm32f40_41xxx.s
../../thirdparty/STM32F4xx_DSP_StdPeriph_Lib_V1.8.0/Libraries/STM32F4xx_StdPeriph_Driver/src/stm32f4xx_flash.c
)
add_definitions(-DSTM32F40_41xxx)
add_definitions(-DSTM32F40_41xxx -DSTM32F407xx)
set(ROTARY_ENCODER YES)
set(LUA_EXPORT lua_export_zorro)
set(BLUETOOTH NO)
set(USB_CHARGER YES)
set(AUX_SERIAL_DRIVER ../common/arm/stm32/aux_serial_driver.cpp)
set(AUX_SERIAL ON)
add_definitions(-DRADIO_ZORRO)
add_definitions(-DEEPROM_VARIANT=0x4006)
add_definitions(-DMANUFACTURER_RADIOMASTER)
@@ -215,6 +222,7 @@ elseif(PCB STREQUAL X7)
set(NAVIGATION_TYPE x7)
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(ROTARY_ENCODER NO)
set(LUA_EXPORT lua_export_t8)
@@ -242,7 +250,7 @@ elseif(PCB STREQUAL X7)
${FIRMWARE_TARGET_SRC}
startup_stm32f40_41xxx.s
)
add_definitions(-DSTM32F40_41xxx)
add_definitions(-DSTM32F40_41xxx -DSTM32F407xx)
add_definitions(-DHARDWARE_POWER_MANAGEMENT_UNIT)
set(PXX2 ON)
set(PXX_FREQUENCY "HIGH")
@@ -255,6 +263,7 @@ elseif(PCB STREQUAL X7)
set(NAVIGATION_TYPE x7)
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(LUA_EXPORT lua_export_x7)
add_definitions(-DRADIO_X7)
@@ -279,6 +288,7 @@ elseif(PCB STREQUAL X9LITE)
set(PWR_BUTTON "PRESS" CACHE STRING "Pwr button type (PRESS/SWITCH)")
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(HAPTIC YES)
set(LUA_EXPORT lua_export_x9lite)
@@ -305,6 +315,7 @@ elseif(PCB STREQUAL X9LITES)
set(PWR_BUTTON "PRESS" CACHE STRING "Pwr button type (PRESS/SWITCH)")
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(HAPTIC YES)
set(LUA_EXPORT lua_export_x9lites)
@@ -332,6 +343,7 @@ elseif(PCB STREQUAL XLITE)
set(PWR_BUTTON "PRESS" CACHE STRING "Pwr button type (PRESS/SWITCH)")
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(HAPTIC YES)
set(LUA_EXPORT lua_export_xlite)
@@ -357,6 +369,7 @@ elseif(PCB STREQUAL XLITES)
set(PWR_BUTTON "PRESS" CACHE STRING "Pwr button type (PRESS/SWITCH)")
set(CPU_TYPE STM32F2)
set(CPU_TYPE_FULL STM32F205xE) # for size report
add_definitions(-DSTM32F205xx)
set(LINKER_SCRIPT targets/taranis/stm32f2_flash.ld)
set(HAPTIC YES)
set(LUA_EXPORT lua_export_xlites)
@@ -384,9 +397,9 @@ endif()
if(GYRO)
add_definitions(-DGYRO)
set(TARGET_SRC
${TARGET_SRC}
../common/arm/stm32/lsm6ds_driver.cpp
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/lsm6ds_driver.cpp
)
set(SRC
${SRC}
@@ -408,9 +421,10 @@ if(INTERNAL_MODULE_SERIAL)
if(PXX_FREQUENCY STREQUAL HIGH)
add_definitions(-DPXX_FREQUENCY_HIGH)
endif()
set(TARGET_SRC
${TARGET_SRC}
../common/arm/stm32/intmodule_serial_driver.cpp
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/intmodule_serial_driver.cpp
targets/common/arm/stm32/stm32_usart_driver.cpp
)
else()
@@ -418,46 +432,51 @@ else()
# defines existing internal modules
set(INTERNAL_MODULES PXX1)
set(TARGET_SRC
${TARGET_SRC}
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
intmodule_pulses_driver.cpp
)
endif()
if(HARDWARE_EXTERNAL_MODULE)
set(TARGET_SRC ${TARGET_SRC} extmodule_driver.cpp)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/extmodule_driver.cpp
targets/common/arm/stm32/stm32_pulse_driver.cpp
targets/common/arm/stm32/extmodule_serial_driver.cpp
targets/common/arm/stm32/stm32_usart_driver.cpp
)
endif()
if(ROTARY_ENCODER)
set(TARGET_SRC
${TARGET_SRC}
../common/arm/stm32/rotary_encoder_driver.cpp
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/rotary_encoder_driver.cpp
)
endif()
if(BIND_KEY)
set(TARGET_SRC
${TARGET_SRC}
bind_button_driver.cpp
)
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
bind_button_driver.cpp
)
add_definitions(-DBIND_KEY)
endif()
if(USB_CHARGER)
set(TARGET_SRC ${TARGET_SRC} usb_charger_driver.cpp)
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC} usb_charger_driver.cpp)
add_definitions(-DUSB_CHARGER)
endif()
if(BLUETOOTH)
add_definitions(-DBLUETOOTH)
set(TARGET_SRC
${TARGET_SRC}
../common/arm/stm32/bluetooth_driver.cpp
)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/bluetooth_driver.cpp)
set(SRC
${SRC}
bluetooth.cpp
)
bluetooth.cpp)
if(NOT PCB STREQUAL X9E)
# Bluetooth on X9E is compatible with almost nothing
add_definitions(-DHARDWARE_TRAINER_BLUETOOTH)
@@ -487,7 +506,6 @@ endif()
add_definitions(-DPCBTARANIS)
add_definitions(-DAUDIO -DVOICE -DRTCLOCK)
add_definitions(-DSBUS_TRAINER)
set(SRC
${SRC}
@@ -512,43 +530,32 @@ if(STATUS_LEDS)
set(LED_DRIVER led_driver.cpp)
endif()
set(SRC
${SRC}
sbus.cpp
)
set(TARGET_SRC
${TARGET_SRC}
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
${LED_DRIVER}
backlight_driver.cpp
trainer_driver.cpp
../common/arm/stm32/timers_driver.cpp
../common/arm/stm32/audio_dac_driver.cpp
)
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
../common/arm/stm32/stm32_hal_adc.cpp
../../hal/adc_driver.cpp
../common/arm/stm32/heartbeat_driver.cpp
../common/arm/stm32/mixer_scheduler_driver.cpp
)
if(PCB STREQUAL XLITE OR PCB STREQUAL XLITES)
set(TARGET_SRC
${TARGET_SRC}
../common/arm/stm32/sticks_pwm_driver.cpp
)
endif()
set(FIRMWARE_TARGET_SRC
${FIRMWARE_TARGET_SRC}
${LCD_DRIVER}
board.cpp
i2c_driver.cpp
../common/arm/stm32/pwr_driver.cpp
../common/arm/stm32/heartbeat_driver.cpp
../common/arm/loadboot.cpp
backlight_driver.cpp
trainer_driver.cpp
)
if(PCB STREQUAL XLITE OR PCB STREQUAL XLITES)
set(FIRMWARE_SRC
${FIRMWARE_SRC}
targets/common/arm/stm32/sticks_pwm_driver.cpp)
endif()
set(FIRMWARE_SRC
${FIRMWARE_SRC}
hal/adc_driver.cpp
targets/common/arm/loadboot.cpp
targets/common/arm/stm32/stm32_hal_adc.cpp
targets/common/arm/stm32/heartbeat_driver.cpp
targets/common/arm/stm32/mixer_scheduler_driver.cpp
targets/common/arm/stm32/timers_driver.cpp
targets/common/arm/stm32/audio_dac_driver.cpp
targets/common/arm/stm32/pwr_driver.cpp
)
if(LCD_DUAL_BUFFER)
+32 -3
View File
@@ -24,6 +24,12 @@
#include "hal/adc_driver.h"
#include "stm32_hal_adc.h"
#include "../common/arm/stm32/timers_driver.h"
#if defined(AUX_SERIAL)
#include "aux_serial_driver.h"
#endif
#if defined(__cplusplus)
extern "C" {
#endif
@@ -221,9 +227,8 @@ void boardInit()
i2cInit();
usbInit();
#if defined(DEBUG) && defined(AUX_SERIAL_GPIO)
auxSerialInit(0, 0); // default serial mode (None if DEBUG not defined)
TRACE("\nTaranis board started :)");
#if defined(DEBUG)
serialInit(SP_AUX1, UART_MODE_DEBUG);
#endif
#if defined(HAPTIC)
@@ -413,3 +418,27 @@ void initJackDetect(void)
GPIO_Init(JACK_DETECT_GPIO, &GPIO_InitStructure);
}
#endif
#if defined(AUX_SERIAL)
const etx_serial_port_t auxSerialPort = {
"AUX1",
&AuxSerialDriver,
nullptr
};
#define AUX_SERIAL_PORT &auxSerialPort
#else
#define AUX_SERIAL_PORT nullptr
#endif
#define AUX2_SERIAL_PORT nullptr
static const etx_serial_port_t* serialPorts[MAX_AUX_SERIAL] = {
AUX_SERIAL_PORT,
AUX2_SERIAL_PORT,
};
const etx_serial_port_t* auxSerialGetPort(int port_nr)
{
if (port_nr >= MAX_AUX_SERIAL) return nullptr;
return serialPorts[port_nr];
}
+12 -73
View File
@@ -27,6 +27,9 @@
#include "opentx_constants.h"
#include "board_common.h"
#include "hal.h"
#include "hal/serial_port.h"
#include "watchdog_driver.h"
#if defined(RADIO_TX12) || defined(RADIO_ZORRO)
#define NAVIGATION_X7_TX12
@@ -65,10 +68,6 @@ extern uint16_t sessionTimer;
void boardInit();
void boardOff();
// Timers driver
void init2MhzTimer();
void init1msTimer();
// PCBREV driver
enum {
// X7
@@ -115,24 +114,15 @@ uint32_t isFirmwareStart(const uint8_t * buffer);
uint32_t isBootloaderStart(const uint8_t * buffer);
// Pulses driver
#define INTERNAL_MODULE_ON() GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#if defined(INTMODULE_USART)
#define INTERNAL_MODULE_OFF() intmoduleStop()
#else
#define INTERNAL_MODULE_OFF() GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#endif
#define INTERNAL_MODULE_ON() GPIO_SetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#define INTERNAL_MODULE_OFF() GPIO_ResetBits(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN)
#if (defined(INTERNAL_MODULE_PXX1) || defined(INTERNAL_MODULE_PXX2)) && (!defined(PCBX9LITE) || defined(PCBX9LITES))
#define HARDWARE_INTERNAL_RAS
#endif
#define EXTERNAL_MODULE_ON() EXTERNAL_MODULE_PWR_ON()
#if defined(EXTMODULE_USART)
#define EXTERNAL_MODULE_OFF() extmoduleStop()
#else
#define EXTERNAL_MODULE_OFF() EXTERNAL_MODULE_PWR_OFF()
#endif
#define EXTERNAL_MODULE_OFF() EXTERNAL_MODULE_PWR_OFF()
#if defined(RADIO_T12)
#define IS_INTERNAL_MODULE_ON() false
@@ -140,12 +130,6 @@ uint32_t isBootloaderStart(const uint8_t * buffer);
#define IS_INTERNAL_MODULE_ON() (GPIO_ReadInputDataBit(INTMODULE_PWR_GPIO, INTMODULE_PWR_GPIO_PIN) == Bit_SET)
#endif
void extmoduleSerialStart();
void extmoduleInvertedSerialStart(uint32_t baudrate);
void extmoduleSendBuffer(const uint8_t * data, uint8_t size);
void extmoduleSendNextFrame();
void extmoduleSendInvertedByte(uint8_t byte);
// Trainer driver
#define SLAVE_MODE() (g_model.trainerData.mode == TRAINER_MODE_SLAVE)
@@ -181,36 +165,20 @@ void extmoduleSendInvertedByte(uint8_t byte);
#define init_trainer_capture()
#define stop_trainer_capture()
#endif
#if defined(TRAINER_MODULE_CPPM)
void init_trainer_module_cppm();
void stop_trainer_module_cppm();
#else
#define init_trainer_module_cppm()
#define stop_trainer_module_cppm()
#endif
#if defined(TRAINER_MODULE_SBUS)
void init_trainer_module_sbus();
void stop_trainer_module_sbus();
#else
#define init_trainer_module_sbus()
#define stop_trainer_module_sbus()
#endif
#if defined(INTMODULE_HEARTBEAT_GPIO)
void init_intmodule_heartbeat();
void stop_intmodule_heartbeat();
void check_intmodule_heartbeat();
#else
#define init_intmodule_heartbeat()
#define stop_intmodule_heartbeat()
#define check_intmodule_heartbeat()
int trainerModuleSbusGetByte(uint8_t* byte);
#endif
void check_telemetry_exti();
// SBUS
int sbusGetByte(uint8_t * byte);
// Keys driver
enum EnumKeys
{
@@ -540,20 +508,6 @@ uint8_t getFSPhysicalState(uint8_t index);
#define TRIMS_PRESSED() (readTrims())
#define KEYS_PRESSED() (readKeys())
// WDT driver
#define WDG_DURATION 500 /*ms*/
#if !defined(WATCHDOG) || defined(SIMU)
#define WDG_ENABLE(x)
#define WDG_RESET()
#else
#define WDG_ENABLE(x) watchdogInit(x)
#define WDG_RESET() IWDG->KR = 0xAAAA
#endif
void watchdogInit(unsigned int duration);
#define WAS_RESET_BY_SOFTWARE() (RCC->CSR & RCC_CSR_SFTRSTF)
#define WAS_RESET_BY_WATCHDOG() (RCC->CSR & (RCC_CSR_WDGRSTF | RCC_CSR_WWDGRSTF))
#define WAS_RESET_BY_WATCHDOG_OR_SOFTWARE() (RCC->CSR & (RCC_CSR_WDGRSTF | RCC_CSR_WWDGRSTF | RCC_CSR_SFTRSTF))
// ADC driver
enum Analogs {
STICK1,
@@ -816,7 +770,7 @@ void sportSendByte(uint8_t byte);
void sportSendByteLoop(uint8_t byte);
void sportStopSendByteLoop();
void sportSendBuffer(const uint8_t * buffer, uint32_t count);
bool telemetryGetByte(uint8_t * byte);
bool sportGetByte(uint8_t * byte);
void telemetryClearFifo();
extern uint32_t telemetryErrors;
@@ -901,23 +855,10 @@ void hapticOff();
void hapticOn();
#endif
// Aux serial port driver
#if defined(AUX_SERIAL_GPIO)
#define DEBUG_BAUDRATE 115200
#define LUA_DEFAULT_BAUDRATE 115200
#define AUX_SERIAL
extern uint8_t auxSerialMode;
#if defined __cplusplus
void auxSerialSetup(unsigned int baudrate, bool dma, uint16_t length = USART_WordLength_8b, uint16_t parity = USART_Parity_No, uint16_t stop = USART_StopBits_1);
#endif
void auxSerialInit(unsigned int mode, unsigned int protocol);
void auxSerialPutc(char c);
#define auxSerialTelemetryInit(protocol) auxSerialInit(UART_MODE_TELEMETRY, protocol)
void auxSerialSbusInit();
void auxSerialStop();
#define AUX_SERIAL_POWER_ON()
#define AUX_SERIAL_POWER_OFF()
#endif
const etx_serial_port_t* auxSerialGetPort(int port_nr);
// BT driver
#define BLUETOOTH_BOOTLOADER_BAUDRATE 230400
@@ -1037,8 +978,6 @@ void setTopBatteryValue(uint32_t volts);
#endif
extern Fifo<uint8_t, TELEMETRY_FIFO_SIZE> telemetryFifo;
typedef DMAFifo<32> AuxSerialRxFifo;
extern AuxSerialRxFifo auxSerialRxFifo;
#endif
// Gyro driver
@@ -1,424 +0,0 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
void extmoduleStop()
{
NVIC_DisableIRQ(EXTMODULE_TIMER_DMA_STREAM_IRQn);
NVIC_DisableIRQ(EXTMODULE_TIMER_CC_IRQn);
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
#if defined(EXTMODULE_USART)
EXTMODULE_USART_TX_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN | EXTMODULE_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(EXTMODULE_USART_GPIO, &GPIO_InitStructure);
// TX and RX are inverted, we set it to HIGH
GPIO_SetBits(EXTMODULE_USART_GPIO, EXTMODULE_TX_GPIO_PIN | EXTMODULE_RX_GPIO_PIN);
#endif
EXTMODULE_TIMER->DIER &= ~(TIM_DIER_CC2IE | TIM_DIER_UDE);
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
if (!IS_TRAINER_EXTERNAL_MODULE()) {
EXTERNAL_MODULE_PWR_OFF();
}
}
void extmodulePpmStart()
{
EXTERNAL_MODULE_ON();
GPIO_PinAFConfig(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PinSource, EXTMODULE_TIMER_TX_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(EXTMODULE_TX_GPIO, &GPIO_InitStructure);
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
EXTMODULE_TIMER->PSC = EXTMODULE_TIMER_FREQ / 2000000 - 1; // 0.5uS from 30MHz
EXTMODULE_TIMER->CCR1 = GET_MODULE_PPM_DELAY(EXTERNAL_MODULE)*2;
EXTMODULE_TIMER->CCER = EXTMODULE_TIMER_OUTPUT_ENABLE | (GET_MODULE_PPM_POLARITY(EXTERNAL_MODULE) ? EXTMODULE_TIMER_OUTPUT_POLARITY : 0); // // we are using complementary output so logic has to be reversed here
EXTMODULE_TIMER->BDTR = TIM_BDTR_MOE;
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0; // Force O/P high
EXTMODULE_TIMER->EGR = 1;
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC2PE; // PWM mode 1
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
EXTMODULE_TIMER->ARR = 45000;
EXTMODULE_TIMER->CCR2 = 40000; // The first frame will be sent in 20ms
EXTMODULE_TIMER->DIER |= TIM_DIER_UDE | TIM_DIER_CC2IE;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
NVIC_EnableIRQ(EXTMODULE_TIMER_DMA_STREAM_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_DMA_STREAM_IRQn, 7);
NVIC_EnableIRQ(EXTMODULE_TIMER_CC_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_CC_IRQn, 7);
}
void extmoduleSerialStart()
{
EXTERNAL_MODULE_ON();
GPIO_PinAFConfig(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PinSource, EXTMODULE_TIMER_TX_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(EXTMODULE_TX_GPIO, &GPIO_InitStructure);
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
EXTMODULE_TIMER->PSC = EXTMODULE_TIMER_FREQ / 2000000 - 1; // 0.5uS (2 MHz)
EXTMODULE_TIMER->CCR3 = 0;
EXTMODULE_TIMER->CCER = EXTMODULE_TIMER_OUTPUT_ENABLE | EXTMODULE_TIMER_OUTPUT_POLARITY;
EXTMODULE_TIMER->BDTR = TIM_BDTR_MOE; // Enable outputs
EXTMODULE_TIMER->CCR1 = 0;
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0; // Force O/P high
EXTMODULE_TIMER->EGR = 1; // Restart
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_0;
EXTMODULE_TIMER->ARR = 40000; // dummy value until the DMA request kicks in
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
EXTMODULE_TIMER->DIER |= TIM_DIER_UDE;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
NVIC_EnableIRQ(EXTMODULE_TIMER_DMA_STREAM_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_DMA_STREAM_IRQn, 7);
NVIC_EnableIRQ(EXTMODULE_TIMER_CC_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_CC_IRQn, 7);
}
#if defined(EXTMODULE_USART)
ModuleFifo extmoduleFifo;
void extmoduleInvertedSerialStart(uint32_t baudrate)
{
EXTERNAL_MODULE_ON();
// TX + RX Pins
GPIO_PinAFConfig(EXTMODULE_USART_GPIO, EXTMODULE_TX_GPIO_PinSource, EXTMODULE_USART_GPIO_AF);
GPIO_PinAFConfig(EXTMODULE_USART_GPIO, EXTMODULE_RX_GPIO_PinSource, EXTMODULE_USART_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN | EXTMODULE_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(EXTMODULE_USART_GPIO, &GPIO_InitStructure);
// UART config
USART_DeInit(EXTMODULE_USART);
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = baudrate;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_Init(EXTMODULE_USART, &USART_InitStructure);
USART_Cmd(EXTMODULE_USART, ENABLE);
extmoduleFifo.clear();
USART_ITConfig(EXTMODULE_USART, USART_IT_RXNE, ENABLE);
NVIC_SetPriority(EXTMODULE_USART_IRQn, 6);
NVIC_EnableIRQ(EXTMODULE_USART_IRQn);
}
void extmoduleSendBuffer(const uint8_t * data, uint8_t size)
{
DMA_InitTypeDef DMA_InitStructure;
DMA_DeInit(EXTMODULE_USART_TX_DMA_STREAM);
DMA_InitStructure.DMA_Channel = EXTMODULE_USART_TX_DMA_CHANNEL;
DMA_InitStructure.DMA_PeripheralBaseAddr = CONVERT_PTR_UINT(&EXTMODULE_USART->DR);
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
DMA_InitStructure.DMA_Memory0BaseAddr = CONVERT_PTR_UINT(data);
DMA_InitStructure.DMA_BufferSize = size;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(EXTMODULE_USART_TX_DMA_STREAM, &DMA_InitStructure);
DMA_Cmd(EXTMODULE_USART_TX_DMA_STREAM, ENABLE);
USART_DMACmd(EXTMODULE_USART, USART_DMAReq_Tx, ENABLE);
}
#define USART_FLAG_ERRORS (USART_FLAG_ORE | USART_FLAG_NE | USART_FLAG_FE | USART_FLAG_PE)
extern "C" void EXTMODULE_USART_IRQHandler(void)
{
uint32_t status = EXTMODULE_USART->SR;
while (status & (USART_FLAG_RXNE | USART_FLAG_ERRORS)) {
uint8_t data = EXTMODULE_USART->DR;
if (status & USART_FLAG_ERRORS) {
extmoduleFifo.errors++;
}
else {
extmoduleFifo.push(data);
}
status = EXTMODULE_USART->SR;
}
}
#endif
#if defined(PXX1)
void extmodulePxx1PulsesStart()
{
EXTERNAL_MODULE_ON();
GPIO_PinAFConfig(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PinSource, EXTMODULE_TIMER_TX_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = EXTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(EXTMODULE_TX_GPIO, &GPIO_InitStructure);
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
EXTMODULE_TIMER->PSC = EXTMODULE_TIMER_FREQ / 2000000 - 1; // 0.5uS (2Mhz)
EXTMODULE_TIMER->CCR3 = 0;
EXTMODULE_TIMER->CCER = EXTMODULE_TIMER_OUTPUT_ENABLE | EXTMODULE_TIMER_OUTPUT_POLARITY; // polarity, default low
EXTMODULE_TIMER->BDTR = TIM_BDTR_MOE; // Enable outputs
EXTMODULE_TIMER->CCR1 = 18;
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_0; // Force O/P high
EXTMODULE_TIMER->EGR = 1; // Restart
EXTMODULE_TIMER->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2; // 0 TOGGLE / 2 PWM1
EXTMODULE_TIMER->ARR = 40000;
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
EXTMODULE_TIMER->DIER |= TIM_DIER_UDE;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
NVIC_EnableIRQ(EXTMODULE_TIMER_DMA_STREAM_IRQn);
NVIC_SetPriority(EXTMODULE_TIMER_DMA_STREAM_IRQn, 7);
}
#endif
#if defined(PXX1) && defined(EXTMODULE_USART)
void extmodulePxx1SerialStart()
{
extmoduleInvertedSerialStart(EXTMODULE_PXX1_SERIAL_BAUDRATE);
}
#endif
void extmoduleSendNextFrame()
{
switch (moduleState[EXTERNAL_MODULE].protocol) {
case PROTOCOL_CHANNELS_PPM:
EXTMODULE_TIMER->CCR1 = GET_MODULE_PPM_DELAY(EXTERNAL_MODULE) * 2;
EXTMODULE_TIMER->CCER = EXTMODULE_TIMER_OUTPUT_ENABLE | (GET_MODULE_PPM_POLARITY(EXTERNAL_MODULE) ? EXTMODULE_TIMER_OUTPUT_POLARITY : 0); // // we are using complementary output so logic has to be reversed here
EXTMODULE_TIMER->CCR2 = *(extmodulePulsesData.ppm.ptr - 1) - 4000; // 2mS in advance
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | DMA_SxCR_PSIZE_0 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
EXTMODULE_TIMER_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
EXTMODULE_TIMER_DMA_STREAM->M0AR = CONVERT_PTR_UINT(extmodulePulsesData.ppm.pulses);
EXTMODULE_TIMER_DMA_STREAM->NDTR = extmodulePulsesData.ppm.ptr - extmodulePulsesData.ppm.pulses;
EXTMODULE_TIMER_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
break;
#if defined(PXX1)
case PROTOCOL_CHANNELS_PXX1_PULSES:
if (EXTMODULE_TIMER_DMA_STREAM->CR & DMA_SxCR_EN)
return;
// disable timer
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | DMA_SxCR_PSIZE_0 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
EXTMODULE_TIMER_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
EXTMODULE_TIMER_DMA_STREAM->M0AR = CONVERT_PTR_UINT(extmodulePulsesData.pxx.getData());
EXTMODULE_TIMER_DMA_STREAM->NDTR = extmodulePulsesData.pxx.getSize();
EXTMODULE_TIMER_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
// re-init timer
EXTMODULE_TIMER->EGR = 1;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
break;
#endif
#if defined(EXTMODULE_USART)
#if defined(PXX1) && defined(HARDWARE_EXTERNAL_MODULE_SIZE_SML)
case PROTOCOL_CHANNELS_PXX1_SERIAL:
extmoduleSendBuffer(extmodulePulsesData.pxx_uart.getData(), extmodulePulsesData.pxx_uart.getSize());
break;
#endif
#if defined(PXX2)
case PROTOCOL_CHANNELS_PXX2_HIGHSPEED:
case PROTOCOL_CHANNELS_PXX2_LOWSPEED:
extmoduleSendBuffer(extmodulePulsesData.pxx2.getData(), extmodulePulsesData.pxx2.getSize());
break;
#endif
#endif
#if defined(AFHDS3)
case PROTOCOL_CHANNELS_AFHDS3:
{
#if defined(EXTMODULE_USART) && defined(EXTMODULE_TX_INVERT_GPIO)
extmoduleSendBuffer(extmodulePulsesData.afhds3.getData(), extmodulePulsesData.afhds3.getSize());
#else
if (EXTMODULE_TIMER_DMA_STREAM->CR & DMA_SxCR_EN)
return;
const uint16_t* dataPtr = extmodulePulsesData.afhds3.getData();
uint32_t dataSize = extmodulePulsesData.afhds3.getSize();
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | DMA_SxCR_PSIZE_0 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
EXTMODULE_TIMER_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
EXTMODULE_TIMER_DMA_STREAM->M0AR = CONVERT_PTR_UINT(dataPtr);
EXTMODULE_TIMER_DMA_STREAM->NDTR = dataSize;
EXTMODULE_TIMER_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
// re-init timer
EXTMODULE_TIMER->EGR = TIM_PSCReloadMode_Immediate;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
#endif
}
break;
#endif
#if defined(SBUS) || defined(DSM2) || defined(MULTIMODULE)
case PROTOCOL_CHANNELS_SBUS:
// no break
case PROTOCOL_CHANNELS_DSM2_LP45:
case PROTOCOL_CHANNELS_DSM2_DSM2:
case PROTOCOL_CHANNELS_DSM2_DSMX:
case PROTOCOL_CHANNELS_MULTIMODULE:
if (EXTMODULE_TIMER_DMA_STREAM->CR & DMA_SxCR_EN)
return;
// disable timer
EXTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
if (PROTOCOL_CHANNELS_SBUS == moduleState[EXTERNAL_MODULE].protocol) {
EXTMODULE_TIMER->CCER = EXTMODULE_TIMER_OUTPUT_ENABLE | (GET_SBUS_POLARITY(EXTERNAL_MODULE) ? EXTMODULE_TIMER_OUTPUT_POLARITY : 0); // reverse polarity for Sbus if needed
}
// send DMA request
EXTMODULE_TIMER_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
EXTMODULE_TIMER_DMA_STREAM->CR |= EXTMODULE_TIMER_DMA_CHANNEL | DMA_SxCR_DIR_0 | DMA_SxCR_MINC | DMA_SxCR_PSIZE_0 | DMA_SxCR_MSIZE_0 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
EXTMODULE_TIMER_DMA_STREAM->PAR = CONVERT_PTR_UINT(&EXTMODULE_TIMER->ARR);
EXTMODULE_TIMER_DMA_STREAM->M0AR = CONVERT_PTR_UINT(extmodulePulsesData.dsm2.pulses);
EXTMODULE_TIMER_DMA_STREAM->NDTR = extmodulePulsesData.dsm2.ptr - extmodulePulsesData.dsm2.pulses;
EXTMODULE_TIMER_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
// re-init timer
EXTMODULE_TIMER->EGR = 1;
EXTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
break;
#endif
#if defined(CROSSFIRE)
case PROTOCOL_CHANNELS_CROSSFIRE:
sportSendBuffer(extmodulePulsesData.crossfire.pulses, extmodulePulsesData.crossfire.length);
break;
#endif
#if defined(GHOST)
case PROTOCOL_CHANNELS_GHOST:
sportSendBuffer(extmodulePulsesData.ghost.pulses, extmodulePulsesData.ghost.length);
break;
#endif
default:
EXTMODULE_TIMER->DIER |= TIM_DIER_CC2IE;
break;
}
}
void extmoduleSendInvertedByte(uint8_t byte)
{
uint16_t time;
uint32_t i;
__disable_irq();
time = getTmr2MHz();
GPIO_SetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
while ((uint16_t) (getTmr2MHz() - time) < 34) {
// wait
}
time += 34;
for (i = 0 ; i < 8 ; i += 1) {
if (byte & 1) {
GPIO_ResetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
}
else {
GPIO_SetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
}
byte >>= 1 ;
while ((uint16_t) (getTmr2MHz() - time) < 35) {
// wait
}
time += 35 ;
}
GPIO_ResetBits(EXTMODULE_TX_GPIO, EXTMODULE_TX_GPIO_PIN);
__enable_irq() ; // No need to wait for the stop bit to complete
while ((uint16_t) (getTmr2MHz() - time) < 34) {
// wait
}
}
extern "C" void EXTMODULE_TIMER_DMA_STREAM_IRQHandler()
{
if (!DMA_GetITStatus(EXTMODULE_TIMER_DMA_STREAM, EXTMODULE_TIMER_DMA_FLAG_TC))
return;
DMA_ClearITPendingBit(EXTMODULE_TIMER_DMA_STREAM, EXTMODULE_TIMER_DMA_FLAG_TC);
switch (moduleState[EXTERNAL_MODULE].protocol) {
case PROTOCOL_CHANNELS_PPM:
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
EXTMODULE_TIMER->DIER |= TIM_DIER_CC2IE; // Enable this interrupt
break;
}
}
extern "C" void EXTMODULE_TIMER_CC_IRQHandler()
{
EXTMODULE_TIMER->DIER &= ~TIM_DIER_CC2IE; // Stop this interrupt
EXTMODULE_TIMER->SR &= ~TIM_SR_CC2IF;
if (setupPulsesExternalModule()) {
extmoduleSendNextFrame();
}
}
+69 -56
View File
@@ -1353,9 +1353,12 @@
#define INTMODULE_GPIO_PinSource_RX GPIO_PinSource7
#define INTMODULE_USART USART1
#define INTMODULE_GPIO_AF GPIO_AF_USART1
#define INTMODULE_GPIO_AF_LL LL_GPIO_AF_7
#define INTMODULE_USART_IRQHandler USART1_IRQHandler
#define INTMODULE_USART_IRQn USART1_IRQn
#define INTMODULE_DMA DMA2
#define INTMODULE_DMA_STREAM DMA2_Stream7
#define INTMODULE_DMA_STREAM_LL LL_DMA_STREAM_7
#define INTMODULE_DMA_STREAM_IRQ DMA2_Stream7_IRQn
#define INTMODULE_DMA_STREAM_IRQHandler DMA2_Stream7_IRQHandler
#define INTMODULE_DMA_FLAG_TC DMA_IT_TCIF7
@@ -1378,9 +1381,12 @@
#define INTMODULE_GPIO_PinSource_RX GPIO_PinSource7
#define INTMODULE_USART USART1
#define INTMODULE_GPIO_AF GPIO_AF_USART1
#define INTMODULE_GPIO_AF_LL LL_GPIO_AF_7
#define INTMODULE_USART_IRQHandler USART1_IRQHandler
#define INTMODULE_USART_IRQn USART1_IRQn
#define INTMODULE_DMA DMA2
#define INTMODULE_DMA_STREAM DMA2_Stream7
#define INTMODULE_DMA_STREAM_LL LL_DMA_STREAM_7
#define INTMODULE_DMA_STREAM_IRQ DMA2_Stream7_IRQn
#define INTMODULE_DMA_STREAM_IRQHandler DMA2_Stream7_IRQHandler
#define INTMODULE_DMA_FLAG_TC DMA_IT_TCIF7
@@ -1398,9 +1404,12 @@
#define INTMODULE_GPIO_PinSource_RX GPIO_PinSource7
#define INTMODULE_USART USART1
#define INTMODULE_GPIO_AF GPIO_AF_USART1
#define INTMODULE_GPIO_AF_LL LL_GPIO_AF_7
#define INTMODULE_USART_IRQHandler USART1_IRQHandler
#define INTMODULE_USART_IRQn USART1_IRQn
#define INTMODULE_DMA DMA2
#define INTMODULE_DMA_STREAM DMA2_Stream7
#define INTMODULE_DMA_STREAM_LL LL_DMA_STREAM_7
#define INTMODULE_DMA_STREAM_IRQ DMA2_Stream7_IRQn
#define INTMODULE_DMA_STREAM_IRQHandler DMA2_Stream7_IRQHandler
#define INTMODULE_DMA_FLAG_TC DMA_IT_TCIF7
@@ -1418,9 +1427,12 @@
#define INTMODULE_GPIO_PinSource_RX GPIO_PinSource7
#define INTMODULE_USART USART1
#define INTMODULE_GPIO_AF GPIO_AF_USART1
#define INTMODULE_GPIO_AF_LL LL_GPIO_AF_7
#define INTMODULE_USART_IRQHandler USART1_IRQHandler
#define INTMODULE_USART_IRQn USART1_IRQn
#define INTMODULE_DMA DMA2
#define INTMODULE_DMA_STREAM DMA2_Stream7
#define INTMODULE_DMA_STREAM_LL LL_DMA_STREAM_7
#define INTMODULE_DMA_STREAM_IRQ DMA2_Stream7_IRQn
#define INTMODULE_DMA_STREAM_IRQHandler DMA2_Stream7_IRQHandler
#define INTMODULE_DMA_FLAG_TC DMA_IT_TCIF7
@@ -1438,15 +1450,17 @@
#define INTMODULE_TX_GPIO GPIOA
#define INTMODULE_TX_GPIO_PIN GPIO_Pin_10 // PA.10
#define INTMODULE_TX_GPIO_PinSource GPIO_PinSource10
#define INTMODULE_TIMER TIM1
#define INTMODULE_TIMER_CC_IRQn TIM1_CC_IRQn
#define INTMODULE_TIMER_CC_IRQHandler TIM1_CC_IRQHandler
#define INTMODULE_TX_GPIO_AF GPIO_AF_TIM1
#define INTMODULE_DMA_CHANNEL DMA_Channel_6
#define INTMODULE_DMA_STREAM DMA2_Stream5
#define INTMODULE_DMA_STREAM_IRQn DMA2_Stream5_IRQn
#define INTMODULE_DMA_STREAM_IRQHandler DMA2_Stream5_IRQHandler
#define INTMODULE_DMA_FLAG_TC DMA_IT_TCIF5
#define INTMODULE_TIMER TIM1
#define INTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH3
#define INTMODULE_TIMER_IRQn TIM1_UP_TIM10_IRQn
#define INTMODULE_TIMER_IRQHandler TIM1_UP_TIM10_IRQHandler
#define INTMODULE_TIMER_DMA DMA2
#define INTMODULE_TIMER_DMA_CHANNEL DMA_Channel_6
#define INTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_5
#define INTMODULE_TIMER_DMA_STREAM DMA2_Stream5
#define INTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream5_IRQn
#define INTMODULE_TIMER_DMA_IRQHandler DMA2_Stream5_IRQHandler
#define INTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#elif (defined(RADIO_FAMILY_JUMPER_T12) && defined(HARDWARE_INTERNAL_MODULE)) || defined(RADIO_TX12) || defined(RADIO_T8) || defined(RADIO_TPRO)
#define INTMODULE_RCC_AHB1Periph (RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOF | RCC_AHB1Periph_DMA1)
@@ -1461,19 +1475,13 @@
#define INTMODULE_GPIO_PinSource_RX GPIO_PinSource11
#define INTMODULE_USART USART3
#define INTMODULE_GPIO_AF GPIO_AF_USART3
#define INTMODULE_GPIO_AF_LL LL_GPIO_AF_7
#define INTMODULE_USART_IRQn USART3_IRQn
#define INTMODULE_USART_IRQHandler USART3_IRQHandler
#define INTMODULE_TIMER TIM2
#define INTMODULE_TIMER_IRQn TIM2_IRQn
#define INTMODULE_TIMER_IRQHandler TIM2_IRQHandler
#define INTMODULE_TIMER_CC_IRQn TIM2_CC_IRQn
#define INTMODULE_TIMER_CC_IRQHandler TIM2_CC_IRQHandler
#define INTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#if defined(RADIO_TPRO)
#define INTMODULE_BOOTCMD_GPIO GPIOF
#define INTMODULE_BOOTCMD_GPIO_PIN GPIO_Pin_11 // PF.11
#define INIT_INTMODULE_BOOTCMD_PIN() GPIO_ResetBits(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_GPIO_PIN);
#endif
// DMA1_Stream3 is already used by SDIO
#define INTMODULE_DMA NULL
#define INTMODULE_DMA_CHANNEL 0
#define INTMODULE_DMA_STREAM_LL 0
#else
#define INTMODULE_PULSES
#define INTMODULE_RCC_AHB1Periph (RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_DMA2)
@@ -1484,15 +1492,17 @@
#define INTMODULE_TX_GPIO GPIOA
#define INTMODULE_TX_GPIO_PIN GPIO_Pin_10 // PA.10
#define INTMODULE_TX_GPIO_PinSource GPIO_PinSource10
#define INTMODULE_TIMER TIM1
#define INTMODULE_TIMER_CC_IRQn TIM1_CC_IRQn
#define INTMODULE_TIMER_CC_IRQHandler TIM1_CC_IRQHandler
#define INTMODULE_TX_GPIO_AF GPIO_AF_TIM1
#define INTMODULE_DMA_CHANNEL DMA_Channel_6
#define INTMODULE_DMA_STREAM DMA2_Stream5
#define INTMODULE_DMA_STREAM_IRQn DMA2_Stream5_IRQn
#define INTMODULE_DMA_STREAM_IRQHandler DMA2_Stream5_IRQHandler
#define INTMODULE_DMA_FLAG_TC DMA_IT_TCIF5
#define INTMODULE_TIMER TIM1
#define INTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH3
#define INTMODULE_TIMER_IRQn TIM1_UP_TIM10_IRQn
#define INTMODULE_TIMER_IRQHandler TIM1_UP_TIM10_IRQHandler
#define INTMODULE_TIMER_DMA DMA2
#define INTMODULE_TIMER_DMA_CHANNEL DMA_Channel_6
#define INTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_5
#define INTMODULE_TIMER_DMA_STREAM DMA2_Stream5
#define INTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream5_IRQn
#define INTMODULE_TIMER_DMA_IRQHandler DMA2_Stream5_IRQHandler
#define INTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#endif
@@ -1527,23 +1537,27 @@
#define EXTMODULE_RX_GPIO_PIN GPIO_Pin_7 // PC.07
#define EXTMODULE_RX_GPIO_PinSource GPIO_PinSource7
#define EXTMODULE_TIMER TIM8
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH1
#define EXTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#define EXTMODULE_TIMER_CC_IRQn TIM8_CC_IRQn
#define EXTMODULE_TIMER_CC_IRQHandler TIM8_CC_IRQHandler
#define EXTMODULE_TIMER_IRQn TIM8_UP_TIM13_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM8_UP_TIM13_IRQHandler
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM8 // TIM8_CH1
#define EXTMODULE_TIMER_DMA_CHANNEL DMA_Channel_7
#define EXTMODULE_TIMER_DMA_STREAM DMA2_Stream1
#define EXTMODULE_TIMER_DMA DMA2
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream1_IRQn
#define EXTMODULE_TIMER_DMA_STREAM_IRQHandler DMA2_Stream1_IRQHandler
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF1
#define EXTMODULE_TIMER_OUTPUT_ENABLE TIM_CCER_CC1E
#define EXTMODULE_TIMER_OUTPUT_POLARITY TIM_CCER_CC1P
#define EXTMODULE_TIMER_DMA_IRQHandler DMA2_Stream1_IRQHandler
#define EXTMODULE_USART_GPIO_AF GPIO_AF_USART6
#define EXTMODULE_USART_GPIO_AF_LL LL_GPIO_AF_8
#define EXTMODULE_USART USART6
#define EXTMODULE_USART_IRQn USART6_IRQn
#define EXTMODULE_USART_IRQHandler USART6_IRQHandler
#define EXTMODULE_USART_TX_DMA DMA2
#define EXTMODULE_USART_TX_DMA_CHANNEL DMA_Channel_5
#define EXTMODULE_USART_TX_DMA_STREAM DMA2_Stream6
#define EXTMODULE_USART_TX_DMA_STREAM_LL LL_DMA_STREAM_6
#define EXTMODULE_USART_TX_DMA_FLAG_TC DMA_FLAG_TCIF6
#define EXTMODULE_USART_RX_DMA_CHANNEL DMA_Channel_5
#define EXTMODULE_USART_RX_DMA_STREAM DMA2_Stream1
#else
@@ -1558,16 +1572,16 @@
#define EXTMODULE_TX_GPIO_PIN GPIO_Pin_7
#define EXTMODULE_TX_GPIO_PinSource GPIO_PinSource7 // PA.07
#define EXTMODULE_TIMER TIM8
#define EXTMODULE_TIMER_Channel LL_TIM_CHANNEL_CH1N
#define EXTMODULE_TIMER_TX_GPIO_AF GPIO_AF_TIM8 // TIM8_CH1N
#define EXTMODULE_TIMER_CC_IRQn TIM8_CC_IRQn
#define EXTMODULE_TIMER_CC_IRQHandler TIM8_CC_IRQHandler
#define EXTMODULE_TIMER_IRQn TIM8_UP_TIM13_IRQn
#define EXTMODULE_TIMER_IRQHandler TIM8_UP_TIM13_IRQHandler
#define EXTMODULE_TIMER_DMA_CHANNEL DMA_Channel_7
#define EXTMODULE_TIMER_DMA_STREAM DMA2_Stream1
#define EXTMODULE_TIMER_DMA DMA2
#define EXTMODULE_TIMER_DMA_STREAM_LL LL_DMA_STREAM_1
#define EXTMODULE_TIMER_DMA_STREAM_IRQn DMA2_Stream1_IRQn
#define EXTMODULE_TIMER_DMA_STREAM_IRQHandler DMA2_Stream1_IRQHandler
#define EXTMODULE_TIMER_DMA_FLAG_TC DMA_IT_TCIF1
#define EXTMODULE_TIMER_OUTPUT_ENABLE TIM_CCER_CC1NE
#define EXTMODULE_TIMER_OUTPUT_POLARITY TIM_CCER_CC1NP
#define EXTMODULE_TIMER_DMA_IRQHandler DMA2_Stream1_IRQHandler
#define EXTMODULE_TIMER_FREQ (PERI2_FREQUENCY * TIMER_MULT_APB2)
#endif
@@ -1667,10 +1681,13 @@
#define AUX_SERIAL_GPIO_PinSource_TX GPIO_PinSource10
#define AUX_SERIAL_GPIO_PinSource_RX GPIO_PinSource11
#define AUX_SERIAL_GPIO_AF GPIO_AF_USART3
#define AUX_SERIAL_GPIO_AF_LL LL_GPIO_AF_7
#define AUX_SERIAL_USART USART3
#define AUX_SERIAL_USART_IRQHandler USART3_IRQHandler
#define AUX_SERIAL_USART_IRQn USART3_IRQn
#define AUX_SERIAL_DMA_RX DMA1
#define AUX_SERIAL_DMA_Stream_RX DMA1_Stream1
#define AUX_SERIAL_DMA_Stream_RX_LL LL_DMA_STREAM_1
#define AUX_SERIAL_DMA_Channel_RX DMA_Channel_4
#endif
@@ -1824,9 +1841,8 @@
#define INTMODULE_HEARTBEAT_EXTI_IRQHandler EXTI1_IRQHandler
#elif defined(RADIO_ZORRO)
#define INTMODULE_HEARTBEAT_RCC_AHB1Periph 0
#elif defined(RADIO_X7) || defined(RADIO_TX12) || defined(RADIO_TPRO)
#else
#define INTMODULE_HEARTBEAT
#define INTMODULE_HEARTBEAT_REUSE_INTERRUPT_ROTARY_ENCODER
#define INTMODULE_HEARTBEAT_RCC_AHB1Periph RCC_AHB1Periph_GPIOC
#define INTMODULE_HEARTBEAT_GPIO GPIOC
#define INTMODULE_HEARTBEAT_GPIO_PIN GPIO_Pin_7 // PC.07
@@ -1834,16 +1850,11 @@
#define INTMODULE_HEARTBEAT_EXTI_PinSource GPIO_PinSource7
#define INTMODULE_HEARTBEAT_EXTI_LINE EXTI_Line7
#define INTMODULE_HEARTBEAT_EXTI_IRQn EXTI9_5_IRQn
#else
#define INTMODULE_HEARTBEAT
#define INTMODULE_HEARTBEAT_RCC_AHB1Periph RCC_AHB1Periph_GPIOC
#define INTMODULE_HEARTBEAT_GPIO GPIOC
#define INTMODULE_HEARTBEAT_GPIO_PIN GPIO_Pin_7
#define INTMODULE_HEARTBEAT_EXTI_PortSource EXTI_PortSourceGPIOC
#define INTMODULE_HEARTBEAT_EXTI_PinSource GPIO_PinSource7
#define INTMODULE_HEARTBEAT_EXTI_LINE EXTI_Line7
#define INTMODULE_HEARTBEAT_EXTI_IRQn EXTI9_5_IRQn
#define INTMODULE_HEARTBEAT_EXTI_IRQHandler EXTI9_5_IRQHandler
#if defined(RADIO_X7) || defined(RADIO_TX12) || defined(RADIO_TPRO)
#define INTMODULE_HEARTBEAT_REUSE_INTERRUPT_ROTARY_ENCODER
#else
#define INTMODULE_HEARTBEAT_EXTI_IRQHandler EXTI9_5_IRQHandler
#endif
#endif
#if defined(PCBX9LITE)
@@ -1858,7 +1869,7 @@
#endif
// Trainer / Trainee from the module bay
#if defined(PCBX9LITE) || defined(PCBXLITE)
#if defined(PCBX9LITE) || defined(PCBXLITE) || defined(RADIO_X9DP2019) || defined(PCBX7ACCESS) || defined(RADIO_ZORRO)
#define TRAINER_MODULE_CPPM
#define TRAINER_MODULE_SBUS
#define TRAINER_MODULE_RCC_AHB1Periph 0
@@ -1875,7 +1886,9 @@
#define TRAINER_MODULE_CPPM_CCMR1 (TIM_CCMR1_IC2F_0 | TIM_CCMR1_IC2F_1 | TIM_CCMR1_CC2S_0)
#define TRAINER_MODULE_CPPM_CCER TIM_CCER_CC2E
#define TRAINER_MODULE_CPPM_TIMER_IRQn TIM3_IRQn
#if defined(PCBX9LITE) || defined(PCBXLITE)
#define TRAINER_MODULE_CPPM_TIMER_IRQHandler TIM3_IRQHandler
#endif
#define TRAINER_MODULE_SBUS_GPIO EXTMODULE_USART_GPIO
#define TRAINER_MODULE_SBUS_GPIO_PIN EXTMODULE_RX_GPIO_PIN
#define TRAINER_MODULE_SBUS_GPIO_AF EXTMODULE_USART_GPIO_AF
@@ -2368,10 +2381,10 @@
#define TIMER_2MHz_TIMER TIM7
// Mixer scheduler timer
#define MIXER_SCHEDULER_TIMER_RCC_APB1Periph RCC_APB1Periph_TIM13
#define MIXER_SCHEDULER_TIMER TIM13
#define MIXER_SCHEDULER_TIMER_RCC_APB1Periph RCC_APB1Periph_TIM12
#define MIXER_SCHEDULER_TIMER TIM12
#define MIXER_SCHEDULER_TIMER_FREQ (PERI1_FREQUENCY * TIMER_MULT_APB1)
#define MIXER_SCHEDULER_TIMER_IRQn TIM8_UP_TIM13_IRQn
#define MIXER_SCHEDULER_TIMER_IRQHandler TIM8_UP_TIM13_IRQHandler
#define MIXER_SCHEDULER_TIMER_IRQn TIM8_BRK_TIM12_IRQn
#define MIXER_SCHEDULER_TIMER_IRQHandler TIM8_BRK_TIM12_IRQHandler
#endif // _HAL_H_
@@ -19,154 +19,71 @@
* GNU General Public License for more details.
*/
#include "opentx.h"
#include "pulses/pulses.h"
#include "stm32_pulse_driver.h"
#include "hal.h"
#include "timers_driver.h"
static const stm32_pulse_timer_t intmoduleTimer = {
.GPIOx = INTMODULE_TX_GPIO,
.GPIO_Pin = INTMODULE_TX_GPIO_PIN,
.GPIO_Alternate = INTMODULE_TX_GPIO_AF,
.TIMx = INTMODULE_TIMER,
.TIM_Prescaler = __LL_TIM_CALC_PSC(INTMODULE_TIMER_FREQ, 2000000),
.TIM_Channel = INTMODULE_TIMER_Channel,
.TIM_IRQn = INTMODULE_TIMER_IRQn,
.DMAx = INTMODULE_TIMER_DMA,
.DMA_Stream = INTMODULE_TIMER_DMA_STREAM_LL,
.DMA_Channel = INTMODULE_TIMER_DMA_CHANNEL,
.DMA_IRQn = INTMODULE_TIMER_DMA_STREAM_IRQn,
};
// Make sure the timer channel is supported
static_assert(__STM32_PULSE_IS_TIMER_CHANNEL_SUPPORTED(INTMODULE_TIMER_Channel),
"Unsupported timer channel");
// Make sure the DMA channel is supported
static_assert(__STM32_PULSE_IS_DMA_STREAM_SUPPORTED(INTMODULE_TIMER_DMA_STREAM_LL),
"Unsupported DMA stream");
#if !defined(INTMODULE_TIMER_DMA_IRQHandler)
#error "Missing INTMODULE_TIMER_DMA_IRQHandler definition"
#endif
extern "C" void INTMODULE_TIMER_DMA_IRQHandler()
{
stm32_pulse_dma_tc_isr(&intmoduleTimer);
}
#if !defined(INTMODULE_TIMER_IRQHandler)
#error "Missing INTMODULE_TIMER_IRQHandler definition"
#endif
extern "C" void INTMODULE_TIMER_IRQHandler()
{
stm32_pulse_tim_update_isr(&intmoduleTimer);
}
void intmoduleStop()
{
INTERNAL_MODULE_OFF();
NVIC_DisableIRQ(INTMODULE_DMA_STREAM_IRQn);
NVIC_DisableIRQ(INTMODULE_TIMER_CC_IRQn);
INTMODULE_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
INTMODULE_TIMER->DIER &= ~(TIM_DIER_CC2IE | TIM_DIER_UDE);
INTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
stm32_pulse_deinit(&intmoduleTimer);
}
// #define HEARBEAT_OFFSET unsigned(6000 + g_model.flightModeData[0].gvars[0] * 100)
constexpr unsigned HEARBEAT_OFFSET = 6000;
#if defined(PXX1)
void intmodulePxx1PulsesStart()
{
INTERNAL_MODULE_ON();
GPIO_PinAFConfig(INTMODULE_TX_GPIO, INTMODULE_TX_GPIO_PinSource, INTMODULE_TX_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = INTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(INTMODULE_TX_GPIO, &GPIO_InitStructure);
INTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
INTMODULE_TIMER->PSC = INTMODULE_TIMER_FREQ / 2000000 - 1; // 0.5uS (2Mhz)
INTMODULE_TIMER->CCER = TIM_CCER_CC3E | TIM_CCER_CC3NE;
INTMODULE_TIMER->BDTR = TIM_BDTR_MOE; // Enable outputs
INTMODULE_TIMER->CCR3 = 16;
INTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3M_0; // Force O/P high
INTMODULE_TIMER->EGR = 1; // Restart
INTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3PE;
INTMODULE_TIMER->ARR = 40000;
INTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
INTMODULE_TIMER->DIER |= TIM_DIER_UDE; // Enable DMA on update
INTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
NVIC_EnableIRQ(INTMODULE_DMA_STREAM_IRQn);
NVIC_SetPriority(INTMODULE_DMA_STREAM_IRQn, 7);
NVIC_EnableIRQ(INTMODULE_TIMER_CC_IRQn);
NVIC_SetPriority(INTMODULE_TIMER_CC_IRQn, 7);
stm32_pulse_config_output(&intmoduleTimer, false, LL_TIM_OCMODE_PWM1, 9 * 2);
stm32_pulse_init(&intmoduleTimer);
}
void intmoduleSendNextFramePxx1(const uint16_t* data, uint8_t size)
{
if (INTMODULE_DMA_STREAM->CR & DMA_SxCR_EN) return;
if (!stm32_pulse_if_not_running_disable(&intmoduleTimer)) return;
// disable timer
INTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
// INTMODULE_TIMER->CCR2 = last - 4000; // 2mS in advance
INTMODULE_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
INTMODULE_DMA_STREAM->CR |= INTMODULE_DMA_CHANNEL | DMA_SxCR_DIR_0 |
DMA_SxCR_MINC | DMA_SxCR_PSIZE_0 |
DMA_SxCR_MSIZE_0 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
INTMODULE_DMA_STREAM->PAR = CONVERT_PTR_UINT(&INTMODULE_TIMER->ARR);
INTMODULE_DMA_STREAM->M0AR = CONVERT_PTR_UINT(data);
INTMODULE_DMA_STREAM->NDTR = size;
INTMODULE_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
// re-init timer
INTMODULE_TIMER->EGR = 1;
INTMODULE_TIMER->CR1 |= TIM_CR1_CEN;
// Start DMA request and re-enable timer
stm32_pulse_start_dma_req(&intmoduleTimer, data, size, LL_TIM_OCMODE_PWM1,
9 * 2);
}
#endif
#if defined(INTERNAL_MODULE_PPM)
void intmodulePpmStart()
{
INTERNAL_MODULE_ON();
GPIO_PinAFConfig(INTMODULE_TX_GPIO, INTMODULE_TX_GPIO_PinSource, INTMODULE_TX_GPIO_AF);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = INTMODULE_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(INTMODULE_TX_GPIO, &GPIO_InitStructure);
INTMODULE_TIMER->CR1 &= ~TIM_CR1_CEN;
INTMODULE_TIMER->PSC = INTMODULE_TIMER_FREQ / 2000000 - 1; // 0.5uS from 30MHz
INTMODULE_TIMER->ARR = 45000;
INTMODULE_TIMER->CCMR2 = TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_2; // PWM mode 1
INTMODULE_TIMER->BDTR = TIM_BDTR_MOE;
INTMODULE_TIMER->EGR = 1;
INTMODULE_TIMER->DIER = TIM_DIER_UDE;
INTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
INTMODULE_TIMER->CCR2 = 40000; // The first frame will be sent in 20ms
INTMODULE_TIMER->DIER |= TIM_DIER_CC2IE; // Enable this interrupt
INTMODULE_TIMER->CR1 = TIM_CR1_CEN;
NVIC_EnableIRQ(INTMODULE_DMA_STREAM_IRQn);
NVIC_SetPriority(INTMODULE_DMA_STREAM_IRQn, 7);
NVIC_EnableIRQ(INTMODULE_TIMER_CC_IRQn);
NVIC_SetPriority(INTMODULE_TIMER_CC_IRQn, 7);
}
void intmoduleSendNextFramePPM(const uint8_t* data, uint8_t size)
{
INTMODULE_TIMER->CCR3 = GET_MODULE_PPM_DELAY(INTERNAL_MODULE) * 2;
INTMODULE_TIMER->CCER =
TIM_CCER_CC3E |
(GET_MODULE_PPM_POLARITY(INTERNAL_MODULE) ? 0 : TIM_CCER_CC3P);
INTMODULE_TIMER->CCR2 =
*(intmodulePulsesData.ppm.ptr - 1) - 4000; // 2mS in advance
INTMODULE_DMA_STREAM->CR &= ~DMA_SxCR_EN; // Disable DMA
INTMODULE_DMA_STREAM->CR |= INTMODULE_DMA_CHANNEL | DMA_SxCR_DIR_0 |
DMA_SxCR_MINC | DMA_SxCR_PSIZE_0 |
DMA_SxCR_MSIZE_0 | DMA_SxCR_PL_0 | DMA_SxCR_PL_1;
INTMODULE_DMA_STREAM->PAR = CONVERT_PTR_UINT(&INTMODULE_TIMER->ARR);
INTMODULE_DMA_STREAM->M0AR = CONVERT_PTR_UINT(data);
INTMODULE_DMA_STREAM->NDTR = size;
INTMODULE_DMA_STREAM->CR |= DMA_SxCR_EN | DMA_SxCR_TCIE; // Enable DMA
}
#endif // defined(INTERNAL_MODULE_PPM)
extern "C" void INTMODULE_DMA_STREAM_IRQHandler()
{
if (!DMA_GetITStatus(INTMODULE_DMA_STREAM, INTMODULE_DMA_FLAG_TC))
return;
DMA_ClearITPendingBit(INTMODULE_DMA_STREAM, INTMODULE_DMA_FLAG_TC);
switch (moduleState[INTERNAL_MODULE].protocol) {
case PROTOCOL_CHANNELS_PPM:
INTMODULE_TIMER->SR &= ~TIM_SR_CC2IF; // Clear flag
INTMODULE_TIMER->DIER |= TIM_DIER_CC2IE; // Enable this interrupt
break;
}
}
extern "C" void INTMODULE_TIMER_CC_IRQHandler()
{
INTMODULE_TIMER->DIER &= ~TIM_DIER_CC2IE; // Stop this interrupt
INTMODULE_TIMER->SR &= ~TIM_SR_CC2IF;
if (setupPulsesInternalModule()) {
intmoduleSendNextFrame();
}
}
+5 -14
View File
@@ -20,6 +20,7 @@
*/
#include "opentx.h"
#include "aux_serial_driver.h"
Fifo<uint8_t, TELEMETRY_FIFO_SIZE> telemetryFifo;
uint32_t telemetryErrors = 0;
@@ -392,22 +393,12 @@ extern "C" void TELEMETRY_TIMER_IRQHandler()
telemetryPortInvertedRxBit();
}
// TODO we should have telemetry in an higher layer, functions above should move to a sport_driver.cpp
bool telemetryGetByte(uint8_t * byte)
// TODO: we should have telemetry in an higher layer,
// functions above should move to a sport_driver.cpp
//
bool sportGetByte(uint8_t * byte)
{
#if defined(AUX_SERIAL)
if (telemetryProtocol == PROTOCOL_TELEMETRY_FRSKY_D_SECONDARY) {
if (auxSerialMode == UART_MODE_TELEMETRY)
return auxSerialRxFifo.pop(*byte);
else
return false;
}
else {
return telemetryFifo.pop(*byte);
}
#else
return telemetryFifo.pop(*byte);
#endif
}
void telemetryClearFifo()
+6 -19
View File
@@ -21,10 +21,6 @@
#include "opentx.h"
#if defined(TRAINER_MODULE_SBUS_USART)
DMAFifo<32> trainerSbusFifo __DMA (TRAINER_MODULE_SBUS_DMA_STREAM);
#endif
void trainerSendNextFrame();
#if defined(TRAINER_GPIO)
@@ -267,7 +263,11 @@ void stop_trainer_module_cppm()
}
#endif
// TODO: use external module serial driver
#if defined(TRAINER_MODULE_SBUS)
static DMAFifo<32> trainerSbusFifo __DMA (TRAINER_MODULE_SBUS_DMA_STREAM);
void init_trainer_module_sbus()
{
EXTERNAL_MODULE_ON();
@@ -328,22 +328,9 @@ void stop_trainer_module_sbus()
EXTERNAL_MODULE_OFF();
}
}
#endif
#if defined(SBUS_TRAINER)
int sbusGetByte(uint8_t * byte)
int trainerModuleSbusGetByte(uint8_t* byte)
{
switch (currentTrainerMode) {
#if defined(TRAINER_MODULE_SBUS_USART)
case TRAINER_MODE_MASTER_SBUS_EXTERNAL_MODULE:
return trainerSbusFifo.pop(*byte);
#endif
#if defined(AUX_SERIAL_USART)
case TRAINER_MODE_MASTER_BATTERY_COMPARTMENT:
return auxSerialRxFifo.pop(*byte);
#endif
default:
return false;
}
return trainerSbusFifo.pop(*byte);
}
#endif