int main(void)
{
shell_t shell;
LED_RED_OFF;
/* initialize (and run) the brain */
puts("initializing the brain");
brain_init();
/* run the shell for debugging purposes */
puts("running the shell");
shell_init(&shell, _commands, SHELL_BUFSIZE, _readc, _putc);
shell_run(&shell);
/* should never be reached */
return 0;
}
int main(void)
{
puts("Sensor Token Up");
/* we assume the transceiver is started! */
netsetup_set_channel(CONFIG_CHANNEL);
netsetup_set_address(CONFIG_OWN_ADDRESS);
netsetup_register_ondata(net_receive);
printf("CHANNEL: %d\tADDRESS: %d\n", CONFIG_CHANNEL, CONFIG_OWN_ADDRESS);
netsetup_start();
/* start shell */
posix_open(uart0_handler_pid, 0);
shell_t shell;
shell_init(&shell, shell_commands, UART0_BUFSIZE, uart0_readc, uart0_putc);
shell_run(&shell);
}
/*-----------------------------------------------------------------------------------*/
PROCESS_THREAD(shell_gui_process, ev, data)
{
PROCESS_BEGIN();
ctk_window_new(&window, SHELL_GUI_XSIZE,
SHELL_GUI_YSIZE + 1, "Command shell");
CTK_WIDGET_ADD(&window, &loglabel);
/* CTK_WIDGET_SET_FLAG(&loglabel, CTK_WIDGET_FLAG_MONOSPACE);*/
CTK_WIDGET_ADD(&window, &commandentry);
/* CTK_WIDGET_SET_FLAG(&commandentry, CTK_WIDGET_FLAG_MONOSPACE);*/
CTK_WIDGET_FOCUS(&window, &commandentry);
shell_init();
shell_file_init();
shell_ps_init();
shell_run_init();
shell_text_init();
shell_time_init();
shell_wget_init();
ctk_window_open(&window);
while(1) {
PROCESS_WAIT_EVENT();
if(ev == ctk_signal_widget_activate &&
data == (process_data_t)&commandentry) {
int command_len = (int)strlen(command);
shell_default_output("> ", 2, command, command_len);
shell_input(command, command_len);
if(shell_gui_process.state) {
CTK_TEXTENTRY_CLEAR(&commandentry);
CTK_WIDGET_REDRAW(&commandentry);
}
} else if(ev == ctk_signal_window_close ||
ev == PROCESS_EVENT_EXIT) {
shell_quit();
ctk_window_close(&window);
process_exit(&shell_gui_process);
LOADER_UNLOAD();
}
}
PROCESS_END();
}
int main(void) {
printf("6LoWPAN\n");
vtimer_init();
posix_open(uart0_handler_pid, 0);
//struct tm now;
//rtc_get_localtime(&now);
//srand((unsigned int)now.tm_sec);
//uint8_t random = rand() % 256;
//printf("address: %d\n", random);
shell_t shell;
shell_init(&shell, shell_commands, uart0_readc, uart0_putc);
shell_run(&shell);
return 0;
}
init(void)
{
int secs;
mem_init();
trap_init();
kstdio_init();
stdio_init();
tty_init();
timer_init();
kern_init();
enable_intrs();
#ifdef MV134_TIMER_TEST
/* for testing only, XXX */
timer_test_init();
#endif
/* gdb_init(); XXX if enabled never returns */
shell_init();
}
int main(void)
{
shell_t shell;
(void) posix_open(uart0_handler_pid, 0);
#ifdef MODULE_LTC4150
ltc4150_start();
#endif
#ifdef MODULE_TRANSCEIVER
init_transceiver();
#endif
(void) puts("Welcome to RIOT!");
shell_init(&shell, NULL, UART0_BUFSIZE, shell_readc, shell_putchar);
shell_run(&shell);
return 0;
}
int main(void) {
#if defined (__USE_LPCOPEN)
// Read clock settings and update SystemCoreClock variable
SystemCoreClockUpdate();
#endif
SwitchMatrix_Init();
IOCON_Init();
uart_init();
uart_setup();
shell_init(uart_get_char, uart_put_char);
gpio_init();
if (!shell_add_command("version", command_version)) {
uart_put_line("shell_add_command(version) error\n");
}
shell_set_prompt("\n$>");
shell_start(); /* no return */
return 0 ;
}
int main(void)
{
shell_t shell;
gnrc_netreg_entry_t dump;
puts("KW2XRF device driver test");
/* register the pktdump thread */
puts("Register the packet dump thread for GNRC_NETTYPE_UNDEF packets");
dump.pid = gnrc_pktdump_getpid();
dump.demux_ctx = GNRC_NETREG_DEMUX_CTX_ALL;
gnrc_netreg_register(GNRC_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;
}
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 )
{
// Initialize platform first
if( platform_init() != PLATFORM_OK )
{
// This should never happen
while( 1 );
}
// Initialize the TLSF allocator
// (if TLSF is not used, the next function does nothing)
tlsf_elua_init();
// Initialize device manager
dm_init();
// Register the ROM filesystem
dm_register( romfs_init() );
// Initialize XMODEM
xmodem_init( xmodem_send, xmodem_recv );
// Initialize terminal
term_init( TERMINAL_LINES, TERMINAL_COLS, term_out, term_in, term_translate );
printf( ".text ends at %p\n", etext );
// Run the shell
if( shell_init( XMODEM_MAX_FILE_SIZE ) == 0 )
{
printf( "Unable to initialize the eLua shell!\n" );
// Start Lua directly
char* lua_argv[] = { "lua", NULL };
lua_main( 1, lua_argv );
}
else
shell_start();
while( 1 );
}
int main()
{
uint32_t mask;
init();
/* Spawn the shell. */
shell_init(&shell, &uart.chin, &uart.chout, NULL, NULL, NULL, NULL);
thrd_spawn(shell_main,
&shell,
0,
shell_stack,
sizeof(shell_stack));
while (1) {
mask = (EVENT_BUTTON_PLAY
| EVENT_BUTTON_NEXT
| EVENT_BUTTON_PREV
| EVENT_BUTTON_STOP);
event_read(&event, &mask, sizeof(mask));
if (mask & EVENT_BUTTON_PLAY) {
handle_event_play();
}
if (mask & EVENT_BUTTON_NEXT) {
handle_event_next();
}
if (mask & EVENT_BUTTON_PREV) {
handle_event_prev();
}
if (mask & EVENT_BUTTON_STOP) {
handle_event_stop();
}
}
return (0);
}
static bsp_init (void)
{
rg_led_init ();
g_led (0);
#if FS_EN == 1
fs_init ();
#endif
#if SHELL_EN == 1
shell_init ();
#endif
#if TCP_EN == 1
init_TcpNet ();
#endif
#if KEY_EN == 1
key_init ();
#endif
#if RESET_KEY_EN == 1
reset_key_init ();
#endif
#if GUI_EN == 1
lcd_init ();
lcd_write_led (0);
widget_init ();
#endif
I2CInit(0);
#if RTC_EN == 1
pcf8563_init ();
#endif
}
void kernel_main() {
gdt_install();
idt_install();
isrs_install();
irq_install();
terminal_initialize();
memory_manager_init();
enable_interrupts();
timer_install();
keyboard_install();
shell_init();
terminal_writestring("Hello, kernel World!\n");
terminal_writestring("Here is some text in a new line\n");
terminal_writestring("Here is some more text\n");
terminal_writestring("Here is a new line\n");
terminal_writestring("Here is some text after terminal scroll\n");
char str[] = "A string";
char ch = 'c';
int integer = 45;
printf("This is a test for printf.\nThis is a char %c and this a string %s\n", ch, str);
printf("This is an int %d. This is the same in hex %x\n", integer, integer);
for (size_t i = 0; i < 5; i++) {
printf("This is line number %d\n", i);
}
puts("waiting for 2 sec\n");
timer_wait(2);
puts("waiting complete\n");
char buffer[200];
gets(buffer);
printf("%s\n", buffer);
while(1) {
shell();
}
}
/**
* @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;
}
void main (void)
{
printf ("Jerry Compilation " __DATE__ " " __TIME__ "\n");
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t print_func_name_val = jerry_create_string ((jerry_char_t *) "print");
print_function = jerry_get_property (global_obj_val, print_func_name_val);
jerry_release_value (print_func_name_val);
jerry_release_value (global_obj_val);
if (jerry_value_has_error_flag (print_function))
{
printf ("Error: could not look up print function, expression results won't be printed\n");
}
shell_register_app_cmd_handler (shell_cmd_handler);
shell_init ("js> ", commands);
/* Don't call jerry_cleanup() here, as shell_init() returns after setting
up background task to process shell input, and that task calls
shell_cmd_handler(), etc. as callbacks. This processing happens in
the infinite loop, so JerryScript doesn't need to be de-initialized. */
} /* main */
//==========================================================| MAIN
int main( int argc, char *argv[] ) {
DEBUG_LEVEL = 0;
logger log = { debug_function };
log.debug( INFO(1), "SHELL START" );
int status;
char* new_line;
line* parsed_line;
shell_init();
while( ! is_end_of_file() ) {
print_prompt();
new_line = get_line();
if( !new_line ) continue;
parsed_line = parseline( new_line );
execute_line( parsed_line );
}
log.debug( INFO(1), "SHELL STOP" );
exit( EXIT_SUCCESS );
}
void user_init( void )
{
positiondebut = 0;
positionfin = 1;
positiondebutUDP = 0;
positionfinUDP = 0;
static struct station_config config;
uart_div_modify( 0, UART_CLK_FREQ / ( 115200 ) );
os_printf( "%s\n", __FUNCTION__ );
uart_init(115200,9600);
spi_slave_init(HSPI,SPI_BUFF);
wifi_station_set_hostname( HOSTNAME );
wifi_set_opmode_current( STATIONAP_MODE );
gpio_init();
spi_gpio_init();
//os_printf sur Uart0
espconn_init() ;
uart0_tx_buffer("init\n", 5);
config.bssid_set = 1;
os_memcpy( &config.ssid, SSID, 14 );
os_memcpy( &config.password, PASSWORD, 41);
wifi_station_set_config( &config );
wifi_station_connect();
// wifi_set_event_handler_cb( wifi_callback );
shell_init();
//Démarage du client UDP
user_set_station_config_udp();
MessageUDP.Status = E_ID;
MessageSPi.Status = E_ID;
system_os_task(all_recvTask,PRIO_SPI, all_recvTaskQueue, TASK_LENGHT); ///demo with a task to process the uart data
system_os_task(uart_recvTask,PRIO_UART, uart_recvTaskQueue, TASK_LENGHT); // //demo with a task to process the spi
}
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;
}
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()
{
#ifdef EMULATION
emu_init();
#endif
irq_setmask(0);
irq_enable(1);
uart_async_init();
banner();
brd_init();
cpustats_init();
time_init();
mem_init();
vga_init();
snd_init();
pfpu_init();
tmu_init();
renderer_init();
apipe_init();
rpipe_init();
slowout_init();
hdlcd_init();
ui_init();
shell_init();
while(1) {
if(readchar_nonblock())
shell_input(readchar());
apipe_service();
rpipe_service();
#ifdef EMULATION
emu_service();
#endif
}
return 0;
}
int main (int argc, char *argv[]) {
char cmd[256];
int ret;
ret = shell_init() ;
if (ret < 0) {
return -1;
}
while (printf("$ "), fgets (cmd, 256, stdin) != NULL) {
ret = create_job (cmd);
if (IS_SYNTAX_ERROR (ret)) {
puts ("Syntax Error!");
}
else if (IS_CMD_LINE_OK (ret))
run_fg_job();
}
return EXIT_SUCCESS;
}
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 main( void )
{
// Initialize platform first
if( platform_init() != PLATFORM_OK )
{
// This should never happen
while( 1 );
}
// Initialize device manager
dm_init();
// Register the ROM filesystem
dm_register( romfs_init() );
// Initialize XMODEM
xmodem_init( xmodem_send, xmodem_recv );
// Initialize terminal
term_init( TERMINAL_LINES, TERMINAL_COLS, term_out, term_in, term_translate );
printf( ".text ends at %p, first free RAM is at %p, last free ram is at %p\r\n", etext, platform_get_first_free_ram(), platform_get_last_free_ram() );
// Run the shell
if( shell_init( XMODEM_MAX_FILE_SIZE ) == 0 )
{
printf( "Unable to initialize the eLua shell!\n" );
// Start Lua directly
char* lua_argv[] = { "lua", NULL };
lua_main( 1, lua_argv );
}
else
shell_start();
while( 1 );
}
int shell(void)
{
shell_init();
while (1) {
int argc;
char *argv[MAX_ARGC];
char line[MAX_ARG_LEN];
command_read_line(line);
argc = command_translate(line, argv);
if (argc < 0) {
printf("Invalid command line: \"%s\"\n", line);
continue;
}
exec(argc, argv);
putchar('\n');
}
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);
}
int main(int argc, char **argv)
{
GSList *modules;
DEBUG("HardInfo version " VERSION ". Debug version.");
DEBUG("g_thread_init()");
if (!g_thread_supported())
g_thread_init(NULL);
/* parse all command line parameters */
parameters_init(&argc, &argv, ¶ms);
/* show version information and quit */
if (params.show_version) {
g_print("HardInfo version " VERSION "\n");
g_print
("Copyright (C) 2003-2009 Leandro A. F. Pereira. See COPYING for details.\n\n");
g_print("Compile-time options:\n"
" Release version: %s (%s)\n"
" BinReloc enabled: %s\n"
" Data prefix: %s\n"
" Library prefix: %s\n"
" Compiled on: %s %s (%s)\n",
RELEASE ? "Yes" : "No (" VERSION ")", ARCH,
ENABLE_BINRELOC ? "Yes" : "No",
PREFIX, LIBPREFIX, PLATFORM, KERNEL, HOSTNAME);
DEBUG(" Debugging is enabled.");
/* show also available modules */
params.list_modules = TRUE;
}
/* initialize the binreloc library, so we can load program data */
if (!binreloc_init(FALSE))
g_error("Failed to find runtime data.\n\n"
"\342\200\242 Is HardInfo correctly installed?\n"
"\342\200\242 See if %s and %s exists and you have read permision.",
PREFIX, LIBPREFIX);
/* list all module names */
if (params.list_modules) {
g_print("Modules:\n"
"%-20s%-15s%-12s\n", "File Name", "Name", "Version");
for (modules = modules_load_all(); modules;
modules = modules->next) {
ShellModule *module = (ShellModule *) modules->data;
ModuleAbout *ma = module_get_about(module);
gchar *name = g_path_get_basename(g_module_name(module->dll));
g_print("%-20s%-15s%-12s\n", name, module->name, ma->version);
g_free(name);
}
return 0;
}
if (!params.create_report && !params.run_benchmark && !params.run_xmlrpc_server) {
/* we only try to open the UI if the user didn't asked for a
report. */
params.gui_running = ui_init(&argc, &argv);
/* as a fallback, if GTK+ initialization failed, run in report
generation mode. */
if (!params.gui_running)
params.create_report = TRUE;
}
if (params.use_modules) {
/* load only selected modules */
DEBUG("loading user-selected modules");
modules = modules_load_selected();
} else {
/* load all modules */
DEBUG("loading all modules");
modules = modules_load_all();
}
/* initialize vendor database */
vendor_init();
if (params.run_xmlrpc_server) {
g_type_init();
xmlrpc_server_init();
xmlrpc_server_start();
} else if (params.run_benchmark) {
gchar *result;
result = module_call_method_param("benchmark::runBenchmark", params.run_benchmark);
if (!result) {
g_error("Unknown benchmark ``%s'' or benchmark.so not loaded", params.run_benchmark);
} else {
g_print("Benchmark result: %s\n", result);
g_free(result);
}
} else if (params.gui_running) {
/* initialize gui and start gtk+ main loop */
icon_cache_init();
stock_icons_init();
shell_init(modules);
DEBUG("entering gtk+ main loop");
gtk_main();
} else if (params.create_report) {
/* generate report */
gchar *report;
DEBUG("generating report");
report = report_create_from_module_list_format(modules,
params.
report_format);
g_print("%s", report);
g_free(report);
} else {
g_error("Don't know what to do. Exiting.");
}
DEBUG("finished");
return 0;
}
void module_shell_init()
{
shell_init();
}
int main(int argc, char *argv[]){
shell_init();
return EXIT_SUCCESS;
}
static void
init_netifs(void)
{
#if PPP_SUPPORT
pppInit();
#if PPP_PTY_TEST
ppp_sio = sio_open(2);
#else
ppp_sio = sio_open(0);
#endif
if(!ppp_sio)
{
perror("Error opening device: ");
exit(1);
}
#ifdef LWIP_PPP_CHAP_TEST
pppSetAuth(PPPAUTHTYPE_CHAP, "lwip", "mysecret");
#endif
pppOpen(ppp_sio, pppLinkStatusCallback, NULL);
#endif /* PPP_SUPPORT */
#if LWIP_DHCP
{
IP4_ADDR(&gw, 0,0,0,0);
IP4_ADDR(&ipaddr, 0,0,0,0);
IP4_ADDR(&netmask, 0,0,0,0);
netif_add(&netif, &ipaddr, &netmask, &gw, NULL, tapif_init,
tcpip_input);
netif_set_default(&netif);
dhcp_start(&netif);
}
#else
netif_set_default(netif_add(&netif,&ipaddr, &netmask, &gw, NULL, tapif_init,
tcpip_input));
netif_set_up(&netif);
#endif
#if LWIP_IPV6
netif_create_ip6_linklocal_address(&netif, 1);
#endif
#if 0
/* Only used for testing purposes: */
netif_add(&ipaddr, &netmask, &gw, NULL, pcapif_init, tcpip_input);
#endif
#if LWIP_TCP
tcpecho_init();
shell_init();
my_http_server_netconn_init();
// httpd_init();
#endif
#if LWIP_UDP
udpecho_init();
#endif
/* sys_timeout(5000, tcp_debug_timeout, NULL);*/
}
