static void shell_cmd_lock(char *args, void *data)
{
int v;
if (strlen(args) > 0) {
v = atoi(args);
switch (v) {
default:
case 0:
home.lock = HOME_RESET;
break;
case 1:
home.lock = HOME_FORCE;
break;
case 2:
home.lock = HOME_WAIT;
break;
}
} else {
shell_printf("syntax: home lock <value>\n");
shell_printf(" Valid values:\n");
shell_printf(" 0 restart home locking\n");
shell_printf(" 1 force home to current GPS data\n");
shell_printf(" 2 bypass arming\n");
}
}
static shell_result_t shell_handler(shell_command_t* command) {
if (command->args_count == 0) return SHELL_RESULT_FAIL;
if (string_eq(command->command, "ht")) {
if (string_eq(command->args[0], "start")) {
start();
} else if (string_eq(command->args[0], "stop")) {
stop();
} else if (string_eq(command->args[0], "sv")) {
uint16_t bytes_written = hum_temp_save();
shell_printf("%u ->\n", bytes_written);
} else if (string_eq(command->args[0], "ld")) {
uint16_t bytes_read = hum_temp_load();
shell_printf("%u <-\n", bytes_read);
} else if (string_eq(command->args[0], "av")) {
hum_temp_print_stats(shell_get_stream());
} else if (string_eq(command->args[0], "dmp")) {
hum_temp_print_samples(shell_get_stream());
} else if (string_eq(command->args[0], "al")) {
ui_set_alarm_on();
} else {
return SHELL_RESULT_FAIL;
}
}
return SHELL_RESULT_SUCCESS;
}
static void handle_failure(shell_result result, const char* command) {
if (result == SHELL_RESULT_FAIL_MATCH) {
PGM_STR(SHELL_UNKNOWN_COMMAND, unknown_cmd)
shell_printf(unknown_cmd, command);
} else {
PGM_STR(SHELL_ERROR, error)
shell_printf(error);
}
}
static void shell_cmd_route(char *args, void *data)
{
unsigned char i;
shell_printf("\nMavlink routing table:\n");
for(i = 0; i < total_routes; i++) {
shell_printf(" sysid(%3u) compid(%3u) on channel(%u)\n",
(unsigned) routes[i].sysid,
(unsigned) routes[i].compid,
(unsigned) routes[i].ch);
}
shell_printf("\ntotal routes=%d max=%d\n", total_routes, MAX_MAVLINK_ROUTES);
}
/*!
* @brief extract from readline
*/
static int parse_line (char * line, char * argv[])
{
uint8_t nargs = 0;
while (nargs < SHELL_MAX_ARGS)
{
/* skip any white space */
while (isblank(*line))
{
++line;
}
if (*line == '\0')
{ /* end of line, no more args */
argv[nargs] = NULL;
return nargs;
}
argv[nargs++] = line; /* begin of argument string */
/* find end of string */
while ((*line) && (!isblank(*line)))
{
++line;
}
if (*line == '\0')
{ /* end of line, no more args */
argv[nargs] = NULL;
return nargs;
}
*line++ = '\0'; /* terminate current arg */
}
shell_printf ("** Too many args (max. %d) **\r\n", SHELL_MAX_ARGS);
return (nargs);
}
/* state change of children handled here */
static void sigchld_handler(int sig)
{
pid_t child_pid;
jobs **job;
int status;
/*
* There can be multiple SIGCHLD at once, not necessarily they will all be handled,
* so we reap all the children in non-blocking mode that takes care of the pending child
* whose SIGCHLD is not attended
*/
/* SIGCHLD should be blocked in critical section of modifying joblist */
/* thy shall NOT pass */
while ((child_pid = waitpid(-1, &status, WNOHANG|WUNTRACED|WCONTINUED)) > 0) {
if (WIFEXITED(status)) {
deljob(child_pid);
}
else if (WIFSIGNALED(status)) {
job = getjob(child_pid, 0);
if (NOTNULL(job)) {
shell_printf(SHELLPRINT_CHKSS | SHELLPRINT_CHKTERM,
TERMSTR_GREEN("SIGCHLD: ")"[%d] (%d) killed by signal %d\n",
(*job)->jid, (*job)->pid[0], WTERMSIG(status));
deljob(child_pid);
}
}
else if (WIFSTOPPED(status)) {
job = getjob(child_pid, 0);
if (NOTNULL(job)) {
(*job)->state = ST;
shell_printf(SHELLPRINT_CHKSS | SHELLPRINT_CHKTERM,
TERMSTR_GREEN("SIGCHLD : ")"[%d] (%d) stopped by signal %d\n",
(*job)->jid, (*job)->pid[0], WSTOPSIG(status));
}
}
else if (WIFCONTINUED(status)) {
job = getjob(child_pid, 0);
if (NOTNULL(job))
(*job)->state = BG;
}
}
/* thy shall pass */
}
static shell_result adc_shell_handler(shell_command* command) {
if (!string_eq(command->command, "adc")) return SHELL_RESULT_FAIL;
if (command->args_count == 0) return SHELL_RESULT_FAIL;
if (string_eq(command->args[0], "read")) {
shell_printf("Channel\tReading\r\n");
if (command->args_count == 2) {
uint8_t channel = atoi(command->args[1]);
shell_printf("%u\t%u\r\n", channel, adc_read(channel));
} else {
for (int i = 0; i < 6; i++) {
shell_printf("%u\t%u\r\n", i, adc_read(i));
}
}
return SHELL_RESULT_SUCCESS;
}
return SHELL_RESULT_FAIL;
}
/*
* the basic wait for foreground used by fg cmd and basic
* non bg cmd in the shell. Make sure SIGCHLD is blocked
* to avoid race conditions that make the joblist unreliable.
* No terminal control or printing if subshell
* */
void wait_fg(jobs **job)
{
int status, i;
/* thy shall NOT pass */
for (i=0; NOTNULL(job); i++) {
if (!subshell_flag && tcsetpgrp(TERMFD, (*job)->pid[0]) < 0)
perror("tcsetpgrp");
while (waitpid((*job)->pid[i], &status, WUNTRACED) == 0)
;
if (WIFEXITED(status)) {
if (!subshell_flag && tcsetpgrp(TERMFD, getpid()) < 0)
perror("tcsetpgrp");
if ((*job)->pid[i+1] == 0) {
deljob((*job)->pid[0]);
break;
}
}
else if (WIFSIGNALED(status)) {
if (!subshell_flag && tcsetpgrp(TERMFD, getpid()) < 0)
perror("tcsetpgrp");
shell_printf(SHELLPRINT_CHKSS | SHELLPRINT_CHKTERM,
"[%d] (%d) killed by signal %d\n", (*job)->jid, (*job)->pid[0],
WTERMSIG(status));
deljob((*job)->pid[0]);
break;
}
else if (WIFSTOPPED(status)) {
if (!subshell_flag && tcsetpgrp(TERMFD, getpid()) < 0)
perror("tcsetpgrp");
shell_printf(SHELLPRINT_CHKSS | SHELLPRINT_CHKTERM,
"[%d] (%d) stopped by signal %d\n", (*job)->jid,
(*job)->pid[0], WSTOPSIG(status));
(*job)->state = ST;
break;
}
}
/* thy shall pass */
}
/* what >bg and >fg run */
void do_bgfg(char **cmd, int state)
{
jobs **job;
sigset_t msk;
MASK_SIG(SIG_BLOCK, SIGCHLD, msk);
if (!cmd[1]) {
job = get_lastjob();
}
else if (*cmd[1]=='%' && atoi(cmd[1]+1)) {
job = getjob(0, atoi(cmd[1]+1));
}
else {
ERRMSG("Invalid argument\n");
return;
}
/* thy shall NOT pass */
if (NOTNULL(job)) {
(*job)->state = state;
if (kill(-(*job)->pid[0], SIGCONT) < 0)
ERR_EXIT("kill");
if (state == BG) {
shell_printf(SHELLPRINT_CHKSS | SHELLPRINT_CHKTERM,
"[%d] (%d) %s\n", (*job)->jid, (*job)->pid[0], (*job)->cmdline);
}
else {
shell_printf(SHELLPRINT_CHKSS | SHELLPRINT_CHKTERM,
"%s\n", (*job)->cmdline);
wait_fg(job);
}
}
else {
ERRMSG("Invalid job\n");
}
/* thy shall pass */
MASK_SIG(SIG_UNBLOCK, SIGCHLD, msk);
}
static void shell_cmd_load(char *args, void *data)
{
struct shell_argval argval[SHELL_CMD_LOAD_ARGS+1], *idx, *tab;
unsigned char t, j;
t = shell_arg_parser(args, argval, SHELL_CMD_LOAD_ARGS);
idx = shell_get_argval(argval, 'i');
tab = shell_get_argval(argval, 't');
if ((t != 1) && ((idx == NULL) && (tab == NULL))) {
shell_printf("load tab: [-i <tab index> | -t <tab number>]\n");
shell_printf(" -i <tab index> tab index (0 to %d)\n", tab_list[0]-1);
shell_printf(" -t <tab id> tab id\n");
} else {
if (idx != NULL) {
j = atoi(idx->val);
if (j < tab_list[0]) {
shell_printf("Loading tab index %d of %d\n", j, tab_list[0]-1);
load_tab(tab_list[j+1]);
} else {
shell_printf("Out of range [0 ... %d]\n", tab_list[0]-1);
}
} else {
j = atoi(tab->val);
shell_printf("Loading tab id %d\n", j);
load_tab(j);
}
}
}
static void on_char_return() {
fputc('\r', output_stream);
fputc('\n', output_stream);
if (curr_index < SHELL_CMD_MAX_LENGTH - 1) {
shell_invoke(command_buffer);
} else {
PGM_STR(SHELL_CMD_TOO_LONG, failed_msg)
shell_printf(failed_msg, SHELL_CMD_MAX_LENGTH);
}
print_prompt();
memset(command_buffer, '\0', SHELL_CMD_MAX_LENGTH);
curr_index = 0;
}
void shell_main_loop(char * prompt)
{
int8_t len;
uint8_t argc;
int8_t result;
const cmd_tbl_t * cmdtp;
char * argv[SHELL_MAX_ARGS]; /* NULL terminated */
for (;;)
{
len = readline(prompt);
if (len > 0)
{
if ((argc = parse_line (console_buffer, argv)) == 0)
{
continue;
}
cmdtp = shell_find_command(argv[0]);
if ((cmdtp != NULL) && (cmdtp->cmd != NULL))
{
if (argc > cmdtp->maxargs)
{
result = CMD_RET_USAGE;
}
else
{
result = (cmdtp->cmd)(argc, argv);
}
}
else
{
shell_printf("Unknown command '%s' - try 'help'\r\n", argv[0]);
}
if (result == CMD_RET_USAGE)
{
if (cmdtp->usage != NULL)
{
shell_printf("%s - %s\r\n", cmdtp->name, cmdtp->usage);
}
if (cmdtp->help != NULL)
{
shell_printf("Usage:\r\n%s ", cmdtp->name);
shell_printf("%s\r\n", cmdtp->help);
}
else
{
shell_printf ("- No additional help available.\r\n");
}
}
}
else if (len == -1)
{
shell_printf("<INTERRUPT>\r\n");
}
}
}
static void shell_cmd_callbacks(char *args, void *data)
{
unsigned char i, t = 0;
struct mavlink_callback *c = callbacks;
shell_printf("\n\nWidget callbacks:\n");
for (i = 0; i < nr_callbacks; i++) {
if ((c->cbk != NULL) && (c->type == CALLBACK_WIDGET)) {
printf(" sysid=%3d msgid=%3d cbk=%p data=%p\n", c->sysid, c->msgid, c->cbk, c->data);
t++;
}
c++;
}
shell_printf("\n\nPersistent callbacks:\n");
c = callbacks;
for (i = 0; i < nr_callbacks; i++) {
if ((c->cbk != NULL) && (c->type == CALLBACK_PERSISTENT)) {
printf(" sysid=%3d msgid=%3d cbk=%p data=%p\n", c->sysid, c->msgid, c->cbk, c->data);
t++;
}
c++;
}
shell_printf("\n\ntotal=%d peak=%d max=%d\n", t, nr_callbacks, MAX_MAVLINK_CALLBACKS);
}
static void shell_cmd_config(char *args, void *data)
{
struct ch_switch *cfg = &config.tab_sw;
struct shell_argval argval[SHELL_CMD_CONFIG_ARGS+1], *p;
unsigned char t, i;
unsigned int w;
t = shell_arg_parser(args, argval, SHELL_CMD_CONFIG_ARGS);
if (t < 1) {
shell_printf("Tab switch config:\n");
shell_printf(" Mode: %d (0:ch percent; 1:flight mode; 2:ch toggle)\n", cfg->mode);
shell_printf(" Ch: CH%d\n", cfg->ch + 1);
shell_printf(" Min: %d\n", cfg->ch_min);
shell_printf(" Max: %d\n", cfg->ch_max);
shell_printf(" Time: %d00ms\n", cfg->time);
shell_printf("\noptions: -m <mode> -c <ch> -l <min> -h <max> -t <time>\n");
} else {
p = shell_get_argval(argval, 'm');
if (p != NULL) {
i = atoi(p->val);
if (i < SW_MODE_END)
cfg->mode = i;
}
p = shell_get_argval(argval, 'c');
if (p != NULL) {
i = atoi(p->val);
i = TRIM(i, 0, 17);
cfg->ch = i;
}
p = shell_get_argval(argval, 'l');
if (p != NULL) {
w = atoi(p->val);
w = TRIM(w, 900, 2100);
cfg->ch_min = w;
}
p = shell_get_argval(argval, 'h');
if (p != NULL) {
w = atoi(p->val);
w = TRIM(w, 900, 2100);
cfg->ch_max = w;
}
p = shell_get_argval(argval, 't');
if (p != NULL) {
w = atoi(p->val);
w = w / 100;
cfg->time = w;
}
}
}
void SPI_ISR(void)
{
static uint8_t i = 1;
static uint16_t temp = 0;
if(i == 7)
{
SPI_ITDMAConfig(BOARD_SPI_INSTANCE, kSPI_IT_TCF, false);
shell_printf("ID:0x%X\r\n", temp);
return ;
}
if(i == 6)
{
temp <<= 8;
}
temp |= SPI_ReadWriteByte(BOARD_SPI_INSTANCE,HW_CTAR0, W25QXX_READ_ID_TABLE[i], 1, kSPI_PCS_KeepAsserted);
i++;
}
void settings_shell_display()
{
int ii;
for (ii = 0;
settings_display_list[ii].fmt != NULL;
ii++)
{
struct settings_display *disp = &settings_display_list[ii];
if (disp->type == FLOAT)
{
sprintf(update_message, disp->fmt, *((float *)disp->value));
}
else if (disp->type == UINT8)
{
sprintf(update_message, disp->fmt, *((uint8_t *)disp->value));
}
shell_printf("%s\t%s", disp->name, update_message);
}
}
static void shell_cmd_stats(char *args, void *data)
{
mavlink_status_t *status;
unsigned char i;
for (i = 0; i < MAVLINK_COMM_NUM_BUFFERS; i++) {
status = mavlink_get_channel_status(i);
shell_printf("\nMavlink channel %d\n", i);
shell_printf(" msg_received=%d\n", status->msg_received);
shell_printf(" packet_rx_drop_count=%d\n", status->packet_rx_drop_count);
shell_printf(" packet_rx_success_count=%d\n", status->packet_rx_success_count);
}
shell_printf("\nActive channel mask=%x\n", active_channel_mask);
shell_printf("\nUAV last seen %lums ago\n", get_millis() - uav_last_seen);
}
static void shell_cmd_stats(char *args, void *data)
{
switch (home.lock) {
default:
case HOME_NONE:
shell_printf("No home; UAV not armed\n");
break;
case HOME_WAIT:
shell_printf("Requesting WP0 (home)\n");
break;
case HOME_LOCKED:
shell_printf("Home GPS coords: lat=%.6f lon=%.6f\n", priv.home_coord.lat, priv.home_coord.lon);
shell_printf("Home M.S.L. altitude: %um\n\n", priv.home_altitude);
shell_printf("Relative altitude to home: %um\n", home.altitude);
shell_printf("Home direction: %d\n", home.direction);
shell_printf("Home distance: %.2fm\n", home.distance);
break;
}
}
void shell_cmd_rates(char *args, void *data)
{
struct shell_argval argval[SHELL_CMD_MAVRATE_ARGS+1], *p;
unsigned char t, i, val;
unsigned char *v;
t = shell_arg_parser(args, argval, SHELL_CMD_MAVRATE_ARGS);
p = shell_get_argval(argval, 's');
if ((t < 2) || (p == NULL)) {
shell_printf("\nMavlink stream rates:\n");
shell_printf("id - rate stream\n");
for (i = 0; i < sizeof(mavlink_stream_map)-1; i++) {
v = (unsigned char*) params_mavlink_rates[i].value;
shell_printf(" %u - [%2u] %s\n", i+1, *v,
params_mavlink_rates[i].name);
};
shell_printf("\nset rate: [-s <stream_id> -r <rate>]\n");
shell_printf(" -s <stream_id> mavlink stream id (0=ALL)\n");
shell_printf(" -r <rate> stream rate: 0-10\n");
} else {
if (p != NULL) {
i = atoi(p->val);
if (i > sizeof(mavlink_stream_map)) {
shell_printf("\nInvalid stream id\n");
} else {
p = shell_get_argval(argval, 'r');
val = atoi(p->val);
if (val > 10)
val = 0;
shell_printf("\nSetting stream id %u to %uHz\n", i, val);
mavlink_request_data_stream(i, val);
}
}
}
}
void ICACHE_FLASH_ATTR shell_process_char(char ch)
{
int8_t i, repeat;
// handle VT100 escape sequences
if (!_translate_escape_sequence(&ch))
return;
// basic command line editing
switch (ch)
{
case 0x03: // Ctrl-C
_reset_rx_buffer();
shell_puts("^C\r\n");
shell_show_prompt();
break;
case 0x08: // backspace ^H
if (ctx.rx_cursor_pos != 0) // not at the beginning?
{
if (ctx.rx_cursor_pos == ctx.rx_buffer_pos) // Cursor at the end?
{
--ctx.rx_buffer_pos;
--ctx.rx_cursor_pos;
ctx.rx_buffer[ctx.rx_buffer_pos] = '\0';
shell_puts("\x08 \x08"); // very tricky way of deleting last character from terminal
}
else // Cursor in the middle
{
repeat = 0;
--ctx.rx_cursor_pos;
shell_puts("\x1B[D"); // move left
for (i = ctx.rx_cursor_pos; i < ctx.rx_buffer_pos; ++i)
{
ctx.rx_buffer[i] = ctx.rx_buffer[i + 1];
if (ctx.rx_buffer[i]) // not NULL
shell_putc(ctx.rx_buffer[i]);
else
shell_putc(' ');
++repeat;
}
--ctx.rx_buffer_pos;
shell_printf("\x1B[%dD", repeat); // move cursor back to original cursor position
}
}
break;
case 0x04: // ^D
case 0x7F: // delete ^?
if (ctx.rx_cursor_pos < ctx.rx_buffer_pos) // delete does not happen when cursor is at the end
{
repeat = 0;
for (i = ctx.rx_cursor_pos; i < ctx.rx_buffer_pos; ++i)
{
ctx.rx_buffer[i] = ctx.rx_buffer[i + 1];
if (ctx.rx_buffer[i]) // not NULL
shell_putc(ctx.rx_buffer[i]);
else
shell_putc(' ');
++repeat;
}
--ctx.rx_buffer_pos;
shell_printf("\x1B[%dD", repeat); // move cursor back to original cursor position
}
break;
case 0x02: // left arrow ^B
if (ctx.rx_cursor_pos != 0) // Not at the beginning
{
--ctx.rx_cursor_pos;
shell_puts("\x1B[D"); // move left
}
break;
case 0x06: // right arrow ^F
if (ctx.rx_cursor_pos < ctx.rx_buffer_pos)
{
++ctx.rx_cursor_pos;
shell_puts("\x1B[C"); // move right
}
break;
case 0x01: // home ^A
if (ctx.rx_cursor_pos != 0)
{
shell_printf("\x1B[%dD", ctx.rx_cursor_pos); // move left
ctx.rx_cursor_pos = 0;
}
break;
case 0x05: // end ^E
if (ctx.rx_cursor_pos != ctx.rx_buffer_pos)
{
shell_printf("\x1B[%dC", ctx.rx_buffer_pos - ctx.rx_cursor_pos); // move right;
ctx.rx_cursor_pos = ctx.rx_buffer_pos;
}
break;
case '\n': // LF
case '\r': // CR
// If terminal sends CRLF, we have processed command during CR, LF can be ignored
if ((ctx.rx_buffer_pos == 0) && (ch == '\n'))
break;
shell_puts("\r\n"); // CRLF ending
if (ctx.rx_buffer_pos == 0) // if empty command
{
_reset_rx_buffer();
shell_show_prompt();
break;
}
if (ctx.busy)
{
// A previous command is being processed
// TODO: Reset if requested
// ignore other commands
_reset_rx_buffer();
}
else // not busy
{
memcpy(ctx.command_line, ctx.rx_buffer, ctx.rx_buffer_pos);
ctx.command_line[ctx.rx_buffer_pos] = '\0';
_reset_rx_buffer();
_execute_command();
}
break;
default:
if (ctx.rx_buffer_pos == SHELL_RX_BUFFER_SIZE) // overflow
{
shell_putc('\x07'); // BELL
return;
}
if ((ch >= 0x20) && (ch < 0x7F)) // visible char
{
if (ctx.rx_cursor_pos == ctx.rx_buffer_pos) // append at end
{
shell_putc(ch);
ctx.rx_buffer[ctx.rx_buffer_pos] = ch;
++ctx.rx_buffer_pos;
++ctx.rx_cursor_pos;
ctx.rx_buffer[ctx.rx_buffer_pos] = '\0'; // safer?
}
else // insert in the middle
{
repeat = ctx.rx_buffer_pos - ctx.rx_cursor_pos;
shell_printf("\x1B[%dC", repeat); // move right to end
i = ctx.rx_buffer_pos;
while (i != ctx.rx_cursor_pos - 1)
{
ctx.rx_buffer[i + 1] = ctx.rx_buffer[i];
if (ctx.rx_buffer[i])
{
shell_putc(ctx.rx_buffer[i]);
shell_puts("\x1B[2D"); // move left twice
}
--i;
}
shell_putc(ch);
ctx.rx_buffer[ctx.rx_cursor_pos] = ch;
++ctx.rx_buffer_pos;
++ctx.rx_cursor_pos;
ctx.rx_buffer[ctx.rx_buffer_pos] = '\0'; // safer?
}
}
else // unknown/unhandled character
{
shell_putc('\x07'); // BELL
}
}
}
static void KeyTest(void* pdat)
{
INT32U key = 0;
while (1)
{
switch (key = key_msg_get ())
{
case KEY_1_UP:
shell_printf ("KEY_1_UP\r\n");
break;
case KEY_1_DOWN:
shell_printf ("KEY_1_DOWN\r\n");
break;
case KEY_1_PUSH:
shell_printf ("KEY_1_PUSH\r\n");
break;
case KEY_1_DOUBLE:
shell_printf ("KEY_1_DOUBLE\r\n");
break;
case KEY_2_UP:
shell_printf ("KEY_2_UP\r\n");
break;
case KEY_2_DOWN:
shell_printf ("KEY_2_DOWN\r\n");
break;
case KEY_2_PUSH:
shell_printf ("KEY_2_PUSH\r\n");
break;
case KEY_2_DOUBLE:
shell_printf ("KEY_2_DOUBLE\r\n");
break;
case KEY_3_UP:
shell_printf ("KEY_3_UP\r\n");
break;
case KEY_3_DOWN:
shell_printf ("KEY_3_DOWN\r\n");
break;
case KEY_3_PUSH:
shell_printf ("KEY_3_PUSH\r\n");
break;
case KEY_3_DOUBLE:
shell_printf ("KEY_3_DOUBLE\r\n");
break;
case KEY_4_UP:
shell_printf ("KEY_4_UP\r\n");
break;
case KEY_4_DOWN:
shell_printf ("KEY_4_DOWN\r\n");
break;
case KEY_4_PUSH:
shell_printf ("KEY_4_PUSH\r\n");
break;
case KEY_4_DOUBLE:
shell_printf ("KEY_4_DOUBLE\r\n");
break;
case KEY_5_UP:
shell_printf ("KEY_5_UP\r\n");
break;
case KEY_5_DOWN:
shell_printf ("KEY_5_DOWN\r\n");
break;
case KEY_5_PUSH:
shell_printf ("KEY_5_PUSH\r\n");
break;
case KEY_5_DOUBLE:
shell_printf ("KEY_5_DOUBLE\r\n");
break;
case KEY_6_UP:
shell_printf ("KEY_6_UP\r\n");
break;
case KEY_6_DOWN:
shell_printf ("KEY_6_DOWN\r\n");
break;
case KEY_6_PUSH:
shell_printf ("KEY_6_PUSH\r\n");
break;
case KEY_6_DOUBLE:
shell_printf ("KEY_6_DOUBLE\r\n");
break;
case KEY_7_UP:
shell_printf ("KEY_7_UP\r\n");
break;
case KEY_7_DOWN:
shell_printf ("KEY_7_DOWN\r\n");
break;
case KEY_7_PUSH:
shell_printf ("KEY_7_PUSH\r\n");
break;
case KEY_7_DOUBLE:
shell_printf ("KEY_7_DOUBLE\r\n");
break;
case KEY_8_UP:
shell_printf ("KEY_8_UP\r\n");
break;
case KEY_8_DOWN:
shell_printf ("KEY_8_DOWN\r\n");
break;
case KEY_8_PUSH:
shell_printf ("KEY_8_PUSH\r\n");
break;
case KEY_8_DOUBLE:
shell_printf ("KEY_8_DOUBLE\r\n");
break;
case KEY_9_UP:
shell_printf ("KEY_9_UP\r\n");
break;
case KEY_9_DOWN:
shell_printf ("KEY_9_DOWN\r\n");
break;
case KEY_9_PUSH:
shell_printf ("KEY_9_PUSH\r\n");
break;
case KEY_9_DOUBLE:
shell_printf ("KEY_9_DOUBLE\r\n");
break;
case KEY_10_UP:
shell_printf ("KEY_10_UP\r\n");
break;
case KEY_10_DOWN:
shell_printf ("KEY_10_DOWN\r\n");
break;
case KEY_10_PUSH:
shell_printf ("KEY_10_PUSH\r\n");
break;
case KEY_10_DOUBLE:
shell_printf ("KEY_10_DOUBLE\r\n");
break;
case KEY_11_UP:
shell_printf ("KEY_11_UP\r\n");
break;
case KEY_11_DOWN:
shell_printf ("KEY_11_DOWN\r\n");
break;
case KEY_11_PUSH:
shell_printf ("KEY_11_PUSH\r\n");
break;
case KEY_11_DOUBLE:
shell_printf ("KEY_11_DOUBLE\r\n");
break;
case KEY_12_UP:
shell_printf ("KEY_12_UP\r\n");
break;
case KEY_12_DOWN:
shell_printf ("KEY_12_DOWN\r\n");
break;
case KEY_12_PUSH:
shell_printf ("KEY_12_PUSH\r\n");
break;
case KEY_12_DOUBLE:
shell_printf ("KEY_12_DOUBLE\r\n");
break;
case KEY_13_UP:
shell_printf ("KEY_13_UP\r\n");
break;
case KEY_13_DOWN:
shell_printf ("KEY_13_DOWN\r\n");
break;
case KEY_13_PUSH:
shell_printf ("KEY_13_PUSH\r\n");
break;
case KEY_13_DOUBLE:
shell_printf ("KEY_13_DOUBLE\r\n");
break;
case KEY_14_UP:
shell_printf ("KEY_14_UP\r\n");
break;
case KEY_14_DOWN:
shell_printf ("KEY_14_DOWN\r\n");
break;
case KEY_14_PUSH:
shell_printf ("KEY_14_PUSH\r\n");
break;
case KEY_14_DOUBLE:
shell_printf ("KEY_14_DOUBLE\r\n");
break;
case KEY_15_UP:
shell_printf ("KEY_15_UP\r\n");
break;
case KEY_15_DOWN:
shell_printf ("KEY_15_DOWN\r\n");
break;
case KEY_15_PUSH:
shell_printf ("KEY_15_PUSH\r\n");
break;
case KEY_15_DOUBLE:
shell_printf ("KEY_15_DOUBLE\r\n");
break;
case KEY_16_UP:
shell_printf ("KEY_16_UP\r\n");
break;
case KEY_16_DOWN:
shell_printf ("KEY_16_DOWN\r\n");
break;
case KEY_16_PUSH:
shell_printf ("KEY_16_PUSH\r\n");
break;
case KEY_16_DOUBLE:
shell_printf ("KEY_16_DOUBLE\r\n");
break;
case KEY_17_UP:
shell_printf ("KEY_17_UP\r\n");
break;
case KEY_17_DOWN:
shell_printf ("KEY_17_DOWN\r\n");
break;
case KEY_17_PUSH:
shell_printf ("KEY_17_PUSH\r\n");
break;
case KEY_17_DOUBLE:
shell_printf ("KEY_17_DOUBLE\r\n");
break;
case KEY_18_UP:
shell_printf ("KEY_18_UP\r\n");
break;
case KEY_18_DOWN:
shell_printf ("KEY_18_DOWN\r\n");
break;
case KEY_18_PUSH:
shell_printf ("KEY_18_PUSH\r\n");
break;
case KEY_18_DOUBLE:
shell_printf ("KEY_18_DOUBLE\r\n");
break;
case KEY_19_UP:
shell_printf ("KEY_19_UP\r\n");
break;
case KEY_19_DOWN:
shell_printf ("KEY_19_DOWN\r\n");
break;
case KEY_19_PUSH:
shell_printf ("KEY_19_PUSH\r\n");
break;
case KEY_19_DOUBLE:
shell_printf ("KEY_19_DOUBLE\r\n");
break;
case KEY_20_UP:
shell_printf ("KEY_20_UP\r\n");
break;
case KEY_20_DOWN:
shell_printf ("KEY_20_DOWN\r\n");
break;
case KEY_20_PUSH:
shell_printf ("KEY_20_PUSH\r\n");
break;
case KEY_20_DOUBLE:
shell_printf ("KEY_20_DOUBLE\r\n");
break;
case KEY_21_UP:
shell_printf ("KEY_21_UP\r\n");
break;
case KEY_21_DOWN:
shell_printf ("KEY_21_DOWN\r\n");
break;
case KEY_21_PUSH:
shell_printf ("KEY_21_PUSH\r\n");
break;
case KEY_21_DOUBLE:
shell_printf ("KEY_21_DOUBLE\r\n");
break;
case KEY_22_UP:
shell_printf ("KEY_22_UP\r\n");
break;
case KEY_22_DOWN:
shell_printf ("KEY_22_DOWN\r\n");
break;
case KEY_22_PUSH:
shell_printf ("KEY_22_PUSH\r\n");
break;
case KEY_22_DOUBLE:
shell_printf ("KEY_22_DOUBLE\r\n");
break;
case KEY_23_UP:
shell_printf ("KEY_23_UP\r\n");
break;
case KEY_23_DOWN:
shell_printf ("KEY_23_DOWN\r\n");
break;
case KEY_23_PUSH:
shell_printf ("KEY_23_PUSH\r\n");
break;
case KEY_23_DOUBLE:
shell_printf ("KEY_23_DOUBLE\r\n");
break;
case KEY_24_UP:
shell_printf ("KEY_24_UP\r\n");
break;
case KEY_24_DOWN:
shell_printf ("KEY_24_DOWN\r\n");
break;
case KEY_24_PUSH:
shell_printf ("KEY_24_PUSH\r\n");
break;
case KEY_24_DOUBLE:
shell_printf ("KEY_24_DOUBLE\r\n");
break;
case 0:
break;
default:
shell_printf ("Undefined key msg %X!\r\n", key);
break;
}
}
}
static void print_prompt() {
shell_printf(current_shell_state.active_handler->command);
shell_printf(">");
}
/*!
* @brief read line into buffer
*/
static int cread_line(const char * const prompt, char * buf, uint8_t * len)
{
uint8_t num = 0;
uint8_t eol_num = 0;
uint8_t wlen;
char ichar = 0;
uint8_t insert = 1;
uint8_t esc_len = 0;
char esc_save[8];
uint8_t init_len = strlen(buf);
if (init_len)
{
cread_add_str(buf, init_len, 1, &num, &eol_num, buf, *len);
}
while (1)
{
do
{
ichar = sgetc();
}while(!ichar);
if ((ichar == '\n') || (ichar == '\r'))
{
sputc('\r');sputc('\n');
break;
}
/* handle standard linux xterm esc sequences for arrow key, etc.*/
if (esc_len != 0)
{
if (esc_len == 1)
{
if (ichar == '[')
{
esc_save[esc_len] = ichar;
esc_len = 2;
}
else
{
cread_add_str(esc_save, esc_len, insert, &num, &eol_num, buf, *len);
esc_len = 0;
}
continue;
}
switch (ichar)
{
case 'D': /* <- key */
ichar = CTL_CH('b');
esc_len = 0;
break;
case 'C': /* -> key */
ichar = CTL_CH('f');
esc_len = 0;
break; /* pass off to ^F handler */
case 'H': /* Home key */
ichar = CTL_CH('a');
esc_len = 0;
break; /* pass off to ^A handler */
case 'A': /* up arrow */
ichar = CTL_CH('p');
esc_len = 0;
break; /* pass off to ^P handler */
case 'B': /* down arrow */
ichar = CTL_CH('n');
esc_len = 0;
break; /* pass off to ^N handler */
default:
esc_save[esc_len++] = ichar;
cread_add_str(esc_save, esc_len, insert,
&num, &eol_num, buf, *len);
esc_len = 0;
continue;
}
}
switch (ichar)
{
case 0x1b:
if (esc_len == 0)
{
esc_save[esc_len] = ichar;
esc_len = 1;
}
else
{
shell_printf("impossible condition #876\n");
esc_len = 0;
}
break;
case CTL_CH('a'):
BEGINNING_OF_LINE()
break;
case CTL_CH('c'): /* ^C - break */
*buf = '\0'; /* discard input */
return (-1);
//break; /* have to follow MISRA */
case CTL_CH('f'):
if (num < eol_num)
{
sputc(buf[num]);
num++;
}
break;
case CTL_CH('b'):
if (num)
{
sputc(CTL_BACKSPACE);
num--;
}
break;
case CTL_CH('d'):
if (num < eol_num)
{
wlen = eol_num - num - 1;
if (wlen)
{
memmove(&buf[num], &buf[num+1], wlen);
putnstr(buf + num, wlen);
}
sputc(' ');
do
{
sputc(CTL_BACKSPACE);
} while (wlen--);
eol_num--;
}
break;
case CTL_CH('k'):
ERASE_TO_EOL()
break;
case CTL_CH('e'):
REFRESH_TO_EOL()
break;
case CTL_CH('o'):
insert = !insert;
break;
case CTL_CH('x'):
case CTL_CH('u'):
BEGINNING_OF_LINE()
ERASE_TO_EOL()
break;
case DEL:
case DEL7:
case 8:
if (num)
{
wlen = eol_num - num;
num--;
memmove(&buf[num], &buf[num+1], wlen);
sputc(CTL_BACKSPACE);
putnstr(buf + num, wlen);
sputc(' ');
do
{
sputc(CTL_BACKSPACE);
} while (wlen--);
eol_num--;
}
break;
case CTL_CH('p'):
case CTL_CH('n'):
#ifdef SHELL_CONFIG_USE_HIST
{
char * hline;
esc_len = 0;
if (ichar == CTL_CH('p'))
{
hline = hist_prev();
}
else
{
hline = hist_next();
}
if (!hline)
{
shell_beep();
continue;
}
/* nuke the current line */
/* first, go home */
BEGINNING_OF_LINE()
ERASE_TO_EOL()
/* copy new line into place and display */
strcpy(buf, hline);
eol_num = strlen(buf);
REFRESH_TO_EOL()
continue;
//break; /* have to follow MISRA */
}
#else
{
continue;
}
#endif /* SHELL_CONFIG_USE_HIST */
case '\t':
#ifdef SHELL_CONFIG_AUTO_COMPLETE
{
uint8_t num2, col;
/* do not autocomplete when in the middle */
if (num < eol_num)
{
shell_beep();
break;
}
buf[num] = '\0';
col = strlen(prompt) + eol_num;
num2 = num;
if (cmd_auto_complete(prompt, buf, &num2, &col))
{
col = num2 - num;
num += col;
eol_num += col;
}
break;
}
#else
{
continue;
}
#endif /* SHELL_CONFIG_AUTO_COMPLETE */
default:
cread_add_char(ichar, insert, &num, &eol_num, buf, *len);
break;
}
}
*len = eol_num;
buf[eol_num] = '\0'; /* lose the newline */
#ifdef SHELL_CONFIG_USE_HIST
if ((buf[0]) && (buf[0] != CREAD_HIST_CHAR))
{
cread_add_to_hist(buf);
}
hist_cur = hist_add_idx;
#endif
return 0;
}
