mirror of
https://github.com/portapack-mayhem/mayhem-firmware.git
synced 2024-12-04 23:45:26 +00:00
306 lines
8.9 KiB
C++
306 lines
8.9 KiB
C++
/*
|
|
ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
* @file shell.c
|
|
* @brief Simple CLI shell code.
|
|
*
|
|
* @addtogroup SHELL
|
|
* @{
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <cstring>
|
|
#include <ctype.h>
|
|
|
|
#include "ch.h"
|
|
#include "hal.h"
|
|
#include "shell.hpp"
|
|
#include "chprintf.h"
|
|
#include "portapack.hpp"
|
|
|
|
/**
|
|
* @brief Shell termination event source.
|
|
*/
|
|
EventSource shell_terminated;
|
|
|
|
static char* _strtok(char* str, const char* delim, char** saveptr) {
|
|
char* token;
|
|
if (str)
|
|
*saveptr = str;
|
|
token = *saveptr;
|
|
|
|
if (!token)
|
|
return NULL;
|
|
|
|
token += strspn(token, delim);
|
|
*saveptr = strpbrk(token, delim);
|
|
if (*saveptr)
|
|
*(*saveptr)++ = '\0';
|
|
|
|
return *token ? token : NULL;
|
|
}
|
|
|
|
static void usage(BaseSequentialStream* chp, char* p) {
|
|
chprintf(chp, "Usage: %s\r\n", p);
|
|
}
|
|
|
|
static void list_commands(BaseSequentialStream* chp, const ShellCommand* scp) {
|
|
while (scp->sc_name != NULL) {
|
|
chprintf(chp, "%s ", scp->sc_name);
|
|
scp++;
|
|
}
|
|
}
|
|
|
|
static void cmd_info(BaseSequentialStream* chp, int argc, char* argv[]) {
|
|
(void)argv;
|
|
if (argc > 0) {
|
|
usage(chp, const_cast<char*>("info"));
|
|
return;
|
|
}
|
|
|
|
chprintf(chp, "Kernel: %s\r\n", CH_KERNEL_VERSION);
|
|
#ifdef CH_COMPILER_NAME
|
|
chprintf(chp, "Compiler: %s\r\n", CH_COMPILER_NAME);
|
|
#endif
|
|
chprintf(chp, "Architecture: %s\r\n", CH_ARCHITECTURE_NAME);
|
|
#ifdef CH_CORE_VARIANT_NAME
|
|
chprintf(chp, "Core Variant: %s\r\n", CH_CORE_VARIANT_NAME);
|
|
#endif
|
|
#ifdef CH_PORT_INFO
|
|
chprintf(chp, "Port Info: %s\r\n", CH_PORT_INFO);
|
|
#endif
|
|
#ifdef PLATFORM_NAME
|
|
chprintf(chp, "Platform: %s\r\n", PLATFORM_NAME);
|
|
#endif
|
|
#ifdef BOARD_NAME
|
|
chprintf(chp, "Board: %s\r\n", BOARD_NAME);
|
|
#endif
|
|
#ifdef VERSION_STRING
|
|
chprintf(chp, "Mayhem Version: %s\r\n", VERSION_STRING);
|
|
#endif
|
|
chprintf(chp, "HackRF Board Rev: %s\r\n", hackrf_r9 ? "R9" : "R1-R8");
|
|
chprintf(chp, "Reference Source: %s\r\n", portapack::clock_manager.get_source().c_str());
|
|
chprintf(chp, "Reference Freq: %s\r\n", portapack::clock_manager.get_freq().c_str());
|
|
#ifdef __DATE__
|
|
#ifdef __TIME__
|
|
chprintf(chp, "Build time: %s%s%s\r\n", __DATE__, " - ", __TIME__);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
static void cmd_systime(BaseSequentialStream* chp, int argc, char* argv[]) {
|
|
(void)argv;
|
|
if (argc > 0) {
|
|
usage(chp, const_cast<char*>("systime"));
|
|
return;
|
|
}
|
|
chprintf(chp, "%lu\r\n", (unsigned long)chTimeNow());
|
|
}
|
|
|
|
/**
|
|
* @brief Array of the default commands.
|
|
*/
|
|
static ShellCommand local_commands[] = {
|
|
{"info", cmd_info},
|
|
{"systime", cmd_systime},
|
|
{NULL, NULL}};
|
|
|
|
static bool_t cmdexec(const ShellCommand* scp, BaseSequentialStream* chp, char* name, int argc, char* argv[]) {
|
|
while (scp->sc_name != NULL) {
|
|
if (strcmp(scp->sc_name, name) == 0) {
|
|
scp->sc_function(chp, argc, argv);
|
|
return FALSE;
|
|
}
|
|
scp++;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* @brief Shell thread function.
|
|
*
|
|
* @param[in] p pointer to a @p BaseSequentialStream object
|
|
* @return Termination reason.
|
|
* @retval RDY_OK terminated by command.
|
|
* @retval RDY_RESET terminated by reset condition on the I/O channel.
|
|
*
|
|
* @notapi
|
|
*/
|
|
static msg_t shell_thread(void* p) {
|
|
int n;
|
|
BaseSequentialStream* chp = ((ShellConfig*)p)->sc_channel;
|
|
const ShellCommand* scp = ((ShellConfig*)p)->sc_commands;
|
|
char *lp, *cmd, *tokp, line[SHELL_MAX_LINE_LENGTH];
|
|
char* args[SHELL_MAX_ARGUMENTS + 1];
|
|
|
|
chRegSetThreadName("shell");
|
|
chprintf(chp, "\r\nChibiOS/RT Shell\r\n");
|
|
while (TRUE) {
|
|
chprintf(chp, "ch> ");
|
|
if (shellGetLine(chp, line, sizeof(line))) {
|
|
chprintf(chp, "\r\nlogout");
|
|
break;
|
|
}
|
|
lp = _strtok(line, " \t", &tokp);
|
|
cmd = lp;
|
|
n = 0;
|
|
while ((lp = _strtok(NULL, " \t", &tokp)) != NULL) {
|
|
if (n >= SHELL_MAX_ARGUMENTS) {
|
|
chprintf(chp, "too many arguments\r\n");
|
|
cmd = NULL;
|
|
break;
|
|
}
|
|
args[n++] = lp;
|
|
}
|
|
args[n] = NULL;
|
|
if (cmd != NULL) {
|
|
if (strcmp(cmd, "exit") == 0) {
|
|
if (n > 0) {
|
|
usage(chp, const_cast<char*>("exit"));
|
|
continue;
|
|
}
|
|
break;
|
|
} else if (strcmp(cmd, "help") == 0) {
|
|
if (n > 0) {
|
|
usage(chp, const_cast<char*>("help"));
|
|
continue;
|
|
}
|
|
chprintf(chp, "Commands: help exit ");
|
|
list_commands(chp, local_commands);
|
|
if (scp != NULL)
|
|
list_commands(chp, scp);
|
|
chprintf(chp, "\r\n");
|
|
} else if (cmdexec(local_commands, chp, cmd, n, args) &&
|
|
((scp == NULL) || cmdexec(scp, chp, cmd, n, args))) {
|
|
chprintf(chp, "%s", cmd);
|
|
chprintf(chp, " ?\r\n");
|
|
}
|
|
}
|
|
}
|
|
shellExit(RDY_OK);
|
|
/* Never executed, silencing a warning.*/
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Shell manager initialization.
|
|
*
|
|
* @api
|
|
*/
|
|
void shellInit(void) {
|
|
chEvtInit(&shell_terminated);
|
|
}
|
|
|
|
/**
|
|
* @brief Terminates the shell.
|
|
* @note Must be invoked from the command handlers.
|
|
* @note Does not return.
|
|
*
|
|
* @param[in] msg shell exit code
|
|
*
|
|
* @api
|
|
*/
|
|
void shellExit(msg_t msg) {
|
|
/* Atomically broadcasting the event source and terminating the thread,
|
|
there is not a chSysUnlock() because the thread terminates upon return.*/
|
|
chSysLock();
|
|
chEvtBroadcastI(&shell_terminated);
|
|
chThdExitS(msg);
|
|
}
|
|
|
|
/**
|
|
* @brief Spawns a new shell.
|
|
* @pre @p CH_USE_HEAP and @p CH_USE_DYNAMIC must be enabled.
|
|
*
|
|
* @param[in] scp pointer to a @p ShellConfig object
|
|
* @param[in] size size of the shell working area to be allocated
|
|
* @param[in] prio priority level for the new shell
|
|
* @return A pointer to the shell thread.
|
|
* @retval NULL thread creation failed because memory allocation.
|
|
*
|
|
* @api
|
|
*/
|
|
#if CH_USE_HEAP && CH_USE_DYNAMIC
|
|
Thread* shellCreate(const ShellConfig* scp, size_t size, tprio_t prio) {
|
|
return chThdCreateFromHeap(NULL, size, prio, shell_thread, (void*)scp);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Create statically allocated shell thread.
|
|
*
|
|
* @param[in] scp pointer to a @p ShellConfig object
|
|
* @param[in] wsp pointer to a working area dedicated to the shell thread stack
|
|
* @param[in] size size of the shell working area
|
|
* @param[in] prio priority level for the new shell
|
|
* @return A pointer to the shell thread.
|
|
*
|
|
* @api
|
|
*/
|
|
Thread* shellCreateStatic(const ShellConfig* scp, void* wsp, size_t size, tprio_t prio) {
|
|
return chThdCreateStatic(wsp, size, prio, shell_thread, (void*)scp);
|
|
}
|
|
|
|
/**
|
|
* @brief Reads a whole line from the input channel.
|
|
*
|
|
* @param[in] chp pointer to a @p BaseSequentialStream object
|
|
* @param[in] line pointer to the line buffer
|
|
* @param[in] size buffer maximum length
|
|
* @return The operation status.
|
|
* @retval TRUE the channel was reset or CTRL-D pressed.
|
|
* @retval FALSE operation successful.
|
|
*
|
|
* @api
|
|
*/
|
|
bool_t shellGetLine(BaseSequentialStream* chp, char* line, unsigned size) {
|
|
char* p = line;
|
|
|
|
while (TRUE) {
|
|
char c;
|
|
|
|
if (chSequentialStreamRead(chp, (uint8_t*)&c, 1) == 0)
|
|
return TRUE;
|
|
if (c == 4) {
|
|
chprintf(chp, "^D");
|
|
return TRUE;
|
|
}
|
|
if ((c == 8) || (c == 127)) {
|
|
if (p != line) {
|
|
chSequentialStreamPut(chp, c);
|
|
chSequentialStreamPut(chp, 0x20);
|
|
chSequentialStreamPut(chp, c);
|
|
p--;
|
|
}
|
|
continue;
|
|
}
|
|
if (c == '\r') {
|
|
chprintf(chp, "\r\n");
|
|
*p = 0;
|
|
return FALSE;
|
|
}
|
|
if (c < 0x20)
|
|
continue;
|
|
if (p < line + size - 1) {
|
|
chSequentialStreamPut(chp, c);
|
|
*p++ = (char)c;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** @} */
|