Merge branch 'dev' into error-mem-viewer
This commit is contained in:
commit
b1a7af28a2
@ -193,6 +193,7 @@ shellmatta_retCode_t calibration_sequence_shell_cmd(shellmatta_handle_t shell, c
|
||||
case CAL_START:
|
||||
/* Clear errors of PT1000 reading */
|
||||
safety_controller_ack_flag(ERR_FLAG_MEAS_ADC_WATCHDOG);
|
||||
safety_controller_ack_flag(ERR_FLAG_OVERTEMP);
|
||||
adc_pt1000_get_resistance_calibration(&offset, &sens_dev, &cal_active);
|
||||
if (cal_active) {
|
||||
shellmatta_printf(shell, "Already calibrated.\r\n\tOffset: %f\r\n\tSens: %f\r\n", offset, sens_dev);
|
||||
@ -213,6 +214,7 @@ shellmatta_retCode_t calibration_sequence_shell_cmd(shellmatta_handle_t shell, c
|
||||
ret_val = SHELLMATTA_BUSY;
|
||||
shellmatta_printf(shell, "Measurement...\r\n");
|
||||
safety_controller_ack_flag(ERR_FLAG_MEAS_ADC_WATCHDOG);
|
||||
safety_controller_ack_flag(ERR_FLAG_OVERTEMP);
|
||||
data_buffer = calibration_acquire_data_start(512UL, &flag);
|
||||
break;
|
||||
} else if (stdin_data[i] == '\x03') {
|
||||
@ -264,6 +266,7 @@ shellmatta_retCode_t calibration_sequence_shell_cmd(shellmatta_handle_t shell, c
|
||||
ret_val = SHELLMATTA_BUSY;
|
||||
shellmatta_printf(shell, "Measurement...\r\n");
|
||||
safety_controller_ack_flag(ERR_FLAG_MEAS_ADC_WATCHDOG);
|
||||
safety_controller_ack_flag(ERR_FLAG_OVERTEMP);
|
||||
data_buffer = calibration_acquire_data_start(512UL, &flag);
|
||||
break;
|
||||
} else if (stdin_data[i] == '\x03') {
|
||||
|
||||
@ -144,6 +144,7 @@ void adc_pt1000_set_moving_average_filter_param(float alpha);
|
||||
*
|
||||
* @param offset Offset \f$O\f$
|
||||
* @param sensitivity_deviation Sensitivity Deviation \f$\sigma\f$ after offset correction
|
||||
* @param active Calibration is active
|
||||
*/
|
||||
void adc_pt1000_set_resistance_calibration(float offset, float sensitivity_deviation, bool active);
|
||||
|
||||
|
||||
@ -55,6 +55,7 @@ enum safety_flag {
|
||||
ERR_FLAG_SAFETY_MEM_CORRUPT = (1<<15),
|
||||
ERR_FLAG_SAFETY_TAB_CORRUPT = (1<<16),
|
||||
ERR_FLAG_AMON_SUPPLY_VOLT = (1<<17),
|
||||
ERR_FLAG_OVERTEMP = (1<<18),
|
||||
};
|
||||
|
||||
/**
|
||||
@ -128,6 +129,11 @@ enum analog_value_monitor {
|
||||
#define SAFETY_EXT_WATCHDOG_RCC_MASK RCC_AHB1ENR_GPIODEN
|
||||
#define SAFETY_EXT_WATCHDOG_PIN (12)
|
||||
|
||||
/**
|
||||
* @brief Default Limit of the overtemperature detection
|
||||
*/
|
||||
#define SAFETY_DEFAULT_OVERTEMP_LIMIT_DEGC (260.0f)
|
||||
|
||||
/**
|
||||
* @brief Key used to lock the safety flags coming from the measurment ADC from external ack'ing
|
||||
*/
|
||||
@ -156,6 +162,7 @@ enum analog_value_monitor {
|
||||
ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_SAFETY_MEM_CORRUPT, true), \
|
||||
ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_SAFETY_TAB_CORRUPT, true), \
|
||||
ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_AMON_SUPPLY_VOLT, false), \
|
||||
ERR_FLAG_PERSIST_ENTRY(ERR_FLAG_OVERTEMP, false), \
|
||||
|
||||
#define SAFETY_CONFIG_DEFAULT_WEIGHTS ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_MEAS_ADC_OFF, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
|
||||
ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_MEAS_ADC_WATCHDOG, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
|
||||
@ -177,5 +184,6 @@ enum analog_value_monitor {
|
||||
ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_SAFETY_MEM_CORRUPT, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
|
||||
ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_SAFETY_TAB_CORRUPT, SAFETY_FLAG_CONFIG_WEIGHT_PANIC), \
|
||||
ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_AMON_SUPPLY_VOLT, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
|
||||
ERR_FLAG_WEIGHT_ENTRY(ERR_FLAG_OVERTEMP, SAFETY_FLAG_CONFIG_WEIGHT_PID), \
|
||||
|
||||
#endif /* __SAFETY_CONFIG_H__ */
|
||||
|
||||
@ -250,7 +250,22 @@ int safety_controller_get_timing_mon_name_by_index(uint32_t index, char *buffer,
|
||||
* @brief Get the count of timing monitors
|
||||
* @return Timing monitor count
|
||||
*/
|
||||
uint32_t safety_controller_get_timing_monitor_count();
|
||||
uint32_t safety_controller_get_timing_monitor_count(void);
|
||||
|
||||
/**
|
||||
* @brief Set the overtemperature limit and store it permanently in the EEPROM
|
||||
*
|
||||
* If no EEPROM is present, this will fail. The default value @ref SAFETY_DEFAULT_OVERTEMP_LIMIT_DEGC will be used.
|
||||
* @param over_temperature Over temperature to set
|
||||
* @return 0 if successfully saved and applied, negative if error
|
||||
*/
|
||||
int safety_controller_set_overtemp_limit(float over_temperature);
|
||||
|
||||
/**
|
||||
* @brief Read the current overtemperature limit.
|
||||
* @return Over temperature limit
|
||||
*/
|
||||
float safety_controller_get_overtemp_limit(void);
|
||||
|
||||
#endif /* __SAFETY_CONTROLLER_H__ */
|
||||
|
||||
|
||||
@ -29,4 +29,8 @@ int settings_eeprom_save_calibration(float sens, float offset, bool active);
|
||||
|
||||
int settings_eeprom_load_calibration(float *sens, float *offset, bool *active);
|
||||
|
||||
int settings_eeprom_save_overtemp_limit(float overtemp_limit, bool active);
|
||||
|
||||
int settings_eeprom_load_overtemp_limit(float *overtemp_limit);
|
||||
|
||||
#endif /* __SETTINGS_SETTINGS_EEPROM_H__ */
|
||||
|
||||
@ -54,6 +54,10 @@ int settings_load_calibration(float *sens_dev, float *offset);
|
||||
|
||||
enum settings_load_result settings_load_pid_oven_parameters(struct oven_pid_settings *settings);
|
||||
|
||||
enum settings_load_result settings_load_overtemp_limit(float *over_temp_limit);
|
||||
|
||||
int settings_save_overtemp_limit(float over_temp_limit, bool active);
|
||||
|
||||
void settings_setup(void);
|
||||
|
||||
#endif /* __SETTINGS_SETTINGS_H__ */
|
||||
|
||||
@ -29,4 +29,13 @@
|
||||
*/
|
||||
int temp_converter_convert_resistance_to_temp(float resistance, float *temp_out);
|
||||
|
||||
/**
|
||||
* @brief Convert temperature to PT1000 resistance
|
||||
* @param temp Temperature in degrees celsius
|
||||
* @param[out] resistance_out Resistance value
|
||||
* @return 0 if ok, -1 if tmeperature is below the lookup table, 1 if value is above the lookup table, -1000 in case of a pointer error,
|
||||
* -100 if an internal error occured. This should never happen, if the lookup table is correct
|
||||
*/
|
||||
int temp_convertet_convert_temp_to_resistance(float temp, float *resistance_out);
|
||||
|
||||
#endif /* __TEMP_CONVERTER_H__ */
|
||||
|
||||
@ -168,6 +168,8 @@ static inline void handle_boot_status(void)
|
||||
|
||||
static inline void setup_system(void)
|
||||
{
|
||||
float tmp;
|
||||
|
||||
setup_nvic_priorities();
|
||||
|
||||
/* Init safety controller and safety memory */
|
||||
@ -182,6 +184,11 @@ static inline void setup_system(void)
|
||||
uart_gpio_config();
|
||||
settings_setup();
|
||||
|
||||
/* Load the overtemperature limit from eeprom if available. Otherwise the default value will be used */
|
||||
if (settings_load_overtemp_limit(&tmp) == SETT_LOAD_SUCCESS) {
|
||||
safety_controller_set_overtemp_limit(tmp);
|
||||
}
|
||||
|
||||
handle_boot_status();
|
||||
|
||||
setup_shell_uart(&shell_uart);
|
||||
|
||||
@ -41,6 +41,8 @@
|
||||
#include <reflow-controller/oven-driver.h>
|
||||
#include <helper-macros/helper-macros.h>
|
||||
#include <stm-periph/rcc-manager.h>
|
||||
#include <reflow-controller/temp-converter.h>
|
||||
#include <reflow-controller/adc-meas.h>
|
||||
|
||||
/**
|
||||
* @brief Macro that checks if a given @ref error_flag is persistent
|
||||
@ -144,6 +146,13 @@ struct analog_mon {
|
||||
uint64_t timestamp;
|
||||
};
|
||||
|
||||
struct overtemp_config {
|
||||
uint32_t crc_dummy_seed;
|
||||
float overtemp_deg_celsius;
|
||||
float overtemp_equiv_resistance;
|
||||
uint32_t crc;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief All safety error flags.
|
||||
*/
|
||||
@ -166,6 +175,7 @@ static volatile struct error_flag IN_SECTION(.ccm.data) flags[] = {
|
||||
ERR_FLAG_ENTRY(ERR_FLAG_SAFETY_MEM_CORRUPT),
|
||||
ERR_FLAG_ENTRY(ERR_FLAG_SAFETY_TAB_CORRUPT),
|
||||
ERR_FLAG_ENTRY(ERR_FLAG_AMON_SUPPLY_VOLT),
|
||||
ERR_FLAG_ENTRY(ERR_FLAG_OVERTEMP),
|
||||
};
|
||||
|
||||
/**
|
||||
@ -233,6 +243,45 @@ static volatile struct safety_weight IN_SECTION(.ccm.bss) flag_weights[COUNT_OF(
|
||||
*/
|
||||
static uint32_t IN_SECTION(.ccm.bss) flag_weight_crc;
|
||||
|
||||
/**
|
||||
* @brief Configuration struct containing the overtemperature flag configuration
|
||||
*/
|
||||
static struct overtemp_config IN_SECTION(.ccm.bss) safety_controller_overtemp_config;
|
||||
|
||||
/**
|
||||
* @brief Configure the overtemperature flag's settings
|
||||
* @param over_temperature Temperature to set the limit to.
|
||||
*/
|
||||
static void set_overtemp_config(float over_temperature)
|
||||
{
|
||||
int result;
|
||||
float resistance;
|
||||
|
||||
result = temp_convertet_convert_temp_to_resistance(over_temperature, &resistance);
|
||||
/* An error in this function is really bad... */
|
||||
if (result < -1)
|
||||
panic_mode();
|
||||
|
||||
crc_unit_reset();
|
||||
safety_controller_overtemp_config.crc_dummy_seed = 0xA4F5C7E6UL;
|
||||
safety_controller_overtemp_config.overtemp_deg_celsius = over_temperature;
|
||||
safety_controller_overtemp_config.overtemp_equiv_resistance = resistance;
|
||||
crc_unit_input_array((const uint32_t *)&safety_controller_overtemp_config, wordsize_of(struct overtemp_config) - 1);
|
||||
safety_controller_overtemp_config.crc = crc_unit_get_crc();
|
||||
}
|
||||
|
||||
static bool over_temperature_config_check(void)
|
||||
{
|
||||
if (safety_controller_overtemp_config.crc_dummy_seed != 0xA4F5C7E6UL)
|
||||
return true;
|
||||
crc_unit_reset();
|
||||
crc_unit_input_array((const uint32_t *)&safety_controller_overtemp_config, wordsize_of(struct overtemp_config) - 1);
|
||||
if (crc_unit_get_crc() != safety_controller_overtemp_config.crc)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Convert a flag enum to the flag number.
|
||||
*
|
||||
@ -515,6 +564,7 @@ static void safety_controller_process_active_timing_mons()
|
||||
/**
|
||||
* @brief safety_controller_process_monitor_checks
|
||||
* Process the analog and timing monitors and set the relevant flags in case of a monitor outside its limits.
|
||||
* Furthermore, the PT1000 resistance is checked for overtemperature
|
||||
*
|
||||
* The checking of the analog monitors will only be armed after a startup delay of 1000 ms to allow the values to stabilize.
|
||||
*/
|
||||
@ -524,6 +574,7 @@ static void safety_controller_process_monitor_checks(void)
|
||||
struct analog_monitor_info amon_info;
|
||||
uint32_t idx;
|
||||
uint32_t analog_mon_count;
|
||||
float pt1000_val = 1000000.0f;
|
||||
|
||||
if (!startup_completed && systick_get_global_tick() >= 1000)
|
||||
startup_completed = true;
|
||||
@ -541,6 +592,11 @@ static void safety_controller_process_monitor_checks(void)
|
||||
}
|
||||
}
|
||||
|
||||
adc_pt1000_get_current_resistance(&pt1000_val);
|
||||
if (pt1000_val > safety_controller_overtemp_config.overtemp_equiv_resistance) {
|
||||
safety_controller_report_error(ERR_FLAG_OVERTEMP);
|
||||
}
|
||||
|
||||
safety_controller_process_active_timing_mons();
|
||||
}
|
||||
|
||||
@ -720,6 +776,9 @@ void safety_controller_init()
|
||||
init_safety_flag_persistencies_from_default();
|
||||
apply_config_overrides();
|
||||
|
||||
/* Set the default limit of the overtemperature check */
|
||||
set_overtemp_config(SAFETY_DEFAULT_OVERTEMP_LIMIT_DEGC);
|
||||
|
||||
if (found_memory_state == SAFETY_MEMORY_INIT_CORRUPTED)
|
||||
safety_controller_report_error(ERR_FLAG_SAFETY_MEM_CORRUPT);
|
||||
else if (found_memory_state == SAFETY_MEMORY_INIT_VALID_MEMORY) {
|
||||
@ -841,6 +900,7 @@ static void safety_controller_handle_safety_adc()
|
||||
* Aditionally, the default flag weights are restored from Flash.
|
||||
* 3) The flag persistency table is CRC checked. In case of an error, the @ref ERR_FLAG_SAFETY_TAB_CORRUPT flag is set.
|
||||
* Aditionally, the default values of the flag persistence is restored from Flash.
|
||||
* 4) Check the Overtemperature flag configuration structure
|
||||
*/
|
||||
static void safety_controller_handle_memory_checks(void)
|
||||
{
|
||||
@ -869,6 +929,12 @@ static void safety_controller_handle_memory_checks(void)
|
||||
safety_controller_report_error(ERR_FLAG_SAFETY_TAB_CORRUPT);
|
||||
init_safety_flag_persistencies_from_default();
|
||||
}
|
||||
|
||||
/* check overtemp struct */
|
||||
if (over_temperature_config_check()) {
|
||||
safety_controller_report_error(ERR_FLAG_SAFETY_TAB_CORRUPT);
|
||||
set_overtemp_config(SAFETY_DEFAULT_OVERTEMP_LIMIT_DEGC);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1219,4 +1285,15 @@ int safety_controller_get_timing_mon_by_index(uint32_t index, struct timing_moni
|
||||
return 0;
|
||||
}
|
||||
|
||||
int safety_controller_set_overtemp_limit(float over_temperature)
|
||||
{
|
||||
set_overtemp_config(over_temperature);
|
||||
return 0;
|
||||
}
|
||||
|
||||
float safety_controller_get_overtemp_limit(void)
|
||||
{
|
||||
return safety_controller_overtemp_config.overtemp_deg_celsius;
|
||||
}
|
||||
|
||||
/** @} */
|
||||
|
||||
@ -23,8 +23,8 @@
|
||||
#include <stm-periph/crc-unit.h>
|
||||
#include <string.h>
|
||||
|
||||
#define EEPROM_HEADER_MAGIC 0xA5
|
||||
#define EEPROM_HEADER_COMP_VER 0xFF
|
||||
#define EEPROM_HEADER_MAGIC 0xC5
|
||||
#define EEPROM_HEADER_COMP_VER 0x01
|
||||
|
||||
static const uint8_t expected_header[2] = {EEPROM_HEADER_MAGIC, EEPROM_HEADER_COMP_VER};
|
||||
|
||||
@ -36,6 +36,12 @@ struct eeprom_calibration_settings {
|
||||
uint32_t crc;
|
||||
};
|
||||
|
||||
#define EEPROM_OVER_TEMP_CONFIG_BASE_ADDR (EEPROM_CALIBRATION_BASE_ADDR + sizeof(struct eeprom_calibration_settings))
|
||||
struct eeprom_over_temp_config {
|
||||
float over_temperature;
|
||||
uint32_t over_temp_crc;
|
||||
};
|
||||
|
||||
static bool check_eeprom_header(void)
|
||||
{
|
||||
uint8_t header[2] = {0};
|
||||
@ -51,6 +57,7 @@ static bool check_eeprom_header(void)
|
||||
static void settings_eeprom_zero()
|
||||
{
|
||||
settings_eeprom_save_calibration(0.0f, 0.0f, false);
|
||||
settings_eeprom_save_overtemp_limit(0.0, false);
|
||||
}
|
||||
|
||||
bool settings_eeprom_detect_and_prepare(void)
|
||||
@ -138,3 +145,46 @@ int settings_eeprom_load_calibration(float *sens, float *offset, bool *active)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int settings_eeprom_save_overtemp_limit(float overtemp_limit, bool active)
|
||||
{
|
||||
int res;
|
||||
struct eeprom_over_temp_config over_temp_conf_entry;
|
||||
const uint8_t zero_vals[sizeof(over_temp_conf_entry)] = {0};
|
||||
|
||||
if (!active) {
|
||||
res = spi_eeprom_write(EEPROM_OVER_TEMP_CONFIG_BASE_ADDR, (const uint8_t *)zero_vals,
|
||||
sizeof(zero_vals));
|
||||
return res ? -1 : 0;
|
||||
}
|
||||
|
||||
over_temp_conf_entry.over_temperature = overtemp_limit;
|
||||
crc_unit_reset();
|
||||
crc_unit_input_array((uint32_t *)&over_temp_conf_entry, 1);
|
||||
over_temp_conf_entry.over_temp_crc = crc_unit_get_crc();
|
||||
res = spi_eeprom_write(EEPROM_OVER_TEMP_CONFIG_BASE_ADDR, (const uint8_t *)&over_temp_conf_entry,
|
||||
sizeof(over_temp_conf_entry));
|
||||
|
||||
return res ? -1 : 0;
|
||||
}
|
||||
|
||||
int settings_eeprom_load_overtemp_limit(float *overtemp_limit)
|
||||
{
|
||||
int res;
|
||||
struct eeprom_over_temp_config over_temp_conf_entry;
|
||||
|
||||
if (!overtemp_limit)
|
||||
return -1001;
|
||||
res = spi_eeprom_read(EEPROM_OVER_TEMP_CONFIG_BASE_ADDR, (uint8_t *)&over_temp_conf_entry,
|
||||
sizeof(struct eeprom_over_temp_config));
|
||||
if (res)
|
||||
return -2;
|
||||
|
||||
crc_unit_reset();
|
||||
crc_unit_input_array((uint32_t *)&over_temp_conf_entry, 1);
|
||||
if (crc_unit_get_crc() != over_temp_conf_entry.over_temp_crc)
|
||||
return -1;
|
||||
|
||||
*overtemp_limit = over_temp_conf_entry.over_temperature;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -64,3 +64,30 @@ void settings_setup(void)
|
||||
else
|
||||
settings_use_eeprom = false;
|
||||
}
|
||||
|
||||
enum settings_load_result settings_load_overtemp_limit(float *over_temp_limit)
|
||||
{
|
||||
int res;
|
||||
float tmp;
|
||||
|
||||
if (!over_temp_limit)
|
||||
return SETT_LOAD_ERR;
|
||||
|
||||
if (!settings_use_eeprom)
|
||||
return SETT_LOAD_FILE_NOT_FOUND;
|
||||
|
||||
res = settings_eeprom_load_overtemp_limit(&tmp);
|
||||
if (res)
|
||||
return SETT_LOAD_DISK_ERR;
|
||||
*over_temp_limit = tmp;
|
||||
|
||||
return SETT_LOAD_SUCCESS;
|
||||
}
|
||||
|
||||
int settings_save_overtemp_limit(float over_temp_limit, bool active)
|
||||
{
|
||||
if (settings_use_eeprom)
|
||||
return settings_eeprom_save_overtemp_limit(over_temp_limit, active);
|
||||
else
|
||||
return -100;
|
||||
}
|
||||
|
||||
@ -334,57 +334,6 @@ static shellmatta_retCode_t shell_cmd_reset(const shellmatta_handle_t handle, co
|
||||
return SHELLMATTA_BUSY;
|
||||
}
|
||||
|
||||
static shellmatta_retCode_t shell_cmd_cat(const shellmatta_handle_t handle, const char *arguments,
|
||||
uint32_t length)
|
||||
{
|
||||
|
||||
#ifdef IMPLEMENT_SHELL_CAT
|
||||
FIL file;
|
||||
char path_buff[256];
|
||||
const char *path;
|
||||
UINT bytes_read;
|
||||
FRESULT res;
|
||||
|
||||
strncpy(path_buff, arguments, MIN(sizeof(path_buff), length));
|
||||
path_buff[MIN(length, sizeof(path_buff)-1)] = 0;
|
||||
path = strtok(path_buff, " ");
|
||||
path = strtok(NULL, " ");
|
||||
|
||||
if (strlen(path) == 0) {
|
||||
shellmatta_printf(handle, "Specify path!\r\n");
|
||||
return SHELLMATTA_OK;
|
||||
}
|
||||
|
||||
res = f_open(&file, path, FA_READ);
|
||||
if (res == FR_OK) {
|
||||
shellmatta_write(handle, "\r\n", 2U);
|
||||
do {
|
||||
res = f_read(&file, path_buff, sizeof(path_buff), &bytes_read);
|
||||
if (bytes_read > 0)
|
||||
shellmatta_write(handle, path_buff, bytes_read);
|
||||
else
|
||||
break;
|
||||
} while (res == FR_OK);
|
||||
|
||||
shellmatta_write(handle, "\r\n", 2U);
|
||||
}
|
||||
|
||||
if (res != FR_OK) {
|
||||
shellmatta_printf(handle, "Error reading file\r\n");
|
||||
}
|
||||
|
||||
f_close(&file);
|
||||
|
||||
#else
|
||||
(void)length;
|
||||
(void)arguments;
|
||||
|
||||
shellmatta_printf(handle, "cat not implemented!\r\n");
|
||||
#endif
|
||||
|
||||
return SHELLMATTA_OK;
|
||||
}
|
||||
|
||||
static shellmatta_retCode_t shell_cmd_read_flags(const shellmatta_handle_t handle, const char *arguments,
|
||||
uint32_t length)
|
||||
{
|
||||
@ -692,6 +641,48 @@ shellmatta_retCode_t shell_cmd_update(const shellmatta_handle_t handle, const ch
|
||||
return SHELLMATTA_OK;
|
||||
}
|
||||
|
||||
shellmatta_retCode_t shell_cmd_overtemp_cfg(const shellmatta_handle_t handle, const char *args, uint32_t len)
|
||||
{
|
||||
float overtemp_lim;
|
||||
shellmatta_retCode_t ret;
|
||||
char *argument;
|
||||
uint32_t arg_length;
|
||||
char option;
|
||||
bool temp_passed = false;
|
||||
bool persistent = false;
|
||||
|
||||
static const shellmatta_opt_long_t options[] = {
|
||||
{"persistent", 'p', SHELLMATTA_OPT_ARG_NONE},
|
||||
{NULL, '\0', SHELLMATTA_OPT_ARG_NONE},
|
||||
};
|
||||
|
||||
do {
|
||||
ret = shellmatta_opt_long(handle, options, &option, &argument, &arg_length);
|
||||
if (ret != SHELLMATTA_OK)
|
||||
break;
|
||||
switch (option) {
|
||||
case 'p':
|
||||
persistent = true;
|
||||
break;
|
||||
case '\0':
|
||||
temp_passed = true;
|
||||
overtemp_lim = strtof(argument, NULL);
|
||||
break;
|
||||
}
|
||||
} while (1);
|
||||
|
||||
if (temp_passed) {
|
||||
safety_controller_set_overtemp_limit(overtemp_lim);
|
||||
if (persistent)
|
||||
settings_save_overtemp_limit(overtemp_lim, true);
|
||||
}
|
||||
|
||||
overtemp_lim = safety_controller_get_overtemp_limit();
|
||||
shellmatta_printf(handle, "Overtemperature configured for: %.1f °C\r\n", overtemp_lim);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
//typedef struct shellmatta_cmd
|
||||
//{
|
||||
// char *cmd; /**< command name */
|
||||
@ -790,21 +781,13 @@ static shellmatta_cmd_t cmd[20] = {
|
||||
.cmdFct = shell_cmd_reset,
|
||||
.next = &cmd[11],
|
||||
},
|
||||
{
|
||||
.cmd = "cat",
|
||||
.cmdAlias = NULL,
|
||||
.helpText = "Print file contents",
|
||||
.usageText = "cat <path>",
|
||||
.cmdFct = shell_cmd_cat,
|
||||
.next = &cmd[12],
|
||||
},
|
||||
{
|
||||
.cmd = "safety-flags",
|
||||
.cmdAlias = "flags",
|
||||
.helpText = "Reads and may clear safety flags",
|
||||
.usageText = "flags [--ack]",
|
||||
.cmdFct = shell_cmd_read_flags,
|
||||
.next = &cmd[13],
|
||||
.next = &cmd[12],
|
||||
},
|
||||
{
|
||||
.cmd = "save-calibration",
|
||||
@ -812,7 +795,7 @@ static shellmatta_cmd_t cmd[20] = {
|
||||
.helpText = "",
|
||||
.usageText = "",
|
||||
.cmdFct = shell_cmd_save_cal,
|
||||
.next = &cmd[14],
|
||||
.next = &cmd[13],
|
||||
},
|
||||
{
|
||||
.cmd = "hang",
|
||||
@ -820,7 +803,7 @@ static shellmatta_cmd_t cmd[20] = {
|
||||
.helpText = "",
|
||||
.usageText = "",
|
||||
.cmdFct = shell_cmd_hang,
|
||||
.next = &cmd[15],
|
||||
.next = &cmd[14],
|
||||
},
|
||||
{
|
||||
.cmd = "ui-emulate",
|
||||
@ -828,7 +811,7 @@ static shellmatta_cmd_t cmd[20] = {
|
||||
.helpText = "",
|
||||
.usageText = "",
|
||||
.cmdFct = shell_cmd_ui_emulation,
|
||||
.next = &cmd[16],
|
||||
.next = &cmd[15],
|
||||
},
|
||||
{
|
||||
.cmd = "panic",
|
||||
@ -836,7 +819,7 @@ static shellmatta_cmd_t cmd[20] = {
|
||||
.helpText = "Panic Mode!",
|
||||
.usageText = "",
|
||||
.cmdFct = shell_cmd_panic,
|
||||
.next = &cmd[17],
|
||||
.next = &cmd[16],
|
||||
},
|
||||
{
|
||||
.cmd = "safety-mem-dump",
|
||||
@ -844,7 +827,7 @@ static shellmatta_cmd_t cmd[20] = {
|
||||
.helpText = "",
|
||||
.usageText = "safety-mem-dump [output-file]",
|
||||
.cmdFct = shell_cmd_dump_safety_mem,
|
||||
.next = &cmd[18],
|
||||
.next = &cmd[17],
|
||||
},
|
||||
{
|
||||
.cmd = "reset-cal",
|
||||
@ -852,7 +835,7 @@ static shellmatta_cmd_t cmd[20] = {
|
||||
.helpText = "Reset Calibration",
|
||||
.usageText = "",
|
||||
.cmdFct = shell_cmd_reset_cal,
|
||||
.next = &cmd[19],
|
||||
.next = &cmd[18],
|
||||
},
|
||||
{
|
||||
.cmd = "update",
|
||||
@ -860,8 +843,16 @@ static shellmatta_cmd_t cmd[20] = {
|
||||
.helpText = "Update Firmware",
|
||||
.usageText = "",
|
||||
.cmdFct = shell_cmd_update,
|
||||
.next = NULL,
|
||||
.next = &cmd[19],
|
||||
|
||||
},
|
||||
{
|
||||
.cmd = "overtemp",
|
||||
.cmdAlias = NULL,
|
||||
.helpText = "Overtemperature Config",
|
||||
.usageText = "",
|
||||
.cmdFct = shell_cmd_overtemp_cfg,
|
||||
.next = NULL,
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -29,7 +29,7 @@ __stack_corruption_area_size = 128;
|
||||
|
||||
/* END OF USER PARAMETERS */
|
||||
ENTRY(Reset_Handler)
|
||||
__ld_top_of_stack = 0x20020000; /* One byte above the end of the SRAM. Stack is pre-decrewmenting, so this is okay */
|
||||
__ld_top_of_stack = 0x20020000; /* One byte above the end of the SRAM. Stack is pre-decrementing, so this is okay */
|
||||
|
||||
|
||||
/* Available memory areas */
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#include <reflow-controller/temp-converter.h>
|
||||
#include <reflow-controller/temp-converter-data.h>
|
||||
#include <helper-macros/helper-macros.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
static const float temp_lookup[(TEMP_CONVERSION_MAX_RES-TEMP_CONVERSION_MIN_RES) / TEMP_CONVERSION_RES_STEP+1] = {TEMP_CONVERSION_ARRAY_DATA};
|
||||
|
||||
@ -73,3 +74,49 @@ int temp_converter_convert_resistance_to_temp(float resistance, float *temp_out)
|
||||
return_ret_val:
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
int temp_convertet_convert_temp_to_resistance(float temp, float *resistance_out)
|
||||
{
|
||||
int retcode = 0;
|
||||
unsigned int i;
|
||||
float lower_temp;
|
||||
float upper_temp;
|
||||
float lower_resistance;
|
||||
float upper_resistance;
|
||||
float temp_ratio;
|
||||
bool found = false;
|
||||
|
||||
if (!resistance_out)
|
||||
return -1000;
|
||||
|
||||
if (temp < temp_lookup[0]) {
|
||||
/* Requested temperature is smaller than minimum value in lookup table */
|
||||
*resistance_out = temp_lookup[0];
|
||||
retcode = -1;
|
||||
goto exit;
|
||||
} else if (temp > temp_lookup[COUNT_OF(temp_lookup) - 1]) {
|
||||
/* Requested temperature is higher than maximum value in lookup table */
|
||||
*resistance_out = temp_lookup[COUNT_OF(temp_lookup) -1];
|
||||
retcode = 1;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
for (i = 0U; i < (COUNT_OF(temp_lookup) - 1); i++) {
|
||||
if (temp >= temp_lookup[i] && temp <= temp_lookup[i+1]) {
|
||||
upper_temp = temp_lookup[i+1];
|
||||
lower_temp = temp_lookup[i];
|
||||
lower_resistance = TEMP_CONVERSION_MIN_RES + TEMP_CONVERSION_RES_STEP * (i);
|
||||
upper_resistance = lower_resistance + TEMP_CONVERSION_RES_STEP;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found)
|
||||
return -100;
|
||||
|
||||
temp_ratio = (temp - lower_temp) / (upper_temp - lower_temp);
|
||||
*resistance_out = lower_resistance + (upper_resistance - lower_resistance) * temp_ratio;
|
||||
|
||||
exit:
|
||||
return retcode;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user