reflow-oven-control-sw/stm-firmware/shell.c

263 lines
6.6 KiB
C
Raw Normal View History

2020-02-12 21:00:35 +01:00
#include <reflow-controller/shell.h>
2020-02-12 21:06:52 +01:00
#include <stm-periph/uart.h>
#include <string.h>
2020-02-12 21:00:35 +01:00
#include <reflow-controller/adc-meas.h>
#include <reflow-controller/digio.h>
#include <stdlib.h>
#include <helper-macros/helper-macros.h>
2020-02-12 21:00:35 +01:00
#include <reflow-controller/systick.h>
#include <stm-periph/unique-id.h>
#include <reflow-controller/calibration.h>
#ifndef GIT_VER
#define GIT_VER "VERSION NOT SET"
#endif
static shellmatta_instance_t shell;
static char shell_buffer[512];
static char history_buffer[1024];
static shellmatta_retCode_t write_shell_callback(const char *data, uint32_t len)
{
2020-02-11 22:49:47 +01:00
uart_send_array_with_dma(data, len);
return SHELLMATTA_OK;
}
static shellmatta_retCode_t shell_cmd_ver(const shellmatta_handle_t handle,
const char *arguments,
uint32_t length)
{
(void)arguments;
(void)length;
uint32_t low_id;
uint32_t mid_id;
uint32_t high_id;
unique_id_get(&high_id, &mid_id, &low_id);
shellmatta_printf(handle, "Reflow Oven Controller Firmware " xstr(GIT_VER) "\r\n"
"Compiled: " __DATE__ " at " __TIME__ "\r\n"
"Serial: %08X-%08X-%08X", high_id, mid_id, low_id);
return SHELLMATTA_OK;
}
static shellmatta_retCode_t shell_cmd_digio_get(const shellmatta_handle_t handle,
const char *arguments,
uint32_t length)
{
(void)arguments;
(void)length;
shellmatta_printf(handle,
"DIGIO0 DIGIO1 DIGIO2 DIGIO3 LED0 LED1 LS\r\n"
"%d %d %d %d %d %d %d\r\n",
digio_get(0), digio_get(1), digio_get(2), digio_get(3),
led_get(0), led_get(1), loudspeaker_get());
return SHELLMATTA_OK;
}
static shellmatta_retCode_t shell_cmd_digio_set(const shellmatta_handle_t handle,
const char *arguments,
uint32_t length)
{
2020-02-12 21:19:11 +01:00
(void)length;
(void)handle;
int num = 100;
int state;
char buff[64];
char *curr_token;
strncpy(buff, arguments, sizeof(buff));
curr_token = strtok(buff, " ");
curr_token = strtok(NULL, " ");
if (!curr_token)
return SHELLMATTA_ERROR;
num = atoi(curr_token);
if (!curr_token)
return SHELLMATTA_ERROR;
curr_token = strtok(NULL, " ");
state = atoi(curr_token);
if (num < 4 && num >= 0)
digio_set(num, state);
else if (num >= 4 && num <= 5)
led_set(num - 4, state);
else if (num == 6)
loudspeaker_set(state);
else
return SHELLMATTA_ERROR;
return SHELLMATTA_OK;
}
static shellmatta_retCode_t shell_cmd_pt1000_res(const shellmatta_handle_t handle,
const char *arguments,
uint32_t length)
{
(void)arguments;
(void)length;
float resistance;
int pt1000_status;
enum adc_pt1000_error pt1000_flags;
char display_status[100];
display_status[0] = 0;
pt1000_status = adc_pt1000_get_current_resistance(&resistance);
if (pt1000_status == 2) {
strcat(display_status, " UNSTABLE ");
} else if (pt1000_status) {
pt1000_flags = adc_pt1000_check_error();
if (pt1000_flags & ADC_PT1000_INACTIVE)
strcat(display_status, " DEACTIVATED ");
else if (pt1000_flags & ADC_PT1000_WATCHDOG_ERROR)
strcat(display_status, " WATCHDOG ");
else if (pt1000_flags & ADC_PT1000_OVERFLOW)
strcat(display_status, " OVERFLOW ");
} else {
strcpy(display_status, "VALID");
}
shellmatta_printf(handle, "PT1000 resistance: %.2f Ohm [%s]\r\n", resistance, display_status);
return SHELLMATTA_OK;
}
2020-02-12 21:08:05 +01:00
static shellmatta_retCode_t shell_cmd_clear_error_status(const shellmatta_handle_t handle, const char *arguments,
uint32_t length)
{
2020-02-12 21:08:05 +01:00
(void)arguments;
(void)length;
2020-02-12 21:10:15 +01:00
(void)handle;
2020-02-12 21:08:05 +01:00
adc_pt1000_clear_error();
return SHELLMATTA_OK;
}
2020-02-11 22:59:30 +01:00
static shellmatta_retCode_t shell_cmd_uptime(const shellmatta_handle_t handle,
const char *arguments,
uint32_t length)
{
(void)arguments;
(void)length;
2020-02-12 21:10:15 +01:00
2020-02-11 22:59:30 +01:00
shellmatta_printf(handle, "Uptime: %llu secs", global_tick_ms/1000);
return SHELLMATTA_OK;
}
static shellmatta_retCode_t shell_cmd_acquire_val(const shellmatta_handle_t handle,
const char *arguments,
uint32_t length)
{
float mu, sigma;
calibration_acquire_data(&mu, &sigma, 128U);
shellmatta_printf(handle, "mu: %.2f\r\nsigma: %.3f\r\n", mu, sigma);
return SHELLMATTA_OK;
}
//typedef struct shellmatta_cmd
//{
// char *cmd; /**< command name */
// char *cmdAlias; /**< command alias */
// char *helpText; /**< help text to print in "help" command */
// char *usageText; /**< usage text to print on parameter error */
// shellmatta_cmdFct_t cmdFct; /**< pointer to the cmd callack function */
// struct shellmatta_cmd *next; /**< pointer to next command or NULL */
//} shellmatta_cmd_t;
static shellmatta_cmd_t cmd[7] = {
{
.cmd = "version",
.cmdAlias = "ver",
.helpText = "Print firmware version",
.usageText = NULL,
.cmdFct = shell_cmd_ver,
.next = &cmd[1],
},
{
.cmd = "pt1000",
.cmdAlias = "pt",
.helpText = "Get current filtered and calibrated PT1000 resistance",
.usageText = NULL,
.cmdFct = shell_cmd_pt1000_res,
.next = &cmd[2],
},
{
.cmd = "pt1000-clear-error",
.cmdAlias = "pt-clear",
.helpText = "Clear error status of PT1000 reading",
.usageText = NULL,
.cmdFct = shell_cmd_clear_error_status,
.next = &cmd[3],
},
{
.cmd = "digio-get",
.cmdAlias = "dg",
.helpText = "Read all digital input/output ports",
.usageText = NULL,
.cmdFct = shell_cmd_digio_get,
.next = &cmd[4],
},
{
.cmd = "digio-set",
.cmdAlias = "ds",
.helpText = "Set DIGIO Port",
.usageText = "digio-set <num> <state>",
.cmdFct = shell_cmd_digio_set,
2020-02-11 22:59:30 +01:00
.next = &cmd[5],
},
{
.cmd = "uptime",
.cmdAlias = "upt",
.helpText = "Get uptime in seconds",
.usageText = "",
.cmdFct = shell_cmd_uptime,
.next = &cmd[6],
},
{
.cmd = "pt1000-acquire",
.cmdAlias = "ptac",
.helpText = "Acquire 128 samples",
.usageText = "",
.cmdFct = shell_cmd_acquire_val,
.next = NULL,
}
};
shellmatta_handle_t shell_init(void)
{
shellmatta_handle_t handle;
shellmatta_retCode_t ret;
ret = shellmatta_doInit(&shell, &handle, shell_buffer, sizeof(shell_buffer), history_buffer, sizeof(history_buffer),
"\e[1;32mEnter command:\e[m\r\n", cmd, write_shell_callback);
if (ret != SHELLMATTA_OK)
handle = NULL;
return handle;
}
void shell_handle_input(shellmatta_handle_t shell, const char *data, size_t len)
{
if (!shell)
return;
shellmatta_processData(shell, (char *)data, (uint32_t)len);
}
void shell_print_string(shellmatta_handle_t shell, const char *string)
{
if (!shell)
return;
shellmatta_write(shell, (char *)string, strlen(string));
}