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

Merge pull request #3247 from jflyper/bfdev-additional-transponders

Browse source 
Porting aRCiTimer and ELRT from CF
This commit is contained in:
Michael Keller 2017-06-14 12:42:40 +12:00 • committed by GitHub
commit a139e71750
16 changed files with 623 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Makefile
View file

@ -696,6 +696,9 @@ COMMON_SRC = \
drivers/system.c \
drivers/timer.c \
drivers/transponder_ir.c \
drivers/transponder_ir_arcitimer.c \
drivers/transponder_ir_ilap.c \
drivers/transponder_ir_erlt.c \
fc/config.c \
fc/fc_dispatch.c \
fc/fc_hardfaults.c \
@ -783,7 +786,6 @@ FC_SRC = \
drivers/serial_escserial.c \
drivers/sonar_hcsr04.c \
drivers/vtx_common.c \
drivers/transponder_ir.c \
flight/navigation.c \
io/dashboard.c \
io/displayport_max7456.c \

116
src/main/drivers/transponder_ir.c
View file

@ -30,36 +30,9 @@
#include "timer.h"
#include "transponder_ir.h"
#define TRANSPONDER_TIMER_MHZ 24
#define TRANSPONDER_CARRIER_HZ 460750
static uint8_t bitToggleOne = 0;
#define BIT_TOGGLE_0 0
#define TRANSPONDER_BITS_PER_BYTE 10 // start + 8 data + stop
#define TRANSPONDER_DATA_LENGTH 6
#define TRANSPONDER_TOGGLES_PER_BIT 11
#define TRANSPONDER_GAP_TOGGLES 1
#define TRANSPONDER_TOGGLES (TRANSPONDER_TOGGLES_PER_BIT + TRANSPONDER_GAP_TOGGLES)
#define TRANSPONDER_DMA_BUFFER_SIZE ((TRANSPONDER_TOGGLES_PER_BIT + 1) * TRANSPONDER_BITS_PER_BYTE * TRANSPONDER_DATA_LENGTH)
/*
* Implementation note:
* Using around over 700 bytes for a transponder DMA buffer is a little excessive, likely an alternative implementation that uses a fast
* ISR to generate the output signal dynamically based on state would be more memory efficient and would likely be more appropriate for
* other targets. However this approach requires very little CPU time and is just fire-and-forget.
*
* On an STM32F303CC 720 bytes is currently fine and that is the target for which this code was designed for.
*/
#if defined(STM32F3)
uint8_t transponderIrDMABuffer[TRANSPONDER_DMA_BUFFER_SIZE];
#elif defined(STM32F4)
uint32_t transponderIrDMABuffer[TRANSPONDER_DMA_BUFFER_SIZE];
#else
#error "Transponder not supported on this MCU."
#endif
#include "drivers/transponder_ir_arcitimer.h"
#include "drivers/transponder_ir_ilap.h"
#include "drivers/transponder_ir_erlt.h"
volatile uint8_t transponderIrDataTransferInProgress = 0;
@ -74,6 +47,8 @@ static DMA_Stream_TypeDef *dmaRef = NULL;
#error "Transponder not supported on this MCU."
#endif
transponder_t transponder;
static void TRANSPONDER_DMA_IRQHandler(dmaChannelDescriptor_t* descriptor)
{
if (DMA_GET_FLAG_STATUS(descriptor, DMA_IT_TCIF)) {
@ -84,7 +59,7 @@ static void TRANSPONDER_DMA_IRQHandler(dmaChannelDescriptor_t* descriptor)
}
}
void transponderIrHardwareInit(ioTag_t ioTag)
void transponderIrHardwareInit(ioTag_t ioTag, transponder_t *transponder)
{
if (!ioTag) {
return;
@ -110,11 +85,10 @@ void transponderIrHardwareInit(ioTag_t ioTag)
RCC_ClockCmd(timerRCC(timer), ENABLE);
uint16_t prescaler = timerGetPrescalerByDesiredMhz(timer, TRANSPONDER_TIMER_MHZ);
uint16_t period = timerGetPeriodByPrescaler(timer, prescaler, TRANSPONDER_CARRIER_HZ);
uint16_t prescaler = timerGetPrescalerByDesiredMhz(timer, transponder->timer_hz);
uint16_t period = timerGetPeriodByPrescaler(timer, prescaler, transponder->timer_carrier_hz);
bitToggleOne = period / 2;
transponder->bitToggleOne = period / 2;
/* Time base configuration */
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = period;
@ -149,15 +123,15 @@ void transponderIrHardwareInit(ioTag_t ioTag)
DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)timerCCR(timer, timerHardware->channel);
#if defined(STM32F3)
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)transponderIrDMABuffer;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&(transponder->transponderIrDMABuffer);
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
#elif defined(STM32F4)
DMA_InitStructure.DMA_Channel = timerHardware->dmaChannel;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)transponderIrDMABuffer;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)&(transponder->transponderIrDMABuffer);
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
#endif
DMA_InitStructure.DMA_BufferSize = TRANSPONDER_DMA_BUFFER_SIZE;
DMA_InitStructure.DMA_BufferSize = transponder->dma_buffer_size;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
#if defined(STM32F3)
@ -178,10 +152,8 @@ void transponderIrHardwareInit(ioTag_t ioTag)
DMA_ITConfig(dmaRef, DMA_IT_TC, ENABLE);
}
bool transponderIrInit(void)
bool transponderIrInit(const transponderProvider_e provider)
{
memset(&transponderIrDMABuffer, 0, TRANSPONDER_DMA_BUFFER_SIZE);
ioTag_t ioTag = IO_TAG_NONE;
for (int i = 0; i < USABLE_TIMER_CHANNEL_COUNT; i++) {
if (timerHardware[i].usageFlags & TIM_USE_TRANSPONDER) {
@ -194,8 +166,21 @@ bool transponderIrInit(void)
return false;
}
switch (provider) {
case TRANSPONDER_ARCITIMER:
transponderIrInitArcitimer(&transponder);
break;
case TRANSPONDER_ILAP:
transponderIrInitIlap(&transponder);
break;
case TRANSPONDER_ERLT:
transponderIrInitERLT(&transponder);
break;
default:
return false;
}
transponderIrHardwareInit(ioTag);
transponderIrHardwareInit(ioTag, &transponder);
return true;
}
@ -207,42 +192,6 @@ bool isTransponderIrReady(void)
static uint16_t dmaBufferOffset;
void updateTransponderDMABuffer(const uint8_t* transponderData)
{
uint8_t byteIndex;
uint8_t bitIndex;
uint8_t toggleIndex;
for (byteIndex = 0; byteIndex < TRANSPONDER_DATA_LENGTH; byteIndex++) {
uint8_t byteToSend = *transponderData;
transponderData++;
for (bitIndex = 0; bitIndex < TRANSPONDER_BITS_PER_BYTE; bitIndex++)
{
bool doToggles = false;
if (bitIndex == 0) {
doToggles = true;
} else if (bitIndex == TRANSPONDER_BITS_PER_BYTE - 1) {
doToggles = false;
} else {
doToggles = byteToSend & (1 << (bitIndex - 1));
}
for (toggleIndex = 0; toggleIndex < TRANSPONDER_TOGGLES_PER_BIT; toggleIndex++)
{
if (doToggles) {
transponderIrDMABuffer[dmaBufferOffset] = bitToggleOne;
} else {
transponderIrDMABuffer[dmaBufferOffset] = BIT_TOGGLE_0;
}
dmaBufferOffset++;
}
transponderIrDMABuffer[dmaBufferOffset] = BIT_TOGGLE_0;
dmaBufferOffset++;
}
}
}
void transponderIrWaitForTransmitComplete(void)
{
static uint32_t waitCounter = 0;
@ -254,14 +203,13 @@ void transponderIrWaitForTransmitComplete(void)
void transponderIrUpdateData(const uint8_t* transponderData)
{
transponderIrWaitForTransmitComplete();
updateTransponderDMABuffer(transponderData);
transponderIrWaitForTransmitComplete();
transponder.vTable->updateTransponderDMABuffer(&transponder, transponderData);
}
void transponderIrDMAEnable(void)
void transponderIrDMAEnable(transponder_t *transponder)
{
DMA_SetCurrDataCounter(dmaRef, TRANSPONDER_DMA_BUFFER_SIZE); // load number of bytes to be transferred
DMA_SetCurrDataCounter(dmaRef, transponder->dma_buffer_size); // load number of bytes to be transferred
TIM_SetCounter(timer, 0);
TIM_Cmd(timer, ENABLE);
DMA_Cmd(dmaRef, ENABLE);
@ -289,6 +237,6 @@ void transponderIrTransmit(void)
dmaBufferOffset = 0;
transponderIrDataTransferInProgress = 1;
transponderIrDMAEnable();
transponderIrDMAEnable(&transponder);
}
#endif

100
src/main/drivers/transponder_ir.h
View file

@ -19,11 +19,105 @@
#include "drivers/io_types.h"
bool transponderIrInit();
/*** ARCITIMER ***/
#define TRANSPONDER_BITS_PER_BYTE_ARCITIMER 8
#define TRANSPONDER_DATA_LENGTH_ARCITIMER 9
#define TRANSPONDER_TOGGLES_PER_BIT_ARCITIMER 4
#define TRANSPONDER_GAP_TOGGLES_ARCITIMER 0
#define TRANSPONDER_TOGGLES_ARCITIMER (TRANSPONDER_TOGGLES_PER_BIT_ARCITIMER + TRANSPONDER_GAP_TOGGLES_ARCITIMER)
#define TRANSPONDER_DMA_BUFFER_SIZE_ARCITIMER 155 * TRANSPONDER_TOGGLES_PER_BIT_ARCITIMER // 620
#define TRANSPONDER_TIMER_MHZ_ARCITIMER 24
#define TRANSPONDER_CARRIER_HZ_ARCITIMER 41886
#define TRANSPONDER_TRANSMIT_DELAY_ARCITIMER 4500
#define TRANSPONDER_TRANSMIT_JITTER_ARCITIMER 10000
/*** ******** ***/
/*** ILAP ***/
#define TRANSPONDER_BITS_PER_BYTE_ILAP 10 // start + 8 data + stop
#define TRANSPONDER_DATA_LENGTH_ILAP 6
#define TRANSPONDER_TOGGLES_PER_BIT_ILAP 11
#define TRANSPONDER_GAP_TOGGLES_ILAP 1
#define TRANSPONDER_TOGGLES_ILAP (TRANSPONDER_TOGGLES_PER_BIT_ILAP + TRANSPONDER_GAP_TOGGLES_ILAP)
#define TRANSPONDER_DMA_BUFFER_SIZE_ILAP ((TRANSPONDER_TOGGLES_PER_BIT_ILAP + 1) * TRANSPONDER_BITS_PER_BYTE_ILAP * TRANSPONDER_DATA_LENGTH_ILAP) //720
#define TRANSPONDER_TIMER_MHZ_ILAP 24
#define TRANSPONDER_CARRIER_HZ_ILAP 460750
#define TRANSPONDER_TRANSMIT_DELAY_ILAP 4500
#define TRANSPONDER_TRANSMIT_JITTER_ILAP 10000
/*** ******** ***/
/*** ERLT ***/
#define TRANSPONDER_DATA_LENGTH_ERLT 1
#define ERLTBitQuiet 0
#define ERLTCyclesForOneBit 25
#define ERLTCyclesForZeroBit 10
#define TRANSPONDER_DMA_BUFFER_SIZE_ERLT 200 // actually ERLT is variable length 91-196 depending on the ERLT id
#define TRANSPONDER_TIMER_MHZ_ERLT 18
#define TRANSPONDER_CARRIER_HZ_ERLT 38000
#define TRANSPONDER_TRANSMIT_DELAY_ERLT 22500
#define TRANSPONDER_TRANSMIT_JITTER_ERLT 5000
/*** ******** ***/
/*
* Implementation note:
* Using around over 700 bytes for a transponder DMA buffer is a little excessive, likely an alternative implementation that uses a fast
* ISR to generate the output signal dynamically based on state would be more memory efficient and would likely be more appropriate for
* other targets. However this approach requires very little CPU time and is just fire-and-forget.
*
* On an STM32F303CC 720 bytes is currently fine and that is the target for which this code was designed for.
*/
#if defined(STM32F3) || defined(UNIT_TEST)
typedef union transponderIrDMABuffer_s {
uint8_t arcitimer[TRANSPONDER_DMA_BUFFER_SIZE_ARCITIMER]; // 620
uint8_t ilap[TRANSPONDER_DMA_BUFFER_SIZE_ILAP]; // 720
uint8_t erlt[TRANSPONDER_DMA_BUFFER_SIZE_ERLT]; // 91-200
} transponderIrDMABuffer_t;
#elif defined(STM32F4)
typedef union transponderIrDMABuffer_s {
uint32_t arcitimer[TRANSPONDER_DMA_BUFFER_SIZE_ARCITIMER]; // 620
uint32_t ilap[TRANSPONDER_DMA_BUFFER_SIZE_ILAP]; // 720
uint32_t erlt[TRANSPONDER_DMA_BUFFER_SIZE_ERLT]; // 91-200
} transponderIrDMABuffer_t;
#endif
typedef struct transponder_s {
uint8_t gap_toggles;
uint32_t timer_hz;
uint32_t timer_carrier_hz;
uint16_t bitToggleOne;
uint32_t dma_buffer_size;
#if defined(STM32F3) || defined(STM32F4)|| defined(UNIT_TEST)
transponderIrDMABuffer_t transponderIrDMABuffer;
#endif
const struct transponderVTable *vTable;
} transponder_t;
typedef enum {
TRANSPONDER_NONE = 0,
TRANSPONDER_ILAP,
TRANSPONDER_ARCITIMER,
TRANSPONDER_ERLT
} transponderProvider_e;
#define TRANSPONDER_PROVIDER_COUNT 3
struct transponderVTable {
void (*updateTransponderDMABuffer)(transponder_t *transponder, const uint8_t* transponderData);
};
bool transponderIrInit(const transponderProvider_e provider);
void transponderIrDisable(void);
void transponderIrHardwareInit(ioTag_t ioTag);
void transponderIrDMAEnable(void);
void transponderIrHardwareInit(ioTag_t ioTag, transponder_t *transponder);
void transponderIrDMAEnable(transponder_t *transponder);
void transponderIrWaitForTransmitComplete(void);

66
src/main/drivers/transponder_ir_arcitimer.c Normal file
View file

@ -0,0 +1,66 @@
/*
* This file is part of Cleanflight.
*
* Cleanflight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Cleanflight 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.
*
* You should have received a copy of the GNU General Public License
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <platform.h>
#include "drivers/transponder_ir.h"
#include "drivers/transponder_ir_arcitimer.h"
#if defined(STM32F3) || defined(STM32F4) || defined(UNIT_TEST)
extern const struct transponderVTable arcitimerTansponderVTable;
static uint16_t dmaBufferOffset;
void transponderIrInitArcitimer(transponder_t *transponder){
// from drivers/transponder_ir.h
transponder->gap_toggles = TRANSPONDER_GAP_TOGGLES_ARCITIMER;
transponder->dma_buffer_size = TRANSPONDER_DMA_BUFFER_SIZE_ARCITIMER;
transponder->vTable = &arcitimerTansponderVTable;
transponder->timer_hz = TRANSPONDER_TIMER_MHZ_ARCITIMER;
transponder->timer_carrier_hz = TRANSPONDER_CARRIER_HZ_ARCITIMER;
memset(&(transponder->transponderIrDMABuffer.arcitimer), 0, TRANSPONDER_DMA_BUFFER_SIZE_ARCITIMER);
}
void updateTransponderDMABufferArcitimer(transponder_t *transponder, const uint8_t* transponderData)
{
uint8_t byteIndex;
uint8_t bitIndex;
uint8_t hightStateIndex;
for (byteIndex = 0; byteIndex < TRANSPONDER_DATA_LENGTH_ARCITIMER; byteIndex++) {
uint8_t byteToSend = *transponderData;
transponderData++;
for (bitIndex = 0; bitIndex < TRANSPONDER_BITS_PER_BYTE_ARCITIMER; bitIndex++)
{
bool isHightState = byteToSend & (1 << (bitIndex));
for (hightStateIndex = 0; hightStateIndex < TRANSPONDER_TOGGLES_PER_BIT_ARCITIMER; hightStateIndex++)
{
transponder->transponderIrDMABuffer.arcitimer[dmaBufferOffset] = isHightState ? transponder->bitToggleOne : 0;
dmaBufferOffset++;
}
}
}
dmaBufferOffset = 0;
}
const struct transponderVTable arcitimerTansponderVTable = {
updateTransponderDMABufferArcitimer,
};
#endif

34
src/main/drivers/transponder_ir_arcitimer.h Normal file
View file

@ -0,0 +1,34 @@
/*
* This file is part of Cleanflight.
*
* Cleanflight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Cleanflight 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.
*
* You should have received a copy of the GNU General Public License
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
// aRCiTimer transponder codes:
//
// ID1 0x1F, 0xFC, 0x8F, 0x3, 0xF0, 0x1, 0xF8, 0x1F, 0x0 // E00370FC0FFE07E0FF
// ID2 0xFF, 0x83, 0xFF, 0xC1, 0x7, 0xFF, 0x3, 0xF0, 0x1 // 007C003EF800FC0FFE
// ID3 0x7, 0x7E, 0xE0, 0x7, 0x7E, 0xE0, 0x0, 0x38, 0x0 // F8811FF8811FFFC7FF
// ID4 0xFF, 0x83, 0xFF, 0xC1, 0x7, 0xE0, 0x7F, 0xF0, 0x1 // 007C003EF81F800FFE
// ID5 0xF, 0xF0, 0x0, 0xFF, 0x0, 0xF, 0xF0, 0xF, 0x0 // F00FFF00FFF00FF0FF
// ID6 0xFF, 0x83, 0xF, 0x3E, 0xF8, 0xE0, 0x83, 0xFF, 0xF // 007CF0C1071F7C00F0
// ID7 0x1F, 0xFC, 0xF, 0xC0, 0xFF, 0x0, 0xFC, 0xF, 0x3E // E003F03F00FF03F0C1
// ID8 0xFF, 0x3, 0xF0, 0x1, 0xF8, 0xE0, 0xC1, 0xFF, 0x1 // 00FC0FFE071F3E00FE
// ID9 0x1F, 0x7C, 0x40, 0xF, 0xF0, 0x61, 0xC7, 0x3F, 0x0 // E083BFF00F9E38C0FF
void transponderIrInitArcitimer(transponder_t *transponder);
void updateTransponderDMABufferArcitimer(transponder_t *transponder, const uint8_t* transponderData);

79
src/main/drivers/transponder_ir_erlt.c Normal file
View file

@ -0,0 +1,79 @@
/*
* This file is part of Cleanflight.
*
* Cleanflight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Cleanflight 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.
*
* You should have received a copy of the GNU General Public License
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <platform.h>
#include "drivers/transponder_ir.h"
#include "drivers/transponder_ir_erlt.h"
#if defined(STM32F3) || defined(STM32F4) || defined(UNIT_TEST)
static uint16_t dmaBufferOffset;
extern const struct transponderVTable erltTansponderVTable;
void transponderIrInitERLT(transponder_t *transponder){
transponder->dma_buffer_size = TRANSPONDER_DMA_BUFFER_SIZE_ERLT;
transponder->vTable = &erltTansponderVTable;
transponder->timer_hz = TRANSPONDER_TIMER_MHZ_ERLT;
transponder->timer_carrier_hz = TRANSPONDER_CARRIER_HZ_ERLT;
memset(&(transponder->transponderIrDMABuffer.erlt), 0, TRANSPONDER_DMA_BUFFER_SIZE_ERLT);
}
void addBitToBuffer(transponder_t *transponder, uint8_t cycles, uint8_t pulsewidth)
{
for (int i = 0; i < cycles; i++) {
transponder->transponderIrDMABuffer.erlt[dmaBufferOffset++] = pulsewidth;
}
}
void updateTransponderDMABufferERLT(transponder_t *transponder, const uint8_t* transponderData)
{
uint8_t byteToSend = ~(*transponderData); //transponderData is stored inverted, so invert before using
uint8_t paritysum = 0; //sum of one bits
dmaBufferOffset = 0; //reset buffer count
//start bit 1, always pulsed, bit value = 0
addBitToBuffer(transponder, ERLTCyclesForZeroBit, transponder->bitToggleOne);
//start bit 2, always not pulsed, bit value = 0
addBitToBuffer(transponder, ERLTCyclesForZeroBit, ERLTBitQuiet);
//add data bits, only the 6 LSB
for(int i = 5; i >= 0; i--)
{
uint8_t bv = (byteToSend >> i) & 0x01;
paritysum += bv;
addBitToBuffer(transponder, (bv ? ERLTCyclesForOneBit : ERLTCyclesForZeroBit), ((i % 2) ? transponder->bitToggleOne : ERLTBitQuiet));
}
//parity bit, always pulsed, bit value is zero if sum is even, one if odd
addBitToBuffer(transponder, ((paritysum % 2) ? ERLTCyclesForOneBit : ERLTCyclesForZeroBit), transponder->bitToggleOne);
//add final zero after the pulsed parity bit to stop pulses until the next update
transponder->transponderIrDMABuffer.erlt[dmaBufferOffset++] = ERLTBitQuiet;
//reset buffer size to that required by this ERLT id
transponder->dma_buffer_size = dmaBufferOffset;
}
const struct transponderVTable erltTansponderVTable = {
updateTransponderDMABufferERLT,
};
#endif

21
src/main/drivers/transponder_ir_erlt.h Normal file
View file

@ -0,0 +1,21 @@
/*
* This file is part of Cleanflight.
*
* Cleanflight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Cleanflight 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.
*
* You should have received a copy of the GNU General Public License
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
void transponderIrInitERLT(transponder_t *transponder);
void updateTransponderDMABufferERLT(transponder_t *transponder, const uint8_t* transponderData);
void addBitToBuffer(transponder_t *transponder, uint8_t cycles, uint8_t pulsewidth);

81
src/main/drivers/transponder_ir_ilap.c Normal file
View file

@ -0,0 +1,81 @@
/*
* This file is part of Cleanflight.
*
* Cleanflight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Cleanflight 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.
*
* You should have received a copy of the GNU General Public License
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <platform.h>
#include "drivers/transponder_ir.h"
#include "drivers/transponder_ir_ilap.h"
#if defined(STM32F3) || defined(STM32F4) || defined(UNIT_TEST)
static uint16_t dmaBufferOffset;
extern const struct transponderVTable ilapTansponderVTable;
void transponderIrInitIlap(transponder_t *transponder){
// from drivers/transponder_ir.h
transponder->gap_toggles = TRANSPONDER_GAP_TOGGLES_ILAP;
transponder->dma_buffer_size = TRANSPONDER_DMA_BUFFER_SIZE_ILAP;
transponder->vTable = &ilapTansponderVTable;
transponder->timer_hz = TRANSPONDER_TIMER_MHZ_ILAP;
transponder->timer_carrier_hz = TRANSPONDER_CARRIER_HZ_ILAP;
memset(&(transponder->transponderIrDMABuffer.ilap), 0, TRANSPONDER_DMA_BUFFER_SIZE_ILAP);
}
void updateTransponderDMABufferIlap(transponder_t *transponder, const uint8_t* transponderData)
{
uint8_t byteIndex;
uint8_t bitIndex;
uint8_t toggleIndex;
for (byteIndex = 0; byteIndex < TRANSPONDER_DATA_LENGTH_ILAP; byteIndex++) {
uint8_t byteToSend = *transponderData;
transponderData++;
for (bitIndex = 0; bitIndex < TRANSPONDER_BITS_PER_BYTE_ILAP; bitIndex++)
{
bool doToggles = false;
if (bitIndex == 0) {
doToggles = true;
}
else if (bitIndex == TRANSPONDER_BITS_PER_BYTE_ILAP - 1) {
doToggles = false;
}
else {
doToggles = byteToSend & (1 << (bitIndex - 1));
}
for (toggleIndex = 0; toggleIndex < TRANSPONDER_TOGGLES_PER_BIT_ILAP; toggleIndex++)
{
if (doToggles) {
transponder->transponderIrDMABuffer.ilap[dmaBufferOffset] = transponder->bitToggleOne;
}
else {
transponder->transponderIrDMABuffer.ilap[dmaBufferOffset] = 0;
}
dmaBufferOffset++;
}
transponder->transponderIrDMABuffer.ilap[dmaBufferOffset] = 0;
dmaBufferOffset++;
}
}
dmaBufferOffset = 0;
}
const struct transponderVTable ilapTansponderVTable = {
updateTransponderDMABufferIlap,
};
#endif

20
src/main/drivers/transponder_ir_ilap.h Normal file
View file

@ -0,0 +1,20 @@
/*
* This file is part of Cleanflight.
*
* Cleanflight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Cleanflight 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.
*
* You should have received a copy of the GNU General Public License
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
void transponderIrInitIlap(transponder_t *transponder);
void updateTransponderDMABufferIlap(transponder_t *transponder, const uint8_t* transponderData);

1
src/main/fc/fc_core.c
View file

@ -36,6 +36,7 @@
#include "drivers/gyro_sync.h"
#include "drivers/light_led.h"
#include "drivers/time.h"
#include "drivers/transponder_ir.h"
#include "sensors/acceleration.h"
#include "sensors/barometer.h"

57
src/main/fc/fc_msp.c
View file

@ -748,16 +748,31 @@ static bool mspCommonProcessOutCommand(uint8_t cmdMSP, sbuf_t *dst, mspPostProce
sbufWriteU8(dst, batteryConfig()->currentMeterSource);
break;
case MSP_TRANSPONDER_CONFIG:
case MSP_TRANSPONDER_CONFIG: {
#ifdef TRANSPONDER
sbufWriteU8(dst, 1); //Transponder supported
for (unsigned int i = 0; i < sizeof(transponderConfig()->data); i++) {
sbufWriteU8(dst, transponderConfig()->data[i]);
// Backward compatibility to BFC 3.1.1 is lost for this message type
sbufWriteU8(dst, TRANSPONDER_PROVIDER_COUNT);
for (unsigned int i = 0; i < TRANSPONDER_PROVIDER_COUNT; i++) {
sbufWriteU8(dst, transponderRequirements[i].provider);
sbufWriteU8(dst, transponderRequirements[i].dataLength);
}
uint8_t provider = transponderConfig()->provider;
sbufWriteU8(dst, provider);
if (provider) {
uint8_t requirementIndex = provider - 1;
uint8_t providerDataLength = transponderRequirements[requirementIndex].dataLength;
for (unsigned int i = 0; i < providerDataLength; i++) {
sbufWriteU8(dst, transponderConfig()->data[i]);
}
}
#else
sbufWriteU8(dst, 0); // Transponder not supported
sbufWriteU8(dst, 0); // no providers
#endif
break;
}
case MSP_OSD_CONFIG: {
#define OSD_FLAGS_OSD_FEATURE (1 << 0)
@ -1987,15 +2002,41 @@ static mspResult_e mspCommonProcessInCommand(uint8_t cmdMSP, sbuf_t *src)
switch (cmdMSP) {
#ifdef TRANSPONDER
case MSP_SET_TRANSPONDER_CONFIG:
if (dataSize != sizeof(transponderConfig()->data)) {
case MSP_SET_TRANSPONDER_CONFIG: {
// Backward compatibility to BFC 3.1.1 is lost for this message type
uint8_t provider = sbufReadU8(src);
uint8_t bytesRemaining = dataSize - 1;
if (provider > TRANSPONDER_PROVIDER_COUNT) {
return MSP_RESULT_ERROR;
}
for (unsigned int i = 0; i < sizeof(transponderConfig()->data); i++) {
const uint8_t requirementIndex = provider - 1;
const uint8_t transponderDataSize = transponderRequirements[requirementIndex].dataLength;
transponderConfigMutable()->provider = provider;
if (provider == TRANSPONDER_NONE) {
break;
}
if (bytesRemaining != transponderDataSize) {
return MSP_RESULT_ERROR;
}
if (provider != transponderConfig()->provider) {
transponderStopRepeating();
}
memset(transponderConfigMutable()->data, 0, sizeof(transponderConfig()->data));
for (unsigned int i = 0; i < transponderDataSize; i++) {
transponderConfigMutable()->data[i] = sbufReadU8(src);
}
transponderUpdateData();
break;
}
#endif
case MSP_SET_VOLTAGE_METER_CONFIG: {

1
src/main/fc/fc_tasks.c
View file

@ -40,6 +40,7 @@
#include "drivers/serial.h"
#include "drivers/stack_check.h"
#include "drivers/vtx_common.h"
#include "drivers/transponder_ir.h"
#include "fc/config.h"
#include "fc/fc_msp.h"

21
src/main/io/transponder_ir.c
View file

@ -30,6 +30,7 @@
#include "config/parameter_group_ids.h"
#include "drivers/transponder_ir.h"
#include "drivers/system.h"
#include "drivers/usb_io.h"
#include "fc/config.h"
@ -39,7 +40,9 @@
PG_REGISTER_WITH_RESET_TEMPLATE(transponderConfig_t, transponderConfig, PG_TRANSPONDER_CONFIG, 0);
PG_RESET_TEMPLATE(transponderConfig_t, transponderConfig,
.data = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC } // Note, this is NOT a valid transponder code, it's just for testing production hardware
.provider = TRANSPONDER_ILAP,
.reserved = 0,
.data = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0x0, 0x0, 0x0 }, // Note, this is NOT a valid transponder code, it's just for testing production hardware
);
static bool transponderInitialised = false;
@ -51,6 +54,12 @@ static timeUs_t nextUpdateAtUs = 0;
#define JITTER_DURATION_COUNT (sizeof(jitterDurations) / sizeof(uint8_t))
static uint8_t jitterDurations[] = {0,9,4,8,3,9,6,7,1,6,9,7,8,2,6};
const transponderRequirement_t transponderRequirements[TRANSPONDER_PROVIDER_COUNT] = {
{TRANSPONDER_ILAP, TRANSPONDER_DATA_LENGTH_ILAP, TRANSPONDER_TRANSMIT_DELAY_ILAP, TRANSPONDER_TRANSMIT_JITTER_ILAP},
{TRANSPONDER_ARCITIMER, TRANSPONDER_DATA_LENGTH_ARCITIMER, TRANSPONDER_TRANSMIT_DELAY_ARCITIMER, TRANSPONDER_TRANSMIT_JITTER_ARCITIMER},
{TRANSPONDER_ERLT, TRANSPONDER_DATA_LENGTH_ERLT, TRANSPONDER_TRANSMIT_DELAY_ERLT, TRANSPONDER_TRANSMIT_JITTER_ERLT}
};
void transponderUpdate(timeUs_t currentTimeUs)
{
static uint32_t jitterIndex = 0;
@ -64,13 +73,15 @@ void transponderUpdate(timeUs_t currentTimeUs)
return;
}
// TODO use a random number genenerator for random jitter? The idea here is to avoid multiple transmitters transmitting at the same time.
uint32_t jitter = (1000 * jitterDurations[jitterIndex++]);
uint8_t provider = transponderConfig()->provider;
// TODO use a random number generator for random jitter? The idea here is to avoid multiple transmitters transmitting at the same time.
uint32_t jitter = (transponderRequirements[provider - 1].transmitJitter / 10 * jitterDurations[jitterIndex++]);
if (jitterIndex >= JITTER_DURATION_COUNT) {
jitterIndex = 0;
}
nextUpdateAtUs = currentTimeUs + 4500 + jitter;
nextUpdateAtUs = currentTimeUs + transponderRequirements[provider - 1].transmitDelay + jitter;
#ifdef REDUCE_TRANSPONDER_CURRENT_DRAW_WHEN_USB_CABLE_PRESENT
// reduce current draw when USB cable is plugged in by decreasing the transponder transmit rate.
@ -84,7 +95,7 @@ void transponderUpdate(timeUs_t currentTimeUs)
void transponderInit(void)
{
transponderInitialised = transponderIrInit();
transponderInitialised = transponderIrInit(transponderConfig()->provider);
if (!transponderInitialised) {
return;
}

13
src/main/io/transponder_ir.h
View file

@ -21,9 +21,20 @@
#include "config/parameter_group.h"
typedef struct transponderConfig_s {
uint8_t data[6];
transponderProvider_e provider;
uint8_t reserved;
uint8_t data[9];
} transponderConfig_t;
typedef struct transponderRequirement_s {
uint8_t provider; // See transponderProvider_e
uint8_t dataLength;
uint16_t transmitDelay;
uint16_t transmitJitter;
} transponderRequirement_t;
extern const transponderRequirement_t transponderRequirements[TRANSPONDER_PROVIDER_COUNT];
PG_DECLARE(transponderConfig_t, transponderConfig);
void transponderInit(void);

9
src/test/Makefile
View file

@ -158,6 +158,11 @@ telemetry_ibus_unittest_SRC := \
$(USER_DIR)/telemetry/ibus.c
transponder_ir_unittest_SRC := \
$(USER_DIR)/drivers/transponder_ir_ilap.c \
$(USER_DIR)/drivers/transponder_ir_arcitimer.c
type_conversion_unittest_SRC := \
$(USER_DIR)/common/typeconversion.c
@ -165,9 +170,6 @@ type_conversion_unittest_SRC := \
ws2811_unittest_SRC := \
$(USER_DIR)/drivers/light_ws2811strip.c
# Please tweak the following variable definitions as needed by your
# project, except GTEST_HEADERS, which you can use in your own targets
# but shouldn't modify.
@ -352,7 +354,6 @@ $(OBJECT_DIR)/$1/$1 : $$($$1_OBJS) \
$(V1) mkdir -p $(dir $$@)
$(V1) $(CXX) $(CXX_FLAGS) $(PG_FLAGS) $$^ -o $$@
test_$1: $(OBJECT_DIR)/$1/$1
$(V1) $$< $$(EXEC_OPTS) "$(STDOUT)" && echo "running $$@: PASS"

106
src/test/unit/transponder_ir_unittest.cc Normal file
View file

@ -0,0 +1,106 @@
/*
* This file is part of Cleanflight.
*
* Cleanflight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Cleanflight 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.
*
* You should have received a copy of the GNU General Public License
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdlib.h>
#include <limits.h>
extern "C" {
#include <platform.h>
#include "build/build_config.h"
#include "drivers/dma.h"
#include "drivers/transponder_ir.h"
#include "drivers/transponder_ir_arcitimer.h"
#include "drivers/transponder_ir_ilap.h"
}
#include "unittest_macros.h"
#include "gtest/gtest.h"
extern "C" {
STATIC_UNIT_TESTED extern uint16_t dmaBufferOffset;
STATIC_UNIT_TESTED void updateTransponderDMABufferIlap(transponder_t *transponder, const uint8_t* transponderData);
STATIC_UNIT_TESTED void updateTransponderDMABufferArcitimer(transponder_t *transponder, const uint8_t* transponderData);
}
TEST(transponderTest, updateTransponderDMABufferArcitimer) {
//input
uint8_t data[9] = {0x1F, 0xFC, 0x8F, 0x3, 0xF0, 0x1, 0xF8, 0x1F, 0x0};
//excepted
uint8_t excepted[TRANSPONDER_DMA_BUFFER_SIZE_ARCITIMER] = {
78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,
78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,0,0,
0,0,0,0,0,0,0,0,0,0,78,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,
78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
uint8_t* transponderData = data;
transponder_t transponder;
transponder.dma_buffer_size = TRANSPONDER_DMA_BUFFER_SIZE_ARCITIMER;
transponder.bitToggleOne = 78;
memset(&(transponder.transponderIrDMABuffer.arcitimer), 0, TRANSPONDER_DMA_BUFFER_SIZE_ARCITIMER);
updateTransponderDMABufferArcitimer(&transponder, transponderData);
uint16_t i;
for(i = 0; i < transponder.dma_buffer_size; i++) {
EXPECT_EQ(transponder.transponderIrDMABuffer.arcitimer[i], excepted[i]);
}
}
TEST(transponderTest, updateTransponderDMABufferIlap) {
uint8_t data[9] = {0x1F, 0xFC, 0x8F, 0x3, 0xF0, 0x1, 0x0, 0x0, 0x0};
uint8_t excepted[TRANSPONDER_DMA_BUFFER_SIZE_ILAP] = {
78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,78,
78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,78,78,
78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,
78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,
78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,78,78,78,78,78,
78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,
78,0,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,
78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,
0,78,78,78,78,78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,78,78,78,78,
78,78,78,78,78,78,78,0,78,78,78,78,78,78,78,78,78,78,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
uint8_t* transponderData = data;
transponder_t transponder;
transponder.dma_buffer_size = TRANSPONDER_DMA_BUFFER_SIZE_ILAP;
transponder.bitToggleOne = 78;
updateTransponderDMABufferIlap(&transponder, transponderData);
uint16_t i;
for(i = 0; i < transponder.dma_buffer_size; i++) {
EXPECT_EQ(transponder.transponderIrDMABuffer.ilap[i], excepted[i]);
}
}