rusefi
/
atbetaflight
mirror of https://github.com/rusefi/atbetaflight.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Moved ESC telemetry to sensors

This commit is contained in:
Bas Delfos 2016-11-23 21:58:29 +01:00
parent aa1ae88ddf
commit b53cbbefc3
33 changed files with 154 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -593,7 +593,7 @@ HIGHEND_SRC = \
telemetry/smartport.c \
telemetry/ltm.c \
telemetry/mavlink.c \
telemetry/esc_telemetry.c \
sensors/esc_sensor.c \
ifeq ($(TARGET),$(filter $(TARGET),$(F4_TARGETS)))
VCP_SRC = \

2
src/main/build/debug.h
View File

@ -59,7 +59,7 @@ typedef enum {
DEBUG_VELOCITY,
DEBUG_DTERM_FILTER,
DEBUG_ANGLERATE,
DEBUG_ESC_TELEMETRY,
DEBUG_ESC_SENSOR,
DEBUG_SCHEDULER,
DEBUG_STACK,
DEBUG_COUNT

2
src/main/fc/config.h
View File

@ -55,7 +55,7 @@ typedef enum {
FEATURE_VTX = 1 << 24,
FEATURE_RX_SPI = 1 << 25,
FEATURE_SOFTSPI = 1 << 26,
FEATURE_ESC_TELEMETRY = 1 << 27
FEATURE_ESC_SENSOR = 1 << 27,
} features_e;
void beeperOffSet(uint32_t mask);

29
src/main/fc/fc_tasks.c
View File

@ -63,11 +63,11 @@
#include "sensors/compass.h"
#include "sensors/gyro.h"
#include "sensors/sonar.h"
#include "sensors/esc_sensor.h"
#include "scheduler/scheduler.h"
#include "telemetry/telemetry.h"
#include "telemetry/esc_telemetry.h"
#include "config/feature.h"
#include "config/config_profile.h"
@ -111,7 +111,7 @@ static void taskUpdateBattery(timeUs_t currentTimeUs)
{
#ifdef USE_ADC
static uint32_t vbatLastServiced = 0;
if (feature(FEATURE_VBAT) || feature(FEATURE_ESC_TELEMETRY)) {
if (feature(FEATURE_VBAT) || feature(FEATURE_ESC_SENSOR)) {
if (cmp32(currentTimeUs, vbatLastServiced) >= VBATINTERVAL) {
vbatLastServiced = currentTimeUs;
updateBattery();
@ -120,7 +120,7 @@ static void taskUpdateBattery(timeUs_t currentTimeUs)
#endif
static uint32_t ibatLastServiced = 0;
if (feature(FEATURE_CURRENT_METER) || feature(FEATURE_ESC_TELEMETRY)) {
if (feature(FEATURE_CURRENT_METER) || feature(FEATURE_ESC_SENSOR)) {
const int32_t ibatTimeSinceLastServiced = cmp32(currentTimeUs, ibatLastServiced);
if (ibatTimeSinceLastServiced >= IBATINTERVAL) {
@ -203,15 +203,6 @@ static void taskTelemetry(timeUs_t currentTimeUs)
}
#endif
#ifdef USE_ESC_TELEMETRY
static void taskEscTelemetry(timeUs_t currentTimeUs)
{
if (feature(FEATURE_ESC_TELEMETRY)) {
escTelemetryProcess(currentTimeUs);
}
}
#endif
void fcTasksInit(void)
{
schedulerInit();
@ -277,8 +268,8 @@ void fcTasksInit(void)
#ifdef USE_BST
setTaskEnabled(TASK_BST_MASTER_PROCESS, true);
#endif
#ifdef USE_ESC_TELEMETRY
setTaskEnabled(TASK_ESC_TELEMETRY, feature(FEATURE_ESC_TELEMETRY));
#ifdef USE_ESC_SENSOR
setTaskEnabled(TASK_ESC_SENSOR, feature(FEATURE_ESC_SENSOR));
#endif
#ifdef CMS
#ifdef USE_MSP_DISPLAYPORT
@ -450,11 +441,11 @@ cfTask_t cfTasks[TASK_COUNT] = {
},
#endif
#ifdef USE_ESC_TELEMETRY
[TASK_ESC_TELEMETRY] = {
.taskName = "ESC_TELEMETRY",
.taskFunc = taskEscTelemetry,
.desiredPeriod = 1000000 / 100, // 100 Hz
#ifdef USE_ESC_SENSOR
[TASK_ESC_SENSOR] = {
.taskName = "ESC_SENSOR",
.taskFunc = escSensorProcess,
.desiredPeriod = TASK_PERIOD_HZ(100), // 100 Hz every 10ms
.staticPriority = TASK_PRIORITY_LOW,
},
#endif

4
src/main/io/serial_cli.c
View File

@ -234,7 +234,7 @@ static const char * const featureNames[] = {
"SONAR", "TELEMETRY", "CURRENT_METER", "3D", "RX_PARALLEL_PWM",
"RX_MSP", "RSSI_ADC", "LED_STRIP", "DISPLAY", "OSD",
"BLACKBOX", "CHANNEL_FORWARDING", "TRANSPONDER", "AIRMODE",
"SDCARD", "VTX", "RX_SPI", "SOFTSPI", "ESC_TELEMETRY", NULL
"SDCARD", "VTX", "RX_SPI", "SOFTSPI", "ESC_SENSOR", NULL
};
// sync this with rxFailsafeChannelMode_e
@ -519,7 +519,7 @@ static const char * const lookupTableDebug[DEBUG_COUNT] = {
"VELOCITY",
"DFILTER",
"ANGLERATE",
"ESC_TELEMETRY",
"ESC_SENSOR",
"SCHEDULER",
};

8
src/main/main.c
View File

@ -104,7 +104,7 @@
#include "sensors/initialisation.h"
#include "telemetry/telemetry.h"
#include "telemetry/esc_telemetry.h"
#include "sensors/esc_sensor.h"
#include "flight/pid.h"
#include "flight/imu.h"
@ -493,9 +493,9 @@ void init(void)
}
#endif
#ifdef USE_ESC_TELEMETRY
if (feature(FEATURE_ESC_TELEMETRY)) {
escTelemetryInit();
#ifdef USE_ESC_SENSOR
if (feature(FEATURE_ESC_SENSOR)) {
escSensorInit();
}
#endif

4
src/main/scheduler/scheduler.h
View File

@ -94,8 +94,8 @@ typedef enum {
#ifdef USE_BST
TASK_BST_MASTER_PROCESS,
#endif
#ifdef USE_ESC_TELEMETRY
TASK_ESC_TELEMETRY,
#ifdef USE_ESC_SENSOR
TASK_ESC_SENSOR,
#endif
#ifdef CMS
TASK_CMS,

33
src/main/sensors/battery.c
View File

@ -34,8 +34,7 @@
#include "config/feature.h"
#include "sensors/battery.h"
#include "telemetry/esc_telemetry.h"
#include "sensors/esc_sensor.h"
#include "fc/rc_controls.h"
#include "io/beeper.h"
@ -84,9 +83,9 @@ static void updateBatteryVoltage(void)
vBatFilterIsInitialised = true;
}
#ifdef USE_ESC_TELEMETRY
if (batteryConfig->batteryMeterType == BATTERY_SENSOR_ESC && isEscTelemetryActive()) {
vbatLatest = getEscTelemetryVbat();
#ifdef USE_ESC_SENSOR
if (feature(FEATURE_ESC_SENSOR) && batteryConfig->batteryMeterType == BATTERY_SENSOR_ESC) {
vbatLatest = getEscSensorVbat();
if (debugMode == DEBUG_BATTERY) {
debug[0] = -1;
}
@ -270,11 +269,9 @@ void updateCurrentMeter(int32_t lastUpdateAt, rxConfig_t *rxConfig, uint16_t dea
updateCurrentDrawn(lastUpdateAt);
updateConsumptionWarning();
break;
case CURRENT_SENSOR_VIRTUAL:
amperageLatest = (int32_t)batteryConfig->currentMeterOffset;
amperage = (int32_t)batteryConfig->currentMeterOffset;
if (ARMING_FLAG(ARMED)) {
throttleStatus_e throttleStatus = calculateThrottleStatus(rxConfig, deadband3d_throttle);
int throttleOffset = (int32_t)rcCommand[THROTTLE] - 1000;
@ -282,30 +279,24 @@ void updateCurrentMeter(int32_t lastUpdateAt, rxConfig_t *rxConfig, uint16_t dea
throttleOffset = 0;
}
int throttleFactor = throttleOffset + (throttleOffset * throttleOffset / 50);
amperageLatest += throttleFactor * (int32_t)batteryConfig->currentMeterScale / 1000;
amperage += throttleFactor * (int32_t)batteryConfig->currentMeterScale / 1000;
}
amperage = amperageLatest;
updateCurrentDrawn(lastUpdateAt);
updateConsumptionWarning();
break;
case CURRENT_SENSOR_ESC:
#ifdef USE_ESC_TELEMETRY
if (isEscTelemetryActive()) {
amperageLatest = getEscTelemetryCurrent();
amperage = amperageLatest;
mAhDrawn = getEscTelemetryConsumption();
#ifdef USE_ESC_SENSOR
if (feature(FEATURE_ESC_SENSOR))
{
amperage = getEscSensorCurrent();
mAhDrawn = getEscSensorConsumption();
updateConsumptionWarning();
updateCurrentDrawn(lastUpdateAt);
}
break;
#endif
case CURRENT_SENSOR_NONE:
amperage = 0;
amperageLatest = 0;
break;
}

142
src/main/telemetry/esc_telemetry.c → src/main/sensors/esc_sensor.c
View File

@ -21,7 +21,7 @@
#include "sensors/battery.h"
#include "esc_telemetry.h"
#include "esc_sensor.h"
#include "build/debug.h"
@ -68,64 +68,64 @@ typedef struct {
} esc_telemetry_t;
typedef enum {
ESC_TLM_FRAME_PENDING = 1 << 0, // 1
ESC_TLM_FRAME_COMPLETE = 1 << 1 // 2
ESC_SENSOR_FRAME_PENDING = 1 << 0, // 1
ESC_SENSOR_FRAME_COMPLETE = 1 << 1 // 2
} escTlmFrameState_t;
typedef enum {
ESC_TLM_TRIGGER_WAIT = 0,
ESC_TLM_TRIGGER_READY = 1 << 0, // 1
ESC_TLM_TRIGGER_PENDING = 1 << 1 // 2
} escTlmTriggerState_t;
ESC_SENSOR_TRIGGER_WAIT = 0,
ESC_SENSOR_TRIGGER_READY = 1 << 0, // 1
ESC_SENSOR_TRIGGER_PENDING = 1 << 1, // 2
} escSensorTriggerState_t;
#define ESC_TLM_BAUDRATE 115200
#define ESC_TLM_BUFFSIZE 10
#define ESC_SENSOR_BAUDRATE 115200
#define ESC_SENSOR_BUFFSIZE 10
#define ESC_BOOTTIME 5000 // 5 seconds
#define ESC_REQUEST_TIMEOUT 100 // 100 ms (data transfer takes only 900us)
static bool tlmFrameDone = false;
static uint8_t tlm[ESC_TLM_BUFFSIZE] = { 0, };
static uint8_t tlm[ESC_SENSOR_BUFFSIZE] = { 0, };
static uint8_t tlmFramePosition = 0;
static serialPort_t *escTelemetryPort = NULL;
static esc_telemetry_t escTelemetryData[MAX_SUPPORTED_MOTORS];
static serialPort_t *escSensorPort = NULL;
static esc_telemetry_t escSensorData[MAX_SUPPORTED_MOTORS];
static uint32_t escTriggerTimestamp = -1;
static uint32_t escTriggerLastTimestamp = -1;
static uint8_t timeoutRetryCount = 0;
static uint8_t escTelemetryMotor = 0; // motor index
static bool escTelemetryEnabled = false;
static escTlmTriggerState_t escTelemetryTriggerState = ESC_TLM_TRIGGER_WAIT;
static uint8_t escSensorMotor = 0; // motor index
static bool escSensorEnabled = false;
static escSensorTriggerState_t escSensorTriggerState = ESC_SENSOR_TRIGGER_WAIT;
static int16_t escVbat = 0;
static int16_t escCurrent = 0;
static int16_t escConsumption = 0;
static void escTelemetryDataReceive(uint16_t c);
static void escSensorDataReceive(uint16_t c);
static uint8_t update_crc8(uint8_t crc, uint8_t crc_seed);
static uint8_t get_crc8(uint8_t *Buf, uint8_t BufLen);
static void selectNextMotor(void);
bool isEscTelemetryActive(void)
bool isEscSensorActive(void)
{
return escTelemetryEnabled;
return escSensorEnabled;
}
int16_t getEscTelemetryVbat(void)
int16_t getEscSensorVbat(void)
{
return escVbat / 10;
}
int16_t getEscTelemetryCurrent(void)
int16_t getEscSensorCurrent(void)
{
return escCurrent;
}
int16_t getEscTelemetryConsumption(void)
int16_t getEscSensorConsumption(void)
{
return escConsumption;
}
bool escTelemetryInit(void)
bool escSensorInit(void)
{
serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_ESC);
if (!portConfig) {
@ -135,35 +135,33 @@ bool escTelemetryInit(void)
portOptions_t options = (SERIAL_NOT_INVERTED);
// Initialize serial port
escTelemetryPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_ESC, escTelemetryDataReceive, ESC_TLM_BAUDRATE, MODE_RX, options);
escSensorPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_ESC, escSensorDataReceive, ESC_SENSOR_BAUDRATE, MODE_RX, options);
if (escTelemetryPort) {
escTelemetryEnabled = true;
batteryConfig()->currentMeterType = CURRENT_SENSOR_ESC;
batteryConfig()->batteryMeterType = BATTERY_SENSOR_ESC;
if (escSensorPort) {
escSensorEnabled = true;
}
return escTelemetryPort != NULL;
return escSensorPort != NULL;
}
void freeEscTelemetryPort(void)
void freeEscSensorPort(void)
{
closeSerialPort(escTelemetryPort);
escTelemetryPort = NULL;
escTelemetryEnabled = false;
closeSerialPort(escSensorPort);
escSensorPort = NULL;
escSensorEnabled = false;
}
// Receive ISR callback
static void escTelemetryDataReceive(uint16_t c)
static void escSensorDataReceive(uint16_t c)
{
// KISS ESC sends some data during startup, ignore this for now (maybe future use)
// startup data could be firmware version and serialnumber
if (escTelemetryTriggerState == ESC_TLM_TRIGGER_WAIT) return;
if (escSensorTriggerState == ESC_SENSOR_TRIGGER_WAIT) return;
tlm[tlmFramePosition] = (uint8_t)c;
if (tlmFramePosition == ESC_TLM_BUFFSIZE - 1) {
if (tlmFramePosition == ESC_SENSOR_BUFFSIZE - 1) {
tlmFrameDone = true;
tlmFramePosition = 0;
} else {
@ -171,9 +169,9 @@ static void escTelemetryDataReceive(uint16_t c)
}
}
uint8_t escTelemetryFrameStatus(void)
uint8_t escSensorFrameStatus(void)
{
uint8_t frameStatus = ESC_TLM_FRAME_PENDING;
uint8_t frameStatus = ESC_SENSOR_FRAME_PENDING;
uint16_t chksum, tlmsum;
if (!tlmFrameDone) {
@ -183,28 +181,28 @@ uint8_t escTelemetryFrameStatus(void)
tlmFrameDone = false;
// Get CRC8 checksum
chksum = get_crc8(tlm, ESC_TLM_BUFFSIZE - 1);
tlmsum = tlm[ESC_TLM_BUFFSIZE - 1]; // last byte contains CRC value
chksum = get_crc8(tlm, ESC_SENSOR_BUFFSIZE - 1);
tlmsum = tlm[ESC_SENSOR_BUFFSIZE - 1]; // last byte contains CRC value
if (chksum == tlmsum) {
escTelemetryData[escTelemetryMotor].skipped = false;
escTelemetryData[escTelemetryMotor].temperature = tlm[0];
escTelemetryData[escTelemetryMotor].voltage = tlm[1] << 8 | tlm[2];
escTelemetryData[escTelemetryMotor].current = tlm[3] << 8 | tlm[4];
escTelemetryData[escTelemetryMotor].consumption = tlm[5] << 8 | tlm[6];
escTelemetryData[escTelemetryMotor].rpm = tlm[7] << 8 | tlm[8];
escSensorData[escSensorMotor].skipped = false;
escSensorData[escSensorMotor].temperature = tlm[0];
escSensorData[escSensorMotor].voltage = tlm[1] << 8 | tlm[2];
escSensorData[escSensorMotor].current = tlm[3] << 8 | tlm[4];
escSensorData[escSensorMotor].consumption = tlm[5] << 8 | tlm[6];
escSensorData[escSensorMotor].rpm = tlm[7] << 8 | tlm[8];
frameStatus = ESC_TLM_FRAME_COMPLETE;
frameStatus = ESC_SENSOR_FRAME_COMPLETE;
}
return frameStatus;
}
void escTelemetryProcess(timeUs_t currentTimeUs)
void escSensorProcess(timeUs_t currentTimeUs)
{
const timeMs_t currentTimeMs = currentTimeUs / 1000;
if (!escTelemetryEnabled) {
if (!escSensorEnabled) {
return;
}
@ -212,66 +210,66 @@ void escTelemetryProcess(timeUs_t currentTimeUs)
if (millis() < ESC_BOOTTIME) {
return;
}
else if (escTelemetryTriggerState == ESC_TLM_TRIGGER_WAIT) {
else if (escSensorTriggerState == ESC_SENSOR_TRIGGER_WAIT) {
// Ready for starting requesting telemetry
escTelemetryTriggerState = ESC_TLM_TRIGGER_READY;
escTelemetryMotor = 0;
escSensorTriggerState = ESC_SENSOR_TRIGGER_READY;
escSensorMotor = 0;
escTriggerTimestamp = currentTimeMs;
escTriggerLastTimestamp = escTriggerTimestamp;
}
else if (escTelemetryTriggerState == ESC_TLM_TRIGGER_READY) {
if (debugMode == DEBUG_ESC_TELEMETRY) debug[0] = escTelemetryMotor+1;
else if (escSensorTriggerState == ESC_SENSOR_TRIGGER_READY) {
if (debugMode == DEBUG_ESC_SENSOR) debug[0] = escSensorMotor+1;
motorDmaOutput_t * const motor = getMotorDmaOutput(escTelemetryMotor);
motorDmaOutput_t * const motor = getMotorDmaOutput(escSensorMotor);
motor->requestTelemetry = true;
escTelemetryTriggerState = ESC_TLM_TRIGGER_PENDING;
escSensorTriggerState = ESC_SENSOR_TRIGGER_PENDING;
}
if (escTriggerTimestamp + ESC_REQUEST_TIMEOUT < currentTimeMs) {
// ESC did not repond in time, retry
timeoutRetryCount++;
escTriggerTimestamp = currentTimeMs;
escTelemetryTriggerState = ESC_TLM_TRIGGER_READY;
escSensorTriggerState = ESC_SENSOR_TRIGGER_READY;
if (timeoutRetryCount == 4) {
// Not responding after 3 times, skip motor
escTelemetryData[escTelemetryMotor].skipped = true;
escSensorData[escSensorMotor].skipped = true;
selectNextMotor();
}
if (debugMode == DEBUG_ESC_TELEMETRY) debug[1]++;
if (debugMode == DEBUG_ESC_SENSOR) debug[1]++;
}
// Get received frame status
uint8_t state = escTelemetryFrameStatus();
uint8_t state = escSensorFrameStatus();
if (state == ESC_TLM_FRAME_COMPLETE) {
if (state == ESC_SENSOR_FRAME_COMPLETE) {
// Wait until all ESCs are processed
if (escTelemetryMotor == getMotorCount()-1) {
if (escSensorMotor == getMotorCount()-1) {
escCurrent = 0;
escConsumption = 0;
escVbat = 0;
for (int i = 0; i < getMotorCount(); i++) {
if (!escTelemetryData[i].skipped) {
escVbat = i > 0 ? ((escVbat + escTelemetryData[i].voltage) / 2) : escTelemetryData[i].voltage;
escCurrent = escCurrent + escTelemetryData[i].current;
escConsumption = escConsumption + escTelemetryData[i].consumption;
if (!escSensorData[i].skipped) {
escVbat = i > 0 ? ((escVbat + escSensorData[i].voltage) / 2) : escSensorData[i].voltage;
escCurrent = escCurrent + escSensorData[i].current;
escConsumption = escConsumption + escSensorData[i].consumption;
}
}
}
if (debugMode == DEBUG_ESC_TELEMETRY) debug[2] = escVbat;
if (debugMode == DEBUG_ESC_TELEMETRY) debug[3] = escCurrent;
if (debugMode == DEBUG_ESC_SENSOR) debug[2] = escVbat;
if (debugMode == DEBUG_ESC_SENSOR) debug[3] = escCurrent;
selectNextMotor();
escTelemetryTriggerState = ESC_TLM_TRIGGER_READY;
escSensorTriggerState = ESC_SENSOR_TRIGGER_READY;
}
if (escTriggerLastTimestamp + 10000 < currentTimeMs) {
// ESCs did not respond for 10 seconds
// Disable ESC telemetry and fallback to onboard vbat sensor
freeEscTelemetryPort();
freeEscSensorPort();
escVbat = 0;
escCurrent = 0;
escConsumption = 0;
@ -280,9 +278,9 @@ void escTelemetryProcess(timeUs_t currentTimeUs)
static void selectNextMotor(void)
{
escTelemetryMotor++;
if (escTelemetryMotor == getMotorCount()) {
escTelemetryMotor = 0;
escSensorMotor++;
if (escSensorMotor == getMotorCount()) {
escSensorMotor = 0;
}
escTriggerTimestamp = millis();
escTriggerLastTimestamp = escTriggerTimestamp;

10
src/main/sensors/esc_sensor.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
uint8_t escSensorFrameStatus(void);
bool escSensorInit(void);
bool isEscSensorActive(void);
int16_t getEscSensorVbat(void);
int16_t getEscSensorCurrent(void);
int16_t getEscSensorConsumption(void);
void escSensorProcess(uint32_t currentTime);

2
src/main/target/ANYFCF7/target.h
View File

@ -24,7 +24,7 @@
#define USBD_PRODUCT_STRING "AnyFCF7"
#define USE_DSHOT
#define USE_ESC_TELEMETRY
#define USE_ESC_SENSOR
#define LED0 PB7
#define LED1 PB6

3
src/main/target/BETAFLIGHTF3/target.h
View File

@ -44,7 +44,8 @@
#define MPU_INT_EXTI PC13
#define USE_EXTI
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define REMAP_TIM16_DMA
#define REMAP_TIM17_DMA

3
src/main/target/BLUEJAYF4/target.h
View File

@ -144,7 +144,8 @@
#define USE_ADC
#define VBAT_ADC_PIN PC3
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define LED_STRIP
#define ENABLE_BLACKBOX_LOGGING_ON_SDCARD_BY_DEFAULT

3
src/main/target/DOGE/target.h
View File

@ -125,7 +125,8 @@
#define ENSURE_MPU_DATA_READY_IS_LOW
#define LED_STRIP
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define DEFAULT_RX_FEATURE FEATURE_RX_PPM

3
src/main/target/FURYF3/target.h
View File

@ -161,7 +161,8 @@
#define USE_SERIAL_4WAY_BLHELI_INTERFACE
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define REMAP_TIM17_DMA
#define TARGET_IO_PORTA 0xffff

3
src/main/target/FURYF4/target.h
View File

@ -175,7 +175,8 @@
#define USE_SERIAL_4WAY_BLHELI_INTERFACE
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define TARGET_IO_PORTA 0xffff
#define TARGET_IO_PORTB 0xffff

2
src/main/target/FURYF7/target.h
View File

@ -24,7 +24,7 @@
#define USBD_PRODUCT_STRING "FuryF7"
#define USE_DSHOT
#define USE_ESC_TELEMETRY
#define USE_ESC_SENSOR
#define LED0 PB5
#define LED1 PB4

3
src/main/target/IMPULSERCF3/target.h
View File

@ -46,7 +46,8 @@
#define USE_FLASHFS
#define USE_FLASH_M25P16
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define REMAP_TIM17_DMA
#define USE_VCP

3
src/main/target/KISSFC/target.h
View File

@ -23,7 +23,8 @@
#define SBUS_PORT_OPTIONS (SERIAL_STOPBITS_2 | SERIAL_PARITY_EVEN | SERIAL_INVERTED | SERIAL_BIDIR)
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define USE_ESCSERIAL
#define ESCSERIAL_TIMER_TX_HARDWARE 6

3
src/main/target/LUX_RACE/target.h
View File

@ -46,7 +46,8 @@
#define USE_MPU_DATA_READY_SIGNAL
#define ENSURE_MPU_DATA_READY_IS_LOW
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define USE_SPI
#define USE_SPI_DEVICE_1

3
src/main/target/MOTOLAB/target.h
View File

@ -95,7 +95,8 @@
#define RSSI_ADC_PIN PB2
#define LED_STRIP
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define SPEKTRUM_BIND
// USART2, PB4

3
src/main/target/MULTIFLITEPICO/target.h
View File

@ -105,7 +105,8 @@
#define CURRENT_METER_ADC_PIN PA5
#define RSSI_ADC_PIN PB2
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define REMAP_TIM17_DMA
// UART1 TX uses DMA1_Channel4, which is also used by dshot on motor 4

3
src/main/target/OMNIBUS/target.h
View File

@ -128,7 +128,8 @@
// Divide to under 25MHz for normal operation:
#define SDCARD_SPI_FULL_SPEED_CLOCK_DIVIDER 2
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
// DSHOT output 4 uses DMA1_Channel5, so don't use it for the SDCARD until we find an alternative
#ifndef USE_DSHOT

3
src/main/target/OMNIBUSF4/target.h
View File

@ -155,7 +155,8 @@
#define VBAT_ADC_PIN PC2
//#define RSSI_ADC_PIN PA0
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define LED_STRIP

3
src/main/target/REVO/target.h
View File

@ -41,7 +41,8 @@
#endif
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define LED0 PB5
// Disable LED1, conflicts with AirbotF4/Flip32F4/Revolt beeper

3
src/main/target/SPARKY2/target.h
View File

@ -35,7 +35,8 @@
#define INVERTER PC6
#define INVERTER_USART USART6
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
// MPU9250 interrupt
#define USE_EXTI

3
src/main/target/SPRACINGF3/target.h
View File

@ -115,7 +115,8 @@
#define CURRENT_METER_ADC_PIN PA5
#define RSSI_ADC_PIN PB2
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define REMAP_TIM17_DMA
// UART1 TX uses DMA1_Channel4, which is also used by dshot on motor 4

3
src/main/target/SPRACINGF3EVO/target.h
View File

@ -35,7 +35,8 @@
#define USE_MAG_DATA_READY_SIGNAL
#define ENSURE_MAG_DATA_READY_IS_HIGH
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define GYRO
#define USE_GYRO_SPI_MPU6500

3
src/main/target/STM32F3DISCOVERY/target.h
View File

@ -169,7 +169,8 @@
#define RSSI_ADC_PIN PC2
#define EXTERNAL1_ADC_PIN PC3
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define LED_STRIP

3
src/main/target/X_RACERSPI/target.h
View File

@ -101,7 +101,8 @@
#define CURRENT_METER_ADC_PIN PA5
#define RSSI_ADC_PIN PB2
#define USE_ESC_TELEMETRY
#define USE_DSHOT
#define USE_ESC_SENSOR
#define REMAP_TIM17_DMA
// UART1 TX uses DMA1_Channel4, which is also used by dshot on motor 4

12
src/main/telemetry/esc_telemetry.h
View File

@ -1,12 +0,0 @@
#pragma once
#include "common/time.h"
uint8_t escTelemetryFrameStatus(void);
bool escTelemetryInit(void);
bool isEscTelemetryActive(void);
int16_t getEscTelemetryVbat(void);
int16_t getEscTelemetryCurrent(void);
int16_t getEscTelemetryConsumption(void);
void escTelemetryProcess(timeUs_t currentTimeUs);

2
src/main/telemetry/frsky.c
View File

@ -529,7 +529,7 @@ void handleFrSkyTelemetry(rxConfig_t *rxConfig, uint16_t deadband3d_throttle)
sendTemperature1();
sendThrottleOrBatterySizeAsRpm(rxConfig, deadband3d_throttle);
if ((feature(FEATURE_VBAT) || feature(FEATURE_ESC_TELEMETRY)) && batteryCellCount > 0) {
if ((feature(FEATURE_VBAT) || feature(FEATURE_ESC_SENSOR)) && batteryCellCount > 0) {
sendVoltage();
sendVoltageAmp();
sendAmperage();

4
src/main/telemetry/smartport.c
View File

@ -646,7 +646,7 @@ void handleSmartPortTelemetry(void)
}
break;
case FSSP_DATAID_CURRENT :
if (feature(FEATURE_CURRENT_METER) || feature(FEATURE_ESC_TELEMETRY)) {
if (feature(FEATURE_CURRENT_METER) || feature(FEATURE_ESC_SENSOR)) {
smartPortSendPackage(id, amperage / 10); // given in 10mA steps, unknown requested unit
smartPortHasRequest = 0;
}
@ -659,7 +659,7 @@ void handleSmartPortTelemetry(void)
}
break;
case FSSP_DATAID_FUEL :
if (feature(FEATURE_CURRENT_METER) || feature(FEATURE_ESC_TELEMETRY)) {
if (feature(FEATURE_CURRENT_METER) || feature(FEATURE_ESC_SENSOR)) {
smartPortSendPackage(id, mAhDrawn); // given in mAh, unknown requested unit
smartPortHasRequest = 0;
}