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
+2 -2
View File
@@ -50,7 +50,7 @@ void BootloaderFirmwareUpdate::flashFirmware(const char * filename, ProgressHand
uint8_t buffer[1024];
UINT count;
pausePulses();
pulsesStop();
f_open(&file, filename, FA_READ);
@@ -110,5 +110,5 @@ void BootloaderFirmwareUpdate::flashFirmware(const char * filename, ProgressHand
f_close(&file);
resumePulses();
pulsesStart();
}
+188 -487
View File
@@ -24,6 +24,7 @@
#include "frsky_firmware_update.h"
#include "debug.h"
#include "timers_driver.h"
#include "tasks/mixer_task.h"
#if defined(LIBOPENUI)
#include "libopenui.h"
@@ -31,9 +32,7 @@
#include "libopenui/src/libopenui_file.h"
#endif
#if defined(INTMODULE_USART)
#include "intmodule_serial_driver.h"
#endif
#include "hal/module_port.h"
#define PRIM_REQ_POWERUP 0
#define PRIM_REQ_VERSION 1
@@ -110,97 +109,65 @@ void FrskyDeviceFirmwareUpdate::processFrame(const uint8_t * frame)
}
}
#if defined(PCBHORUS)
bool FrskyDeviceFirmwareUpdate::readBuffer(uint8_t * buffer, uint8_t count, uint32_t timeout)
{
watchdogSuspend(timeout);
switch (module) {
case INTERNAL_MODULE:
{
uint32_t elapsed = 0;
uint8_t index = 0;
while (index < count && elapsed < timeout) {
if (IntmoduleSerialDriver.getByte(uart_ctx, &(buffer[index]))) {
++index;
}
else {
RTOS_WAIT_MS(1);
if (++elapsed == timeout)
return false;
}
}
break;
uint32_t elapsed = 0;
uint8_t index = 0;
while (index < count && elapsed < timeout) {
if (uart_drv->getByte(uart_ctx, &(buffer[index]))) {
++index;
}
else {
RTOS_WAIT_MS(1);
if (++elapsed == timeout)
return false;
}
default:
break;
}
return true;
}
#endif
const uint8_t * FrskyDeviceFirmwareUpdate::readFullDuplexFrame(uint32_t timeout)
{
#if defined(INTMODULE_USART)
uint8_t len = 0;
bool bytestuff = false;
while (len < 10) {
uint32_t elapsed = 0;
uint8_t byte = 0;
while (IntmoduleSerialDriver.getByte(uart_ctx, &byte) == 0) {
RTOS_WAIT_MS(1);
if (elapsed++ >= timeout) {
return nullptr;
}
}
if (byte == 0x7D) {
bytestuff = true;
continue;
}
if (bytestuff) {
frame[len] = 0x20 ^ byte;
bytestuff = false;
}
else {
frame[len] = byte;
}
if (len > 0 || byte == 0x7E) {
++len;
}
}
return &frame[1];
#else
return nullptr;
#endif
}
const uint8_t * FrskyDeviceFirmwareUpdate::readHalfDuplexFrame(uint32_t timeout)
{
for (int i = timeout; i >= 0; i--) {
uint8_t byte ;
while (sportGetByte(&byte)) {
if (pushFrskyTelemetryData(byte)) {
return telemetryRxBuffer;
}
}
RTOS_WAIT_MS(1);
}
return nullptr;
}
const uint8_t * FrskyDeviceFirmwareUpdate::readFrame(uint32_t timeout)
{
RTOS_WAIT_MS(1);
#if defined(INTERNAL_MODULE_PXX2)
if ((module == INTERNAL_MODULE) &&
(g_eeGeneral.internalModule = MODULE_TYPE_ISRM_PXX2)) {
return readFullDuplexFrame(timeout);
uint8_t len = 0;
bool bytestuff = false;
while (len <= FRSKY_SPORT_PACKET_SIZE) {
uint32_t elapsed = 0;
uint8_t byte = 0;
while (uart_drv->getByte(uart_ctx, &byte) == 0) {
RTOS_WAIT_MS(1);
if (elapsed++ >= timeout) {
TRACE("timeout in frame (len=%d)",len);
return nullptr;
}
}
if (byte == BYTE_STUFF) {
bytestuff = true;
continue;
}
if (bytestuff) {
frame[len] = STUFF_MASK ^ byte;
bytestuff = false;
}
else {
frame[len] = byte;
}
if (len > 0 || byte == START_STOP) {
++len;
}
}
#endif
return readHalfDuplexFrame(timeout);
return &frame[1];
}
bool FrskyDeviceFirmwareUpdate::waitState(State newState, uint32_t timeout)
@@ -238,29 +205,20 @@ void FrskyDeviceFirmwareUpdate::startFrame(uint8_t command)
void FrskyDeviceFirmwareUpdate::sendFrame()
{
uint8_t * ptr = outputTelemetryBuffer.data;
*ptr++ = 0x7E;
*ptr++ = START_STOP;
*ptr++ = 0xFF;
frame[7] = crc16(CRC_1021, frame, 7);
for (int i=0; i<8; i++) {
if (frame[i] == 0x7E || frame[i] == 0x7D) {
*ptr++ = 0x7D;
*ptr++ = 0x20 ^ frame[i];
}
else {
for (int i = 0; i < 8; i++) {
if (frame[i] == START_STOP || frame[i] == BYTE_STUFF) {
*ptr++ = BYTE_STUFF;
*ptr++ = STUFF_MASK ^ frame[i];
} else {
*ptr++ = frame[i];
}
}
#if defined(INTERNAL_MODULE_PXX2)
if ((module == INTERNAL_MODULE) &&
(g_eeGeneral.internalModule = MODULE_TYPE_ISRM_PXX2)) {
IntmoduleSerialDriver.sendBuffer(uart_ctx, outputTelemetryBuffer.data,
ptr - outputTelemetryBuffer.data);
return;
}
#endif
sportSendBuffer(outputTelemetryBuffer.data, ptr - outputTelemetryBuffer.data);
uart_drv->sendBuffer(uart_ctx, outputTelemetryBuffer.data,
ptr - outputTelemetryBuffer.data);
return;
}
@@ -269,7 +227,7 @@ const char * FrskyDeviceFirmwareUpdate::sendPowerOn()
state = SPORT_POWERUP_REQ;
RTOS_WAIT_MS(50);
telemetryClearFifo();
uart_drv->clearRxBuffer(uart_ctx);
for (int i=0; i<10; i++) {
// max 10 attempts
@@ -279,21 +237,13 @@ const char * FrskyDeviceFirmwareUpdate::sendPowerOn()
return nullptr;
}
if (telemetryProtocol != PROTOCOL_TELEMETRY_FRSKY_SPORT) {
return STR_DEVICE_NO_RESPONSE;
}
if (!IS_FRSKY_SPORT_PROTOCOL()) {
return STR_DEVICE_NO_RESPONSE;
}
return STR_DEVICE_NO_RESPONSE;
}
const char * FrskyDeviceFirmwareUpdate::sendReqVersion()
{
RTOS_WAIT_MS(20);
telemetryClearFifo();
uart_drv->clearRxBuffer(uart_ctx);
state = SPORT_VERSION_REQ;
for (int i=0; i<10; i++) {
@@ -311,20 +261,18 @@ const char * FrskyDeviceFirmwareUpdate::sendReqVersion()
// X9D / X9D+ / X9E / XLite IXJT = use S.PORT @ 57600 bauds
// XLite PRO / X9Lite / X9D+ 2019 ISRM = use TX + RX @ 57600 bauds
#if defined(INTMODULE_USART)
static const etx_serial_init serialInitParams = {
.baudrate = 0,
.parity = ETX_Parity_None,
.stop_bits = ETX_StopBits_One,
.word_length = ETX_WordLength_8,
.rx_enable = true,
.encoding = ETX_Encoding_8N1,
.direction = ETX_Dir_TX_RX,
.polarity = ETX_Pol_Normal,
};
#endif
const char * FrskyDeviceFirmwareUpdate::doFlashFirmware(const char * filename, ProgressHandler progressHandler)
const char *FrskyDeviceFirmwareUpdate::doFlashFirmware(
const char *filename, ProgressHandler progressHandler)
{
FIL file;
const char * result;
const char *result;
FrSkyFirmwareInformation information;
UINT count;
@@ -332,64 +280,99 @@ const char * FrskyDeviceFirmwareUpdate::doFlashFirmware(const char * filename, P
return STR_NEEDS_FILE;
}
const char * ext = getFileExtension(filename);
// Start with checking if we have a firmware description:
// this mainly covers "newer" modules (ISRM, ACCESS based)
// default to S.PORT update...
uint8_t port = ETX_MOD_PORT_SPORT;
void (*set_pwr)(uint8_t) = nullptr;
void (*set_bootcmd)(uint8_t) = nullptr;
// TODO: what about S.PORT update power control? (RX?)
auto mod_desc = modulePortGetModuleDescription(module);
set_pwr = mod_desc->set_pwr;
// ... and 57600 bps
etx_serial_init cfg(serialInitParams);
cfg.baudrate = 57600;
const char *ext = getFileExtension(filename);
if (ext && !strcasecmp(ext, FRSKY_FIRMWARE_EXT)) {
auto ret = f_read(&file, &information, sizeof(FrSkyFirmwareInformation), &count);
auto ret =
f_read(&file, &information, sizeof(FrSkyFirmwareInformation), &count);
if (ret != FR_OK || count != sizeof(FrSkyFirmwareInformation)) {
f_close(&file);
return STR_DEVICE_FILE_ERROR;
}
// probably some ISRM or ACCESS module...
// TODO: what are we supposed to start with the firmware header file?
if ((information.productFamily == FIRMWARE_FAMILY_INTERNAL_MODULE &&
module != INTERNAL_MODULE) ||
(information.productFamily == FIRMWARE_FAMILY_EXTERNAL_MODULE &&
module != EXTERNAL_MODULE)) {
return STR_DEVICE_FILE_WRONG_SIG;
}
if (information.productFamily == FIRMWARE_FAMILY_INTERNAL_MODULE &&
information.productId == FIRMWARE_ID_MODULE_ISRM) {
port = ETX_MOD_PORT_UART;
}
} else if (module == INTERNAL_MODULE) {
// For the older modules we need some guess work:
//
// - X12S / X10 IXJT = use TX + RX @ 38400 bauds with BOOTCMD pin
// -> internal USART + boot pin
//
// - X9D / X9D+ / X9E / XLite IXJT = use S.PORT @ 57600 bauds
// -> no internal USART OR no boot pin (XLite has an internal USART)
// X12S / X10 iXJT: TX + RX @ 38400 bauds with BOOTCMD pin inverted
if (mod_desc->set_bootcmd) {
cfg.baudrate = 38400;
port = ETX_MOD_PORT_UART;
set_bootcmd = mod_desc->set_bootcmd;
} else {
// keep the above defaults (S.PORT @ 57600 bps)
}
} else {
#if defined(PCBHORUS)
information.productId = FIRMWARE_ID_MODULE_XJT;
#endif
}
#if defined(PCBHORUS)
if (module == INTERNAL_MODULE && information.productId == FIRMWARE_ID_MODULE_XJT) {
INTERNAL_MODULE_ON();
RTOS_WAIT_MS(1);
// SPORT_MODULE is only defined for power control
// but has not ports declared on it.
//
uint8_t serial_module = module != SPORT_MODULE ? module : EXTERNAL_MODULE;
etx_serial_init params(serialInitParams);
params.baudrate = 38400;
uart_ctx = IntmoduleSerialDriver.init(&params);
mod_st = modulePortInitSerial(serial_module, port, &cfg);
if (!mod_st) return "Communication port error";
GPIO_SetBits(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_GPIO_PIN);
// assume RX port is the same as TX
uart_drv = modulePortGetSerialDrv(mod_st->tx);
uart_ctx = modulePortGetCtx(mod_st->tx);
if (set_bootcmd) set_bootcmd(true);
if (set_pwr) set_pwr(true);
// wait a bit for PWR to settle
RTOS_WAIT_MS(1);
// Special update method for X12S / X10 iXJT
if (module == INTERNAL_MODULE && port == ETX_MOD_PORT_UART && set_bootcmd != nullptr) {
result = uploadFileToHorusXJT(filename, &file, progressHandler);
GPIO_ResetBits(INTMODULE_BOOTCMD_GPIO, INTMODULE_BOOTCMD_GPIO_PIN);
f_close(&file);
return result;
}
#endif
#if defined(INTERNAL_MODULE_PXX2)
if ((module == INTERNAL_MODULE) &&
(g_eeGeneral.internalModule = MODULE_TYPE_ISRM_PXX2)) {
etx_serial_init params(serialInitParams);
params.baudrate = 57600;
uart_ctx = IntmoduleSerialDriver.init(&params);
}
else
#endif
{
telemetryInit(PROTOCOL_TELEMETRY_FRSKY_SPORT);
} else {
result = uploadFileNormal(filename, &file, progressHandler);
}
if (module == INTERNAL_MODULE)
INTERNAL_MODULE_ON();
else if (module == EXTERNAL_MODULE)
EXTERNAL_MODULE_ON();
else
SPORT_UPDATE_POWER_ON();
if (set_pwr) set_pwr(false);
if (set_bootcmd) set_bootcmd(false);
result = uploadFileNormal(filename, &file, progressHandler);
f_close(&file);
modulePortDeInit(mod_st);
return result;
}
#if defined(PCBHORUS)
const char * FrskyDeviceFirmwareUpdate::uploadFileToHorusXJT(const char * filename, FIL * file, ProgressHandler progressHandler)
const char *FrskyDeviceFirmwareUpdate::uploadFileToHorusXJT(
const char *filename, FIL *file, ProgressHandler progressHandler)
{
uint32_t buffer[1024 / sizeof(uint32_t)];
UINT count;
@@ -399,14 +382,14 @@ const char * FrskyDeviceFirmwareUpdate::uploadFileToHorusXJT(const char * filena
return STR_DEVICE_NO_RESPONSE;
}
IntmoduleSerialDriver.sendByte(uart_ctx, 0x81);
uart_drv->sendByte(uart_ctx, 0x81);
readBuffer(frame, 1, 100);
if (!readBuffer(frame, 8, 100) || frame[0] != 0x02) {
return STR_DEVICE_NO_RESPONSE;
}
IntmoduleSerialDriver.sendByte(uart_ctx, 0x82);
uart_drv->sendByte(uart_ctx, 0x82);
readBuffer(frame, 1, 100);
uint8_t index = 0;
@@ -424,7 +407,7 @@ const char * FrskyDeviceFirmwareUpdate::uploadFileToHorusXJT(const char * filena
return STR_DEVICE_WRONG_REQUEST;
if (count == 0) {
IntmoduleSerialDriver.sendByte(uart_ctx, 0xA1);
uart_drv->sendByte(uart_ctx, 0xA1);
RTOS_WAIT_MS(50);
return nullptr;
}
@@ -432,22 +415,32 @@ const char * FrskyDeviceFirmwareUpdate::uploadFileToHorusXJT(const char * filena
if (count < 1024)
memset(((uint8_t *)buffer) + count, 0, 1024 - count);
IntmoduleSerialDriver.sendByte(uart_ctx, frame[0] + 0x80);
IntmoduleSerialDriver.sendByte(uart_ctx, frame[1]);
uart_drv->sendByte(uart_ctx, frame[0] + 0x80);
uart_drv->sendByte(uart_ctx, frame[1]);
uint16_t crc_16 = crc16(CRC_1189, (uint8_t *)buffer, 1024, crc16(CRC_1189, &frame[1], 1));
for (size_t i = 0; i < sizeof(buffer); i++) {
IntmoduleSerialDriver.sendByte(uart_ctx, ((uint8_t *)buffer)[i]);
uart_drv->sendByte(uart_ctx, ((uint8_t *)buffer)[i]);
}
IntmoduleSerialDriver.sendByte(uart_ctx, crc_16 >> 8);
IntmoduleSerialDriver.sendByte(uart_ctx, crc_16);
uart_drv->sendByte(uart_ctx, crc_16 >> 8);
uart_drv->sendByte(uart_ctx, crc_16);
index++;
}
}
#endif
const char * FrskyDeviceFirmwareUpdate::uploadFileNormal(const char * filename, FIL * file, ProgressHandler progressHandler)
void FrskyDeviceFirmwareUpdate::sendDataTransfer(uint32_t* buffer)
{
startFrame(PRIM_DATA_WORD);
uint32_t offset = (address & 1023) >> 2; // 32 bit word offset into buffer
*((uint32_t *)(frame + 2)) = buffer[offset];
frame[6] = address & 0x000000FF;
state = SPORT_DATA_TRANSFER;
sendFrame();
}
const char *FrskyDeviceFirmwareUpdate::uploadFileNormal(
const char *filename, FIL *file, ProgressHandler progressHandler)
{
uint32_t buffer[1024 / sizeof(uint32_t)];
UINT count;
@@ -461,12 +454,14 @@ const char * FrskyDeviceFirmwareUpdate::uploadFileNormal(const char * filename,
return result;
RTOS_WAIT_MS(200);
telemetryClearFifo();
uart_drv->clearRxBuffer(uart_ctx);
state = SPORT_DATA_TRANSFER;
startFrame(PRIM_CMD_DOWNLOAD);
sendFrame();
uint8_t retries = 0;
while (true) {
if (f_read(file, buffer, 1024, &count) != FR_OK) {
return STR_DEVICE_FILE_ERROR;
@@ -474,16 +469,19 @@ const char * FrskyDeviceFirmwareUpdate::uploadFileNormal(const char * filename,
count >>= 2;
for (uint32_t i=0; i<count; i++) {
if (!waitState(SPORT_DATA_REQ, 2000)) {
for (uint32_t i = 0; i < count; i++) {
if (waitState(SPORT_DATA_REQ, 80)) {
retries = 4; // reset retries
} else if (retries > 0){
--retries;
TRACE("retrying last transfer (address=0x%04X)", address);
} else {
return STR_DEVICE_DATA_REFUSED;
}
startFrame(PRIM_DATA_WORD);
uint32_t offset = (address & 1023) >> 2; // 32 bit word offset into buffer
*((uint32_t *)(frame + 2)) = buffer[offset];
frame[6] = address & 0x000000FF;
state = SPORT_DATA_TRANSFER,
sendFrame();
sendDataTransfer(buffer);
if (i == 0) {
progressHandler(getBasename(filename), STR_WRITING, file->fptr, file->obj.objsize);
}
@@ -509,23 +507,13 @@ const char * FrskyDeviceFirmwareUpdate::endTransfer()
return nullptr;
}
const char * FrskyDeviceFirmwareUpdate::flashFirmware(const char * filename, ProgressHandler progressHandler)
const char *FrskyDeviceFirmwareUpdate::flashFirmware(
const char *filename, ProgressHandler progressHandler)
{
pauseMixerCalculations();
pausePulses();
pulsesStop();
#if defined(HARDWARE_INTERNAL_MODULE)
stopPulsesInternalModule();
#endif
#if defined(HARDWARE_EXTERNAL_MODULE)
stopPulsesExternalModule();
#endif
#if defined(SPORT_UPDATE_PWR_GPIO)
uint8_t spuPwr = IS_SPORT_UPDATE_POWER_ON();
SPORT_UPDATE_POWER_OFF();
#endif
// switch S.PORT power OFF if supported
modulePortSetPower(SPORT_MODULE, false);
progressHandler(getBasename(filename), STR_DEVICE_RESET, 0, 0);
@@ -544,305 +532,18 @@ const char * FrskyDeviceFirmwareUpdate::flashFirmware(const char * filename, Pro
POPUP_INFORMATION(STR_FIRMWARE_UPDATE_SUCCESS);
}
#if defined(INTMODULE_USART)
if (uart_ctx) {
// If the UART is not deactivated, the module
// will not properly reset
IntmoduleSerialDriver.deinit(uart_ctx);
}
#endif
#if defined(HARDWARE_INTERNAL_MODULE)
INTERNAL_MODULE_OFF();
#endif
EXTERNAL_MODULE_OFF();
SPORT_UPDATE_POWER_OFF();
watchdogSuspend(50 /*500ms*/);
pulsesStart();
/* wait 2s off */
watchdogSuspend(500 /*5s*/);
RTOS_WAIT_MS(2000);
telemetryClearFifo();
resumePulses();
resumeMixerCalculations();
#if defined(SPORT_UPDATE_PWR_GPIO)
if (spuPwr) {
SPORT_UPDATE_POWER_ON();
}
#endif
// TODO: S.PORT power control
// -> where is it actually turned ON normally?
//
// #if defined(SPORT_UPDATE_PWR_GPIO)
// if (spuPwr) {
// SPORT_UPDATE_POWER_ON();
// }
// #endif
state = SPORT_IDLE;
return result;
}
#define CHIP_FIRMWARE_UPDATE_TIMEOUT 20000 /* 20s */
const char * FrskyChipFirmwareUpdate::waitAnswer(uint8_t & status)
{
watchdogSuspend(CHIP_FIRMWARE_UPDATE_TIMEOUT);
telemetryPortSetDirectionInput();
uint8_t buffer[12];
for (uint8_t i = 0; i < sizeof(buffer); i++) {
uint32_t retry = 0;
while (true) {
if (sportGetByte(&buffer[i])) {
if ((i == 0 && buffer[0] != 0x7F) ||
(i == 1 && buffer[1] != 0xFE) ||
(i == 10 && buffer[10] != 0x0D) ||
(i == 11 && buffer[11] != 0x0A)) {
i = 0;
continue;
}
break;
}
if (++retry == CHIP_FIRMWARE_UPDATE_TIMEOUT) {
return STR_DEVICE_NO_RESPONSE;
}
RTOS_WAIT_MS(1);
}
}
status = buffer[8];
return nullptr;
}
const char * FrskyChipFirmwareUpdate::startBootloader()
{
sportSendByte(0x03);
RTOS_WAIT_MS(20);
sportSendByte(0x02);
RTOS_WAIT_MS(20);
sportSendByte(0x01);
for (uint8_t i = 0; i < 30; i++)
sportSendByte(0x7E);
for (uint32_t i = 0; i < 100; i++) {
RTOS_WAIT_MS(20);
sportSendByte(0x7F);
}
RTOS_WAIT_MS(20);
sportSendByte(0xFA);
/*for (uint8_t i=0; i < 30; i++)
sportSendByte(0x7E);
for (uint8_t i=0; i < 50; i++)
sportSendByte(0x7F);*/
uint8_t status;
const char * result = waitAnswer(status);
if (result)
return result;
return status == 0x08 ? nullptr : "Bootloader failed";
}
void FrskyChipFirmwareUpdate::sendByte(uint8_t byte, bool crcFlag)
{
sportSendByte(byte);
if (crcFlag) {
crc ^= byte;
}
}
const char * FrskyChipFirmwareUpdate::sendUpgradeCommand(char command, uint32_t packetsCount)
{
crc = 0;
// Head
sendByte(0x7F, false);
sendByte(0xFE, false);
// Addr
sendByte(0xFA);
// Cmd
sendByte(command);
// Packets count
sendByte(packetsCount >> 8);
sendByte(packetsCount);
// Len
sendByte('E' == command ? 0x00 : 0x0C);
sendByte(0x40);
// Data
for (uint8_t i=0; i < 0x40; i++)
sendByte('E' == command ? 0xF7 : 0x7F);
// Checksum
sendByte(crc, false);
// Tail
sendByte(0x0D, false);
sendByte(0x0A, false);
uint8_t status;
const char * result = waitAnswer(status);
if (result)
return result;
return status == 0x00 ? nullptr : STR_FIRMWARE_UPDATE_ERROR;
}
const char * FrskyChipFirmwareUpdate::sendUpgradeData(uint32_t index, uint8_t * data)
{
crc = 0;
// Head
sendByte(0x7F, false);
sendByte(0xFE, false);
// Addr
sendByte(0xFA);
// Cmd
sendByte('W');
// Packets count
sendByte(index >> 8);
sendByte(index);
// Len
sendByte(0x00);
sendByte(0x40);
// Data
for (uint8_t i = 0; i < 0x40; i++)
sendByte(*data++);
// Checksum
sendByte(crc, false);
// Tail
sendByte(0x0D, false);
sendByte(0x0A, false);
uint8_t status;
const char * result = waitAnswer(status);
if (result)
return result;
return status == 0x00 ? nullptr : STR_FIRMWARE_UPDATE_ERROR;
}
const char * FrskyChipFirmwareUpdate::doFlashFirmware(const char * filename, ProgressHandler progressHandler)
{
const char * result;
FIL file;
uint8_t buffer[64];
UINT count;
result = startBootloader();
if (result)
return result;
if (f_open(&file, filename, FA_READ) != FR_OK) {
return STR_NEEDS_FILE;
}
FrSkyFirmwareInformation * information = (FrSkyFirmwareInformation *)buffer;
if (f_read(&file, buffer, sizeof(FrSkyFirmwareInformation), &count) != FR_OK || count != sizeof(FrSkyFirmwareInformation)) {
f_close(&file);
return STR_DEVICE_FILE_ERROR;
}
uint32_t packetsCount = (information->size + sizeof(buffer) - 1) / sizeof(buffer);
progressHandler(getBasename(filename), STR_FLASH_WRITE, 0, packetsCount);
result = sendUpgradeCommand('A', packetsCount);
if (result)
return result;
uint32_t index = 0;
while (1) {
progressHandler(getBasename(filename), STR_FLASH_WRITE, index, packetsCount);
if (f_read(&file, buffer, sizeof(buffer), &count) != FR_OK) {
f_close(&file);
return STR_DEVICE_FILE_ERROR;
}
result = sendUpgradeData(index + 1, buffer);
if (result)
return result;
if (++index == packetsCount)
break;
}
f_close(&file);
return sendUpgradeCommand('E', packetsCount);
}
const char * FrskyChipFirmwareUpdate::flashFirmware(const char * filename, ProgressHandler progressHandler, bool wait)
{
progressHandler(getBasename(filename), STR_DEVICE_RESET, 0, 0);
pausePulses();
#if defined(HARDWARE_INTERNAL_MODULE)
uint8_t intPwr = IS_INTERNAL_MODULE_ON();
INTERNAL_MODULE_OFF();
#endif
#if defined(HARDWARE_EXTERNAL_MODULE)
uint8_t extPwr = IS_EXTERNAL_MODULE_ON();
EXTERNAL_MODULE_OFF();
#endif
#if defined(SPORT_UPDATE_PWR_GPIO)
uint8_t spuPwr = IS_SPORT_UPDATE_POWER_ON();
SPORT_UPDATE_POWER_OFF();
#endif
if (wait) {
/* wait 2s off */
watchdogSuspend(1000 /*10s*/);
RTOS_WAIT_MS(2000);
}
telemetryInit(PROTOCOL_TELEMETRY_FRSKY_SPORT);
const char * result = doFlashFirmware(filename, progressHandler);
AUDIO_PLAY(AU_SPECIAL_SOUND_BEEP1);
BACKLIGHT_ENABLE();
if (result) {
POPUP_WARNING(STR_FIRMWARE_UPDATE_ERROR, result);
}
else {
POPUP_INFORMATION(STR_FIRMWARE_UPDATE_SUCCESS);
}
/* wait 2s off */
watchdogSuspend(1000 /*10s*/);
RTOS_WAIT_MS(2000);
#if defined(HARDWARE_INTERNAL_MODULE)
if (intPwr) {
INTERNAL_MODULE_ON();
setupPulsesInternalModule();
}
#endif
#if defined(HARDWARE_EXTERNAL_MODULE)
if (extPwr) {
EXTERNAL_MODULE_ON();
setupPulsesExternalModule();
}
#endif
#if defined(SPORT_UPDATE_PWR_GPIO)
if (spuPwr) {
SPORT_UPDATE_POWER_ON();
}
#endif
resumePulses();
return result;
}
+6 -20
View File
@@ -25,6 +25,8 @@
#include "dataconstants.h"
#include "definitions.h"
#include "hal/module_port.h"
enum FrskyFirmwareProductFamily {
FIRMWARE_FAMILY_INTERNAL_MODULE,
FIRMWARE_FAMILY_EXTERNAL_MODULE,
@@ -133,6 +135,9 @@ class FrskyDeviceFirmwareUpdate {
uint32_t address = 0;
ModuleIndex module;
uint8_t frame[12];
etx_module_state_t* mod_st = nullptr;
const etx_serial_driver_t* uart_drv = nullptr;
void* uart_ctx = nullptr;
void startFrame(uint8_t command);
@@ -144,6 +149,7 @@ class FrskyDeviceFirmwareUpdate {
const uint8_t * readFrame(uint32_t timeout);
bool waitState(State state, uint32_t timeout);
void processFrame(const uint8_t * frame);
void sendDataTransfer(uint32_t* buffer);
const char * doFlashFirmware(const char * filename, ProgressHandler progressHandler);
const char * sendPowerOn();
@@ -153,24 +159,4 @@ class FrskyDeviceFirmwareUpdate {
const char * endTransfer();
};
class FrskyChipFirmwareUpdate {
public:
FrskyChipFirmwareUpdate()
{
}
const char * flashFirmware(const char * filename, ProgressHandler progressHandler, bool wait = true);
protected:
uint8_t crc;
void sendByte(uint8_t byte, bool crc = true);
const char * waitAnswer(uint8_t & status);
const char * startBootloader();
const char * sendUpgradeCommand(char command, uint32_t packetsCount);
const char * sendUpgradeData(uint32_t index, uint8_t * data);
const char * doFlashFirmware(const char * filename, ProgressHandler progressHandler);
};
#endif // _FRSKY_FIRMWARE_UPDATE_H_
+130 -241
View File
@@ -21,6 +21,9 @@
#if !defined(DISABLE_MULTI_UPDATE)
#include "hal.h"
#include "hal/module_port.h"
#include <stdio.h>
#include "opentx.h"
#include "multi_firmware_update.h"
@@ -40,181 +43,121 @@
#include "io/multi_protolist.h"
#endif
#if defined(INTMODULE_USART)
#include "intmodule_serial_driver.h"
#endif
#include "extmodule_driver.h"
#define UPDATE_MULTI_EXT_BIN ".bin"
class MultiFirmwareUpdateDriver
{
public:
MultiFirmwareUpdateDriver() {}
virtual ~MultiFirmwareUpdateDriver() {}
const char* flashFirmware(FIL* file, const char* label,
ProgressHandler progressHandler);
ModuleIndex module;
MultiModuleType type;
protected:
virtual void moduleOn() const = 0;
virtual void init(bool inverted) = 0;
virtual bool getByte(uint8_t & byte) const = 0;
virtual void sendByte(uint8_t byte) const = 0;
virtual void clear() const = 0;
virtual void deinit(bool inverted) {}
etx_module_state_t* mod_st = nullptr;
private:
bool getRxByte(uint8_t & byte) const;
bool checkRxByte(uint8_t byte) const;
const char * waitForInitialSync(bool& inverted);
const char * getDeviceSignature(uint8_t * signature) const;
const char * loadAddress(uint32_t offset) const;
const char * progPage(uint8_t * buffer, uint16_t size) const;
void leaveProgMode(bool inverted);
bool init();
bool getByte(uint8_t& byte) const;
void sendByte(uint8_t byte) const;
void sendBuffer(uint8_t* buffer, uint16_t size) const;
void clear() const;
void deinit();
bool getRxByte(uint8_t& byte) const;
bool checkRxByte(uint8_t byte) const;
const char* waitForInitialSync();
const char* getDeviceSignature(uint8_t* signature) const;
const char* loadAddress(uint32_t offset) const;
const char* progPage(uint8_t* buffer, uint16_t size) const;
void leaveProgMode();
public:
MultiFirmwareUpdateDriver(ModuleIndex module, MultiModuleType type) :
module(module), type(type)
{
}
const char* flashFirmware(FIL* file, const char* label,
ProgressHandler progressHandler);
};
#if defined(INTERNAL_MODULE_MULTI)
static const etx_serial_init serialInitParams = {
.baudrate = 0,
.parity = ETX_Parity_None,
.stop_bits = ETX_StopBits_One,
.word_length = ETX_WordLength_8,
.rx_enable = true,
.baudrate = 57600,
.encoding = ETX_Encoding_8N1,
.direction = ETX_Dir_TX_RX,
.polarity = ETX_Pol_Normal,
};
class MultiInternalUpdateDriver: public MultiFirmwareUpdateDriver
bool MultiFirmwareUpdateDriver::init()
{
public:
MultiInternalUpdateDriver() {}
protected:
void* uart_ctx = nullptr;
void moduleOn() const override
{
INTERNAL_MODULE_ON();
if (type == MULTI_TYPE_MULTIMODULE && module == INTERNAL_MODULE) {
// duplex internal USART
mod_st = modulePortInitSerial(INTERNAL_MODULE, ETX_MOD_PORT_UART, &serialInitParams);
} else if (type == MULTI_TYPE_MULTIMODULE && module == EXTERNAL_MODULE) {
// TX on PPM (inverted softserial)
etx_serial_init params(serialInitParams);
params.direction = ETX_Dir_TX;
params.polarity = ETX_Pol_Inverted;
mod_st = modulePortInitSerial(EXTERNAL_MODULE, ETX_MOD_PORT_UART, &params);
if (!mod_st) {
params.polarity = ETX_Pol_Normal;
mod_st = modulePortInitSerial(EXTERNAL_MODULE, ETX_MOD_PORT_SOFT_INV, &params);
if (!mod_st) return false;
}
void init(bool inverted) override
{
etx_serial_init params(serialInitParams);
params.baudrate = 57600;
uart_ctx = IntmoduleSerialDriver.init(&params);
// RX on S.PORT (inverted softserial)
params.direction = ETX_Dir_RX;
params.polarity = ETX_Pol_Inverted;
if (!modulePortInitSerial(EXTERNAL_MODULE, ETX_MOD_PORT_SPORT, &params)) {
params.polarity = ETX_Pol_Normal;
if (!modulePortInitSerial(EXTERNAL_MODULE, ETX_MOD_PORT_SPORT_INV, &params)) {
modulePortDeInit(mod_st);
return false;
}
}
} else if (type == MULTI_TYPE_ELRS && module == EXTERNAL_MODULE) {
// half-duplex on S.PORT USART
mod_st = modulePortInitSerial(EXTERNAL_MODULE, ETX_MOD_PORT_SPORT, &serialInitParams);
}
bool getByte(uint8_t & byte) const override
{
return IntmoduleSerialDriver.getByte(uart_ctx, &byte) > 0;
}
if (!mod_st) return false;
void sendByte(uint8_t byte) const override
{
IntmoduleSerialDriver.sendByte(uart_ctx, byte);
}
modulePortSetPower(module, true);
return true;
}
void clear() const override
{
IntmoduleSerialDriver.clearRxBuffer(uart_ctx);
}
void deinit(bool inverted) override
{
IntmoduleSerialDriver.deinit(uart_ctx);
clear();
uart_ctx = nullptr;
}
};
#endif
#if defined(HARDWARE_EXTERNAL_MODULE)
class MultiExternalUpdateDriver: public MultiFirmwareUpdateDriver
bool MultiFirmwareUpdateDriver::getByte(uint8_t & byte) const
{
public:
MultiExternalUpdateDriver() {}
auto drv = modulePortGetSerialDrv(mod_st->rx);
auto ctx = modulePortGetCtx(mod_st->rx);
return drv->getByte(ctx, &byte) > 0;
}
protected:
void moduleOn() const override
{
EXTERNAL_MODULE_ON();
}
void init(bool inverted) override
{
extmoduleInitTxPin();
if (inverted)
telemetryPortInvertedInit(57600);
else
telemetryPortInit(57600, TELEMETRY_SERIAL_WITHOUT_DMA);
}
bool getByte(uint8_t & byte) const override
{
return sportGetByte(&byte);
}
void sendByte(uint8_t byte) const override
{
extmoduleSendInvertedByte(byte);
}
void clear() const override
{
telemetryClearFifo();
}
void deinit(bool inverted) override
{
if (inverted)
telemetryPortInvertedInit(0);
else
telemetryPortInit(0, 0);
clear();
}
};
#endif
class MultiExtSportUpdateDriver: public MultiFirmwareUpdateDriver
void MultiFirmwareUpdateDriver::sendByte(uint8_t byte) const
{
public:
MultiExtSportUpdateDriver(): MultiFirmwareUpdateDriver() {}
auto drv = modulePortGetSerialDrv(mod_st->tx);
auto ctx = modulePortGetCtx(mod_st->tx);
drv->sendByte(ctx, byte);
}
protected:
void moduleOn() const override
{
EXTERNAL_MODULE_ON();
}
void MultiFirmwareUpdateDriver::sendBuffer(uint8_t* buffer, uint16_t size) const
{
auto drv = modulePortGetSerialDrv(mod_st->tx);
auto ctx = modulePortGetCtx(mod_st->tx);
void init(bool inverted) override
{
telemetryPortInit(57600, TELEMETRY_SERIAL_WITHOUT_DMA);
}
drv->waitForTxCompleted(ctx);
drv->sendBuffer(ctx, buffer, size);
drv->waitForTxCompleted(ctx);
}
bool getByte(uint8_t & byte) const override
{
return sportGetByte(&byte);
}
void MultiFirmwareUpdateDriver::clear() const
{
auto drv = modulePortGetSerialDrv(mod_st->rx);
auto ctx = modulePortGetCtx(mod_st->rx);
drv->clearRxBuffer(ctx);
}
void sendByte(uint8_t byte) const override
{
sportSendByte(byte);
telemetryPortSetDirectionInput();
}
void clear() const override
{
telemetryClearFifo();
}
void deinit(bool inverted) override
{
telemetryPortInit(0, 0);
clear();
}
};
void MultiFirmwareUpdateDriver::deinit()
{
clear();
modulePortSetPower(module, false);
modulePortDeInit(mod_st);
}
bool MultiFirmwareUpdateDriver::getRxByte(uint8_t & byte) const
{
@@ -241,7 +184,7 @@ bool MultiFirmwareUpdateDriver::checkRxByte(uint8_t byte) const
return getRxByte(rxchar) ? rxchar == byte : false;
}
const char * MultiFirmwareUpdateDriver::waitForInitialSync(bool & inverted)
const char * MultiFirmwareUpdateDriver::waitForInitialSync()
{
uint8_t byte;
int retries = 200;
@@ -253,13 +196,6 @@ const char * MultiFirmwareUpdateDriver::waitForInitialSync(bool & inverted)
clear();
do {
// Invert at half-time
if (retries == 100) {
deinit(inverted);
inverted = !inverted;
init(inverted);
}
// Send sync request
sendByte(STK_GET_SYNC);
sendByte(CRC_EOP);
@@ -300,7 +236,6 @@ const char * MultiFirmwareUpdateDriver::getDeviceSignature(uint8_t * signature)
// Read signature
sendByte(STK_READ_SIGN);
sendByte(CRC_EOP);
clear();
if (!checkRxByte(STK_INSYNC))
return STR_DEVICE_NO_RESPONSE;
@@ -343,9 +278,7 @@ const char * MultiFirmwareUpdateDriver::progPage(uint8_t * buffer, uint16_t size
// flash/eeprom flag
sendByte(0);
for (uint16_t i = 0; i < size; i++) {
sendByte(buffer[i]);
}
sendBuffer(buffer, size);
sendByte(CRC_EOP);
@@ -365,14 +298,14 @@ const char * MultiFirmwareUpdateDriver::progPage(uint8_t * buffer, uint16_t size
return nullptr;
}
void MultiFirmwareUpdateDriver::leaveProgMode(bool inverted)
void MultiFirmwareUpdateDriver::leaveProgMode()
{
sendByte(STK_LEAVE_PROGMODE);
sendByte(CRC_EOP);
// eat last sync byte
checkRxByte(STK_INSYNC);
deinit(inverted);
deinit();
}
const char* MultiFirmwareUpdateDriver::flashFirmware(
@@ -388,25 +321,22 @@ const char* MultiFirmwareUpdateDriver::flashFirmware(
#endif
const char * result = nullptr;
moduleOn();
bool inverted = true; //false; // true
init(inverted);
if (!init()) return "Initialisation error";
/* wait 500ms for power on */
watchdogSuspend(500 /*5s*/);
RTOS_WAIT_MS(500);
result = waitForInitialSync(inverted);
result = waitForInitialSync();
if (result) {
leaveProgMode(inverted);
leaveProgMode();
return result;
}
unsigned char signature[4]; // 3 bytes signature + STK_OK
result = getDeviceSignature(signature);
if (result) {
leaveProgMode(inverted);
leaveProgMode();
return result;
}
@@ -415,7 +345,7 @@ const char* MultiFirmwareUpdateDriver::flashFirmware(
uint32_t writeOffset = 0;
if (signature[0] != 0x1E) {
leaveProgMode(inverted);
leaveProgMode();
return STR_DEVICE_FILE_WRONG_SIG;
}
@@ -456,7 +386,7 @@ const char* MultiFirmwareUpdateDriver::flashFirmware(
progressHandler(label, STR_WRITING, file->fptr, file->obj.objsize);
}
leaveProgMode(inverted);
leaveProgMode();
return result;
}
@@ -591,6 +521,7 @@ bool MultiDeviceFirmwareUpdate::flashFirmware(const char * filename, ProgressHan
}
f_lseek(&file, 0);
#if defined(HARDWARE_EXTERNAL_MODULE)
if (module == EXTERNAL_MODULE) {
if (!firmwareFile.isMultiExternalFirmware()) {
f_close(&file);
@@ -598,43 +529,29 @@ bool MultiDeviceFirmwareUpdate::flashFirmware(const char * filename, ProgressHan
return false;
}
}
else {
#endif
#if defined(HARDWARE_INTERNAL_MODULE)
if (module == INTERNAL_MODULE) {
if (!firmwareFile.isMultiInternalFirmware()) {
f_close(&file);
POPUP_WARNING(STR_NEEDS_FILE, STR_INT_MULTI_SPEC);
return false;
}
}
#endif
}
std::unique_ptr<MultiFirmwareUpdateDriver> driver;
#if defined(INTERNAL_MODULE_MULTI)
if (type == MULTI_TYPE_MULTIMODULE && module == INTERNAL_MODULE)
driver.reset(new MultiInternalUpdateDriver());
#endif
#if defined(HARDWARE_EXTERNAL_MODULE)
if (type == MULTI_TYPE_MULTIMODULE && module == EXTERNAL_MODULE)
driver.reset(new MultiExternalUpdateDriver());
if (type == MULTI_TYPE_ELRS && module == EXTERNAL_MODULE)
driver.reset(new MultiExtSportUpdateDriver());
pulsesStop();
#if defined(MULTI_PROTOLIST)
for (uint8_t i = 0; i < MAX_MODULES; i++) {
MultiRfProtocols::removeInstance(i);
}
#endif
pausePulses();
#if defined(HARDWARE_INTERNAL_MODULE)
uint8_t intPwr = IS_INTERNAL_MODULE_ON();
INTERNAL_MODULE_OFF();
#endif
#if defined(HARDWARE_EXTERNAL_MODULE)
uint8_t extPwr = IS_EXTERNAL_MODULE_ON();
EXTERNAL_MODULE_OFF();
#endif
#if defined(SPORT_UPDATE_PWR_GPIO)
uint8_t spuPwr = IS_SPORT_UPDATE_POWER_ON();
SPORT_UPDATE_POWER_OFF();
#endif
// switch S.PORT power OFF if supported
modulePortSetPower(SPORT_MODULE, false);
progressHandler(getBasename(filename), STR_DEVICE_RESET, 0, 0);
@@ -642,22 +559,13 @@ bool MultiDeviceFirmwareUpdate::flashFirmware(const char * filename, ProgressHan
watchdogSuspend(500 /*5s*/);
RTOS_WAIT_MS(3000);
const char * result = driver->flashFirmware(&file, getBasename(filename), progressHandler);
MultiFirmwareUpdateDriver driver(module, type);
const char * result = driver.flashFirmware(&file, getBasename(filename), progressHandler);
f_close(&file);
AUDIO_PLAY(AU_SPECIAL_SOUND_BEEP1);
BACKLIGHT_ENABLE();
#if defined(HARDWARE_INTERNAL_MODULE)
INTERNAL_MODULE_OFF();
#endif
EXTERNAL_MODULE_OFF();
SPORT_UPDATE_POWER_OFF();
/* wait 2s off */
watchdogSuspend(500 /*5s*/);
RTOS_WAIT_MS(2000);
if (result) {
POPUP_WARNING(STR_FIRMWARE_UPDATE_ERROR, result);
}
@@ -665,36 +573,17 @@ bool MultiDeviceFirmwareUpdate::flashFirmware(const char * filename, ProgressHan
POPUP_INFORMATION(STR_FIRMWARE_UPDATE_SUCCESS);
}
// reset telemetry protocol
telemetryInit(255);
watchdogSuspend(50 /*500ms*/);
pulsesStart();
#if defined(HARDWARE_INTERNAL_MODULE)
if (intPwr) {
#if defined(MULTI_PROTOLIST)
MultiRfProtocols::removeInstance(INTERNAL_MODULE);
#endif
INTERNAL_MODULE_ON();
setupPulsesInternalModule();
}
#endif
#if defined(HARDWARE_EXTERNAL_MODULE)
if (extPwr) {
#if defined(MULTI_PROTOLIST)
MultiRfProtocols::removeInstance(EXTERNAL_MODULE);
#endif
EXTERNAL_MODULE_ON();
setupPulsesExternalModule();
}
#endif
#if defined(SPORT_UPDATE_PWR_GPIO)
if (spuPwr) {
SPORT_UPDATE_POWER_ON();
}
#endif
resumePulses();
// TODO: S.PORT power control
// -> where is it actually turned ON normally?
//
// #if defined(SPORT_UPDATE_PWR_GPIO)
// if (spuPwr) {
// SPORT_UPDATE_POWER_ON();
// }
// #endif
return result == nullptr;
}
+6 -2
View File
@@ -74,12 +74,16 @@ class MultiFirmwareInformation
bool isMultiInternalFirmware() const
{
return (boardType == FIRMWARE_MULTI_STM && optibootSupport && bootloaderCheck && telemetryType == FIRMWARE_MULTI_TELEM_MULTI_TELEMETRY);
return (boardType == FIRMWARE_MULTI_STM && optibootSupport &&
bootloaderCheck &&
telemetryType == FIRMWARE_MULTI_TELEM_MULTI_TELEMETRY);
}
bool isMultiExternalFirmware() const
{
return ((telemetryInversion || boardType == FIRMWARE_MULTI_STM ) && optibootSupport && bootloaderCheck && telemetryType == FIRMWARE_MULTI_TELEM_MULTI_TELEMETRY);
return ((telemetryInversion || boardType == FIRMWARE_MULTI_STM) &&
optibootSupport && bootloaderCheck &&
telemetryType == FIRMWARE_MULTI_TELEM_MULTI_TELEMETRY);
}
const char * readMultiFirmwareInformation(const char * filename);
+1 -1
View File
@@ -54,7 +54,7 @@ void MultiRfProtocols::timerCb(TimerHandle_t xTimer)
}
#endif
MultiRfProtocols* MultiRfProtocols::_instance[NUM_MODULES] = {};
MultiRfProtocols* MultiRfProtocols::_instance[MAX_MODULES] = {};
// MPM telemetry packet format type = MultiProtoDef (0x11)
//