#include <parse_num.h>
#include "main.h"
+#include "state.h"
#include "cmdline.h"
#include "../common/i2c_commands.h"
#include "i2c_protocol.h"
};
+/**********************************************************/
+/* State1 */
+
+/* this structure is filled when cmd_state1 is parsed successfully */
+struct cmd_state1_result {
+ fixed_string_t arg0;
+ fixed_string_t arg1;
+};
+
+/* function called when cmd_state1 is parsed successfully */
+static void cmd_state1_parsed(void *parsed_result,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_state1_result *res = parsed_result;
+
+ if (!strcmp_P(res->arg1, PSTR("init")))
+ state_init();
+ else if (!strcmp_P(res->arg1, PSTR("off")))
+ state_set_mode(I2C_BALLBOARD_MODE_OFF);
+ else if (!strcmp_P(res->arg1, PSTR("eject")))
+ state_set_mode(I2C_BALLBOARD_MODE_EJECT);
+ else if (!strcmp_P(res->arg1, PSTR("harvest")))
+ state_set_mode(I2C_BALLBOARD_MODE_HARVEST);
+
+ /* other commands */
+}
+
+prog_char str_state1_arg0[] = "ballboard";
+parse_pgm_token_string_t cmd_state1_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_state1_result, arg0, str_state1_arg0);
+prog_char str_state1_arg1[] = "init#eject#harvest#off";
+parse_pgm_token_string_t cmd_state1_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_state1_result, arg1, str_state1_arg1);
+
+prog_char help_state1[] = "set ballboard mode";
+parse_pgm_inst_t cmd_state1 = {
+ .f = cmd_state1_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_state1,
+ .tokens = { /* token list, NULL terminated */
+ (prog_void *)&cmd_state1_arg0,
+ (prog_void *)&cmd_state1_arg1,
+ NULL,
+ },
+};
+
+/**********************************************************/
+/* State2 */
+
+/* this structure is filled when cmd_state2 is parsed successfully */
+struct cmd_state2_result {
+ fixed_string_t arg0;
+ fixed_string_t arg1;
+ fixed_string_t arg2;
+};
+
+/* function called when cmd_state2 is parsed successfully */
+static void cmd_state2_parsed(void *parsed_result,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_state2_result *res = parsed_result;
+ uint8_t mode;
+
+ if (!strcmp_P(res->arg2, PSTR("left"))) {
+ if (!strcmp_P(res->arg1, PSTR("prepare")))
+ mode = I2C_BALLBOARD_MODE_PREP_L_FORK;
+ else if (!strcmp_P(res->arg1, PSTR("take")))
+ mode = I2C_BALLBOARD_MODE_TAKE_L_FORK;
+ }
+ else {
+ if (!strcmp_P(res->arg1, PSTR("prepare")))
+ mode = I2C_BALLBOARD_MODE_PREP_R_FORK;
+ else if (!strcmp_P(res->arg1, PSTR("take")))
+ mode = I2C_BALLBOARD_MODE_TAKE_R_FORK;
+ }
+ //state_set_mode(mode);
+}
+
+prog_char str_state2_arg0[] = "ballboard";
+parse_pgm_token_string_t cmd_state2_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_state2_result, arg0, str_state2_arg0);
+prog_char str_state2_arg1[] = "prepare#take";
+parse_pgm_token_string_t cmd_state2_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_state2_result, arg1, str_state2_arg1);
+prog_char str_state2_arg2[] = "left#right";
+parse_pgm_token_string_t cmd_state2_arg2 = TOKEN_STRING_INITIALIZER(struct cmd_state2_result, arg2, str_state2_arg2);
+
+prog_char help_state2[] = "set ballboard mode";
+parse_pgm_inst_t cmd_state2 = {
+ .f = cmd_state2_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_state2,
+ .tokens = { /* token list, NULL terminated */
+ (prog_void *)&cmd_state2_arg0,
+ (prog_void *)&cmd_state2_arg1,
+ (prog_void *)&cmd_state2_arg2,
+ NULL,
+ },
+};
+
+/**********************************************************/
+/* State3 */
+
+/* this structure is filled when cmd_state3 is parsed successfully */
+struct cmd_state3_result {
+ fixed_string_t arg0;
+ fixed_string_t arg1;
+ uint8_t arg2;
+};
+
+/* function called when cmd_state3 is parsed successfully */
+static void cmd_state3_parsed(void *parsed_result,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_state3_result *res = parsed_result;
+
+ if (!strcmp_P(res->arg1, PSTR("xxx"))) {
+ /* xxx = res->arg2 */
+ }
+ else if (!strcmp_P(res->arg1, PSTR("yyy"))) {
+ }
+ state_set_mode(0);
+}
+
+prog_char str_state3_arg0[] = "ballboard";
+parse_pgm_token_string_t cmd_state3_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_state3_result, arg0, str_state3_arg0);
+prog_char str_state3_arg1[] = "xxx";
+parse_pgm_token_string_t cmd_state3_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_state3_result, arg1, str_state3_arg1);
+parse_pgm_token_num_t cmd_state3_arg2 = TOKEN_NUM_INITIALIZER(struct cmd_state3_result, arg2, UINT8);
+
+prog_char help_state3[] = "set ballboard mode";
+parse_pgm_inst_t cmd_state3 = {
+ .f = cmd_state3_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_state3,
+ .tokens = { /* token list, NULL terminated */
+ (prog_void *)&cmd_state3_arg0,
+ (prog_void *)&cmd_state3_arg1,
+ (prog_void *)&cmd_state3_arg2,
+ NULL,
+ },
+};
+
+/**********************************************************/
+/* State_Machine */
+
+/* this structure is filled when cmd_state_machine is parsed successfully */
+struct cmd_state_machine_result {
+ fixed_string_t arg0;
+};
+
+/* function called when cmd_state_machine is parsed successfully */
+static void cmd_state_machine_parsed(__attribute__((unused)) void *parsed_result,
+ __attribute__((unused)) void *data)
+{
+ state_machine();
+}
+
+prog_char str_state_machine_arg0[] = "state_machine";
+parse_pgm_token_string_t cmd_state_machine_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_state_machine_result, arg0, str_state_machine_arg0);
+
+prog_char help_state_machine[] = "launch state machine";
+parse_pgm_inst_t cmd_state_machine = {
+ .f = cmd_state_machine_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_state_machine,
+ .tokens = { /* token list, NULL terminated */
+ (prog_void *)&cmd_state_machine_arg0,
+ NULL,
+ },
+};
+
+/**********************************************************/
+/* State_Debug */
+
+/* this structure is filled when cmd_state_debug is parsed successfully */
+struct cmd_state_debug_result {
+ fixed_string_t arg0;
+ uint8_t on;
+};
+
+/* function called when cmd_state_debug is parsed successfully */
+static void cmd_state_debug_parsed(void *parsed_result,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_state_debug_result *res = parsed_result;
+ state_debug = res->on;
+}
+
+prog_char str_state_debug_arg0[] = "state_debug";
+parse_pgm_token_string_t cmd_state_debug_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_state_debug_result, arg0, str_state_debug_arg0);
+parse_pgm_token_num_t cmd_state_debug_on = TOKEN_NUM_INITIALIZER(struct cmd_state_debug_result, on, UINT8);
+
+prog_char help_state_debug[] = "Set debug for state machine";
+parse_pgm_inst_t cmd_state_debug = {
+ .f = cmd_state_debug_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_state_debug,
+ .tokens = { /* token list, NULL terminated */
+ (prog_void *)&cmd_state_debug_arg0,
+ (prog_void *)&cmd_state_debug_on,
+ NULL,
+ },
+};
+
+/**********************************************************/
+/* Fork */
+
+/* this structure is filled when cmd_fork is parsed successfully */
+struct cmd_fork_result {
+ fixed_string_t arg0;
+ fixed_string_t arg1;
+};
+
+/* function called when cmd_fork is parsed successfully */
+static void cmd_fork_parsed(void *parsed_result,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_fork_result *res = parsed_result;
+ if (!strcmp_P(res->arg1, PSTR("deploy")))
+ fork_deploy();
+ else if (!strcmp_P(res->arg1, PSTR("pack")))
+ fork_pack();
+ else if (!strcmp_P(res->arg1, PSTR("left")))
+ fork_left();
+ else if (!strcmp_P(res->arg1, PSTR("right")))
+ fork_right();
+ else if (!strcmp_P(res->arg1, PSTR("middle")))
+ fork_middle();
+}
+
+prog_char str_fork_arg0[] = "fork";
+parse_pgm_token_string_t cmd_fork_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_fork_result, arg0, str_fork_arg0);
+prog_char str_fork_arg1[] = "deploy#pack#left#right#middle";
+parse_pgm_token_string_t cmd_fork_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_fork_result, arg1, str_fork_arg1);
+
+prog_char help_fork[] = "move fork";
+parse_pgm_inst_t cmd_fork = {
+ .f = cmd_fork_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_fork,
+ .tokens = { /* token list, NULL terminated */
+ (prog_void *)&cmd_fork_arg0,
+ (prog_void *)&cmd_fork_arg1,
+ NULL,
+ },
+};
+
+/**********************************************************/
+/* Roller */
+
+/* this structure is filled when cmd_roller is parsed successfully */
+struct cmd_roller_result {
+ fixed_string_t arg0;
+ fixed_string_t arg1;
+};
+
+/* function called when cmd_roller is parsed successfully */
+static void cmd_roller_parsed(void *parsed_result,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_roller_result *res = parsed_result;
+ if (!strcmp_P(res->arg1, PSTR("on")))
+ roller_on();
+ else if (!strcmp_P(res->arg1, PSTR("off")))
+ roller_off();
+ else if (!strcmp_P(res->arg1, PSTR("reverse")))
+ roller_reverse();
+}
+
+prog_char str_roller_arg0[] = "roller";
+parse_pgm_token_string_t cmd_roller_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_roller_result, arg0, str_roller_arg0);
+prog_char str_roller_arg1[] = "on#off#reverse";
+parse_pgm_token_string_t cmd_roller_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_roller_result, arg1, str_roller_arg1);
+
+prog_char help_roller[] = "Servo door function";
+parse_pgm_inst_t cmd_roller = {
+ .f = cmd_roller_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_roller,
+ .tokens = { /* token list, NULL terminated */
+ (prog_void *)&cmd_roller_arg0,
+ (prog_void *)&cmd_roller_arg1,
+ NULL,
+ },
+};
+
/**********************************************************/
/* Test */
static void cmd_test_parsed(void *parsed_result, void *data)
{
//struct cmd_test_result *res = parsed_result;
-
}
prog_char str_test_arg0[] = "test";
-/*
+/*
* Copyright Droids Corporation
* Olivier Matz <zer0@droids-corp.org>
- *
+ *
* 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; either version 2 of the License, or
#include "actuator.h"
#include "cs.h"
#include "i2c_protocol.h"
-#include "beacon.h"
-#include "scanner.h"
/* 0 means "programmed"
* ---- with 16 Mhz quartz
* CKSEL 3-0 : 0111
- * SUT 1-0 : 10
+ * SUT 1-0 : 10
* CKDIV8 : 1
* ---- bootloader
* BOOTZ 1-0 : 01 (4K bootloader)
__asm__ __volatile__ ("ldi r31,0xf8\n");
__asm__ __volatile__ ("ldi r30,0x00\n");
__asm__ __volatile__ ("eijmp\n");
-
+
/* never returns */
}
LED1_ON();
else
LED1_OFF();
-
+
a = !a;
#endif
}
memset(&gen, 0, sizeof(gen));
memset(&ballboard, 0, sizeof(ballboard));
ballboard.flags = DO_ENCODERS | DO_CS | DO_POWER; // DO_BD
-
+
/* UART */
uart_init();
#if CMDLINE_UART == 3
# error not supported
#endif
- //eeprom_write_byte(EEPROM_MAGIC_ADDRESS, EEPROM_MAGIC_BALLBOARD);
+ eeprom_write_byte(EEPROM_MAGIC_ADDRESS, EEPROM_MAGIC_BALLBOARD);
/* check eeprom to avoid to run the bad program */
if (eeprom_read_byte(EEPROM_MAGIC_ADDRESS) !=
EEPROM_MAGIC_BALLBOARD) {
timer0_register_OV_intr(main_timer_interrupt);
/* PWM */
- PWM_NG_TIMER_16BITS_INIT(1, TIMER_16_MODE_PWM_10,
+ PWM_NG_TIMER_16BITS_INIT(1, TIMER_16_MODE_PWM_10,
TIMER1_PRESCALER_DIV_1);
- PWM_NG_TIMER_16BITS_INIT(4, TIMER_16_MODE_PWM_10,
+ PWM_NG_TIMER_16BITS_INIT(4, TIMER_16_MODE_PWM_10,
TIMER4_PRESCALER_DIV_1);
-
- PWM_NG_INIT16(&gen.pwm1_4A, 4, A, 10, PWM_NG_MODE_SIGNED |
+
+ PWM_NG_INIT16(&gen.pwm1_4A, 4, A, 10, PWM_NG_MODE_SIGNED |
PWM_NG_MODE_SIGN_INVERTED,
&PORTD, 4);
PWM_NG_INIT16(&gen.pwm2_4B, 4, B, 10, PWM_NG_MODE_SIGNED,
/* servos */
- PWM_NG_TIMER_16BITS_INIT(3, TIMER_16_MODE_PWM_10,
+ PWM_NG_TIMER_16BITS_INIT(3, TIMER_16_MODE_PWM_10,
TIMER1_PRESCALER_DIV_256);
PWM_NG_INIT16(&gen.servo1, 3, C, 10, PWM_NG_MODE_NORMAL,
NULL, 0);
- PWM_NG_TIMER_16BITS_INIT(5, TIMER_16_MODE_PWM_10,
+ PWM_NG_TIMER_16BITS_INIT(5, TIMER_16_MODE_PWM_10,
TIMER1_PRESCALER_DIV_256);
PWM_NG_INIT16(&gen.servo2, 5, A, 10, PWM_NG_MODE_NORMAL,
NULL, 0);
NULL, 0);
PWM_NG_INIT16(&gen.servo4, 5, C, 10, PWM_NG_MODE_NORMAL,
NULL, 0);
-
+
/* SCHEDULER */
scheduler_init();
- scheduler_add_periodical_event_priority(do_led_blink, NULL,
- 100000L / SCHEDULER_UNIT,
+ scheduler_add_periodical_event_priority(do_led_blink, NULL,
+ 100000L / SCHEDULER_UNIT,
LED_PRIO);
/* all cs management */
microb_cs_init();
git.droids-corp.org / aversive.git / commitdiff