#include "rc_proto.h"
#include "main.h"
#include "cmdline.h"
+#include "beep.h"
+#include "eeprom_config.h"
/* commands_gen.c */
extern const parse_inst_t PROGMEM cmd_reset;
},
};
+
+/**********************************************************/
+
+/* this structure is filled when cmd_beep is parsed successfully */
+struct cmd_beep_result {
+ fixed_string_t beep;
+};
+
+/* function called when cmd_beep is parsed successfully */
+static void cmd_beep_parsed(void *parsed_result, void *data)
+{
+ (void)parsed_result;
+ (void)data;
+
+ beep(0, 3, 3);
+ beep(1, 3, 3);
+ beep(2, 3, 3);
+ beep(0, 1, 1);
+ beep(1, 1, 1);
+ beep(2, 1, 1);
+}
+
+const char PROGMEM str_beep[] = "beep";
+const parse_token_string_t PROGMEM cmd_beep_beep =
+ TOKEN_STRING_INITIALIZER(struct cmd_beep_result, beep,
+ str_beep);
+
+const char PROGMEM help_beep[] = "Send a beep";
+
+const parse_inst_t PROGMEM cmd_beep = {
+ .f = cmd_beep_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_beep,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_beep_beep,
+ NULL,
+ },
+};
+
+/**********************************************************/
+
+/* this structure is filled when cmd_servo is parsed successfully */
+struct cmd_servo_result {
+ fixed_string_t arg0;
+ fixed_string_t arg1;
+ uint16_t num;
+ uint16_t val;
+};
+
+/* function called when cmd_servo is parsed successfully */
+static void cmd_servo_parsed(void * parsed_result, void *data)
+{
+ struct cmd_servo_result *res = parsed_result;
+
+ (void)data;
+
+ if (!strcmp_P(res->arg1, PSTR("set"))) {
+ if (res->num >= N_SERVO) {
+ printf_P(PSTR("bad servo num\n"));
+ return;
+ }
+ if (res->val >= 1024) {
+ printf_P(PSTR("bad servo val\n"));
+ return;
+ }
+ spi_servo_set(res->num, res->val);
+ }
+ else if (!strcmp_P(res->arg1, PSTR("bypass"))) {
+ spi_servo_set_bypass(!!res->val);
+ }
+ else if (!strcmp_P(res->arg1, PSTR("ppm"))) {
+ spi_servo_set_ppm(!!res->val);
+ }
+ else if (!strcmp_P(res->arg1, PSTR("show"))) {
+ spi_servo_dump();
+ }
+}
+
+const char PROGMEM str_servo_arg0[] = "servo";
+const parse_token_string_t PROGMEM cmd_servo_arg0 =
+ TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg0,
+ str_servo_arg0);
+const char PROGMEM str_servo_arg1_set[] = "set";
+const parse_token_string_t PROGMEM cmd_servo_arg1_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1,
+ str_servo_arg1_set);
+const parse_token_num_t PROGMEM cmd_servo_num =
+ TOKEN_NUM_INITIALIZER(struct cmd_servo_result, num,
+ UINT16);
+const parse_token_num_t PROGMEM cmd_servo_val =
+ TOKEN_NUM_INITIALIZER(struct cmd_servo_result, val,
+ UINT16);
+
+const char PROGMEM help_servo_set[] = "set servo value";
+const parse_inst_t PROGMEM cmd_servo_set = {
+ .f = cmd_servo_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_servo_set,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_servo_arg0,
+ (PGM_P)&cmd_servo_arg1_set,
+ (PGM_P)&cmd_servo_num,
+ (PGM_P)&cmd_servo_val,
+ NULL,
+ },
+};
+
+const char PROGMEM str_servo_arg1_show[] = "show";
+const parse_token_string_t PROGMEM cmd_servo_arg1_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1,
+ str_servo_arg1_show);
+
+const char PROGMEM help_servo_show[] = "read servo and config";
+const parse_inst_t PROGMEM cmd_servo_show = {
+ .f = cmd_servo_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_servo_show,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_servo_arg0,
+ (PGM_P)&cmd_servo_arg1_show,
+ NULL,
+ },
+};
+
+const char PROGMEM str_servo_arg1_bypassppm[] = "bypass#ppm";
+const parse_token_string_t PROGMEM cmd_servo_arg1_bypassppm =
+ TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1,
+ str_servo_arg1_bypassppm);
+
+const char PROGMEM help_servo_bypassppm[] = "change bypass/ppm";
+const parse_inst_t PROGMEM cmd_servo_bypassppm = {
+ .f = cmd_servo_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_servo_bypassppm,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_servo_arg0,
+ (PGM_P)&cmd_servo_arg1_bypassppm,
+ (PGM_P)&cmd_servo_val,
+ NULL,
+ },
+};
+
+/**********************************************************/
+
/* this structure is filled when cmd_test_spi is parsed successfully */
struct cmd_test_spi_result {
fixed_string_t arg0;
static void cmd_test_spi_parsed(void * parsed_result, void *data)
{
- int i;
+ uint8_t i, flags, wait_time = 0;
+ uint16_t val = 0;
(void)parsed_result;
(void)data;
- while (1) {
- for (i = 0; i < 50; i++) {
- spi_servo_set(0, 0);
- wait_ms(100);
- spi_servo_set(0, 500);
- wait_ms(100);
+ spi_servo_set_bypass(0);
+ spi_servo_set_ppm(0);
+
+ /* stress test: send many commands, no wait between each servo
+ * of a series, and a variable delay between series */
+ printf_P(PSTR("stress test\r\n"));
+ while (!cmdline_keypressed()) {
+
+ wait_time++;
+ if (wait_time > 20)
+ wait_time = 0;
+
+ IRQ_LOCK(flags);
+ val = global_ms;
+ IRQ_UNLOCK(flags);
+ val >>= 3;
+ val &= 1023;
+
+ for (i = 0; i < 6; i++)
+ spi_servo_set(i, val);
+
+ wait_ms(wait_time);
+ printf_P(PSTR("%4.4d %4.4d %4.4d %4.4d %4.4d %4.4d\r\n"),
+ spi_servo_get(0), spi_servo_get(1), spi_servo_get(2),
+ spi_servo_get(3), spi_servo_get(4), spi_servo_get(5));
+ }
+
+ printf_P(PSTR("bypass mode, with spi commands in background\r\n"));
+ spi_servo_set_bypass(1);
+
+ /* test bypass mode */
+ while (!cmdline_keypressed()) {
+
+ wait_time++;
+ if (wait_time > 20)
+ wait_time = 0;
+
+ IRQ_LOCK(flags);
+ val = global_ms;
+ IRQ_UNLOCK(flags);
+ val >>= 3;
+ val &= 1023;
+
+ for (i = 0; i < 6; i++)
+ spi_servo_set(i, val);
+
+ wait_ms(wait_time);
+ printf_P(PSTR("%4.4d %4.4d %4.4d %4.4d %4.4d %4.4d\r\n"),
+ spi_servo_get(0), spi_servo_get(1), spi_servo_get(2),
+ spi_servo_get(3), spi_servo_get(4), spi_servo_get(5));
+ }
+
+ printf_P(PSTR("PPM to servo\r\n"));
+ spi_servo_set_bypass(0);
+ spi_servo_set_ppm(0);
+
+ /* test PPM to servo (bypass) mode */
+ while (!cmdline_keypressed()) {
+ for (i = 0; i < 6; i++) {
+ val = spi_servo_get(i);
+ spi_servo_set(i, val);
}
+ }
+
+ printf_P(PSTR("PPM to (servo + PPM)\r\n"));
+ spi_servo_set_bypass(0);
+ spi_servo_set_ppm(1);
- spi_servo_bypass(1);
- wait_ms(10000);
- spi_servo_bypass(0);
- wait_ms(1);
+ /* test PPM to servo (bypass) mode */
+ while (!cmdline_keypressed()) {
+ for (i = 0; i < 6; i++) {
+ val = spi_servo_get(i);
+ spi_servo_set(i, val);
+ }
}
}
},
};
+/**********************************************************/
+
+/* this structure is filled when cmd_test_eeprom_config is parsed successfully */
+struct cmd_test_eeprom_config_result {
+ fixed_string_t arg0;
+};
+
+static void cmd_test_eeprom_config_parsed(void *parsed_result, void *data)
+{
+ (void)parsed_result;
+ (void)data;
+
+ eeprom_dump_cmds();
+ eeprom_append_cmd("salut1\n");
+ eeprom_dump_cmds();
+ eeprom_append_cmd("salut2\n");
+ eeprom_append_cmd("salut3\n");
+ eeprom_append_cmd("salut4\n");
+ eeprom_dump_cmds();
+ eeprom_insert_cmd_before("coin\n", 0);
+ eeprom_insert_cmd_before("coin2\n", 2);
+ eeprom_dump_cmds();
+ eeprom_delete_cmd(2);
+ eeprom_delete_cmd(0);
+ eeprom_dump_cmds();
+}
+
+const char PROGMEM str_test_eeprom_config_arg0[] = "test_eeprom_config";
+const parse_token_string_t PROGMEM cmd_test_eeprom_config_arg0 =
+ TOKEN_STRING_INITIALIZER(struct cmd_test_eeprom_config_result, arg0,
+ str_test_eeprom_config_arg0);
+
+const char PROGMEM help_test_eeprom_config[] = "Test the eeprom configuration";
+const parse_inst_t PROGMEM cmd_test_eeprom_config = {
+ .f = cmd_test_eeprom_config_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_test_eeprom_config,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_test_eeprom_config_arg0,
+ NULL,
+ },
+};
+
+/* ************* */
+
+struct cmd_eeprom_del_result {
+ fixed_string_t cmd;
+ fixed_string_t action;
+ uint8_t n;
+};
+
+static void cmd_eeprom_del_parsed(void *parsed_result,
+ void *data)
+{
+ struct cmd_eeprom_del_result *res = parsed_result;
+
+ (void)data;
+ if (eeprom_delete_cmd(res->n) < 0)
+ printf_P(PSTR("cannot delete command\n"));
+ eeprom_dump_cmds();
+}
+
+const char PROGMEM str_eeprom_del_eeprom[] = "eeprom";
+const parse_token_string_t PROGMEM cmd_eeprom_del_cmd =
+ TOKEN_STRING_INITIALIZER(struct cmd_eeprom_del_result, cmd,
+ str_eeprom_del_eeprom);
+const char PROGMEM str_eeprom_del_del[] = "del";
+const parse_token_string_t PROGMEM cmd_eeprom_del_action =
+ TOKEN_STRING_INITIALIZER(struct cmd_eeprom_del_result, action,
+ str_eeprom_del_del);
+const parse_token_num_t PROGMEM cmd_eeprom_del_num =
+ TOKEN_NUM_INITIALIZER(struct cmd_eeprom_del_result, n,
+ UINT8);
+
+const char PROGMEM help_eeprom_del[] = "delete an eeprom init command";
+const parse_inst_t PROGMEM cmd_eeprom_del = {
+ .f = cmd_eeprom_del_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_eeprom_del,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_eeprom_del_cmd,
+ (PGM_P)&cmd_eeprom_del_action,
+ (PGM_P)&cmd_eeprom_del_num,
+ NULL,
+ },
+};
+
+/* ************* */
+
+struct cmd_eeprom_add_result {
+ fixed_string_t cmd;
+ fixed_string_t action;
+ uint8_t n;
+};
+
+static void cmd_eeprom_add_parsed(void *parsed_result,
+ void *data)
+{
+ struct cmd_eeprom_add_result *res = parsed_result;
+ struct rdline rdl;
+ const char *buffer;
+ int8_t ret;
+ int16_t c;
+
+ rdline_init(&rdl, cmdline_write_char, NULL, NULL);
+ rdline_newline(&rdl, "> ");
+
+ /* XXX bad: we should not block as we do not serve callout */
+ while (1) {
+ c = cmdline_dev_recv(NULL);
+ if (c < 0)
+ continue;
+
+ ret = rdline_char_in(&rdl, c);
+ if (ret == -2) {
+ printf_P(PSTR("abort\n"));
+ return;
+ }
+ if (ret == 1)
+ break;
+ }
+
+ buffer = rdline_get_buffer(&rdl);
+ if (data == NULL)
+ eeprom_insert_cmd_before(buffer, res->n);
+ else
+ eeprom_append_cmd(buffer);
+ eeprom_dump_cmds();
+}
+
+const char PROGMEM str_eeprom_add_eeprom[] = "eeprom";
+const parse_token_string_t PROGMEM cmd_eeprom_add_cmd =
+ TOKEN_STRING_INITIALIZER(struct cmd_eeprom_add_result, cmd,
+ str_eeprom_add_eeprom);
+const char PROGMEM str_eeprom_add_add[] = "add";
+const parse_token_string_t PROGMEM cmd_eeprom_add_action =
+ TOKEN_STRING_INITIALIZER(struct cmd_eeprom_add_result, action,
+ str_eeprom_add_add);
+const parse_token_num_t PROGMEM cmd_eeprom_add_num =
+ TOKEN_NUM_INITIALIZER(struct cmd_eeprom_add_result, n,
+ UINT8);
+
+const char PROGMEM help_eeprom_add[] = "insert an eeprom init command";
+const parse_inst_t PROGMEM cmd_eeprom_add = {
+ .f = cmd_eeprom_add_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_eeprom_add,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_eeprom_add_cmd,
+ (PGM_P)&cmd_eeprom_add_action,
+ (PGM_P)&cmd_eeprom_add_num,
+ NULL,
+ },
+};
+
+const char PROGMEM help_eeprom_add2[] = "append an eeprom init command";
+const parse_inst_t PROGMEM cmd_eeprom_add2 = {
+ .f = cmd_eeprom_add_parsed, /* function to call */
+ .data = (void *)1, /* 2nd arg of func */
+ .help_str = help_eeprom_add2,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_eeprom_add_cmd,
+ (PGM_P)&cmd_eeprom_add_action,
+ NULL,
+ },
+};
+
+/* ************* */
+
+struct cmd_eeprom_list_result {
+ fixed_string_t cmd;
+ fixed_string_t action;
+};
+
+static void cmd_eeprom_list_parsed(void *parsed_result,
+ void *data)
+{
+ (void)parsed_result;
+ (void)data;
+ eeprom_dump_cmds();
+}
+
+const char PROGMEM str_eeprom_list_eeprom[] = "eeprom";
+const parse_token_string_t PROGMEM cmd_eeprom_list_cmd =
+ TOKEN_STRING_INITIALIZER(struct cmd_eeprom_list_result, cmd,
+ str_eeprom_list_eeprom);
+const char PROGMEM str_eeprom_list_list[] = "list";
+const parse_token_string_t PROGMEM cmd_eeprom_list_action =
+ TOKEN_STRING_INITIALIZER(struct cmd_eeprom_list_result, action,
+ str_eeprom_list_list);
+
+const char PROGMEM help_eeprom_list[] = "list all eeprom init commands";
+const parse_inst_t PROGMEM cmd_eeprom_list = {
+ .f = cmd_eeprom_list_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_eeprom_list,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_eeprom_list_cmd,
+ (PGM_P)&cmd_eeprom_list_action,
+ NULL,
+ },
+};
+
+
+/* ************* */
+
/* in progmem */
const parse_ctx_t PROGMEM main_ctx[] = {
&cmd_dump,
&cmd_debug,
&cmd_baudrate,
+ &cmd_beep,
+ &cmd_servo_set,
+ &cmd_servo_bypassppm,
+ &cmd_servo_show,
&cmd_test_spi,
+ &cmd_test_eeprom_config,
+ &cmd_eeprom_del,
+ &cmd_eeprom_add,
+ &cmd_eeprom_add2,
+ &cmd_eeprom_list,
NULL,
};
git.droids-corp.org / protos / xbee-avr.git / blobdiff