static void shift_btn(shifter_dd *dt, void **wdata, int what, void **where)
{
int i;
if ((what == op_EVT_OK) || (what == op_EVT_CANCEL))
{
shift_play_state = FALSE; // Stop
mem_pal_copy(mem_pal, dt->old_pal);
update_stuff(UPD_PAL);
run_destroy(wdata);
return;
}
if (what == op_EVT_CHANGE) // Play toggle
{
cmd_read(where, dt);
if (shift_play_state && !shift_timer_state) // Start timer
shift_timer_state = threads_timeout_add(100,
shift_play_timer_call, dt);
return;
}
where = origin_slot(where);
if (where == dt->fix) // Button to fix palette pressed
{
i = dt->frame[0];
if (!i || (i > dt->frame[2])) return; // Nothing to do
mem_pal_copy(mem_pal, dt->old_pal);
spot_undo(UNDO_PAL);
shifter_set_palette(dt, i);
mem_pal_copy(dt->old_pal, mem_pal);
cmd_set(dt->slider, 0);
update_stuff(UPD_PAL);
}
else if (where == dt->clear) // Button to clear all of the values
{
for (i = 0; i < NSHIFT; i++)
spins[i][0][0] = spins[i][1][0] = spins[i][2][0] = 0;
cmd_reset(dt->spinpack, dt);
shifter_moved(dt, wdata, op_EVT_CHANGE, dt->spinpack);
}
else if (where == dt->create) // Button to create a sequence of undo images
{
if (!dt->frame[2]) return; // Nothing to do
for (i = 0; i <= dt->frame[2]; i++)
{
shifter_set_palette(dt, i);
spot_undo(UNDO_PAL);
}
shifter_set_palette(dt, dt->frame[0]);
update_stuff(UPD_PAL);
}
}
/*****************************************************************************
Main program.
*****************************************************************************/
int main (int argc, char* argv[]) {
const char* usage0 =
"usage: rtkgps [-h] [-v] [-d <dev> [-r <rate>] | -b <addr>]\n"
" ([-e] status | date | list | [-y] erase |\n"
" [-c <flg>] [-l <lgtp>] [-m <mfo>] [-s <int>] set |\n"
" [-n] [-p] [-o <dest> [-u]] [-f <nstr>] read)\n\n"
" -h display usage\n"
" -v verbose mode\n"
" -d <dev> specify serial device\n"
" -r <rate> specify baud rate for serial device\n"
" -b <addr> specify bluetooth address\n"
" -e display extended status information\n";
const char* usage1 =
" -c <flg> set real-time output (GPS mouse) mode "
"(0=disable, 1=enable)\n"
" -l <lgtp> set log record type (tl, tla, or tlav)\n"
" -m <mfo> set memory overwrite behaviour (o=overwrite, s=stop)\n"
" -s <int> set sampling interval in seconds\n"
" -n output data in simple native text form\n"
" -p display text progress bar\n"
" -o <dest> specify destination file or directory\n"
" -u skip downloading date for existing files\n";
const char* usage2 =
" -f <nstr> string specifying index number(s) of log file(s) \n"
" to retrieve as a single file number, or range of \n"
" file numbers in the format -n, n-, or n-m\n"
" -y don't ask for confirmation\n";
/* most Royalteks operate on 57600 baud, use that as the default */
cmdlnopts_t cmdopt = {0,0,0,0,0,0,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,-1,-1,-1,57600,""};
/* Initialise usage string */
strcpy(cmdopt.usgs, usage0);
strcat(cmdopt.usgs, usage1);
strcat(cmdopt.usgs, usage2);
/* Scan command line options */
scan_cmdline(argc, argv, &cmdopt);
/* Set up warning callback function */
gcwrnfp = warning;
/* Perform requested task */
if (strcmp(cmdopt.cmds,"status") == 0) {
cmd_status(&cmdopt);
} else if (strcmp(cmdopt.cmds,"date") == 0) {
cmd_date(&cmdopt);
} else if (strcmp(cmdopt.cmds,"list") == 0) {
cmd_list(&cmdopt);
} else if (strcmp(cmdopt.cmds,"set") == 0) {
cmd_set(&cmdopt);
} else if (strcmp(cmdopt.cmds,"read") == 0) {
cmd_read(&cmdopt);
} else if (strcmp(cmdopt.cmds,"erase") == 0) {
cmd_erase(&cmdopt);
}
exit(0);
}
void cmd_debug(char *s)
{
freopen("debug.bce", "w+", stdout);
printboard();
cmd_inspect(NULL);
cmd_set(NULL);
exit(EXIT_FAILURE);
}
static void click_newchan_cancel(cchan_dd *dt, void **wdata)
{
cmd_set(menu_slots[MENU_CHAN0 + mem_channel], TRUE);
// Stops cancelled new channel showing as selected in the menu
run_destroy(wdata);
newchan_window = NULL;
}
void handle_packet(Packet packet){
char *params = &packet.data[1];
switch (packet.data[0]){
case CMD_PWM_SET: cmd_pwm_set(params); break;
case CMD_PWM_SETSCALAR: cmd_pwm_setscalar(params); break;
case CMD_RPMSET : cmd_rpmset(params); break;
case CMD_SET : cmd_set(params); break;
default: Packets_sendError(ERROR_INVALIDCMD, 0x00);
}
}
/*
* rpt_init_status_report()
*
* Call this function to completely re-initialze the status report
* Sets SR list to hard-coded defaults and re-initializes sr values in NVM
*/
void rpt_init_status_report()
{
cmdObj_t *cmd = cmd_reset_list(); // used for status report persistence locations
char sr_defaults[CMD_STATUS_REPORT_LEN][CMD_TOKEN_LEN+1] = { SR_DEFAULTS }; // see settings.h
cm.status_report_counter = (cfg.status_report_interval / RTC_MILLISECONDS); // RTC fires every 10 ms
cmd->index = cmd_get_index("","se00"); // set first SR persistence index
for (uint8_t i=0; i < CMD_STATUS_REPORT_LEN ; i++) {
if (sr_defaults[i][0] == NUL) break; // quit on first blank array entry
cfg.status_report_value[i] = -1234567; // pre-load values with an unlikely number
cmd->value = cmd_get_index("", sr_defaults[i]); // load the index for the SR element
cmd_set(cmd);
cmd_persist(cmd); // conditionally persist - automatic by cmd_persis()
cmd->index++; // increment SR NVM index
}
}
static gboolean shift_play_timer_call(gpointer data)
{
if (!shift_play_state)
{
shift_timer_state = 0;
return FALSE; // Stop animating
}
else
{
shifter_dd *dt = data;
int i;
cmd_read(dt->slider, dt);
i = dt->frame[0] + 1;
if (i > dt->frame[2]) i = dt->frame[1];
cmd_set(dt->slider, i);
return TRUE;
}
}
/*
* Command for passing strings directly to gdb.
*/
void
cmd_gdb(void)
{
char buf[BUFSIZE];
char **argv;
argv = STREQ(args[0], "gdb") ? &args[1] : &args[0];
if (*argv == NULL)
cmd_usage(pc->curcmd, SYNOPSIS);
if (STREQ(*argv, "set") && argv[1]) {
/*
* Intercept set commands in case something has to be done
* here or elsewhere.
*/
if (STREQ(argv[1], "gdb")) {
cmd_set();
return;
}
if (STREQ(argv[1], "output-radix") && argv[2])
pc->output_radix = stol(argv[2], FAULT_ON_ERROR, NULL);
}
/*
* If the command is not restricted, pass it on.
*/
if (!is_restricted_command(*argv, FAULT_ON_ERROR)) {
if (STREQ(pc->command_line, "gdb")) {
strcpy(buf, first_space(pc->orig_line));
strip_beginning_whitespace(buf);
} else
strcpy(buf, pc->orig_line);
if (pc->redirect & (REDIRECT_TO_FILE|REDIRECT_TO_PIPE))
strip_redirection(buf);
if (!gdb_pass_through(buf, NULL, GNU_RETURN_ON_ERROR))
error(INFO, "gdb request failed: %s\n", buf);
}
}
//相关接口封装
//router reboot; 1:success, 0:failed
static int router_reboot(DEVICE_TYPE_t type, void* context)
{
char result[64];
if (context == NULL)
{
return(-1);
}
#ifdef _DEBUG_ROUTER_DEV_
DEBUG_WARN("%s\n", __FUNCTION__);
#endif
if (cmd_set("reboot", result) < 0)
{
DEBUG_ERR("router reboot error\n");
return(-1);
}
//run_init_script("all");
sprintf((char*)context, "\{\"STATUS\":\"%s\"}", result);
stat_t _json_parser_kernal(char *str)
{
uint8_t status;
int8_t depth;
cmdObj_t *cmd = cmd_reset_list(); // get a fresh cmdObj list
char group[CMD_GROUP_LEN+1] = {""}; // group identifier - starts as NUL
int8_t i = CMD_BODY_LEN;
ritorno(_normalize_json_string(str, JSON_OUTPUT_STRING_MAX)); // return if error
// parse the JSON command into the cmd body
do {
if (--i == 0) { return (STAT_JSON_TOO_MANY_PAIRS); } // length error
if ((status = _get_nv_pair_strict(cmd, &str, &depth)) > STAT_EAGAIN) { // erred out
return (status);
}
// propagate the group from previous NV pair (if relevant)
if (group[0] != NUL) {
strncpy(cmd->group, group, CMD_GROUP_LEN);// copy the parent's group to this child
}
// validate the token and get the index
if ((cmd->index = cmd_get_index(cmd->group, cmd->token)) == NO_MATCH) {
return (STAT_UNRECOGNIZED_COMMAND);
}
if ((cmd_index_is_group(cmd->index)) && (cmd_group_is_prefixed(cmd->token))) {
strncpy(group, cmd->token, CMD_GROUP_LEN);// record the group ID
}
if ((cmd = cmd->nx) == NULL) return (STAT_JSON_TOO_MANY_PAIRS);// Not supposed to encounter a NULL
} while (status != STAT_OK); // breaks when parsing is complete
// execute the command
cmd = cmd_body;
if (cmd->objtype == TYPE_NULL){ // means GET the value
ritorno(cmd_get(cmd)); // ritorno returns w/status on any errors
} else {
ritorno(cmd_set(cmd)); // set value or call a function (e.g. gcode)
cmd_persist(cmd);
}
return (STAT_OK); // only successful commands exit through this point
}
/****************************************************************************
* cmd_text_parser() - update a config setting from a text block (text mode)
* _text_parser() - helper for above
*
* Use cases handled:
* - $xfr=1200 set a parameter
* - $xfr display a parameter
* - $x display a group
* - ? generate a status report (multiline format)
*/
uint8_t cmd_text_parser(char *str)
{
// return (SC_OK); // There is no text parser in this code - just JSON
//}
cmdObj_t *cmd = cmd_reset_list(); // returns first object in the body
uint8_t status = SC_OK;
// single-unit parser processing
ritorno(_text_parser(str, cmd)); // decode the request or return if error
if ((cmd->type == TYPE_PARENT) || (cmd->type == TYPE_NULL)) {
if (cmd_get(cmd) == SC_COMPLETE) { // populate value, group values, or run uber-group displays
return (SC_OK); // return for uber-group displays so they don't print twice
}
} else { // process SET and RUN commands
status = cmd_set(cmd); // set single value
cmd_persist(cmd);
}
cmd_print_list(status, TEXT_MULTILINE_FORMATTED, JSON_RESPONSE_FORMAT); // print the results
return (status);
return (SC_OK);
}
// runs a script
// returns -1 is esc was pressed, 0 o/w
int run_script(char *script, DATAFILE *d) {
char buf[512];
Ttoken *token;
int i;
// set datafile
data = d;
clear_keybuf();
// init sound memory
for(i = 0; i < MAX_SCRIPT_SOUNDS; i ++) active_sounds[i] = -1;
// create gfx buffers
swap_buffer = create_bitmap(160, 120);
buffer = create_bitmap(160, 120);
script_done = FALSE;
while(!script_done) {
// get commands from script string
script = get_line(buf, script);
if (buf[0] != '#' && buf[0] != '\n' && buf[0] != '\r' && buf[0] != '-') {
token = tokenize(buf);
if (token != NULL) {
if (!stricmp(token->word, "load_map")) cmd_loadmap(get_next_word(token));
else if (!stricmp(token->word, "draw_map")) cmd_drawmap();
else if (!stricmp(token->word, "set")) cmd_set((Ttoken *)token->next);
else if (!stricmp(token->word, "move")) cmd_move((Ttoken *)token->next);
else if (!stricmp(token->word, "delete")) cmd_del((Ttoken *)token->next);
else if (!stricmp(token->word, "run")) cmd_run((Ttoken *)token->next);
else if (!stricmp(token->word, "speak")) cmd_speak((Ttoken *)token->next, 1);
else if (!stricmp(token->word, "text")) cmd_speak((Ttoken *)token->next, 0);
else if (!stricmp(token->word, "save_buffer")) cmd_savebmp();
else if (!stricmp(token->word, "show_bmp")) cmd_showbmp(get_next_word(token));
else if (!stricmp(token->word, "blit")) cmd_blit();
else if (!stricmp(token->word, "fade_in")) cmd_fadein();
else if (!stricmp(token->word, "fade_out")) cmd_fadeout();
else if (!stricmp(token->word, "wait")) cmd_wait(atoi(get_next_word(token)));
else if (!stricmp(token->word, "play_sample")) cmd_play_sample((Ttoken *)token->next);
else if (!stricmp(token->word, "stop_sample")) cmd_stop_sample((Ttoken *)token->next);
else if (!stricmp(token->word, "end_script")) cmd_end();
else {
char msg[256];
sprintf(msg, "unknown: %s", token->word);
msg_box(msg);
}
flush_tokens(token);
}
}
}
// destroy buffers
delete_all_objects();
destroy_bitmap(buffer);
destroy_bitmap(swap_buffer);
// stop old sounds
for(i = 0; i < MAX_SCRIPT_SOUNDS; i ++) {
if (active_sounds[i] != -1) {
stop_sound_id(active_sounds[i]);
forget_sound(active_sounds[i]);
}
}
return (script_done == -1 ? -1 : 0);
}
int main(void) {
int isRunning = 1;
char buffer[MAX_LINE_LENGTH];
char command[MAX_LINE_LENGTH];
while(isRunning){
//int i;
printf("> ");
fgets(buffer, MAX_LINE_LENGTH, stdin);
/*for( i = 0; i < MAX_LINE_LENGTH; i++ ){
buffer[i] = tolower(buffer[i]);
}*/
sscanf(buffer, " %s ", (char*)&command);
//Switch for commands
if(strcmp(command, "BYE") == 0){ /*BYE*/
deleteAllEntry(entry_head);
deleteAllSnapshot(snapshot_head);
printf("bye");
isRunning = 0;
}else if(strcmp(command, "HELP") == 0){ /*HELP*/
cmd_help();
}else if(strcmp(command, "LIST") == 0){
sscanf(buffer + strlen(command), "%s", (char*)&command);
if(strcmp(command, "KEYS") == 0){ /*LIST KEYS*/
cmd_list_keys();
}else if(strcmp(command, "ENTRIES") == 0){ /*LIST ENTRIES*/
cmd_list_entries();
}else if(strcmp(command, "SNAPSHOTS") == 0){ /*LIST SNAPSHOTS*/
cmd_list_snapshots();
}
}else if(strcmp(command, "GET") == 0){ /*GET*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_get(key);
}else if(strcmp(command, "DEL") == 0){ /*DEL*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_del(key);
}else if(strcmp(command, "PURGE") == 0){ /*PURGE*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_purge(key);
}else if(strcmp(command, "SET") == 0){ /*SET*/
int i = 0;
char key[MAX_KEY_LENGTH];
char *endptr;
int *values = (int*)malloc(MAX_LINE_LENGTH/2*sizeof(int));
sscanf(buffer + strlen(command), "%s", (char*)&key);
endptr = buffer + strlen(command) + strlen(key) + 2;
while(1){
values[i] = strtol(endptr, &endptr, 10);
if(*endptr == '\n'){
cmd_set(key, values, i+1);
break;
}
i++;
}
free(values);
}else if(strcmp(command, "PUSH") == 0){ /*PUSH*/
int i = 0;
char key[MAX_KEY_LENGTH];
char *endptr;
int *values = (int*)malloc(MAX_LINE_LENGTH/2*sizeof(int));
sscanf(buffer + strlen(command), "%s", (char*)&key);
endptr = buffer + strlen(command) + strlen(key) + 2;
while(1){
values[i] = strtol(endptr, &endptr, 10);
if(*endptr == '\n'){
cmd_push(key, values, i+1);
break;
}
i++;
}
free(values);
}else if(strcmp(command, "APPEND") == 0){ /*APPEND*/
int i = 0;
char key[MAX_KEY_LENGTH];
char *endptr;
int *values = (int*)malloc(MAX_LINE_LENGTH/2*sizeof(int));
sscanf(buffer + strlen(command), "%s", (char*)&key);
endptr = buffer + strlen(command) + strlen(key) + 2;
while(1){
values[i] = strtol(endptr, &endptr, 10);
if(*endptr == '\n'){
cmd_append(key, values, i+1);
break;
}
i++;
}
free(values);
}else if(strcmp(command, "PICK") == 0){ /*PICK*/
char key[MAX_KEY_LENGTH];
int index;
sscanf(buffer + strlen(command)+1, "%s", (char*)&key);
index = strtol(buffer + strlen(command) + strlen(key)+2, (char**)&command, 0);
cmd_pick(key, index);
}else if(strcmp(command, "PLUCK") == 0){ /*PLUCK*/
char key[MAX_KEY_LENGTH];
int index;
sscanf(buffer + strlen(command)+1, "%s", (char*)&key);
index = strtol(buffer + strlen(command) + strlen(key)+2, (char**)&command, 0);
cmd_pluck(key, index);
}else if(strcmp(command, "POP") == 0){ /*POP*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_pop(key);
}else if(strcmp(command, "DROP") == 0){ /*DROP*/
int id = strtol(buffer + strlen(command) +1 , (char**)&command, 10);
cmd_drop(id);
}else if(strcmp(command, "ROLLBACK") == 0){ /*ROLLBACK*/
int id = strtol(buffer + strlen(command) +1 , (char**)&command, 10);
cmd_rollback(id);
}else if(strcmp(command, "CHECKOUT") == 0){ /*CHECKOUT*/
int id = strtol(buffer + strlen(command) +1 , (char**)&command, 10);
cmd_checkout(id);
}else if(strcmp(command, "SNAPSHOT") == 0){ /*SNAPSHOT*/
cmd_snapshot();
}else if(strcmp(command, "MIN") == 0){ /*MIN*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_min(key);
}else if(strcmp(command, "MAX") == 0){ /*MAX*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_max(key);
}else if(strcmp(command, "SUM") == 0){ /*SUM*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_sum(key);
}else if(strcmp(command, "LEN") == 0){ /*LEN*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_len(key);
}else if(strcmp(command, "REV") == 0){ /*REV*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_rev(key);
}else if(strcmp(command, "UNIQ") == 0){ /*UNIQ*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_uniq(key);
}else if(strcmp(command, "SORT") == 0){ /*SORT*/
char key[MAX_KEY_LENGTH];
sscanf(buffer + strlen(command), "%s", (char*)&key);
cmd_sort(key);
}else{
printf("\n");
}
}
return 0;
}
static int main_cmd(int argc, char *argv[])
{
if (argc < 1) {
return help();
}
char *cmd = *argv++; argc--;
if (contains(cmd, "key")) {
if (argc < 2) {
return help();
}
uint32_t lockkey = strtoul(argv[0], NULL, 0);
hdhomerun_device_tuner_lockkey_use_value(hd, lockkey);
cmd = argv[1];
argv+=2; argc-=2;
}
if (contains(cmd, "get")) {
if (argc < 1) {
return help();
}
return cmd_get(argv[0]);
}
if (contains(cmd, "set")) {
if (argc < 2) {
return help();
}
return cmd_set(argv[0], argv[1]);
}
if (contains(cmd, "scan")) {
if (argc < 1) {
return help();
}
if (argc < 2) {
return cmd_scan(argv[0], NULL);
} else {
return cmd_scan(argv[0], argv[1]);
}
}
if (contains(cmd, "save")) {
if (argc < 2) {
return help();
}
return cmd_save(argv[0], argv[1]);
}
if (contains(cmd, "upgrade")) {
if (argc < 1) {
return help();
}
return cmd_upgrade(argv[0]);
}
if (contains(cmd, "execute")) {
return cmd_execute();
}
return help();
}
int main (int argc, char * argv[]) {
char * server = NULL;
char * k;
int i;
struct roar_connection con;
for (i = 1; i < argc; i++) {
k = argv[i];
if ( !strcmp(k, "--server") || !strcmp(k, "-s") ) {
server = argv[++i];
} else if ( !strcmp(k, "--codec") ) {
} else if ( !strcmp(k, "--help") || !strcmp(k, "-h") ) {
usage();
return 0;
} else if ( *k == '-' ) {
fprintf(stderr, "Error: unknown argument: %s\n", k);
usage();
return 1;
} else {
break;
}
}
if ( roar_simple_connect(&con, server, "roarlight") == -1 ) {
fprintf(stderr, "Error: Can not connect to server\n");
return 1;
}
if ( i == argc ) {
fprintf(stderr, "Error: No Commands given\n");
return 0; // this is not a fatal error...
}
for (; i < argc; i++) {
k = argv[i];
// cmd is in k
printf("--- [ %s ] ---\n", k);
if ( !strcmp(k, "help") ) {
usage();
} else if ( !strcmp(k, "sleep") ) {
sleep(atoi(argv[++i]));
} else if ( !strcmp(k, "set") ) {
i++;
if ( cmd_set(&con, argv[i]) == -1 ) {
fprintf(stderr, "Error: can not set channels\n");
} else {
printf("channels changed\n");
}
} else {
fprintf(stderr, "Error: invalid command: %s\n", k);
}
}
roar_disconnect(&con);
return 0;
}
int main(int argc, char **argv)
{
uint8_t ret[2];
int i;
initialize();
send_cmd(devh,CMD_GET_MODEL,ret);
printf("Model:");
switch (ret[0]){
case 1:
printf("Basic\n");
break;
case 2:
printf("digIO\n");
break;
case 3:
printf("watchdog\n");
break;
case 4:
printf("smart\n");
break;
}
send_cmd(devh,CMD_GET_FIRM_VER,ret);
printf("Firmware version: %d.%d\n",ret[0],ret[1]);
send_cmd(devh,CMD_GET_STATE1,ret);
state[1] = ret[0];
send_cmd(devh,CMD_GET_STATE2,ret);
state[2] = ret[0];
send_cmd(devh,CMD_GET_STATE3,ret);
state[3] = ret[0];
for (i=1;i<4;i++){
printf("Outlet%d:",i);
switch(state[i]){
case 0:
printf("off\n");
break;
case 1:
printf("on\n");
break;
}
}
if (argc < 2) {
usage();
exit(1);
}
if (!strcmp(argv[1],"get")) {
cmd_get(argc,argv);
}else if (!strcmp(argv[1],"set")) {
Dprintf("set\n");
cmd_set(argc,argv);
}else {
usage();
exit(1);
}
finalize();
exit(0);
}
