2014-09-19 18:27:06 -07:00
|
|
|
/*
|
2022-03-11 09:08:28 -08:00
|
|
|
Copyright 2016 - 2022 Benjamin Vedder benjamin@vedder.se
|
2014-09-19 18:27:06 -07:00
|
|
|
|
2016-11-04 07:18:34 -07:00
|
|
|
This file is part of the VESC firmware.
|
|
|
|
|
|
|
|
The VESC firmware is free software: you can redistribute it and/or modify
|
2014-09-19 18:27:06 -07:00
|
|
|
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.
|
|
|
|
|
2016-11-04 07:18:34 -07:00
|
|
|
The VESC firmware is distributed in the hope that it will be useful,
|
2014-09-19 18:27:06 -07:00
|
|
|
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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2014-09-14 14:08:22 -07:00
|
|
|
#ifndef DATATYPES_H_
|
|
|
|
#define DATATYPES_H_
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdbool.h>
|
2015-02-19 12:20:07 -08:00
|
|
|
#include "ch.h"
|
2014-09-14 14:08:22 -07:00
|
|
|
|
|
|
|
// Data types
|
2020-10-09 12:08:48 -07:00
|
|
|
typedef enum {
|
|
|
|
HW_TYPE_VESC = 0,
|
|
|
|
HW_TYPE_VESC_BMS,
|
|
|
|
HW_TYPE_CUSTOM_MODULE
|
|
|
|
} HW_TYPE;
|
|
|
|
|
2014-09-14 14:08:22 -07:00
|
|
|
typedef enum {
|
|
|
|
MC_STATE_OFF = 0,
|
|
|
|
MC_STATE_DETECTING,
|
|
|
|
MC_STATE_RUNNING,
|
|
|
|
MC_STATE_FULL_BRAKE,
|
|
|
|
} mc_state;
|
|
|
|
|
|
|
|
typedef enum {
|
2014-09-14 17:39:58 -07:00
|
|
|
PWM_MODE_NONSYNCHRONOUS_HISW = 0, // This mode is not recommended
|
2014-09-14 14:08:22 -07:00
|
|
|
PWM_MODE_SYNCHRONOUS, // The recommended and most tested mode
|
|
|
|
PWM_MODE_BIPOLAR // Some glitches occasionally, can kill MOSFETs
|
|
|
|
} mc_pwm_mode;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
COMM_MODE_INTEGRATE = 0,
|
|
|
|
COMM_MODE_DELAY
|
|
|
|
} mc_comm_mode;
|
|
|
|
|
2015-06-19 14:38:46 -07:00
|
|
|
typedef enum {
|
|
|
|
SENSOR_MODE_SENSORLESS = 0,
|
|
|
|
SENSOR_MODE_SENSORED,
|
|
|
|
SENSOR_MODE_HYBRID
|
|
|
|
} mc_sensor_mode;
|
|
|
|
|
2015-12-08 12:01:23 -08:00
|
|
|
typedef enum {
|
|
|
|
FOC_SENSOR_MODE_SENSORLESS = 0,
|
2016-01-27 14:57:23 -08:00
|
|
|
FOC_SENSOR_MODE_ENCODER,
|
2020-01-20 00:39:33 -08:00
|
|
|
FOC_SENSOR_MODE_HALL,
|
2021-03-13 02:36:47 -08:00
|
|
|
FOC_SENSOR_MODE_HFI,
|
|
|
|
FOC_SENSOR_MODE_HFI_START
|
2015-12-08 12:01:23 -08:00
|
|
|
} mc_foc_sensor_mode;
|
|
|
|
|
2018-07-06 12:20:54 -07:00
|
|
|
// Auxiliary output mode
|
|
|
|
typedef enum {
|
|
|
|
OUT_AUX_MODE_OFF = 0,
|
|
|
|
OUT_AUX_MODE_ON_AFTER_2S,
|
|
|
|
OUT_AUX_MODE_ON_AFTER_5S,
|
2019-12-19 07:55:38 -08:00
|
|
|
OUT_AUX_MODE_ON_AFTER_10S,
|
2021-06-19 08:50:44 -07:00
|
|
|
OUT_AUX_MODE_UNUSED,
|
|
|
|
OUT_AUX_MODE_ON_WHEN_RUNNING,
|
|
|
|
OUT_AUX_MODE_ON_WHEN_NOT_RUNNING,
|
2021-07-12 05:31:01 -07:00
|
|
|
OUT_AUX_MODE_MOTOR_50,
|
|
|
|
OUT_AUX_MODE_MOSFET_50,
|
|
|
|
OUT_AUX_MODE_MOTOR_70,
|
|
|
|
OUT_AUX_MODE_MOSFET_70,
|
|
|
|
OUT_AUX_MODE_MOTOR_MOSFET_50,
|
|
|
|
OUT_AUX_MODE_MOTOR_MOSFET_70,
|
2018-07-06 12:20:54 -07:00
|
|
|
} out_aux_mode;
|
|
|
|
|
2019-12-22 12:22:07 -08:00
|
|
|
// Temperature sensor type
|
|
|
|
typedef enum {
|
|
|
|
TEMP_SENSOR_NTC_10K_25C = 0,
|
2020-01-05 05:22:53 -08:00
|
|
|
TEMP_SENSOR_PTC_1K_100C,
|
|
|
|
TEMP_SENSOR_KTY83_122,
|
2020-12-18 09:05:00 -08:00
|
|
|
TEMP_SENSOR_NTC_100K_25C,
|
2022-01-23 15:36:53 -08:00
|
|
|
TEMP_SENSOR_KTY84_130,
|
|
|
|
TEMP_SENSOR_NTCX,
|
|
|
|
TEMP_SENSOR_PTCX
|
2019-12-22 12:22:07 -08:00
|
|
|
} temp_sensor_type;
|
|
|
|
|
2019-02-18 10:30:19 -08:00
|
|
|
// General purpose drive output mode
|
|
|
|
typedef enum {
|
|
|
|
GPD_OUTPUT_MODE_NONE = 0,
|
|
|
|
GPD_OUTPUT_MODE_MODULATION,
|
|
|
|
GPD_OUTPUT_MODE_VOLTAGE,
|
|
|
|
GPD_OUTPUT_MODE_CURRENT
|
|
|
|
} gpd_output_mode;
|
|
|
|
|
2015-04-12 09:23:17 -07:00
|
|
|
typedef enum {
|
|
|
|
MOTOR_TYPE_BLDC = 0,
|
|
|
|
MOTOR_TYPE_DC,
|
2019-02-18 10:30:19 -08:00
|
|
|
MOTOR_TYPE_FOC,
|
|
|
|
MOTOR_TYPE_GPD
|
2015-04-12 09:23:17 -07:00
|
|
|
} mc_motor_type;
|
|
|
|
|
2020-01-12 12:25:21 -08:00
|
|
|
// FOC current controller decoupling mode.
|
|
|
|
typedef enum {
|
|
|
|
FOC_CC_DECOUPLING_DISABLED = 0,
|
|
|
|
FOC_CC_DECOUPLING_CROSS,
|
|
|
|
FOC_CC_DECOUPLING_BEMF,
|
|
|
|
FOC_CC_DECOUPLING_CROSS_BEMF
|
|
|
|
} mc_foc_cc_decoupling_mode;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
FOC_OBSERVER_ORTEGA_ORIGINAL = 0,
|
|
|
|
} mc_foc_observer_type;
|
|
|
|
|
2014-09-14 14:08:22 -07:00
|
|
|
typedef enum {
|
|
|
|
FAULT_CODE_NONE = 0,
|
|
|
|
FAULT_CODE_OVER_VOLTAGE,
|
|
|
|
FAULT_CODE_UNDER_VOLTAGE,
|
2017-09-04 12:12:43 -07:00
|
|
|
FAULT_CODE_DRV,
|
2015-01-22 15:40:09 -08:00
|
|
|
FAULT_CODE_ABS_OVER_CURRENT,
|
|
|
|
FAULT_CODE_OVER_TEMP_FET,
|
2018-12-12 15:03:12 -08:00
|
|
|
FAULT_CODE_OVER_TEMP_MOTOR,
|
|
|
|
FAULT_CODE_GATE_DRIVER_OVER_VOLTAGE,
|
2019-01-08 06:36:42 -08:00
|
|
|
FAULT_CODE_GATE_DRIVER_UNDER_VOLTAGE,
|
2019-01-24 07:19:44 -08:00
|
|
|
FAULT_CODE_MCU_UNDER_VOLTAGE,
|
2019-01-29 10:16:15 -08:00
|
|
|
FAULT_CODE_BOOTING_FROM_WATCHDOG_RESET,
|
2019-04-02 06:37:15 -07:00
|
|
|
FAULT_CODE_ENCODER_SPI,
|
|
|
|
FAULT_CODE_ENCODER_SINCOS_BELOW_MIN_AMPLITUDE,
|
2019-04-15 13:48:34 -07:00
|
|
|
FAULT_CODE_ENCODER_SINCOS_ABOVE_MAX_AMPLITUDE,
|
2019-04-20 05:24:32 -07:00
|
|
|
FAULT_CODE_FLASH_CORRUPTION,
|
|
|
|
FAULT_CODE_HIGH_OFFSET_CURRENT_SENSOR_1,
|
|
|
|
FAULT_CODE_HIGH_OFFSET_CURRENT_SENSOR_2,
|
|
|
|
FAULT_CODE_HIGH_OFFSET_CURRENT_SENSOR_3,
|
2020-01-09 15:38:06 -08:00
|
|
|
FAULT_CODE_UNBALANCED_CURRENTS,
|
2020-01-18 12:08:30 -08:00
|
|
|
FAULT_CODE_BRK,
|
|
|
|
FAULT_CODE_RESOLVER_LOT,
|
|
|
|
FAULT_CODE_RESOLVER_DOS,
|
2020-09-13 22:12:11 -07:00
|
|
|
FAULT_CODE_RESOLVER_LOS,
|
|
|
|
FAULT_CODE_FLASH_CORRUPTION_APP_CFG,
|
2020-11-30 13:51:10 -08:00
|
|
|
FAULT_CODE_FLASH_CORRUPTION_MC_CFG,
|
2021-07-30 06:36:21 -07:00
|
|
|
FAULT_CODE_ENCODER_NO_MAGNET,
|
|
|
|
FAULT_CODE_ENCODER_MAGNET_TOO_STRONG
|
2014-09-14 14:08:22 -07:00
|
|
|
} mc_fault_code;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
CONTROL_MODE_DUTY = 0,
|
|
|
|
CONTROL_MODE_SPEED,
|
|
|
|
CONTROL_MODE_CURRENT,
|
|
|
|
CONTROL_MODE_CURRENT_BRAKE,
|
2015-04-26 15:02:32 -07:00
|
|
|
CONTROL_MODE_POS,
|
2016-11-04 07:18:34 -07:00
|
|
|
CONTROL_MODE_HANDBRAKE,
|
|
|
|
CONTROL_MODE_OPENLOOP,
|
2019-02-18 10:30:19 -08:00
|
|
|
CONTROL_MODE_OPENLOOP_PHASE,
|
2019-03-31 01:49:18 -07:00
|
|
|
CONTROL_MODE_OPENLOOP_DUTY,
|
|
|
|
CONTROL_MODE_OPENLOOP_DUTY_PHASE,
|
2014-09-14 14:08:22 -07:00
|
|
|
CONTROL_MODE_NONE
|
|
|
|
} mc_control_mode;
|
|
|
|
|
2015-12-27 16:50:23 -08:00
|
|
|
typedef enum {
|
|
|
|
DISP_POS_MODE_NONE = 0,
|
|
|
|
DISP_POS_MODE_INDUCTANCE,
|
|
|
|
DISP_POS_MODE_OBSERVER,
|
|
|
|
DISP_POS_MODE_ENCODER,
|
2016-02-24 12:17:39 -08:00
|
|
|
DISP_POS_MODE_PID_POS,
|
|
|
|
DISP_POS_MODE_PID_POS_ERROR,
|
2015-12-27 16:50:23 -08:00
|
|
|
DISP_POS_MODE_ENCODER_OBSERVER_ERROR
|
|
|
|
} disp_pos_mode;
|
|
|
|
|
2016-04-27 06:32:32 -07:00
|
|
|
typedef enum {
|
|
|
|
SENSOR_PORT_MODE_HALL = 0,
|
|
|
|
SENSOR_PORT_MODE_ABI,
|
2019-02-18 10:30:19 -08:00
|
|
|
SENSOR_PORT_MODE_AS5047_SPI,
|
2019-03-30 14:05:53 -07:00
|
|
|
SENSOR_PORT_MODE_AD2S1205,
|
2019-12-05 10:50:17 -08:00
|
|
|
SENSOR_PORT_MODE_SINCOS,
|
2020-01-31 15:37:25 -08:00
|
|
|
SENSOR_PORT_MODE_TS5700N8501,
|
2020-11-30 13:51:10 -08:00
|
|
|
SENSOR_PORT_MODE_TS5700N8501_MULTITURN,
|
|
|
|
SENSOR_PORT_MODE_MT6816_SPI
|
2016-04-27 06:32:32 -07:00
|
|
|
} sensor_port_mode;
|
|
|
|
|
2014-09-14 14:08:22 -07:00
|
|
|
typedef struct {
|
2014-09-17 12:05:57 -07:00
|
|
|
float cycle_int_limit;
|
|
|
|
float cycle_int_limit_running;
|
|
|
|
float cycle_int_limit_max;
|
|
|
|
float comm_time_sum;
|
|
|
|
float comm_time_sum_min_rpm;
|
|
|
|
int32_t comms;
|
2019-03-10 06:57:42 -07:00
|
|
|
float time_at_comm;
|
2014-09-14 14:08:22 -07:00
|
|
|
} mc_rpm_dep_struct;
|
|
|
|
|
2017-09-04 12:12:43 -07:00
|
|
|
typedef enum {
|
|
|
|
DRV8301_OC_LIMIT = 0,
|
|
|
|
DRV8301_OC_LATCH_SHUTDOWN,
|
|
|
|
DRV8301_OC_REPORT_ONLY,
|
|
|
|
DRV8301_OC_DISABLED
|
|
|
|
} drv8301_oc_mode;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
DEBUG_SAMPLING_OFF = 0,
|
|
|
|
DEBUG_SAMPLING_NOW,
|
|
|
|
DEBUG_SAMPLING_START,
|
|
|
|
DEBUG_SAMPLING_TRIGGER_START,
|
|
|
|
DEBUG_SAMPLING_TRIGGER_FAULT,
|
|
|
|
DEBUG_SAMPLING_TRIGGER_START_NOSEND,
|
|
|
|
DEBUG_SAMPLING_TRIGGER_FAULT_NOSEND,
|
|
|
|
DEBUG_SAMPLING_SEND_LAST_SAMPLES
|
|
|
|
} debug_sampling_mode;
|
|
|
|
|
2017-11-08 05:07:35 -08:00
|
|
|
typedef enum {
|
|
|
|
CAN_BAUD_125K = 0,
|
|
|
|
CAN_BAUD_250K,
|
|
|
|
CAN_BAUD_500K,
|
2020-01-31 15:37:25 -08:00
|
|
|
CAN_BAUD_1M,
|
|
|
|
CAN_BAUD_10K,
|
|
|
|
CAN_BAUD_20K,
|
|
|
|
CAN_BAUD_50K,
|
2020-12-14 15:27:58 -08:00
|
|
|
CAN_BAUD_75K,
|
|
|
|
CAN_BAUD_100K
|
2017-11-08 05:07:35 -08:00
|
|
|
} CAN_BAUD;
|
|
|
|
|
2019-02-18 10:30:19 -08:00
|
|
|
typedef enum {
|
|
|
|
BATTERY_TYPE_LIION_3_0__4_2,
|
|
|
|
BATTERY_TYPE_LIIRON_2_6__3_6,
|
|
|
|
BATTERY_TYPE_LEAD_ACID
|
|
|
|
} BATTERY_TYPE;
|
|
|
|
|
2020-01-28 10:46:19 -08:00
|
|
|
typedef enum {
|
|
|
|
HFI_SAMPLES_8 = 0,
|
|
|
|
HFI_SAMPLES_16,
|
|
|
|
HFI_SAMPLES_32
|
|
|
|
} foc_hfi_samples;
|
|
|
|
|
2020-10-21 23:32:51 -07:00
|
|
|
typedef enum {
|
|
|
|
BMS_TYPE_NONE = 0,
|
|
|
|
BMS_TYPE_VESC
|
|
|
|
} BMS_TYPE;
|
|
|
|
|
2021-03-13 02:36:47 -08:00
|
|
|
typedef enum {
|
|
|
|
BMS_FWD_CAN_MODE_DISABLED = 0,
|
|
|
|
BMS_FWD_CAN_MODE_USB_ONLY,
|
|
|
|
BMS_FWD_CAN_MODE_ANY
|
|
|
|
} BMS_FWD_CAN_MODE;
|
|
|
|
|
2020-10-21 23:32:51 -07:00
|
|
|
typedef struct {
|
|
|
|
BMS_TYPE type;
|
|
|
|
float t_limit_start;
|
|
|
|
float t_limit_end;
|
|
|
|
float soc_limit_start;
|
|
|
|
float soc_limit_end;
|
2021-03-13 02:36:47 -08:00
|
|
|
BMS_FWD_CAN_MODE fwd_can_mode;
|
2020-10-21 23:32:51 -07:00
|
|
|
} bms_config;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
float v_tot;
|
|
|
|
float v_charge;
|
|
|
|
float i_in;
|
|
|
|
float i_in_ic;
|
|
|
|
float ah_cnt;
|
|
|
|
float wh_cnt;
|
|
|
|
int cell_num;
|
|
|
|
float v_cell[32];
|
|
|
|
bool bal_state[32];
|
|
|
|
int temp_adc_num;
|
|
|
|
float temps_adc[10];
|
|
|
|
float temp_ic;
|
|
|
|
float temp_hum;
|
|
|
|
float hum;
|
|
|
|
float temp_max_cell;
|
|
|
|
float soc;
|
|
|
|
float soh;
|
|
|
|
int can_id;
|
2021-04-08 13:34:01 -07:00
|
|
|
float ah_cnt_chg_total;
|
|
|
|
float wh_cnt_chg_total;
|
|
|
|
float ah_cnt_dis_total;
|
|
|
|
float wh_cnt_dis_total;
|
2020-10-21 23:32:51 -07:00
|
|
|
systime_t update_time;
|
|
|
|
} bms_values;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float v_cell_min;
|
|
|
|
float v_cell_max;
|
|
|
|
float t_cell_max;
|
|
|
|
float soc;
|
|
|
|
float soh;
|
|
|
|
bool is_charging;
|
|
|
|
bool is_balancing;
|
|
|
|
bool is_charge_allowed;
|
|
|
|
} bms_soc_soh_temp_stat;
|
|
|
|
|
2021-07-12 05:31:01 -07:00
|
|
|
typedef enum {
|
|
|
|
PID_RATE_25_HZ = 0,
|
|
|
|
PID_RATE_50_HZ,
|
|
|
|
PID_RATE_100_HZ,
|
|
|
|
PID_RATE_250_HZ,
|
|
|
|
PID_RATE_500_HZ,
|
|
|
|
PID_RATE_1000_HZ,
|
|
|
|
PID_RATE_2500_HZ,
|
|
|
|
PID_RATE_5000_HZ,
|
|
|
|
PID_RATE_10000_HZ,
|
|
|
|
} PID_RATE;
|
|
|
|
|
2021-10-24 09:10:00 -07:00
|
|
|
typedef enum {
|
|
|
|
MTPA_MODE_OFF = 0,
|
|
|
|
MTPA_MODE_IQ_TARGET,
|
|
|
|
MTPA_MODE_IQ_MEASURED
|
|
|
|
} MTPA_MODE;
|
|
|
|
|
2014-09-14 14:08:22 -07:00
|
|
|
typedef struct {
|
|
|
|
// Limits
|
|
|
|
float l_current_max;
|
|
|
|
float l_current_min;
|
|
|
|
float l_in_current_max;
|
|
|
|
float l_in_current_min;
|
|
|
|
float l_abs_current_max;
|
|
|
|
float l_min_erpm;
|
|
|
|
float l_max_erpm;
|
2016-11-04 07:18:34 -07:00
|
|
|
float l_erpm_start;
|
2014-09-14 17:39:58 -07:00
|
|
|
float l_max_erpm_fbrake;
|
2014-12-13 02:46:26 -08:00
|
|
|
float l_max_erpm_fbrake_cc;
|
2014-09-14 14:08:22 -07:00
|
|
|
float l_min_vin;
|
|
|
|
float l_max_vin;
|
2015-08-26 14:12:39 -07:00
|
|
|
float l_battery_cut_start;
|
|
|
|
float l_battery_cut_end;
|
2014-09-14 14:08:22 -07:00
|
|
|
bool l_slow_abs_current;
|
2014-11-25 12:05:46 -08:00
|
|
|
float l_temp_fet_start;
|
|
|
|
float l_temp_fet_end;
|
|
|
|
float l_temp_motor_start;
|
|
|
|
float l_temp_motor_end;
|
2017-10-27 12:29:12 -07:00
|
|
|
float l_temp_accel_dec;
|
2015-05-20 07:13:48 -07:00
|
|
|
float l_min_duty;
|
|
|
|
float l_max_duty;
|
2017-09-04 12:12:43 -07:00
|
|
|
float l_watt_max;
|
|
|
|
float l_watt_min;
|
2019-02-18 10:30:19 -08:00
|
|
|
float l_current_max_scale;
|
|
|
|
float l_current_min_scale;
|
2020-04-21 10:58:12 -07:00
|
|
|
float l_duty_start;
|
2014-10-19 10:31:06 -07:00
|
|
|
// Overridden limits (Computed during runtime)
|
|
|
|
float lo_current_max;
|
|
|
|
float lo_current_min;
|
|
|
|
float lo_in_current_max;
|
|
|
|
float lo_in_current_min;
|
2017-09-04 12:12:43 -07:00
|
|
|
float lo_current_motor_max_now;
|
|
|
|
float lo_current_motor_min_now;
|
2020-10-21 23:32:51 -07:00
|
|
|
|
|
|
|
// BLDC switching and drive
|
|
|
|
mc_pwm_mode pwm_mode;
|
|
|
|
mc_comm_mode comm_mode;
|
|
|
|
mc_motor_type motor_type;
|
|
|
|
mc_sensor_mode sensor_mode;
|
|
|
|
|
2017-09-04 12:12:43 -07:00
|
|
|
// Sensorless (bldc)
|
2014-09-14 14:08:22 -07:00
|
|
|
float sl_min_erpm;
|
|
|
|
float sl_min_erpm_cycle_int_limit;
|
2014-12-12 16:31:54 -08:00
|
|
|
float sl_max_fullbreak_current_dir_change;
|
2014-09-14 14:08:22 -07:00
|
|
|
float sl_cycle_int_limit;
|
2015-02-19 12:20:07 -08:00
|
|
|
float sl_phase_advance_at_br;
|
2014-09-14 14:08:22 -07:00
|
|
|
float sl_cycle_int_rpm_br;
|
|
|
|
float sl_bemf_coupling_k;
|
|
|
|
// Hall sensor
|
2015-06-19 14:38:46 -07:00
|
|
|
int8_t hall_table[8];
|
|
|
|
float hall_sl_erpm;
|
2020-10-21 23:32:51 -07:00
|
|
|
|
2015-12-08 12:01:23 -08:00
|
|
|
// FOC
|
|
|
|
float foc_current_kp;
|
|
|
|
float foc_current_ki;
|
2022-01-06 11:44:00 -08:00
|
|
|
float foc_f_zv;
|
2015-12-08 12:01:23 -08:00
|
|
|
float foc_dt_us;
|
|
|
|
float foc_encoder_offset;
|
|
|
|
bool foc_encoder_inverted;
|
|
|
|
float foc_encoder_ratio;
|
2019-04-08 17:02:56 -07:00
|
|
|
float foc_encoder_sin_offset;
|
|
|
|
float foc_encoder_sin_gain;
|
|
|
|
float foc_encoder_cos_offset;
|
|
|
|
float foc_encoder_cos_gain;
|
|
|
|
float foc_encoder_sincos_filter_constant;
|
2015-12-08 12:01:23 -08:00
|
|
|
float foc_motor_l;
|
2020-04-30 14:34:29 -07:00
|
|
|
float foc_motor_ld_lq_diff;
|
2015-12-08 12:01:23 -08:00
|
|
|
float foc_motor_r;
|
|
|
|
float foc_motor_flux_linkage;
|
|
|
|
float foc_observer_gain;
|
2017-09-04 12:12:43 -07:00
|
|
|
float foc_observer_gain_slow;
|
2022-01-12 03:27:45 -08:00
|
|
|
float foc_observer_offset;
|
2015-12-08 12:01:23 -08:00
|
|
|
float foc_pll_kp;
|
|
|
|
float foc_pll_ki;
|
|
|
|
float foc_duty_dowmramp_kp;
|
|
|
|
float foc_duty_dowmramp_ki;
|
|
|
|
float foc_openloop_rpm;
|
2020-10-09 12:08:48 -07:00
|
|
|
float foc_openloop_rpm_low;
|
2020-12-06 12:33:08 -08:00
|
|
|
float foc_d_gain_scale_start;
|
|
|
|
float foc_d_gain_scale_max_mod;
|
2015-12-08 12:01:23 -08:00
|
|
|
float foc_sl_openloop_hyst;
|
|
|
|
float foc_sl_openloop_time;
|
2020-10-09 12:08:48 -07:00
|
|
|
float foc_sl_openloop_time_lock;
|
|
|
|
float foc_sl_openloop_time_ramp;
|
2015-12-08 12:01:23 -08:00
|
|
|
mc_foc_sensor_mode foc_sensor_mode;
|
2016-01-27 14:57:23 -08:00
|
|
|
uint8_t foc_hall_table[8];
|
2020-10-21 23:32:51 -07:00
|
|
|
float foc_hall_interp_erpm;
|
2016-04-27 06:32:32 -07:00
|
|
|
float foc_sl_erpm;
|
2017-09-04 12:12:43 -07:00
|
|
|
bool foc_sample_v0_v7;
|
|
|
|
bool foc_sample_high_current;
|
|
|
|
float foc_sat_comp;
|
|
|
|
bool foc_temp_comp;
|
|
|
|
float foc_temp_comp_base_temp;
|
2018-03-24 14:32:58 -07:00
|
|
|
float foc_current_filter_const;
|
2020-01-12 12:25:21 -08:00
|
|
|
mc_foc_cc_decoupling_mode foc_cc_decoupling;
|
|
|
|
mc_foc_observer_type foc_observer_type;
|
2020-01-20 00:39:33 -08:00
|
|
|
float foc_hfi_voltage_start;
|
|
|
|
float foc_hfi_voltage_run;
|
2020-01-28 10:46:19 -08:00
|
|
|
float foc_hfi_voltage_max;
|
2020-01-20 00:39:33 -08:00
|
|
|
float foc_sl_erpm_hfi;
|
|
|
|
uint16_t foc_hfi_start_samples;
|
|
|
|
float foc_hfi_obs_ovr_sec;
|
2020-01-28 10:46:19 -08:00
|
|
|
foc_hfi_samples foc_hfi_samples;
|
2021-03-22 04:13:19 -07:00
|
|
|
bool foc_offsets_cal_on_boot;
|
2021-02-28 11:28:23 -08:00
|
|
|
float foc_offsets_current[3];
|
|
|
|
float foc_offsets_voltage[3];
|
|
|
|
float foc_offsets_voltage_undriven[3];
|
|
|
|
bool foc_phase_filter_enable;
|
|
|
|
float foc_phase_filter_max_erpm;
|
2021-10-24 09:10:00 -07:00
|
|
|
MTPA_MODE foc_mtpa_mode;
|
2021-04-10 02:37:35 -07:00
|
|
|
// Field Weakening
|
|
|
|
float foc_fw_current_max;
|
|
|
|
float foc_fw_duty_start;
|
|
|
|
float foc_fw_ramp_time;
|
2021-04-15 01:04:28 -07:00
|
|
|
float foc_fw_q_current_factor;
|
2020-10-21 23:32:51 -07:00
|
|
|
|
2019-02-18 10:30:19 -08:00
|
|
|
// GPDrive
|
|
|
|
int gpd_buffer_notify_left;
|
|
|
|
int gpd_buffer_interpol;
|
|
|
|
float gpd_current_filter_const;
|
|
|
|
float gpd_current_kp;
|
|
|
|
float gpd_current_ki;
|
2020-10-21 23:32:51 -07:00
|
|
|
|
2021-07-12 05:31:01 -07:00
|
|
|
PID_RATE sp_pid_loop_rate;
|
|
|
|
|
2014-09-14 14:08:22 -07:00
|
|
|
// Speed PID
|
|
|
|
float s_pid_kp;
|
|
|
|
float s_pid_ki;
|
|
|
|
float s_pid_kd;
|
2018-03-24 14:32:58 -07:00
|
|
|
float s_pid_kd_filter;
|
2015-09-17 14:24:55 -07:00
|
|
|
float s_pid_min_erpm;
|
2017-09-04 12:12:43 -07:00
|
|
|
bool s_pid_allow_braking;
|
2020-05-12 06:53:32 -07:00
|
|
|
float s_pid_ramp_erpms_s;
|
2020-10-21 23:32:51 -07:00
|
|
|
|
2015-04-26 15:02:32 -07:00
|
|
|
// Pos PID
|
|
|
|
float p_pid_kp;
|
|
|
|
float p_pid_ki;
|
|
|
|
float p_pid_kd;
|
2021-07-11 11:19:26 -07:00
|
|
|
float p_pid_kd_proc;
|
2018-03-24 14:32:58 -07:00
|
|
|
float p_pid_kd_filter;
|
2016-02-24 12:17:39 -08:00
|
|
|
float p_pid_ang_div;
|
2021-04-26 14:14:05 -07:00
|
|
|
float p_pid_gain_dec_angle;
|
2021-07-11 11:19:26 -07:00
|
|
|
float p_pid_offset;
|
2020-10-21 23:32:51 -07:00
|
|
|
|
2014-09-14 14:08:22 -07:00
|
|
|
// Current controller
|
|
|
|
float cc_startup_boost_duty;
|
|
|
|
float cc_min_current;
|
|
|
|
float cc_gain;
|
2015-04-26 15:02:32 -07:00
|
|
|
float cc_ramp_step_max;
|
2020-10-21 23:32:51 -07:00
|
|
|
|
2014-09-18 14:00:14 -07:00
|
|
|
// Misc
|
|
|
|
int32_t m_fault_stop_time_ms;
|
2015-08-26 14:12:39 -07:00
|
|
|
float m_duty_ramp_step;
|
|
|
|
float m_current_backoff_gain;
|
2015-12-08 12:01:23 -08:00
|
|
|
uint32_t m_encoder_counts;
|
2016-04-27 06:32:32 -07:00
|
|
|
sensor_port_mode m_sensor_port_mode;
|
2016-11-06 09:14:06 -08:00
|
|
|
bool m_invert_direction;
|
2017-09-04 12:12:43 -07:00
|
|
|
drv8301_oc_mode m_drv8301_oc_mode;
|
|
|
|
int m_drv8301_oc_adj;
|
|
|
|
float m_bldc_f_sw_min;
|
|
|
|
float m_bldc_f_sw_max;
|
|
|
|
float m_dc_f_sw;
|
2017-09-06 12:13:28 -07:00
|
|
|
float m_ntc_motor_beta;
|
2018-07-06 12:20:54 -07:00
|
|
|
out_aux_mode m_out_aux_mode;
|
2019-12-22 12:22:07 -08:00
|
|
|
temp_sensor_type m_motor_temp_sens_type;
|
|
|
|
float m_ptc_motor_coeff;
|
2020-10-09 12:08:48 -07:00
|
|
|
int m_hall_extra_samples;
|
2022-01-23 15:36:53 -08:00
|
|
|
float m_ntcx_ptcx_temp_base;
|
|
|
|
float m_ntcx_ptcx_res;
|
2019-02-18 10:30:19 -08:00
|
|
|
// Setup info
|
|
|
|
uint8_t si_motor_poles;
|
|
|
|
float si_gear_ratio;
|
|
|
|
float si_wheel_diameter;
|
|
|
|
BATTERY_TYPE si_battery_type;
|
|
|
|
int si_battery_cells;
|
|
|
|
float si_battery_ah;
|
2021-11-21 09:17:40 -08:00
|
|
|
float si_motor_nl_current;
|
2020-10-21 23:32:51 -07:00
|
|
|
|
|
|
|
// BMS Configuration
|
|
|
|
bms_config bms;
|
|
|
|
|
2020-09-13 22:12:11 -07:00
|
|
|
// Protect from flash corruption.
|
|
|
|
uint16_t crc;
|
2014-09-14 14:08:22 -07:00
|
|
|
} mc_configuration;
|
|
|
|
|
2014-09-17 12:05:57 -07:00
|
|
|
// Applications to use
|
|
|
|
typedef enum {
|
|
|
|
APP_NONE = 0,
|
|
|
|
APP_PPM,
|
2015-05-04 14:25:43 -07:00
|
|
|
APP_ADC,
|
2014-09-19 18:22:38 -07:00
|
|
|
APP_UART,
|
|
|
|
APP_PPM_UART,
|
2015-05-04 14:25:43 -07:00
|
|
|
APP_ADC_UART,
|
2014-10-18 16:00:53 -07:00
|
|
|
APP_NUNCHUK,
|
2015-04-11 01:07:36 -07:00
|
|
|
APP_NRF,
|
2019-09-11 23:18:12 -07:00
|
|
|
APP_CUSTOM,
|
2020-12-07 11:00:25 -08:00
|
|
|
APP_BALANCE,
|
|
|
|
APP_PAS,
|
|
|
|
APP_ADC_PAS
|
2014-09-17 12:05:57 -07:00
|
|
|
} app_use;
|
|
|
|
|
2017-09-04 12:12:43 -07:00
|
|
|
// Throttle curve mode
|
|
|
|
typedef enum {
|
|
|
|
THR_EXP_EXPO = 0,
|
|
|
|
THR_EXP_NATURAL,
|
|
|
|
THR_EXP_POLY
|
|
|
|
} thr_exp_mode;
|
|
|
|
|
2021-08-16 08:48:06 -07:00
|
|
|
typedef enum {
|
|
|
|
SAFE_START_DISABLED = 0,
|
|
|
|
SAFE_START_REGULAR,
|
|
|
|
SAFE_START_NO_FAULT
|
|
|
|
} SAFE_START_MODE;
|
|
|
|
|
2014-09-17 12:05:57 -07:00
|
|
|
// PPM control types
|
|
|
|
typedef enum {
|
2014-09-20 04:41:18 -07:00
|
|
|
PPM_CTRL_TYPE_NONE = 0,
|
|
|
|
PPM_CTRL_TYPE_CURRENT,
|
2014-09-18 14:00:14 -07:00
|
|
|
PPM_CTRL_TYPE_CURRENT_NOREV,
|
|
|
|
PPM_CTRL_TYPE_CURRENT_NOREV_BRAKE,
|
2014-09-17 12:05:57 -07:00
|
|
|
PPM_CTRL_TYPE_DUTY,
|
2014-09-18 14:00:14 -07:00
|
|
|
PPM_CTRL_TYPE_DUTY_NOREV,
|
|
|
|
PPM_CTRL_TYPE_PID,
|
2019-06-24 13:36:35 -07:00
|
|
|
PPM_CTRL_TYPE_PID_NOREV,
|
2019-09-09 10:34:26 -07:00
|
|
|
PPM_CTRL_TYPE_CURRENT_BRAKE_REV_HYST,
|
|
|
|
PPM_CTRL_TYPE_CURRENT_SMART_REV
|
2014-09-17 12:05:57 -07:00
|
|
|
} ppm_control_type;
|
|
|
|
|
2015-02-19 12:20:07 -08:00
|
|
|
typedef struct {
|
|
|
|
ppm_control_type ctrl_type;
|
|
|
|
float pid_max_erpm;
|
|
|
|
float hyst;
|
|
|
|
float pulse_start;
|
2015-04-30 16:57:55 -07:00
|
|
|
float pulse_end;
|
2017-09-04 12:12:43 -07:00
|
|
|
float pulse_center;
|
2015-04-20 13:09:53 -07:00
|
|
|
bool median_filter;
|
2021-08-16 08:48:06 -07:00
|
|
|
SAFE_START_MODE safe_start;
|
2017-09-04 12:12:43 -07:00
|
|
|
float throttle_exp;
|
2017-09-06 12:13:28 -07:00
|
|
|
float throttle_exp_brake;
|
2017-09-04 12:12:43 -07:00
|
|
|
thr_exp_mode throttle_exp_mode;
|
|
|
|
float ramp_time_pos;
|
|
|
|
float ramp_time_neg;
|
2015-02-19 12:20:07 -08:00
|
|
|
bool multi_esc;
|
|
|
|
bool tc;
|
|
|
|
float tc_max_diff;
|
2019-06-19 19:00:46 -07:00
|
|
|
float max_erpm_for_dir;
|
2019-09-09 10:34:26 -07:00
|
|
|
float smart_rev_max_duty;
|
|
|
|
float smart_rev_ramp_time;
|
2015-02-19 12:20:07 -08:00
|
|
|
} ppm_config;
|
|
|
|
|
2015-05-04 14:25:43 -07:00
|
|
|
// ADC control types
|
|
|
|
typedef enum {
|
|
|
|
ADC_CTRL_TYPE_NONE = 0,
|
|
|
|
ADC_CTRL_TYPE_CURRENT,
|
|
|
|
ADC_CTRL_TYPE_CURRENT_REV_CENTER,
|
|
|
|
ADC_CTRL_TYPE_CURRENT_REV_BUTTON,
|
2017-09-04 12:12:43 -07:00
|
|
|
ADC_CTRL_TYPE_CURRENT_REV_BUTTON_BRAKE_ADC,
|
2019-04-08 16:45:46 -07:00
|
|
|
ADC_CTRL_TYPE_CURRENT_REV_BUTTON_BRAKE_CENTER,
|
2015-05-04 14:25:43 -07:00
|
|
|
ADC_CTRL_TYPE_CURRENT_NOREV_BRAKE_CENTER,
|
|
|
|
ADC_CTRL_TYPE_CURRENT_NOREV_BRAKE_BUTTON,
|
2016-02-02 07:28:55 -08:00
|
|
|
ADC_CTRL_TYPE_CURRENT_NOREV_BRAKE_ADC,
|
2015-05-04 14:25:43 -07:00
|
|
|
ADC_CTRL_TYPE_DUTY,
|
|
|
|
ADC_CTRL_TYPE_DUTY_REV_CENTER,
|
2017-10-27 12:29:12 -07:00
|
|
|
ADC_CTRL_TYPE_DUTY_REV_BUTTON,
|
|
|
|
ADC_CTRL_TYPE_PID,
|
|
|
|
ADC_CTRL_TYPE_PID_REV_CENTER,
|
|
|
|
ADC_CTRL_TYPE_PID_REV_BUTTON
|
2015-05-04 14:25:43 -07:00
|
|
|
} adc_control_type;
|
|
|
|
|
2020-12-07 11:00:25 -08:00
|
|
|
// PAS control types
|
|
|
|
typedef enum {
|
|
|
|
PAS_CTRL_TYPE_NONE = 0,
|
PAS: add constant torque control type
For gearless electric bicycles, riding up the slope and during start,
good torque support from the motor helps the rider ride with less
effort. Pedal assist based on cadence provides higher torque with higher
pedalling speed. In the situations mentioned above, where user naturally
pedals slow, aid from cadence based system is less. On a geared setup,
changing to low gear comes to the rider's help.
Here another control type is provided - Constant Torque, whenever the
rider pedals, motor would provide constant torque. The torque value can
be set using 'PAS max current' setting thus acting as fine PAS assist
level.
This type of control is similar to 'Basic PAS, constant throttle' of
'PAS Control Schemes' [1], with the difference that throttle setting
in that article corresponds to speed, while here torque.
Also riding experience on some of the popular (not high end) e-bicycles
having PAS indicates they might be having this kind of control
internally.
[1] https://ebikes.ca/learn/pedal-assist.html
2021-10-04 04:22:44 -07:00
|
|
|
PAS_CTRL_TYPE_CADENCE,
|
2021-11-19 11:21:39 -08:00
|
|
|
PAS_CTRL_TYPE_TORQUE,
|
|
|
|
PAS_CTRL_TYPE_TORQUE_WITH_CADENCE_TIMEOUT
|
2020-12-07 11:00:25 -08:00
|
|
|
} pas_control_type;
|
|
|
|
|
|
|
|
// PAS sensor types
|
|
|
|
typedef enum {
|
|
|
|
PAS_SENSOR_TYPE_QUADRATURE = 0
|
|
|
|
} pas_sensor_type;
|
|
|
|
|
2015-05-04 14:25:43 -07:00
|
|
|
typedef struct {
|
|
|
|
adc_control_type ctrl_type;
|
|
|
|
float hyst;
|
|
|
|
float voltage_start;
|
|
|
|
float voltage_end;
|
2017-09-04 12:12:43 -07:00
|
|
|
float voltage_center;
|
2016-11-04 07:18:34 -07:00
|
|
|
float voltage2_start;
|
|
|
|
float voltage2_end;
|
2015-05-04 14:25:43 -07:00
|
|
|
bool use_filter;
|
2021-08-16 08:48:06 -07:00
|
|
|
SAFE_START_MODE safe_start;
|
2015-08-23 09:26:05 -07:00
|
|
|
bool cc_button_inverted;
|
|
|
|
bool rev_button_inverted;
|
2015-05-04 14:25:43 -07:00
|
|
|
bool voltage_inverted;
|
2016-11-04 07:18:34 -07:00
|
|
|
bool voltage2_inverted;
|
2017-09-04 12:12:43 -07:00
|
|
|
float throttle_exp;
|
2017-09-06 12:13:28 -07:00
|
|
|
float throttle_exp_brake;
|
2017-09-04 12:12:43 -07:00
|
|
|
thr_exp_mode throttle_exp_mode;
|
|
|
|
float ramp_time_pos;
|
|
|
|
float ramp_time_neg;
|
2015-05-04 14:25:43 -07:00
|
|
|
bool multi_esc;
|
|
|
|
bool tc;
|
|
|
|
float tc_max_diff;
|
|
|
|
uint32_t update_rate_hz;
|
|
|
|
} adc_config;
|
|
|
|
|
2014-10-18 16:00:53 -07:00
|
|
|
// Nunchuk control types
|
|
|
|
typedef enum {
|
|
|
|
CHUK_CTRL_TYPE_NONE = 0,
|
|
|
|
CHUK_CTRL_TYPE_CURRENT,
|
2020-05-03 13:35:37 -07:00
|
|
|
CHUK_CTRL_TYPE_CURRENT_NOREV,
|
|
|
|
CHUK_CTRL_TYPE_CURRENT_BIDIRECTIONAL
|
2014-10-18 16:00:53 -07:00
|
|
|
} chuk_control_type;
|
|
|
|
|
2015-02-19 12:20:07 -08:00
|
|
|
typedef struct {
|
|
|
|
chuk_control_type ctrl_type;
|
|
|
|
float hyst;
|
|
|
|
float ramp_time_pos;
|
|
|
|
float ramp_time_neg;
|
2015-09-17 14:24:55 -07:00
|
|
|
float stick_erpm_per_s_in_cc;
|
2017-09-04 12:12:43 -07:00
|
|
|
float throttle_exp;
|
2017-09-06 12:13:28 -07:00
|
|
|
float throttle_exp_brake;
|
2017-09-04 12:12:43 -07:00
|
|
|
thr_exp_mode throttle_exp_mode;
|
2015-02-19 12:20:07 -08:00
|
|
|
bool multi_esc;
|
|
|
|
bool tc;
|
|
|
|
float tc_max_diff;
|
2019-09-08 09:25:38 -07:00
|
|
|
bool use_smart_rev;
|
|
|
|
float smart_rev_max_duty;
|
|
|
|
float smart_rev_ramp_time;
|
2015-02-19 12:20:07 -08:00
|
|
|
} chuk_config;
|
|
|
|
|
2020-12-07 11:00:25 -08:00
|
|
|
typedef struct {
|
|
|
|
pas_control_type ctrl_type;
|
|
|
|
pas_sensor_type sensor_type;
|
|
|
|
float current_scaling;
|
|
|
|
float pedal_rpm_start;
|
|
|
|
float pedal_rpm_end;
|
|
|
|
bool invert_pedal_direction;
|
|
|
|
uint8_t magnets;
|
|
|
|
bool use_filter;
|
|
|
|
float ramp_time_pos;
|
|
|
|
float ramp_time_neg;
|
|
|
|
uint32_t update_rate_hz;
|
|
|
|
} pas_config;
|
|
|
|
|
2016-02-09 03:23:58 -08:00
|
|
|
// NRF Datatypes
|
|
|
|
typedef enum {
|
|
|
|
NRF_SPEED_250K = 0,
|
|
|
|
NRF_SPEED_1M,
|
|
|
|
NRF_SPEED_2M
|
|
|
|
} NRF_SPEED;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
NRF_POWER_M18DBM = 0,
|
|
|
|
NRF_POWER_M12DBM,
|
|
|
|
NRF_POWER_M6DBM,
|
2018-02-17 08:59:21 -08:00
|
|
|
NRF_POWER_0DBM,
|
|
|
|
NRF_POWER_OFF
|
2016-02-09 03:23:58 -08:00
|
|
|
} NRF_POWER;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
NRF_AW_3 = 0,
|
|
|
|
NRF_AW_4,
|
|
|
|
NRF_AW_5
|
|
|
|
} NRF_AW;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
NRF_CRC_DISABLED = 0,
|
|
|
|
NRF_CRC_1B,
|
|
|
|
NRF_CRC_2B
|
|
|
|
} NRF_CRC;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
NRF_RETR_DELAY_250US = 0,
|
|
|
|
NRF_RETR_DELAY_500US,
|
|
|
|
NRF_RETR_DELAY_750US,
|
|
|
|
NRF_RETR_DELAY_1000US,
|
|
|
|
NRF_RETR_DELAY_1250US,
|
|
|
|
NRF_RETR_DELAY_1500US,
|
|
|
|
NRF_RETR_DELAY_1750US,
|
|
|
|
NRF_RETR_DELAY_2000US,
|
|
|
|
NRF_RETR_DELAY_2250US,
|
|
|
|
NRF_RETR_DELAY_2500US,
|
|
|
|
NRF_RETR_DELAY_2750US,
|
|
|
|
NRF_RETR_DELAY_3000US,
|
|
|
|
NRF_RETR_DELAY_3250US,
|
|
|
|
NRF_RETR_DELAY_3500US,
|
|
|
|
NRF_RETR_DELAY_3750US,
|
|
|
|
NRF_RETR_DELAY_4000US
|
|
|
|
} NRF_RETR_DELAY;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
NRF_SPEED speed;
|
|
|
|
NRF_POWER power;
|
|
|
|
NRF_CRC crc_type;
|
|
|
|
NRF_RETR_DELAY retry_delay;
|
|
|
|
unsigned char retries;
|
|
|
|
unsigned char channel;
|
|
|
|
unsigned char address[3];
|
|
|
|
bool send_crc_ack;
|
|
|
|
} nrf_config;
|
|
|
|
|
2019-07-27 21:25:56 -07:00
|
|
|
typedef struct {
|
|
|
|
float kp;
|
|
|
|
float ki;
|
|
|
|
float kd;
|
2019-08-25 23:49:33 -07:00
|
|
|
uint16_t hertz;
|
2021-06-06 14:01:42 -07:00
|
|
|
uint16_t loop_time_filter;
|
2020-07-02 01:07:54 -07:00
|
|
|
float fault_pitch;
|
|
|
|
float fault_roll;
|
|
|
|
float fault_duty;
|
2020-07-03 20:33:15 -07:00
|
|
|
float fault_adc1;
|
|
|
|
float fault_adc2;
|
2020-07-02 01:07:54 -07:00
|
|
|
uint16_t fault_delay_pitch;
|
|
|
|
uint16_t fault_delay_roll;
|
2020-07-03 20:33:15 -07:00
|
|
|
uint16_t fault_delay_duty;
|
|
|
|
uint16_t fault_delay_switch_half;
|
|
|
|
uint16_t fault_delay_switch_full;
|
|
|
|
uint16_t fault_adc_half_erpm;
|
2021-08-18 00:45:51 -07:00
|
|
|
float tiltback_duty_angle;
|
|
|
|
float tiltback_duty_speed;
|
2020-07-03 20:33:15 -07:00
|
|
|
float tiltback_duty;
|
2021-07-29 17:09:31 -07:00
|
|
|
float tiltback_hv_angle;
|
|
|
|
float tiltback_hv_speed;
|
2021-08-18 00:45:51 -07:00
|
|
|
float tiltback_hv;
|
2021-07-29 17:09:31 -07:00
|
|
|
float tiltback_lv_angle;
|
|
|
|
float tiltback_lv_speed;
|
2021-08-18 00:45:51 -07:00
|
|
|
float tiltback_lv;
|
2021-07-29 17:09:31 -07:00
|
|
|
float tiltback_return_speed;
|
2020-07-02 01:07:54 -07:00
|
|
|
float tiltback_constant;
|
|
|
|
uint16_t tiltback_constant_erpm;
|
2021-06-25 21:41:41 -07:00
|
|
|
float tiltback_variable;
|
|
|
|
float tiltback_variable_max;
|
2021-07-29 17:09:31 -07:00
|
|
|
float noseangling_speed;
|
2019-09-21 01:07:31 -07:00
|
|
|
float startup_pitch_tolerance;
|
|
|
|
float startup_roll_tolerance;
|
2019-08-07 00:22:51 -07:00
|
|
|
float startup_speed;
|
|
|
|
float deadzone;
|
2020-02-23 00:22:21 -08:00
|
|
|
bool multi_esc;
|
|
|
|
float yaw_kp;
|
|
|
|
float yaw_ki;
|
|
|
|
float yaw_kd;
|
|
|
|
float roll_steer_kp;
|
2020-03-15 23:18:34 -07:00
|
|
|
float roll_steer_erpm_kp;
|
2020-07-03 20:33:15 -07:00
|
|
|
float brake_current;
|
2021-06-05 16:05:19 -07:00
|
|
|
uint16_t brake_timeout;
|
2020-03-15 23:18:34 -07:00
|
|
|
float yaw_current_clamp;
|
2021-05-16 14:53:03 -07:00
|
|
|
uint16_t kd_pt1_lowpass_frequency;
|
|
|
|
uint16_t kd_pt1_highpass_frequency;
|
2021-06-01 03:20:00 -07:00
|
|
|
float kd_biquad_lowpass;
|
|
|
|
float kd_biquad_highpass;
|
2021-03-27 14:00:55 -07:00
|
|
|
float booster_angle;
|
|
|
|
float booster_ramp;
|
|
|
|
float booster_current;
|
2021-03-27 20:13:22 -07:00
|
|
|
float torquetilt_start_current;
|
|
|
|
float torquetilt_angle_limit;
|
2021-06-01 03:20:00 -07:00
|
|
|
float torquetilt_on_speed;
|
|
|
|
float torquetilt_off_speed;
|
2021-04-17 18:05:24 -07:00
|
|
|
float torquetilt_strength;
|
2021-03-27 20:13:22 -07:00
|
|
|
float torquetilt_filter;
|
2021-04-17 18:05:24 -07:00
|
|
|
float turntilt_strength;
|
2021-04-06 02:18:32 -07:00
|
|
|
float turntilt_angle_limit;
|
2021-04-17 18:05:24 -07:00
|
|
|
float turntilt_start_angle;
|
|
|
|
uint16_t turntilt_start_erpm;
|
2021-04-06 02:18:32 -07:00
|
|
|
float turntilt_speed;
|
|
|
|
uint16_t turntilt_erpm_boost;
|
|
|
|
uint16_t turntilt_erpm_boost_end;
|
2019-07-27 21:25:56 -07:00
|
|
|
} balance_config;
|
|
|
|
|
2019-09-03 11:39:05 -07:00
|
|
|
typedef enum {
|
|
|
|
SHUTDOWN_MODE_ALWAYS_OFF = 0,
|
|
|
|
SHUTDOWN_MODE_ALWAYS_ON,
|
|
|
|
SHUTDOWN_MODE_TOGGLE_BUTTON_ONLY,
|
|
|
|
SHUTDOWN_MODE_OFF_AFTER_10S,
|
|
|
|
SHUTDOWN_MODE_OFF_AFTER_1M,
|
|
|
|
SHUTDOWN_MODE_OFF_AFTER_5M,
|
|
|
|
SHUTDOWN_MODE_OFF_AFTER_10M,
|
|
|
|
SHUTDOWN_MODE_OFF_AFTER_30M,
|
|
|
|
SHUTDOWN_MODE_OFF_AFTER_1H,
|
|
|
|
SHUTDOWN_MODE_OFF_AFTER_5H,
|
|
|
|
} SHUTDOWN_MODE;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
IMU_TYPE_OFF = 0,
|
|
|
|
IMU_TYPE_INTERNAL,
|
|
|
|
IMU_TYPE_EXTERNAL_MPU9X50,
|
|
|
|
IMU_TYPE_EXTERNAL_ICM20948,
|
2020-05-29 03:10:43 -07:00
|
|
|
IMU_TYPE_EXTERNAL_BMI160,
|
|
|
|
IMU_TYPE_EXTERNAL_LSM6DS3
|
2019-09-03 11:39:05 -07:00
|
|
|
} IMU_TYPE;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
AHRS_MODE_MADGWICK = 0,
|
2021-08-19 09:48:23 -07:00
|
|
|
AHRS_MODE_MAHONY,
|
|
|
|
AHRS_MODE_MADGWICK_FUSION
|
2019-09-03 11:39:05 -07:00
|
|
|
} AHRS_MODE;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
IMU_TYPE type;
|
|
|
|
AHRS_MODE mode;
|
|
|
|
int sample_rate_hz;
|
|
|
|
float accel_confidence_decay;
|
|
|
|
float mahony_kp;
|
|
|
|
float mahony_ki;
|
|
|
|
float madgwick_beta;
|
|
|
|
float rot_roll;
|
|
|
|
float rot_pitch;
|
|
|
|
float rot_yaw;
|
|
|
|
float accel_offsets[3];
|
|
|
|
float gyro_offsets[3];
|
|
|
|
} imu_config;
|
|
|
|
|
2020-01-28 10:46:19 -08:00
|
|
|
typedef enum {
|
|
|
|
CAN_MODE_VESC = 0,
|
|
|
|
CAN_MODE_UAVCAN,
|
|
|
|
CAN_MODE_COMM_BRIDGE
|
|
|
|
} CAN_MODE;
|
|
|
|
|
2020-12-04 08:54:22 -08:00
|
|
|
typedef enum {
|
|
|
|
UAVCAN_RAW_MODE_CURRENT = 0,
|
|
|
|
UAVCAN_RAW_MODE_CURRENT_NO_REV_BRAKE,
|
2021-11-24 01:56:45 -08:00
|
|
|
UAVCAN_RAW_MODE_DUTY,
|
|
|
|
UAVCAN_RAW_MODE_RPM
|
2020-12-04 08:54:22 -08:00
|
|
|
} UAVCAN_RAW_MODE;
|
|
|
|
|
2021-06-13 04:46:27 -07:00
|
|
|
typedef enum {
|
|
|
|
KILL_SW_MODE_DISABLED = 0,
|
|
|
|
KILL_SW_MODE_PPM_LOW,
|
|
|
|
KILL_SW_MODE_PPM_HIGH,
|
|
|
|
KILL_SW_MODE_ADC2_LOW,
|
|
|
|
KILL_SW_MODE_ADC2_HIGH
|
|
|
|
} KILL_SW_MODE;
|
|
|
|
|
2014-09-17 12:05:57 -07:00
|
|
|
typedef struct {
|
2014-09-20 04:41:18 -07:00
|
|
|
// Settings
|
2015-02-19 12:20:07 -08:00
|
|
|
uint8_t controller_id;
|
2014-09-20 04:41:18 -07:00
|
|
|
uint32_t timeout_msec;
|
|
|
|
float timeout_brake_current;
|
2022-03-11 09:08:28 -08:00
|
|
|
uint32_t can_status_rate_1;
|
|
|
|
uint8_t can_status_msgs_r1;
|
|
|
|
uint32_t can_status_rate_2;
|
|
|
|
uint8_t can_status_msgs_r2;
|
2017-11-08 05:07:35 -08:00
|
|
|
CAN_BAUD can_baud_rate;
|
2019-02-18 10:30:19 -08:00
|
|
|
bool pairing_done;
|
2019-03-10 06:57:42 -07:00
|
|
|
bool permanent_uart_enabled;
|
2019-09-03 11:39:05 -07:00
|
|
|
SHUTDOWN_MODE shutdown_mode;
|
2021-03-31 07:28:46 -07:00
|
|
|
bool servo_out_enable;
|
2021-06-13 04:46:27 -07:00
|
|
|
KILL_SW_MODE kill_sw_mode;
|
2019-02-18 10:30:19 -08:00
|
|
|
|
2020-01-28 10:46:19 -08:00
|
|
|
// CAN modes
|
|
|
|
CAN_MODE can_mode;
|
2019-02-18 10:30:19 -08:00
|
|
|
uint8_t uavcan_esc_index;
|
2020-12-04 08:54:22 -08:00
|
|
|
UAVCAN_RAW_MODE uavcan_raw_mode;
|
2021-11-24 01:56:45 -08:00
|
|
|
float uavcan_raw_rpm_max;
|
2014-09-20 04:41:18 -07:00
|
|
|
|
2014-09-17 12:05:57 -07:00
|
|
|
// Application to use
|
|
|
|
app_use app_to_use;
|
|
|
|
|
|
|
|
// PPM application settings
|
2015-02-19 12:20:07 -08:00
|
|
|
ppm_config app_ppm_conf;
|
2014-09-18 14:00:14 -07:00
|
|
|
|
2015-05-04 14:25:43 -07:00
|
|
|
// ADC application settings
|
|
|
|
adc_config app_adc_conf;
|
|
|
|
|
2014-09-18 14:00:14 -07:00
|
|
|
// UART application settings
|
|
|
|
uint32_t app_uart_baudrate;
|
2014-10-18 16:00:53 -07:00
|
|
|
|
2015-02-19 12:20:07 -08:00
|
|
|
// Nunchuk application settings
|
|
|
|
chuk_config app_chuk_conf;
|
2016-02-09 03:23:58 -08:00
|
|
|
|
|
|
|
// NRF application settings
|
|
|
|
nrf_config app_nrf_conf;
|
2019-09-03 11:39:05 -07:00
|
|
|
|
2019-08-25 23:49:33 -07:00
|
|
|
// Balance application settings
|
|
|
|
balance_config app_balance_conf;
|
|
|
|
|
2020-12-07 11:00:25 -08:00
|
|
|
// Pedal Assist application settings
|
|
|
|
pas_config app_pas_conf;
|
|
|
|
|
2019-09-03 11:39:05 -07:00
|
|
|
// IMU Settings
|
|
|
|
imu_config imu_conf;
|
2020-09-13 22:12:11 -07:00
|
|
|
|
|
|
|
// Protect from flash corruption
|
|
|
|
uint16_t crc;
|
2014-09-17 12:05:57 -07:00
|
|
|
} app_configuration;
|
|
|
|
|
2014-09-19 18:22:38 -07:00
|
|
|
// Communication commands
|
|
|
|
typedef enum {
|
2015-05-04 14:25:43 -07:00
|
|
|
COMM_FW_VERSION = 0,
|
2015-05-08 13:53:59 -07:00
|
|
|
COMM_JUMP_TO_BOOTLOADER,
|
|
|
|
COMM_ERASE_NEW_APP,
|
|
|
|
COMM_WRITE_NEW_APP_DATA,
|
2015-05-04 14:25:43 -07:00
|
|
|
COMM_GET_VALUES,
|
2014-09-19 18:22:38 -07:00
|
|
|
COMM_SET_DUTY,
|
|
|
|
COMM_SET_CURRENT,
|
|
|
|
COMM_SET_CURRENT_BRAKE,
|
|
|
|
COMM_SET_RPM,
|
2015-04-26 15:02:32 -07:00
|
|
|
COMM_SET_POS,
|
2016-11-04 07:18:34 -07:00
|
|
|
COMM_SET_HANDBRAKE,
|
2014-09-19 18:22:38 -07:00
|
|
|
COMM_SET_DETECT,
|
2015-07-31 14:26:50 -07:00
|
|
|
COMM_SET_SERVO_POS,
|
2014-09-19 18:22:38 -07:00
|
|
|
COMM_SET_MCCONF,
|
|
|
|
COMM_GET_MCCONF,
|
2015-12-08 12:01:23 -08:00
|
|
|
COMM_GET_MCCONF_DEFAULT,
|
2014-09-19 18:22:38 -07:00
|
|
|
COMM_SET_APPCONF,
|
|
|
|
COMM_GET_APPCONF,
|
2015-12-08 12:01:23 -08:00
|
|
|
COMM_GET_APPCONF_DEFAULT,
|
2014-09-19 18:22:38 -07:00
|
|
|
COMM_SAMPLE_PRINT,
|
|
|
|
COMM_TERMINAL_CMD,
|
|
|
|
COMM_PRINT,
|
|
|
|
COMM_ROTOR_POSITION,
|
|
|
|
COMM_EXPERIMENT_SAMPLE,
|
|
|
|
COMM_DETECT_MOTOR_PARAM,
|
2015-12-08 12:01:23 -08:00
|
|
|
COMM_DETECT_MOTOR_R_L,
|
|
|
|
COMM_DETECT_MOTOR_FLUX_LINKAGE,
|
2015-12-27 16:50:23 -08:00
|
|
|
COMM_DETECT_ENCODER,
|
2016-01-27 14:57:23 -08:00
|
|
|
COMM_DETECT_HALL_FOC,
|
2014-09-20 04:41:18 -07:00
|
|
|
COMM_REBOOT,
|
2014-09-20 06:23:36 -07:00
|
|
|
COMM_ALIVE,
|
2014-10-18 16:00:53 -07:00
|
|
|
COMM_GET_DECODED_PPM,
|
2015-05-04 14:25:43 -07:00
|
|
|
COMM_GET_DECODED_ADC,
|
2015-04-26 15:02:32 -07:00
|
|
|
COMM_GET_DECODED_CHUK,
|
2016-01-24 04:44:51 -08:00
|
|
|
COMM_FORWARD_CAN,
|
|
|
|
COMM_SET_CHUCK_DATA,
|
2016-11-04 07:18:34 -07:00
|
|
|
COMM_CUSTOM_APP_DATA,
|
2019-02-18 10:30:19 -08:00
|
|
|
COMM_NRF_START_PAIRING,
|
|
|
|
COMM_GPD_SET_FSW,
|
|
|
|
COMM_GPD_BUFFER_NOTIFY,
|
|
|
|
COMM_GPD_BUFFER_SIZE_LEFT,
|
|
|
|
COMM_GPD_FILL_BUFFER,
|
|
|
|
COMM_GPD_OUTPUT_SAMPLE,
|
|
|
|
COMM_GPD_SET_MODE,
|
|
|
|
COMM_GPD_FILL_BUFFER_INT8,
|
|
|
|
COMM_GPD_FILL_BUFFER_INT16,
|
|
|
|
COMM_GPD_SET_BUFFER_INT_SCALE,
|
|
|
|
COMM_GET_VALUES_SETUP,
|
|
|
|
COMM_SET_MCCONF_TEMP,
|
|
|
|
COMM_SET_MCCONF_TEMP_SETUP,
|
|
|
|
COMM_GET_VALUES_SELECTIVE,
|
|
|
|
COMM_GET_VALUES_SETUP_SELECTIVE,
|
|
|
|
COMM_EXT_NRF_PRESENT,
|
|
|
|
COMM_EXT_NRF_ESB_SET_CH_ADDR,
|
|
|
|
COMM_EXT_NRF_ESB_SEND_DATA,
|
|
|
|
COMM_EXT_NRF_ESB_RX_DATA,
|
|
|
|
COMM_EXT_NRF_SET_ENABLED,
|
|
|
|
COMM_DETECT_MOTOR_FLUX_LINKAGE_OPENLOOP,
|
|
|
|
COMM_DETECT_APPLY_ALL_FOC,
|
|
|
|
COMM_JUMP_TO_BOOTLOADER_ALL_CAN,
|
|
|
|
COMM_ERASE_NEW_APP_ALL_CAN,
|
|
|
|
COMM_WRITE_NEW_APP_DATA_ALL_CAN,
|
|
|
|
COMM_PING_CAN,
|
2019-03-10 06:57:42 -07:00
|
|
|
COMM_APP_DISABLE_OUTPUT,
|
|
|
|
COMM_TERMINAL_CMD_SYNC,
|
2019-03-31 01:49:18 -07:00
|
|
|
COMM_GET_IMU_DATA,
|
|
|
|
COMM_BM_CONNECT,
|
|
|
|
COMM_BM_ERASE_FLASH_ALL,
|
|
|
|
COMM_BM_WRITE_FLASH,
|
|
|
|
COMM_BM_REBOOT,
|
2019-09-03 11:39:05 -07:00
|
|
|
COMM_BM_DISCONNECT,
|
|
|
|
COMM_BM_MAP_PINS_DEFAULT,
|
|
|
|
COMM_BM_MAP_PINS_NRF5X,
|
|
|
|
COMM_ERASE_BOOTLOADER,
|
|
|
|
COMM_ERASE_BOOTLOADER_ALL_CAN,
|
2019-09-08 09:25:38 -07:00
|
|
|
COMM_PLOT_INIT,
|
|
|
|
COMM_PLOT_DATA,
|
|
|
|
COMM_PLOT_ADD_GRAPH,
|
|
|
|
COMM_PLOT_SET_GRAPH,
|
2019-09-08 22:23:31 -07:00
|
|
|
COMM_GET_DECODED_BALANCE,
|
2019-09-21 03:50:39 -07:00
|
|
|
COMM_BM_MEM_READ,
|
2019-12-05 10:50:17 -08:00
|
|
|
COMM_WRITE_NEW_APP_DATA_LZO,
|
|
|
|
COMM_WRITE_NEW_APP_DATA_ALL_CAN_LZO,
|
2019-12-19 07:55:38 -08:00
|
|
|
COMM_BM_WRITE_FLASH_LZO,
|
2020-01-28 10:46:19 -08:00
|
|
|
COMM_SET_CURRENT_REL,
|
2020-03-20 09:35:25 -07:00
|
|
|
COMM_CAN_FWD_FRAME,
|
2020-04-01 17:58:37 -07:00
|
|
|
COMM_SET_BATTERY_CUT,
|
|
|
|
COMM_SET_BLE_NAME,
|
2020-04-04 13:28:41 -07:00
|
|
|
COMM_SET_BLE_PIN,
|
2020-04-19 01:20:48 -07:00
|
|
|
COMM_SET_CAN_MODE,
|
2020-05-01 06:22:09 -07:00
|
|
|
COMM_GET_IMU_CALIBRATION,
|
2020-09-16 08:19:36 -07:00
|
|
|
COMM_GET_MCCONF_TEMP,
|
2020-10-21 23:32:51 -07:00
|
|
|
|
|
|
|
// Custom configuration for hardware
|
|
|
|
COMM_GET_CUSTOM_CONFIG_XML,
|
|
|
|
COMM_GET_CUSTOM_CONFIG,
|
|
|
|
COMM_GET_CUSTOM_CONFIG_DEFAULT,
|
|
|
|
COMM_SET_CUSTOM_CONFIG,
|
|
|
|
|
|
|
|
// BMS commands
|
|
|
|
COMM_BMS_GET_VALUES,
|
|
|
|
COMM_BMS_SET_CHARGE_ALLOWED,
|
|
|
|
COMM_BMS_SET_BALANCE_OVERRIDE,
|
|
|
|
COMM_BMS_RESET_COUNTERS,
|
|
|
|
COMM_BMS_FORCE_BALANCE,
|
|
|
|
COMM_BMS_ZERO_CURRENT_OFFSET,
|
|
|
|
|
|
|
|
// FW updates commands for different HW types
|
|
|
|
COMM_JUMP_TO_BOOTLOADER_HW,
|
|
|
|
COMM_ERASE_NEW_APP_HW,
|
|
|
|
COMM_WRITE_NEW_APP_DATA_HW,
|
|
|
|
COMM_ERASE_BOOTLOADER_HW,
|
|
|
|
COMM_JUMP_TO_BOOTLOADER_ALL_CAN_HW,
|
|
|
|
COMM_ERASE_NEW_APP_ALL_CAN_HW,
|
|
|
|
COMM_WRITE_NEW_APP_DATA_ALL_CAN_HW,
|
|
|
|
COMM_ERASE_BOOTLOADER_ALL_CAN_HW,
|
|
|
|
|
|
|
|
COMM_SET_ODOMETER,
|
2021-02-28 11:28:23 -08:00
|
|
|
|
|
|
|
// Power switch commands
|
|
|
|
COMM_PSW_GET_STATUS,
|
|
|
|
COMM_PSW_SWITCH,
|
2021-03-13 02:36:47 -08:00
|
|
|
|
|
|
|
COMM_BMS_FWD_CAN_RX,
|
2021-04-08 09:09:53 -07:00
|
|
|
COMM_BMS_HW_DATA,
|
2021-03-09 23:37:15 -08:00
|
|
|
COMM_GET_BATTERY_CUT,
|
2021-04-23 06:58:24 -07:00
|
|
|
COMM_BM_HALT_REQ,
|
2021-04-24 13:36:00 -07:00
|
|
|
COMM_GET_QML_UI_HW,
|
|
|
|
COMM_GET_QML_UI_APP,
|
|
|
|
COMM_CUSTOM_HW_DATA,
|
2021-05-01 04:28:46 -07:00
|
|
|
COMM_QMLUI_ERASE,
|
|
|
|
COMM_QMLUI_WRITE,
|
2021-05-11 00:57:27 -07:00
|
|
|
|
|
|
|
// IO Board
|
|
|
|
COMM_IO_BOARD_GET_ALL,
|
|
|
|
COMM_IO_BOARD_SET_PWM,
|
|
|
|
COMM_IO_BOARD_SET_DIGITAL,
|
2021-10-01 06:54:21 -07:00
|
|
|
|
|
|
|
COMM_BM_MEM_WRITE,
|
2021-11-09 04:33:28 -08:00
|
|
|
COMM_BMS_BLNC_SELFTEST,
|
|
|
|
COMM_GET_EXT_HUM_TMP,
|
2021-11-10 16:08:21 -08:00
|
|
|
COMM_GET_STATS,
|
|
|
|
COMM_RESET_STATS,
|
2022-01-28 18:36:34 -08:00
|
|
|
|
|
|
|
// Lisp
|
|
|
|
COMM_LISP_READ_CODE,
|
|
|
|
COMM_LISP_WRITE_CODE,
|
|
|
|
COMM_LISP_ERASE_CODE,
|
|
|
|
COMM_LISP_SET_RUNNING,
|
|
|
|
COMM_LISP_GET_STATS,
|
2022-02-11 00:12:11 -08:00
|
|
|
COMM_LISP_PRINT,
|
|
|
|
|
|
|
|
COMM_BMS_SET_BATT_TYPE,
|
|
|
|
COMM_BMS_GET_BATT_TYPE,
|
2022-03-01 03:07:27 -08:00
|
|
|
|
|
|
|
COMM_LISP_REPL_CMD,
|
2014-09-19 18:22:38 -07:00
|
|
|
} COMM_PACKET_ID;
|
|
|
|
|
2014-12-06 19:30:25 -08:00
|
|
|
// CAN commands
|
|
|
|
typedef enum {
|
|
|
|
CAN_PACKET_SET_DUTY = 0,
|
|
|
|
CAN_PACKET_SET_CURRENT,
|
|
|
|
CAN_PACKET_SET_CURRENT_BRAKE,
|
2015-02-19 12:20:07 -08:00
|
|
|
CAN_PACKET_SET_RPM,
|
2015-04-26 15:02:32 -07:00
|
|
|
CAN_PACKET_SET_POS,
|
|
|
|
CAN_PACKET_FILL_RX_BUFFER,
|
2015-05-20 07:13:48 -07:00
|
|
|
CAN_PACKET_FILL_RX_BUFFER_LONG,
|
2015-04-26 15:02:32 -07:00
|
|
|
CAN_PACKET_PROCESS_RX_BUFFER,
|
2015-04-27 11:43:02 -07:00
|
|
|
CAN_PACKET_PROCESS_SHORT_BUFFER,
|
2017-09-04 12:12:43 -07:00
|
|
|
CAN_PACKET_STATUS,
|
|
|
|
CAN_PACKET_SET_CURRENT_REL,
|
2018-03-02 02:48:49 -08:00
|
|
|
CAN_PACKET_SET_CURRENT_BRAKE_REL,
|
|
|
|
CAN_PACKET_SET_CURRENT_HANDBRAKE,
|
2019-02-18 10:30:19 -08:00
|
|
|
CAN_PACKET_SET_CURRENT_HANDBRAKE_REL,
|
|
|
|
CAN_PACKET_STATUS_2,
|
|
|
|
CAN_PACKET_STATUS_3,
|
|
|
|
CAN_PACKET_STATUS_4,
|
|
|
|
CAN_PACKET_PING,
|
|
|
|
CAN_PACKET_PONG,
|
|
|
|
CAN_PACKET_DETECT_APPLY_ALL_FOC,
|
|
|
|
CAN_PACKET_DETECT_APPLY_ALL_FOC_RES,
|
|
|
|
CAN_PACKET_CONF_CURRENT_LIMITS,
|
|
|
|
CAN_PACKET_CONF_STORE_CURRENT_LIMITS,
|
|
|
|
CAN_PACKET_CONF_CURRENT_LIMITS_IN,
|
|
|
|
CAN_PACKET_CONF_STORE_CURRENT_LIMITS_IN,
|
|
|
|
CAN_PACKET_CONF_FOC_ERPMS,
|
2019-05-16 14:30:40 -07:00
|
|
|
CAN_PACKET_CONF_STORE_FOC_ERPMS,
|
2020-01-28 10:46:19 -08:00
|
|
|
CAN_PACKET_STATUS_5,
|
2020-03-20 09:35:25 -07:00
|
|
|
CAN_PACKET_POLL_TS5700N8501_STATUS,
|
|
|
|
CAN_PACKET_CONF_BATTERY_CUT,
|
|
|
|
CAN_PACKET_CONF_STORE_BATTERY_CUT,
|
2020-10-09 12:08:48 -07:00
|
|
|
CAN_PACKET_SHUTDOWN,
|
|
|
|
CAN_PACKET_IO_BOARD_ADC_1_TO_4,
|
|
|
|
CAN_PACKET_IO_BOARD_ADC_5_TO_8,
|
|
|
|
CAN_PACKET_IO_BOARD_ADC_9_TO_12,
|
|
|
|
CAN_PACKET_IO_BOARD_DIGITAL_IN,
|
|
|
|
CAN_PACKET_IO_BOARD_SET_OUTPUT_DIGITAL,
|
|
|
|
CAN_PACKET_IO_BOARD_SET_OUTPUT_PWM,
|
|
|
|
CAN_PACKET_BMS_V_TOT,
|
|
|
|
CAN_PACKET_BMS_I,
|
|
|
|
CAN_PACKET_BMS_AH_WH,
|
|
|
|
CAN_PACKET_BMS_V_CELL,
|
|
|
|
CAN_PACKET_BMS_BAL,
|
|
|
|
CAN_PACKET_BMS_TEMPS,
|
|
|
|
CAN_PACKET_BMS_HUM,
|
2021-02-28 11:28:23 -08:00
|
|
|
CAN_PACKET_BMS_SOC_SOH_TEMP_STAT,
|
|
|
|
CAN_PACKET_PSW_STAT,
|
2021-04-08 09:09:53 -07:00
|
|
|
CAN_PACKET_PSW_SWITCH,
|
|
|
|
CAN_PACKET_BMS_HW_DATA_1,
|
|
|
|
CAN_PACKET_BMS_HW_DATA_2,
|
|
|
|
CAN_PACKET_BMS_HW_DATA_3,
|
|
|
|
CAN_PACKET_BMS_HW_DATA_4,
|
|
|
|
CAN_PACKET_BMS_HW_DATA_5,
|
2021-04-08 13:34:01 -07:00
|
|
|
CAN_PACKET_BMS_AH_WH_CHG_TOTAL,
|
|
|
|
CAN_PACKET_BMS_AH_WH_DIS_TOTAL,
|
2021-07-11 11:19:26 -07:00
|
|
|
CAN_PACKET_UPDATE_PID_POS_OFFSET,
|
2021-08-30 00:39:21 -07:00
|
|
|
CAN_PACKET_POLL_ROTOR_POS,
|
2022-02-03 04:58:49 -08:00
|
|
|
CAN_PACKET_NOTIFY_BOOT,
|
2022-03-13 12:56:26 -07:00
|
|
|
CAN_PACKET_STATUS_6,
|
2021-08-30 00:39:21 -07:00
|
|
|
CAN_PACKET_MAKE_ENUM_32_BITS = 0xFFFFFFFF,
|
2014-12-06 19:30:25 -08:00
|
|
|
} CAN_PACKET_ID;
|
|
|
|
|
2014-11-27 11:56:17 -08:00
|
|
|
// Logged fault data
|
|
|
|
typedef struct {
|
2020-03-16 10:32:39 -07:00
|
|
|
uint8_t motor;
|
2014-11-27 11:56:17 -08:00
|
|
|
mc_fault_code fault;
|
|
|
|
float current;
|
|
|
|
float current_filtered;
|
|
|
|
float voltage;
|
2019-01-18 14:03:53 -08:00
|
|
|
float gate_driver_voltage;
|
2014-11-27 11:56:17 -08:00
|
|
|
float duty;
|
|
|
|
float rpm;
|
|
|
|
int tacho;
|
2015-08-23 09:26:05 -07:00
|
|
|
int cycles_running;
|
|
|
|
int tim_val_samp;
|
|
|
|
int tim_current_samp;
|
|
|
|
int tim_top;
|
2014-11-27 11:56:17 -08:00
|
|
|
int comm_step;
|
|
|
|
float temperature;
|
2017-09-04 12:12:43 -07:00
|
|
|
int drv8301_faults;
|
2014-11-27 11:56:17 -08:00
|
|
|
} fault_data;
|
|
|
|
|
2014-12-20 03:52:38 -08:00
|
|
|
typedef struct {
|
|
|
|
int js_x;
|
|
|
|
int js_y;
|
|
|
|
int acc_x;
|
|
|
|
int acc_y;
|
|
|
|
int acc_z;
|
|
|
|
bool bt_c;
|
|
|
|
bool bt_z;
|
2019-02-18 10:30:19 -08:00
|
|
|
bool rev_has_state;
|
|
|
|
bool is_rev;
|
2015-02-19 12:20:07 -08:00
|
|
|
} chuck_data;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float rpm;
|
|
|
|
float current;
|
|
|
|
float duty;
|
|
|
|
} can_status_msg;
|
2014-12-20 03:52:38 -08:00
|
|
|
|
2019-02-18 10:30:19 -08:00
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float amp_hours;
|
|
|
|
float amp_hours_charged;
|
|
|
|
} can_status_msg_2;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float watt_hours;
|
|
|
|
float watt_hours_charged;
|
|
|
|
} can_status_msg_3;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float temp_fet;
|
|
|
|
float temp_motor;
|
|
|
|
float current_in;
|
|
|
|
float pid_pos_now;
|
|
|
|
} can_status_msg_4;
|
|
|
|
|
2019-05-16 14:30:40 -07:00
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float v_in;
|
|
|
|
int32_t tacho_value;
|
|
|
|
} can_status_msg_5;
|
|
|
|
|
2022-03-13 12:56:26 -07:00
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float adc_1;
|
|
|
|
float adc_2;
|
|
|
|
float adc_3;
|
|
|
|
float ppm;
|
|
|
|
} can_status_msg_6;
|
|
|
|
|
2020-10-09 12:08:48 -07:00
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float adc_voltages[4];
|
|
|
|
} io_board_adc_values;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
uint64_t inputs;
|
|
|
|
} io_board_digial_inputs;
|
|
|
|
|
2021-02-28 11:28:23 -08:00
|
|
|
typedef struct {
|
|
|
|
int id;
|
|
|
|
systime_t rx_time;
|
|
|
|
float v_in;
|
|
|
|
float v_out;
|
|
|
|
float temp;
|
|
|
|
bool is_out_on;
|
|
|
|
bool is_pch_on;
|
|
|
|
bool is_dsc_on;
|
|
|
|
} psw_status;
|
|
|
|
|
2015-04-11 01:07:36 -07:00
|
|
|
typedef struct {
|
|
|
|
uint8_t js_x;
|
|
|
|
uint8_t js_y;
|
|
|
|
bool bt_c;
|
|
|
|
bool bt_z;
|
|
|
|
bool bt_push;
|
2019-02-18 10:30:19 -08:00
|
|
|
bool rev_has_state;
|
|
|
|
bool is_rev;
|
2015-04-11 01:07:36 -07:00
|
|
|
float vbat;
|
|
|
|
} mote_state;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
MOTE_PACKET_BATT_LEVEL = 0,
|
2015-07-31 14:26:50 -07:00
|
|
|
MOTE_PACKET_BUTTONS,
|
2015-12-27 16:50:23 -08:00
|
|
|
MOTE_PACKET_ALIVE,
|
|
|
|
MOTE_PACKET_FILL_RX_BUFFER,
|
|
|
|
MOTE_PACKET_FILL_RX_BUFFER_LONG,
|
|
|
|
MOTE_PACKET_PROCESS_RX_BUFFER,
|
|
|
|
MOTE_PACKET_PROCESS_SHORT_BUFFER,
|
2016-11-04 07:18:34 -07:00
|
|
|
MOTE_PACKET_PAIRING_INFO
|
2015-04-11 01:07:36 -07:00
|
|
|
} MOTE_PACKET;
|
|
|
|
|
2015-10-08 14:09:39 -07:00
|
|
|
typedef struct {
|
|
|
|
float v_in;
|
2020-03-20 09:35:25 -07:00
|
|
|
float temp_mos;
|
|
|
|
float temp_mos_1;
|
|
|
|
float temp_mos_2;
|
|
|
|
float temp_mos_3;
|
|
|
|
float temp_motor;
|
2015-10-08 14:09:39 -07:00
|
|
|
float current_motor;
|
|
|
|
float current_in;
|
2020-03-20 09:35:25 -07:00
|
|
|
float id;
|
|
|
|
float iq;
|
2015-10-08 14:09:39 -07:00
|
|
|
float rpm;
|
|
|
|
float duty_now;
|
|
|
|
float amp_hours;
|
|
|
|
float amp_hours_charged;
|
|
|
|
float watt_hours;
|
|
|
|
float watt_hours_charged;
|
|
|
|
int tachometer;
|
|
|
|
int tachometer_abs;
|
2020-03-20 09:35:25 -07:00
|
|
|
float position;
|
2015-10-08 14:09:39 -07:00
|
|
|
mc_fault_code fault_code;
|
2020-03-20 09:35:25 -07:00
|
|
|
int vesc_id;
|
|
|
|
float vd;
|
|
|
|
float vq;
|
2015-10-08 14:09:39 -07:00
|
|
|
} mc_values;
|
|
|
|
|
2016-11-04 07:18:34 -07:00
|
|
|
typedef enum {
|
|
|
|
NRF_PAIR_STARTED = 0,
|
|
|
|
NRF_PAIR_OK,
|
|
|
|
NRF_PAIR_FAIL
|
|
|
|
} NRF_PAIR_RES;
|
|
|
|
|
2019-03-10 06:57:42 -07:00
|
|
|
// Orientation data
|
|
|
|
typedef struct {
|
|
|
|
float q0;
|
|
|
|
float q1;
|
|
|
|
float q2;
|
|
|
|
float q3;
|
|
|
|
float integralFBx;
|
|
|
|
float integralFBy;
|
|
|
|
float integralFBz;
|
|
|
|
float accMagP;
|
|
|
|
int initialUpdateDone;
|
|
|
|
} ATTITUDE_INFO;
|
|
|
|
|
2019-04-19 01:42:43 -07:00
|
|
|
// Custom EEPROM variables
|
|
|
|
typedef union {
|
|
|
|
uint32_t as_u32;
|
|
|
|
int32_t as_i32;
|
|
|
|
float as_float;
|
|
|
|
} eeprom_var;
|
|
|
|
|
|
|
|
#define EEPROM_VARS_HW 64
|
|
|
|
#define EEPROM_VARS_CUSTOM 64
|
|
|
|
|
2019-09-03 11:39:05 -07:00
|
|
|
typedef struct {
|
|
|
|
float ah_tot;
|
|
|
|
float ah_charge_tot;
|
|
|
|
float wh_tot;
|
|
|
|
float wh_charge_tot;
|
|
|
|
float current_tot;
|
|
|
|
float current_in_tot;
|
|
|
|
uint8_t num_vescs;
|
|
|
|
} setup_values;
|
|
|
|
|
2021-11-10 16:08:21 -08:00
|
|
|
typedef struct {
|
|
|
|
systime_t time_start;
|
|
|
|
double samples;
|
|
|
|
double speed_sum;
|
|
|
|
float max_speed;
|
|
|
|
double power_sum;
|
|
|
|
float max_power;
|
|
|
|
double temp_motor_sum;
|
|
|
|
float max_temp_motor;
|
|
|
|
double temp_mos_sum;
|
|
|
|
float max_temp_mos;
|
|
|
|
double current_sum;
|
|
|
|
float max_current;
|
|
|
|
} setup_stats;
|
|
|
|
|
2021-04-11 10:36:11 -07:00
|
|
|
#define BACKUP_VAR_INIT_CODE 92891934
|
|
|
|
|
|
|
|
typedef struct __attribute__((packed)) {
|
|
|
|
uint32_t odometer_init_flag;
|
|
|
|
uint64_t odometer; // Meters
|
|
|
|
|
|
|
|
uint32_t runtime_init_flag;
|
|
|
|
uint64_t runtime; // Seconds
|
|
|
|
} backup_data;
|
|
|
|
|
2014-09-14 14:08:22 -07:00
|
|
|
#endif /* DATATYPES_H_ */
|