feat: Major serial driver re-write - see #1089 for details
Serial refactor
This commit is contained in:
@@ -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();
|
||||
|
||||
@@ -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(¶ms);
|
||||
}
|
||||
|
||||
#if defined(PXX1)
|
||||
void extmodulePxx1SerialStart()
|
||||
{
|
||||
EXTERNAL_MODULE_ON();
|
||||
etx_serial_init params(extmoduleSerialParams);
|
||||
params.baudrate = EXTMODULE_PXX1_SERIAL_BAUDRATE;
|
||||
ExtmoduleSerialDriver.init(¶ms);
|
||||
}
|
||||
#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(¶ms);
|
||||
(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;
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
)
|
||||
|
||||
|
||||
@@ -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
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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_
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
|
||||
@@ -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_
|
||||
|
||||
@@ -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)
|
||||
{
|
||||
}
|
||||
@@ -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)
|
||||
|
||||
@@ -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() {}
|
||||
@@ -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; }
|
||||
|
||||
@@ -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*) {}
|
||||
@@ -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) {}
|
||||
@@ -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,
|
||||
};
|
||||
@@ -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;
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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];
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user