*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
#include "ao.h"
#include "ao_task.h"
-__pdata uint16_t ao_cmd_lex_i;
-__pdata uint32_t ao_cmd_lex_u32;
-__pdata char ao_cmd_lex_c;
-__pdata enum ao_cmd_status ao_cmd_status;
+char ao_cmd_lex_c;
+enum ao_cmd_status ao_cmd_status;
+#ifndef AO_CMD_LEN
#if AO_PYRO_NUM
-#define CMD_LEN 128
+#define AO_CMD_LEN 128
#else
-#define CMD_LEN 48
+#define AO_CMD_LEN 48
+#endif
#endif
-static __xdata char cmd_line[CMD_LEN];
-static __pdata uint8_t cmd_len;
-static __pdata uint8_t cmd_i;
+static char cmd_line[AO_CMD_LEN];
+static uint8_t cmd_len;
+static uint8_t cmd_i;
void
-ao_put_string(__code char *s)
+ao_put_string(const char *s)
{
char c;
while ((c = *s++))
ao_put_string ("\010 \010");
}
-static void
-readline(void)
+void
+ao_cmd_readline(void)
{
char c;
if (ao_echo())
break;
}
- if (cmd_len >= CMD_LEN - 2)
+ if (cmd_len >= AO_CMD_LEN - 2)
continue;
cmd_line[cmd_len++] = c;
if (ao_echo())
cmd_i = 0;
}
-void
+char
ao_cmd_lex(void)
{
ao_cmd_lex_c = '\n';
if (cmd_i < cmd_len)
ao_cmd_lex_c = cmd_line[cmd_i++];
+ return ao_cmd_lex_c;
}
static void
return -1;
}
-void
-ao_cmd_hexbyte(void)
+static
+uint32_t
+_ao_cmd_hex(uint8_t lim)
{
+ uint32_t result = 0;
uint8_t i;
- int8_t n;
- ao_cmd_lex_i = 0;
ao_cmd_white();
- for (i = 0; i < 2; i++) {
- n = ao_cmd_hexchar(ao_cmd_lex_c);
+ for (i = 0; i < lim; i++) {
+ int8_t n = ao_cmd_hexchar(ao_cmd_lex_c);
if (n < 0) {
- ao_cmd_status = ao_cmd_syntax_error;
+ if (i == 0 || lim != 0xff)
+ ao_cmd_status = ao_cmd_lex_error;
break;
}
- ao_cmd_lex_i = (ao_cmd_lex_i << 4) | n;
+ result = (result << 4) | n;
ao_cmd_lex();
}
+ return result;
}
-void
-ao_cmd_hex(void)
+uint8_t
+ao_cmd_hexbyte(void)
{
- __pdata uint8_t r = ao_cmd_lex_error;
- int8_t n;
+ return _ao_cmd_hex(2);
+}
- ao_cmd_lex_i = 0;
- ao_cmd_white();
- for(;;) {
- n = ao_cmd_hexchar(ao_cmd_lex_c);
- if (n < 0)
- break;
- ao_cmd_lex_i = (ao_cmd_lex_i << 4) | n;
- r = ao_cmd_success;
- ao_cmd_lex();
- }
- if (r != ao_cmd_success)
- ao_cmd_status = r;
+uint32_t
+ao_cmd_hex(void)
+{
+ return _ao_cmd_hex(0xff);
}
-void
-ao_cmd_decimal(void) __reentrant
+uint32_t
+ao_cmd_decimal(void)
{
+ uint32_t result = 0;
uint8_t r = ao_cmd_lex_error;
- ao_cmd_lex_u32 = 0;
ao_cmd_white();
for(;;) {
if ('0' <= ao_cmd_lex_c && ao_cmd_lex_c <= '9')
- ao_cmd_lex_u32 = (ao_cmd_lex_u32 * 10) + (ao_cmd_lex_c - '0');
+ result = result * 10 + (ao_cmd_lex_c - '0');
else
break;
r = ao_cmd_success;
}
if (r != ao_cmd_success)
ao_cmd_status = r;
- ao_cmd_lex_i = (uint16_t) ao_cmd_lex_u32;
+ return result;
}
uint8_t
-ao_match_word(__code char *word)
+ao_match_word(const char *word)
{
while (*word) {
if (ao_cmd_lex_c != *word) {
static void
echo(void)
{
- ao_cmd_hex();
+ uint32_t v = ao_cmd_hex();
if (ao_cmd_status == ao_cmd_success)
- ao_stdios[ao_cur_stdio].echo = ao_cmd_lex_i != 0;
+ ao_stdios[ao_cur_stdio].echo = v != 0;
}
static void
, ao_flight_number
#endif
#if HAS_LOG
- , ao_log_format
+ , AO_LOG_FORMAT
#if !DISABLE_LOG_SPACE
, (unsigned long) ao_storage_log_max
#endif
#endif
#if defined(AO_BOOT_APPLICATION_BASE) && defined(AO_BOOT_APPLICATION_BOUND)
- , (uint32_t) AO_BOOT_APPLICATION_BOUND - (uint32_t) AO_BOOT_APPLICATION_BASE
+ , (unsigned) ((uint32_t) AO_BOOT_APPLICATION_BOUND - (uint32_t) AO_BOOT_APPLICATION_BASE)
#endif
);
printf("software-version %s\n", ao_version);
#define NUM_CMDS 11
#endif
-static __code struct ao_cmds *__xdata (ao_cmds[NUM_CMDS]);
-static __pdata uint8_t ao_ncmds;
+static const struct ao_cmds *(ao_cmds[NUM_CMDS]);
+static uint8_t ao_ncmds;
static void
help(void)
{
- __pdata uint8_t cmds;
- __pdata uint8_t cmd;
- __code struct ao_cmds * __pdata cs;
- __code const char *h;
+ uint8_t cmds;
+ uint8_t cmd;
+ const struct ao_cmds * cs;
+ const char *h;
uint8_t e;
for (cmds = 0; cmds < ao_ncmds; cmds++) {
switch(ao_cmd_status) {
case ao_cmd_lex_error:
case ao_cmd_syntax_error:
- puts("Syntax error");
+ ao_put_string("Syntax error\n");
ao_cmd_status = 0;
default:
break;
}
void
-ao_cmd_register(__code struct ao_cmds *cmds)
+ao_cmd_register(const struct ao_cmds *cmds)
{
if (ao_ncmds >= NUM_CMDS)
ao_panic(AO_PANIC_CMD);
void
ao_cmd(void)
{
- __pdata char c;
+ char c;
uint8_t cmd, cmds;
- __code struct ao_cmds * __xdata cs;
- void (*__xdata func)(void);
+ const struct ao_cmds * cs;
+ void (*func)(void);
for (;;) {
- readline();
+ ao_cmd_readline();
ao_cmd_lex();
ao_cmd_white();
c = ao_cmd_lex_c;
if (func)
break;
}
+#if HAS_MONITOR
+ ao_mutex_get(&ao_monitoring_mutex);
+#endif
if (func)
(*func)();
else
ao_cmd_status = ao_cmd_syntax_error;
report();
+#if HAS_MONITOR
+ ao_mutex_put(&ao_monitoring_mutex);
+#endif
}
}
}
#endif
-__xdata struct ao_task ao_cmd_task;
+#if HAS_TASK
+struct ao_task ao_cmd_task;
+#endif
-__code struct ao_cmds ao_base_cmds[] = {
+const struct ao_cmds ao_base_cmds[] = {
{ help, "?\0Help" },
-#if HAS_TASK_INFO
+#if HAS_TASK_INFO && HAS_TASK
{ ao_task_info, "T\0Tasks" },
#endif
{ echo, "E <0 off, 1 on>\0Echo" },
ao_cmd_init(void)
{
ao_cmd_register(&ao_base_cmds[0]);
+#if HAS_TASK
ao_add_task(&ao_cmd_task, ao_cmd, "cmd");
+#endif
}
projects / fw / altos / blobdiff