void serial_reader_f(void)
{
int main_pid = 0;
int bytes;
msg_t m;
border_packet_t *uart_buf;
posix_open(uart0_handler_pid, 0);
msg_receive(&m);
main_pid = m.sender_pid;
while(1) {
posix_open(uart0_handler_pid, 0);
bytes = readpacket(get_serial_in_buffer(0), BORDER_BUFFER_SIZE);
if(bytes < 0) {
switch(bytes) {
case(-SIXLOWERROR_ARRAYFULL): {
printf("ERROR: Array was full\n");
break;
}
default: {
printf("ERROR: unknown\n");
break;
}
}
continue;
}
uart_buf = (border_packet_t *)get_serial_in_buffer(0);
if(uart_buf->empty == 0) {
if(uart_buf->type == BORDER_PACKET_CONF_TYPE) {
border_conf_header_t *conf_packet = (border_conf_header_t *)uart_buf;
if(conf_packet->conftype == BORDER_CONF_SYN) {
m.content.ptr = (char *)conf_packet;
msg_send(&m, main_pid, 1);
continue;
}
}
flowcontrol_deliver_from_uart(uart_buf, bytes);
}
}
}
int main(void)
{
shell_t shell;
kernel_pid_t mac = basic_mac_init(mac_stack, BASIC_MAC_CONTROL_STACKSIZE,
PRIORITY_MAIN - 1, CREATE_STACKTEST,
"basic_mac_default", NETDEV_DEFAULT);
sixlowpan = sixlowpan_init(mac, sixlowpan_stack, SIXLOWPAN_CONTROL_STACKSIZE,
PRIORITY_MAIN - 1, CREATE_STACKTEST,
"basic_mac_default");
genrand_init(hwtimer_now());
data_value = (uint8_t)(genrand_uint32() % 256);
netapi_set_option(sixlowpan, NETAPI_CONF_SRC_LEN, &src_len, sizeof(size_t));
netapi_get_option(sixlowpan, NETAPI_CONF_ADDRESS, &src, sizeof(uint16_t));
(void) posix_open(uart0_handler_pid, 0);
(void) puts("Welcome to RIOT!");
shell_init(&shell, shell_command, UART0_BUFSIZE, uart0_readc, uart0_putc);
shell_run(&shell);
return 0;
}
int main(void)
{
puts("RIOT 6LoWPAN example v"APP_VERSION);
sixlowpan_lowpan_init_interface(IF_ID);
/* start thread for monitor mode */
kernel_pid_t monitor_pid = thread_create(monitor_stack_buffer,
sizeof(monitor_stack_buffer),
PRIORITY_MAIN - 2,
CREATE_STACKTEST,
sixlowapp_monitor, NULL,
"monitor");
ipv6_register_packet_handler(monitor_pid);
/* Start the UDP server thread */
sixlowapp_udp_server_pid = thread_create(udp_server_stack_buffer,
sizeof(udp_server_stack_buffer),
PRIORITY_MAIN, CREATE_STACKTEST,
sixlowapp_udp_server_loop, NULL,
"UDP receiver");
/* Open the UART0 for the shell */
posix_open(uart0_handler_pid, 0);
/* initialize the shell */
shell_t shell;
shell_init(&shell, shell_commands, UART0_BUFSIZE, uart0_readc, uart0_putc);
/* start the shell loop */
shell_run(&shell);
return 0;
}
int main(void)
{
puts("IETF90 - BnB - CCN-RPL router");
/*
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();
id = 2;
/* fill neighbor cache */
fill_nc();
riot_ccn_appserver(1, NULL);
rpl_ex_init('n');
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 link_open(link_transport_mdriver_t * driver, const char * path, int flags, ...){
link_op_t op;
link_reply_t reply;
link_mode_t mode;
int err;
va_list ap;
if ( flags & LINK_O_CREAT ){
va_start(ap, flags);
mode = va_arg(ap, link_mode_t);
va_end(ap);
} else {
mode = 0;
}
if( driver == 0 ){
return posix_open(path, convert_flags(flags) | POSIX_OPEN_FLAGS, mode);
}
link_debug(LINK_DEBUG_MESSAGE, "open %s 0%o 0x%X using %p", path, mode, flags, driver->dev.handle);
op.open.cmd = LINK_CMD_OPEN;
op.open.path_size = strlen(path) + 1;
op.open.flags = flags;
op.open.mode = mode;
link_debug(LINK_DEBUG_MESSAGE, "Write open op (%p)", driver->dev.handle);
err = link_transport_masterwrite(driver, &op, sizeof(link_open_t));
if ( err < 0 ){
link_error("failed to write open op with handle %p", driver->dev.handle);
return link_handle_err(driver, err);
}
//Send the path on the bulk out endpoint
link_debug(LINK_DEBUG_MESSAGE, "Write open path (%d bytes)", op.open.path_size);
err = link_transport_masterwrite(driver, path, op.open.path_size);
if ( err < 0 ){
link_error("failed to write path");
return link_handle_err(driver, err);
}
//read the reply to see if the file opened correctly
err = link_transport_masterread(driver, &reply, sizeof(reply));
if ( err < 0 ){
link_error("failed to read the reply");
return link_handle_err(driver, err);
}
if ( reply.err < 0 ){
link_errno = reply.err_number;
link_debug(LINK_DEBUG_WARNING, "Failed to ioctl file (%d)", link_errno);
} else {
link_debug(LINK_DEBUG_MESSAGE, "Opened fildes: %d", reply.err);
}
return reply.err;
}
int fd_init(void)
{
memset(fd_table, 0, sizeof(fd_t) * FD_MAX);
posix_open(uart0_handler_pid, 0);
fd_t fd = {
.__active = 1,
.fd = uart0_handler_pid,
.read = (ssize_t ( *)(int, void *, size_t))posix_read,
.write = (ssize_t ( *)(int, const void *, size_t))posix_write,
.close = posix_close
};
memcpy(&fd_table[STDIN_FILENO], &fd, sizeof(fd_t));
memcpy(&fd_table[STDOUT_FILENO], &fd, sizeof(fd_t));
memcpy(&fd_table[STDERR_FILENO], &fd, sizeof(fd_t));
return FD_MAX;
}
static int fd_get_next_free(void)
{
for (int i = 0; i < FD_MAX; i++) {
fd_t *cur = &fd_table[i];
if (!cur->__active) {
return i;
}
}
return -1;
}
int fd_new(int internal_fd, ssize_t (*internal_read)(int, void *, size_t),
ssize_t (*internal_write)(int, const void *, size_t),
int (*internal_close)(int))
{
int fd = fd_get_next_free();
if (fd >= 0) {
fd_t *fd_s = fd_get(fd);
fd_s->__active = 1;
fd_s->fd = internal_fd;
fd_s->read = internal_read;
fd_s->write = internal_write;
fd_s->close = internal_close;
}
else {
errno = ENFILE;
return -1;
}
return fd;
}
int main(void)
{
board_uart0_init();
posix_open(uart0_handler_pid, 0);
shell_t shell;
shell_init(&shell, shell_commands, SHELL_BUFSIZE, shell_readc, shell_putchar);
puts("`struct tm` utility shell.");
shell_run(&shell);
return 0;
}
int main(void) {
shell_t shell;
(void) posix_open(uart0_handler_pid, 0);
puts("Welcome to RIOT!");
shell_init(&shell, shell_commands, UART0_BUFSIZE, shell_readc, shell_putchar);
shell_run(&shell);
return 0;
}
int main(void)
{
shell_t shell;
posix_open(uart0_handler_pid, 0);
init_transceiver();
puts("Welcome to RIOT!");
shell_init(&shell, NULL, UART0_BUFSIZE, shell_readc, shell_putchar);
shell_run(&shell);
return 0;
}
int main(void) {
printf("6LoWPAN Transport Layers\n");
posix_open(uart0_handler_pid, 0);
init_tl(NULL);
shell_t shell;
shell_init(&shell, shell_commands, uart0_readc, uart0_putc);
shell_run(&shell);
return 0;
}
int main(void)
{
puts("SAFEST demo router v"SAFEST_VERSION);
puts("station: "STATION);
/* start shell */
posix_open(uart0_handler_pid, 0);
shell_t shell;
shell_init(&shell, shell_commands, uart0_readc, uart0_putc);
shell_run(&shell);
return 0;
}
int main(void) {
printf("test_shell.\n");
board_uart0_init();
posix_open(uart0_handler_pid, 0);
shell_t shell;
shell_init(&shell, shell_commands, shell_readc, shell_putchar);
shell_run(&shell);
return 0;
}
int main(void)
{
shell_t shell;
puts("RIOT network stack example application");
/* start shell */
puts("All up, running the shell now");
posix_open(uart0_handler_pid, 0);
shell_init(&shell, shell_commands, UART0_BUFSIZE, uart0_readc, uart0_putc);
shell_run(&shell);
/* should be never reached */
return 0;
}
/******************************************************************************
Open a new GIF file for read, given by its name.
Returns dynamically allocated GifFileType pointer which serves as the GIF
info record.
******************************************************************************/
GifFileType *
DGifOpenFileName(const char *FileName, int *Error)
{
int FileHandle;
GifFileType *GifFile;
if ((FileHandle = posix_open(FileName, O_RDONLY)) == -1) {
if (Error != NULL)
*Error = D_GIF_ERR_OPEN_FAILED;
return NULL;
}
GifFile = DGifOpenFileHandle(FileHandle, Error);
return GifFile;
}
int main(void)
{
puts("Portal down Token Up");
/* we assume the transceiver is started! */
netsetup_set_channel(CONFIG_CHANNEL);
netsetup_set_address(CONFIG_OWN_ADDRESS);
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);
}
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;
}
int main(void)
{
shell_t shell;
puts("Test for the low-level I2C driver");
#ifndef MODULE_NEWLIB
/* prepare I/O for shell */
board_uart0_init();
(void) posix_open(uart0_handler_pid, 0);
shell_init(&shell, shell_commands, UART0_BUFSIZE, uart0_readc, uart0_putc);
#else
shell_init(&shell, shell_commands, UART0_BUFSIZE, getchar, putchar);
#endif
/* define own shell commands */
shell_run(&shell);
return 0;
}
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)
{
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;
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)
{
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)
{
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)
{
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;
}
void shell_runner(void) {
shell_init(&shell, sc, UART0_BUFSIZE, uart0_readc, uart0_putc);
posix_open(uart0_handler_pid, 0);
shell_run(&shell);
}
