int main(void) { puts("CCN!"); if (msg_init_queue(msg_buffer_shell, SHELL_MSG_BUFFER_SIZE) != 0) { DEBUG("msg init queue failed...abording\n"); return -1; } riot_ccn_relay_start(); puts("starting shell..."); puts(" posix open"); posix_open(uart0_handler_pid, 0); puts(" shell init"); shell_init(&shell, sc, UART0_BUFSIZE, uart0_readc, uart0_putc); puts(" shell run"); shell_run(&shell); return 0; }
int main(void) { shell_t shell; const char *disco_addr = DISCO_ADDR; port[0] = (uint8_t)DISCO_PORT; port[1] = (uint8_t)(DISCO_PORT >> 8); ng_ipv6_addr_from_str(&addr, disco_addr); char buf[100]; ng_ipv6_addr_to_str(buf, &addr, 100); printf("got address: %s\n", buf); set_chan(DISCO_CHANNEL); shell_init(&shell, shell_commands, STDIO_RX_BUFSIZE, getchar, putchar); shell_run(&shell); return 0; }
int main(void) { char *args[2]; char *cmd = "udp_server"; char *port = "8888"; args[0] = cmd; args[1] = port; msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE); udp_server(2, args); thread_create(_stack, sizeof(_stack), THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST, _send, NULL, "send"); char line_buf[SHELL_DEFAULT_BUFSIZE]; shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE); return 0; }
/** * @brief Maybe you are a golfer?! */ int main(void) { shell_t shell; ng_netreg_entry_t dump; puts("AT86RF2xx device driver test"); /* register the pktdump thread */ puts("Register the packet dump thread for NG_NETTYPE_UNDEF packets"); dump.pid = ng_pktdump_getpid(); dump.demux_ctx = NG_NETREG_DEMUX_CTX_ALL; ng_netreg_register(NG_NETTYPE_UNDEF, &dump); /* start the shell */ puts("Initialization successful - starting the shell now"); (void) posix_open(uart0_handler_pid, 0); shell_init(&shell, NULL, SHELL_BUFSIZE, uart0_readc, uart0_putc); shell_run(&shell); return 0; }
/** * @brief the main programm loop * * @return non zero on error */ int main(void) { // some initial infos puts("Girls Day 2016 @ HAW Hamburg!"); puts("================"); printf("You are running RIOT on a(n) %s board.\n", RIOT_BOARD); printf("This board features a(n) %s MCU.\n", RIOT_MCU); puts("================"); // init 6lowpan interface puts(". init network"); if (comm_init()!=0) { return 1; } puts("."); // start sensor loop puts(".. init sensors"); sensor_pid = sensor_start_thread(); if (sensor_pid < 0) { return 1; } LED0_OFF; LED1_OFF; LED2_OFF; puts(":"); // start coap receiver puts("... init coap"); coap_pid = coap_start_thread(); puts("."); puts(":"); // start shell puts(".... init shell"); puts(":"); puts(":"); char line_buf[SHELL_DEFAULT_BUFSIZE]; shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE); // should be never reached return 0; }
int main(void) { #ifdef WITH_SHELL /* initialize message queue */ msg_init_queue(_main_msg_q, Q_SZ); #endif eui64_t iid; // uint16_t chan = 15; netopt_enable_t acks = NETOPT_DISABLE; kernel_pid_t ifs[GNRC_NETIF_NUMOF]; gnrc_netif_get(ifs); gnrc_netapi_set(ifs[0], NETOPT_AUTOACK, 0, &acks, sizeof(acks)); ipv6_addr_from_str(&dst_addr, "2001:affe:1234::1"); // gnrc_netapi_set(ifs[0], NETOPT_CHANNEL, 0, &chan, sizeof(chan)); // ipv6_addr_from_str(&dst_addr, "fd38:3734:ad48:0:211d:50ce:a189:7cc4"); /* initialize senml payload */ gnrc_netapi_get(ifs[0], NETOPT_IPV6_IID, 0, &iid, sizeof(eui64_t)); initial_pos = sprintf(&p_buf[initial_pos], "[{\"bn\":\"urn:dev:mac:"); initial_pos += sprintf(&p_buf[initial_pos], "%02x%02x%02x%02x%02x%02x%02x%02x", iid.uint8[0], iid.uint8[1], iid.uint8[2], iid.uint8[3], iid.uint8[4], iid.uint8[5], iid.uint8[6], iid.uint8[7]); initial_pos += sprintf(&p_buf[initial_pos], "\"},"); thread_create(coap_stack, sizeof(coap_stack), PRIO - 1, THREAD_CREATE_STACKTEST, microcoap_server, NULL, "coap"); #ifdef WITH_SHELL thread_create(beac_stack, sizeof(beac_stack), PRIO, THREAD_CREATE_STACKTEST, beaconing, NULL, "beaconing"); char line_buf[SHELL_DEFAULT_BUFSIZE]; shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE); #else beaconing(NULL); #endif return 0; }
/** * @brief Maybe you are a golfer?! */ int main(void) { gnrc_netreg_entry_t dump = GNRC_NETREG_ENTRY_INIT_PID(GNRC_NETREG_DEMUX_CTX_ALL, gnrc_pktdump_pid); puts("Xbee S1 device driver test"); /* initialize and register pktdump */ if (gnrc_pktdump_pid <= KERNEL_PID_UNDEF) { puts("Error starting pktdump thread"); return -1; } gnrc_netreg_register(GNRC_NETTYPE_UNDEF, &dump); /* start the shell */ puts("Initialization OK, starting shell now"); char line_buf[SHELL_DEFAULT_BUFSIZE]; shell_run(NULL, line_buf, SHELL_DEFAULT_BUFSIZE); return 0; }
/** * @brief the main programm loop * * @return non zero on error */ int main(void) { // some initial infos puts("SmartUniversity - COAP Example!"); puts("================"); printf("You are running RIOT on a(n) %s board.\n", RIOT_BOARD); printf("This board features a(n) %s MCU.\n", RIOT_MCU); puts("================"); // init coap endpoints endpoint_setup(); // start coap receiver start_coap_server(); // start shell puts("All up, running the shell now"); char line_buf[SHELL_DEFAULT_BUFSIZE]; shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE); // should be never reached return 0; }
int main(void) { shell_t shell; puts("GPIO peripheral driver test\n"); puts("In this test, pins are specified by integer port and pin numbers.\n" "So if your platform has a pin PA01, it will be port=0 and pin=1,\n" "PC14 would be port=2 and pin=14 etc.\n\n" "NOTE: make sure the values you use exist on your platform! The\n" " behavior for not existing ports/pins is not defined!"); /* start the shell */ #ifndef MODULE_NEWLIB (void) posix_open(uart0_handler_pid, 0); shell_init(&shell, shell_commands, SHELL_BUFSIZE, uart0_readc, uart0_putc); #else shell_init(&shell, shell_commands, SHELL_BUFSIZE, getchar, putchar); #endif shell_run(&shell); return 0; }
/** * @brief Maybe you are a golfer?! */ int main(void) { shell_t shell; ng_netreg_entry_t dump; puts("RIOT sniffer application"); /* start and register rawdump thread */ puts("Run the rawdump thread and register it"); dump.pid = thread_create(rawdmp_stack, sizeof(rawdmp_stack), RAWDUMP_PRIO, CREATE_STACKTEST, rawdump, NULL, "rawdump"); dump.demux_ctx = NG_NETREG_DEMUX_CTX_ALL; ng_netreg_register(NG_NETTYPE_UNDEF, &dump); /* start the shell */ puts("All ok, starting the shell now"); (void) posix_open(uart0_handler_pid, 0); shell_init(&shell, NULL, SHELL_BUFSIZE, uart0_readc, uart0_putc); shell_run(&shell); return 0; }
int main(void) { puts("IETF90 - BnB - UDP server"); if (msg_init_queue(msg_buffer_shell, SHELL_MSG_BUFFER_SIZE) != 0) { DEBUG("msg init queue failed...abording\n"); return -1; } /* fill neighbor cache */ fill_nc(); id = 1; helper_ignore(3); rpl_ex_init('r'); udp_server(1, NULL); posix_open(uart0_handler_pid, 0); net_if_set_src_address_mode(0, NET_IF_TRANS_ADDR_M_SHORT); shell_init(&shell, sc, UART0_BUFSIZE, uart0_readc, uart0_putc); shell_run(&shell); return 0; }
void pcnet32_test_run() { xprintf("PCNET32 TEST\n"); xprintf("root fnode %p\n", process_current()->root); xprintf("root filesystem name %s\n", process_current()->root->mounted->filesystem->name); xprintf("file id %d\n", process_current()->root->file_id); pci_init(); // ide_init(); ether_init(); ip_init(); pcnet32_init(); //pcnet32 // mounting devfs devfs_mount(); // registering devfs driver_register_devfs(); // mounting tarfs at standard boot location tarfs_mount(multiboot_get_module(0), "/System/Startup"); shell_run(); xprintf("pcnet32_test end\n"); }
int main(void) { #ifdef MODULE_LTC4150 ltc4150_start(); #endif #ifdef FEATURE_PERIPH_RTC rtc_init(); #endif #ifdef MODULE_NETIF gnrc_netreg_entry_t dump = GNRC_NETREG_ENTRY_INIT_PID(GNRC_NETREG_DEMUX_CTX_ALL, gnrc_pktdump_pid); gnrc_netreg_register(GNRC_NETTYPE_UNDEF, &dump); #endif (void) puts("Welcome to RIOT!"); char line_buf[SHELL_DEFAULT_BUFSIZE]; shell_run(NULL, line_buf, SHELL_DEFAULT_BUFSIZE); return 0; }
int main(void) { shell_t shell; kernel_pid_t radio; /* initialize the radio */ radio = comm_init(); if (radio == KERNEL_PID_UNDEF) { puts("ERROR initializing the radio, aborting"); return 1; } /* initialize the sensing module */ sense_init(radio); /* run the shell */ (void) posix_open(uart0_handler_pid, 0); shell_init(&shell, _commands, SHELL_BUFSIZE, _readc, _putc); shell_run(&shell); /* never reached */ return 0; }
int main(void) { memcpy(&sx127x.params, sx127x_params, sizeof(sx127x_params)); netdev = (netdev_t*) &sx127x; netdev->driver = &sx127x_driver; netdev->driver->init(netdev); netdev->event_callback = _event_cb; _recv_pid = thread_create(stack, sizeof(stack), THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST, _recv_thread, NULL, "recv_thread"); if (_recv_pid <= KERNEL_PID_UNDEF) { puts("Creation of receiver thread failed"); return 1; } /* start the shell */ puts("Initialization successful - starting the shell now"); char line_buf[SHELL_DEFAULT_BUFSIZE]; shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE); return 0; }
int main(void) { printf("test_shell.\n"); board_uart0_init(); posix_open(uart0_handler_pid, 0); /* define own shell commands */ shell_t shell; shell_init(&shell, shell_commands, SHELL_BUFSIZE, shell_readc, shell_putchar); shell_run(&shell); /* or use only system shell commands */ /* shell_t sys_shell; shell_init(&sys_shell, NULL, SHELL_BUFSIZE, shell_readc, shell_putchar); shell_run(&sys_shell); */ return 0; }
int shell_execute(shell_context_t *ctx, const char *cmd) { yyscan_t scanner; if(yylex_init_extra(ctx, &scanner) == -1) return -1; ctx->line = strdup(cmd); char *ptr = ctx->line; int token; int state = STATE_WANTSTR; int argc = 0; char **argv = NULL; int fret = 0; do { int noway = 0; token = yylex(scanner); if((token == TOK_SEPARATOR || token == TOK_COMMENT || token == 0)) { if(argc > 0) { int ret = shell_run(ctx, argc, argv); for(int i = 0; i < argc; i++) { free(argv[i]); } free(argv); argv = NULL; argc = 0; if(ret == -1) { fret = -1; break; } } state = STATE_WANTSTR; } else { switch(state) { case STATE_WANTSTR: if(token == TOK_SPACE) { state = STATE_WANTSTR; } else if(token == TOK_STRING) { int oargc = argc++; argv = realloc(argv, sizeof(char *) * argc); argv[oargc] = ctx->strval; state = STATE_WANTSPACE; } else { noway = 1; } break; case STATE_WANTSPACE: if(token == TOK_STRING) { free(ctx->strval); noway = 1; } else if(token == TOK_SPACE) { state = STATE_WANTSTR; } else noway = 1; } if(noway) { debug(LEVEL_ERROR, "No way from state %d by token %d\n", state, token); for(int i = 0; i < argc; i++) free(argv[i]); free(argv); fret = -1; break; } } } while(token && token != TOK_COMMENT); free(ptr); yylex_destroy(scanner); return fret; }
int main(void) { #ifndef NO_DEBUG uart_init(); stdout = &uart_stdout; banner(); #endif shared_memory_init(); system_init(); sram_init(); pwm_init(); irq_init(); boot_startup_rom(50); globals_init(); pwm_stop(); usbInit(); usb_connect(); sei(); while (1) { system_set_bus_avr(); system_set_wr_disable(); while (usb_trans.req_state != REQ_STATUS_SNES) { usbPoll(); #if DO_SHELL #ifndef NO_DEBUG shell_run(); #endif #endif } #if DO_SHM shared_memory_write(SHARED_MEM_TX_CMD_TERMINATE, 0); #endif #if DO_SHM_SCRATCHPAD shared_memory_scratchpad_region_tx_restore(); shared_memory_scratchpad_region_rx_restore(); #endif #if DO_CRC_CHECK info_P(PSTR("-->CRC Check\n")); crc_check_bulk_memory(0x000000, usb_trans.req_bank_size * usb_trans.req_bank_cnt, usb_trans.req_bank_size); #endif system_set_rom_mode(&usb_trans); system_set_wr_disable(); system_set_bus_snes(); system_send_snes_reset(); irq_stop(); while ((usb_trans.req_state != REQ_STATUS_AVR)) { usbPoll(); #if DO_SHELL #ifndef NO_DEBUG shell_run(); #endif #endif } info_P(PSTR("-->Switch TO AVR\n")); shared_memory_init(); irq_init(); if (usb_trans.loader_enabled) { boot_startup_rom(50); } else { system_set_bus_avr(); system_send_snes_reset(); } globals_init(); } return 0; }
static int run(int argc, char **argv) { static struct option long_options[] = { { "trace", no_argument, 0, 't' }, { "batch", no_argument, 0, 'b' }, { "command", no_argument, 0, 'c' }, { "stop-time", required_argument, 0, 's' }, { "stats", no_argument, 0, 'S' }, { "wave", optional_argument, 0, 'w' }, { "stop-delta", required_argument, 0, 'd' }, { "format", required_argument, 0, 'f' }, { "include", required_argument, 0, 'i' }, { "exclude", required_argument, 0, 'e' }, { "exit-severity", required_argument, 0, 'x' }, #if ENABLE_VHPI { "load", required_argument, 0, 'l' }, { "vhpi-trace", no_argument, 0, 'T' }, #endif { 0, 0, 0, 0 } }; enum { BATCH, COMMAND } mode = BATCH; enum { LXT, FST, VCD} wave_fmt = FST; uint64_t stop_time = UINT64_MAX; const char *wave_fname = NULL; const char *vhpi_plugins = NULL; static bool have_run = false; if (have_run) fatal("multiple run commands are not supported"); have_run = true; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = "bcw::l:"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': fatal("unrecognised run option %s", argv[optind - 1]); case 't': opt_set_int("rt_trace_en", 1); break; case 'T': opt_set_int("vhpi_trace_en", 1); break; case 'b': mode = BATCH; break; case 'c': mode = COMMAND; break; case 's': stop_time = parse_time(optarg); break; case 'f': if (strcmp(optarg, "vcd") == 0) wave_fmt = VCD; else if (strcmp(optarg, "fst") == 0) wave_fmt = FST; else if (strcmp(optarg, "lxt") == 0) wave_fmt = LXT; else fatal("invalid waveform format: %s", optarg); break; case 'S': opt_set_int("rt-stats", 1); break; case 'w': if (optarg == NULL) wave_fname = ""; else wave_fname = optarg; break; case 'd': opt_set_int("stop-delta", parse_int(optarg)); break; case 'i': wave_include_glob(optarg); break; case 'e': wave_exclude_glob(optarg); break; case 'l': vhpi_plugins = optarg; break; case 'x': rt_set_exit_severity(parse_severity(optarg)); break; default: abort(); } } set_top_level(argv, next_cmd); ident_t ename = ident_prefix(top_level, ident_new("elab"), '.'); tree_rd_ctx_t ctx; tree_t e = lib_get_ctx(lib_work(), ename, &ctx); if (e == NULL) fatal("%s not elaborated", istr(top_level)); else if (tree_kind(e) != T_ELAB) fatal("%s not suitable top level", istr(top_level)); if (wave_fname != NULL) { const char *name_map[] = { "LXT", "FST", "VCD" }; const char *ext_map[] = { "lxt", "fst", "vcd" }; char *tmp LOCAL = NULL; if (*wave_fname == '\0') { tmp = xasprintf("%s.%s", argv[optind], ext_map[wave_fmt]); wave_fname = tmp; notef("writing %s waveform data to %s", name_map[wave_fmt], tmp); } wave_include_file(argv[optind]); switch (wave_fmt) { case LXT: lxt_init(wave_fname, e); break; case VCD: vcd_init(wave_fname, e); break; case FST: fst_init(wave_fname, e); break; } } rt_start_of_tool(e, ctx); if (vhpi_plugins != NULL) vhpi_load_plugins(e, vhpi_plugins); rt_restart(e); if (mode == COMMAND) shell_run(e, ctx); else rt_run_sim(stop_time); rt_end_of_tool(e); tree_read_end(ctx); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv) : EXIT_SUCCESS; }
static int builtin_safe(shell_context_t *ctx, int argc, char *argv[]) { if(shell_run(ctx, argc - 1, argv + 1) == -1) perror("shell_run"); return 0; }
void shell_runner(void) { shell_init(&shell, sc, UART0_BUFSIZE, uart0_readc, uart0_putc); posix_open(uart0_handler_pid, 0); shell_run(&shell); }
static int run(int argc, char **argv) { set_work_lib(); static struct option long_options[] = { { "trace", no_argument, 0, 't' }, { "batch", no_argument, 0, 'b' }, { "command", no_argument, 0, 'c' }, { "stop-time", required_argument, 0, 's' }, { "stats", no_argument, 0, 'S' }, { "wave", optional_argument, 0, 'w' }, { "stop-delta", required_argument, 0, 'd' }, { "format", required_argument, 0, 'f' }, { "include", required_argument, 0, 'i' }, { "exclude", required_argument, 0, 'e' }, { 0, 0, 0, 0 } }; enum { BATCH, COMMAND } mode = BATCH; enum { LXT, FST, VCD} wave_fmt = FST; uint64_t stop_time = UINT64_MAX; const char *wave_fname = NULL; int c, index = 0; const char *spec = "bcw::"; optind = 1; while ((c = getopt_long(argc, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': // getopt_long already printed an error message exit(EXIT_FAILURE); case 't': opt_set_int("rt_trace_en", 1); break; case 'b': mode = BATCH; break; case 'c': mode = COMMAND; break; case 's': stop_time = parse_time(optarg); break; case 'f': if (strcmp(optarg, "vcd") == 0) wave_fmt = VCD; else if (strcmp(optarg, "fst") == 0) wave_fmt = FST; else if (strcmp(optarg, "lxt") == 0) wave_fmt = LXT; else fatal("invalid waveform format: %s", optarg); break; case 'S': opt_set_int("rt-stats", 1); break; case 'w': if (optarg == NULL) wave_fname = ""; else wave_fname = optarg; break; case 'd': opt_set_int("stop-delta", parse_int(optarg)); break; case 'i': wave_include_glob(optarg); break; case 'e': wave_exclude_glob(optarg); break; default: abort(); } } if (optind == argc) fatal("missing top-level unit name"); ident_t top = to_unit_name(argv[optind]); ident_t ename = ident_prefix(top, ident_new("elab"), '.'); tree_rd_ctx_t ctx; tree_t e = lib_get_ctx(lib_work(), ename, &ctx); if (e == NULL) fatal("%s not elaborated", istr(top)); else if (tree_kind(e) != T_ELAB) fatal("%s not suitable top level", istr(top)); if (wave_fname != NULL) { const char *name_map[] = { "LXT", "FST", "VCD" }; const char *ext_map[] = { "lxt", "fst", "vcd" }; char *tmp = NULL; if (*wave_fname == '\0') { tmp = xasprintf("%s.%s", argv[optind], ext_map[wave_fmt]); wave_fname = tmp; notef("writing %s waveform data to %s", name_map[wave_fmt], tmp); } wave_include_file(argv[optind]); switch (wave_fmt) { case LXT: lxt_init(wave_fname, e); break; case VCD: vcd_init(wave_fname, e); break; case FST: fst_init(wave_fname, e); break; } if (tmp != NULL) free(tmp); } if (mode == BATCH) rt_batch_exec(e, stop_time, ctx); else { bool master = slave_fork(); if (master) shell_run(e, ctx); else rt_slave_exec(e, ctx); } tree_read_end(ctx); return EXIT_SUCCESS; }