chore: New module/serial API (#3055)

* WiP: new module interface

* WiP: softserial timer DMA

* WiP: setup() and send() in one step

and remove methods specific to internal or external module

* fixes and extra port config

* horus targets

* module ports have moved

* T8 support (only internal module)

* fix nv14

* stupid GCC....

* disable BT

* remove nv14 telem driver

* remove old aux serial driver

* Move module buffers out of pulses.h

* Soft serial fixes and PXX1 support

* Fixed PPM module output

* Fixed CLI

* compilation fixes

* Ported bluetooth and flysky gimbal to new serial driver

* Re-enable soft-serial RX

* fixes and cleanup

* nv14 fixes

* Fix flysky gimbals

* Ghost module

* 16 bytes of RAM

* Remove getByte from module API

* Ghost cleanup

* fix: _half_duplex_input() must be called after usart init

* WiP

* more cleanup

* Remove board specific settings from PXX1 / PXX2 drivers

* A bit of PXX2 header cleanup

* Add support for OVER8 and ONEBIT

* Add some support for inverters (NV14 / EL18)

* Support NV14 power fixes in generic board

* Fix polarity handling

* Fix RX DMA

* Fix mixer not running

* Add soft-serial polarity control

* Quick fix for telemetry polling while module port is changed

* Fix bootloader DEBUG

* Fix MPM telemetry

* Fix pulse start

* DSM2 soft-serial fallback

* DSMP async module restart

* Fix CRSF LUA upstream

* Remove global variable telemetryProtocol

* Use HAL/LL constants

* Fix various issue with AFHDS3 and NV14/EL18 internal module

* Fixed S.PORT unit tests

* fix: update widx after writing at current index

* fix: init error condition

* Fix: possible infinite loop in _find_port()

* Add support for bidir S.PORT init

* Add support for "getLastByte" in HW serial driver

* PXX1: Add support for S.PORT based on IDLE callback

* Fix rebase error

* Fix softserial _rx_fifo_push()

* Add softserial support for waitForTxCompleted()

* Fix MPM flashing (internal / external)

* Fixed external MPM

* Activate RX DMA on internal module

Seems to work with serial passthrough without issues, at least on the L3R PRO.

* Fix softserial DMA on stdlcd F4 targets

* Add softserial support for 32bit timers (mostly TIM2)

* More precise soft-serial

* Fix MPM update using inverters & HW uart

* Raise S.PORT DMA/USART IRQ prio to achieve faster switching to input

* Remove useless delays

* Fix flashing external ELRS module

* Added a retry mechanism for FrSky S.PORT update

* Remove useless enableRx()

* External FrSky modules are all flashed via S.PORT

* Remove power management unit update

This was only used on the first batch of X-lite.
This commit is contained in:
Raphael Coeffic
2023-02-09 19:44:32 +10:00
committed by GitHub
parent d80adc6c4d
commit 72193eda82
189 changed files with 7960 additions and 8364 deletions
+19 -143
View File
@@ -23,8 +23,9 @@
#include "opentx_helpers.h"
#include "debug.h"
#include "extmodule_driver.h"
#include "board.h"
#include "dataconstants.h"
#include "mixer_scheduler.h"
// timer is 2 MHz
#if defined(AFHDS3_SLOW)
@@ -60,110 +61,16 @@ enum DeviceAddress
//Address used in transmitted frames - it constrains of target address and source address
const uint8_t FrameAddress = DeviceAddress::TRANSMITTER | (DeviceAddress::MODULE << 4);
static void _serial_reset(void* buffer)
void FrameTransport::init(void* buffer)
{
auto data = (SerialData*)buffer;
data->ptr = data->pulses;
}
static void _serial_sendByte(void* buffer, uint8_t b)
{
auto data = (SerialData*)buffer;
*(data->ptr++) = b;
}
static void _serial_flush(void*) {}
uint32_t _serial_getSize(void* buffer)
{
auto data = (SerialData*)buffer;
return data->ptr - data->pulses;
}
static void _pulses_reset(void* buffer)
{
auto data = (PulsesData*)buffer;
data->ptr = data->pulses;
}
static inline void _pulses_send_level(PulsesData* data, uint16_t v)
{
uint32_t size = data->ptr - data->pulses;
if (size >= AFHDS_MAX_PULSES_TRANSITIONS) return;
*(data->ptr)++ = v;
}
static void _pulses_sendByte(void* buffer, uint8_t b)
{
auto data = (PulsesData*)buffer;
uint32_t size = data->ptr - data->pulses;
if (size >= AFHDS_MAX_PULSES_TRANSITIONS) return;
// use 8n1
// parity: If the parity is enabled, then the MSB bit of the data to be
// transmitted is changed by the parity bit start is always 0
bool level = 0;
uint16_t length = BITLEN_AFHDS; // start bit
for (uint8_t i = 0; i <= 8; i++) { // 8 data bits + Stop=1
bool next_level = b & 1;
if (level == next_level) {
length += BITLEN_AFHDS;
} else {
_pulses_send_level(data, length);
length = BITLEN_AFHDS;
level = next_level;
}
b = (b >> 1) | 0x80; // shift left to get next bit, fill msb with stop
// bit - needed just once
}
_pulses_send_level(data, length); // last bit (stop)
}
static void _pulses_flush(void* buffer)
{
// TODO: use less, as the new driver can handle it
auto data = (PulsesData*)buffer;
*data->ptr = 60000;
}
uint32_t _pulses_getSize(void* buffer)
{
auto data = (PulsesData*)buffer;
return data->ptr - data->pulses;
}
void ByteTransport::init(Type t)
{
if (t == Serial) {
reset = _serial_reset;
sendByte = _serial_sendByte;
flush = _serial_flush;
getSize = _serial_getSize;
} else if (t == Pulses) {
reset = _pulses_reset;
sendByte = _pulses_sendByte;
flush = _pulses_flush;
getSize = _pulses_getSize;
} else {
reset = nullptr;
sendByte = nullptr;
flush = nullptr;
getSize = nullptr;
}
}
void FrameTransport::init(ByteTransport::Type t, void* buffer)
{
trsp.init(t);
trsp_buffer = buffer;
trsp_buffer = (uint8_t*)buffer;
clear();
}
void FrameTransport::clear()
{
// reset send buffer
trsp.reset(trsp_buffer);
data_ptr = trsp_buffer;
// reset parser
esc_state = 0;
@@ -171,7 +78,7 @@ void FrameTransport::clear()
void FrameTransport::sendByte(uint8_t b)
{
trsp.sendByte(trsp_buffer, b);
*(data_ptr++) = b;
}
void FrameTransport::putBytes(uint8_t* data, int length)
@@ -197,7 +104,8 @@ void FrameTransport::putFrame(COMMAND command, FRAME_TYPE frameType, uint8_t* da
uint8_t dataLength, uint8_t frameIndex)
{
//header
trsp.reset(trsp_buffer);
data_ptr = trsp_buffer;
crc = 0;
sendByte(START);
@@ -213,7 +121,11 @@ void FrameTransport::putFrame(COMMAND command, FRAME_TYPE frameType, uint8_t* da
uint8_t crcValue = crc ^ 0xff;
putBytes(&crcValue, 1);
sendByte(END);
trsp.flush(trsp_buffer);
}
uint32_t FrameTransport::getFrameSize()
{
return data_ptr - trsp_buffer;
}
static bool _checkCRC(const uint8_t* data, uint8_t size)
@@ -311,35 +223,10 @@ void CommandFifo::enqueue(COMMAND command, FRAME_TYPE frameType, bool useData,
}
}
static const etx_serial_init _uartParams = {
.baudrate = AFHDS3_UART_BAUDRATE,
.parity = ETX_Parity_None,
.stop_bits = ETX_StopBits_One,
.word_length = ETX_WordLength_8,
.rx_enable = true,
};
void Transport::init(ByteTransport::Type t, void* buffer, const etx_serial_driver_t* drv)
void Transport::init(void* buffer, etx_module_state_t* mod_st)
{
trsp.init(t, buffer);
if (drv) {
uart_drv = drv;
uart_ctx = drv->init(&_uartParams);
} else {
uart_drv = nullptr;
uart_ctx = nullptr;
extmoduleSerialStart();
}
}
void Transport::deinit()
{
if (uart_drv) {
uart_drv->deinit(uart_ctx);
} else {
extmoduleStop();
}
trsp.init(buffer);
this->mod_st = mod_st;
}
void Transport::clear()
@@ -385,11 +272,9 @@ void Transport::enqueue(COMMAND command, FRAME_TYPE frameType, bool useData,
void Transport::sendBuffer()
{
if (uart_drv) {
uart_drv->sendBuffer(uart_ctx, (uint8_t*)trsp.trsp_buffer, trsp.getFrameSize());
} else {
extmoduleSendNextFrameSoftSerial((uint8_t*)trsp.trsp_buffer, trsp.getFrameSize());
}
auto drv = modulePortGetSerialDrv(mod_st->tx);
auto ctx = modulePortGetCtx(mod_st->tx);
drv->sendBuffer(ctx, (uint8_t*)trsp.trsp_buffer, trsp.getFrameSize());
}
bool Transport::processQueue()
@@ -474,15 +359,6 @@ bool Transport::handleReply(uint8_t* buffer, uint8_t len)
return false;
}
int Transport::getTelemetryByte(uint8_t* data)
{
if (uart_drv) {
return uart_drv->getByte(uart_ctx, data);
} else {
return sportGetByte(data);
}
}
bool Transport::processTelemetryData(uint8_t byte, uint8_t* rxBuffer,
uint8_t& rxBufferCount, uint8_t maxSize)
{