static void set_global_address(void) { uip_ipaddr_t ipaddr; uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); /* set server address */ uip_ip6addr(&server_ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 1); //uip_ip6addr(&server_ipaddr, 0xfe80, 0, 0, 0,0x0212, 0x7401, 1, 0x0101); }
/*---------------------------------------------------------------------------*/ static void set_connection_address(uip_ipaddr_t *ipaddr) { #define _QUOTEME(x) #x #define QUOTEME(x) _QUOTEME(x) #ifdef UDP_CONNECTION_ADDR if(uiplib_ipaddrconv(QUOTEME(UDP_CONNECTION_ADDR), ipaddr) == 0) { PRINTF("UDP client failed to parse address '%s'\n", QUOTEME(UDP_CONNECTION_ADDR)); } #elif UIP_CONF_ROUTER uip_ip6addr(ipaddr,0xaaaa,0,0,0,0x0212,0x7404,0x0004,0x0404); #else uip_ip6addr(ipaddr,0xfe80,0,0,0,0x6466,0x6666,0x6666,0x6666); #endif /* UDP_CONNECTION_ADDR */ }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(unicast_sender_process, ev, data) { static struct etimer periodic_timer; static struct etimer send_timer; uip_ipaddr_t global_ipaddr; PROCESS_BEGIN(); printf("App: %u starting\n", node_id); uip_ip6addr(&root_ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 1); if(node_id == ROOT_ID) { memcpy(&global_ipaddr, &root_ipaddr, 16); uip_ds6_addr_add(&global_ipaddr, 0, ADDR_MANUAL); rpl_dag_t *dag = rpl_set_root(RPL_DEFAULT_INSTANCE, &global_ipaddr); rpl_set_prefix(dag, &global_ipaddr, 64); } else { uip_ip6addr(&global_ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&global_ipaddr, &uip_lladdr); uip_ds6_addr_add(&global_ipaddr, 0, ADDR_AUTOCONF); } orpl_init(&global_ipaddr, node_id == ROOT_ID, 1); simple_udp_register(&unicast_connection, UDP_PORT, NULL, UDP_PORT, receiver); if(node_id == ROOT_ID) { NETSTACK_RDC.off(1); } else { etimer_set(&periodic_timer, SEND_INTERVAL); while(1) { etimer_set(&send_timer, random_rand() % (SEND_INTERVAL)); PROCESS_WAIT_UNTIL(etimer_expired(&send_timer)); if(orpl_current_edc() != 0xffff) { app_send_to(ROOT_ID); } else { printf("App: not in DODAG\n"); } PROCESS_WAIT_UNTIL(etimer_expired(&periodic_timer)); etimer_reset(&periodic_timer); } } PROCESS_END(); }
/* Glowny program */ PROCESS_THREAD(program_UDP, ev, data) { static struct etimer et; PROCESS_BEGIN(); #if UIP_CONF_IPV6 > 0 uip_ip6addr(&ipaddr, addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]); #else uip_ipaddr(&ipaddr, addr[0], addr[1], addr[2], addr[3]); #endif conn = udp_new(&ipaddr, UIP_HTONS(port), &state); udp_bind(conn, UIP_HTONS(port + 1)); printf("Binded\n"); etimer_set(&et, CLOCK_CONF_SECOND * 3); while (1) { PROCESS_WAIT_EVENT(); if (uip_newdata()) { str = uip_appdata; str[uip_datalen()] = '\0'; printf("Received: '%s'\n", str); } etimer_reset(&et); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(start_app, ev, data) { PROCESS_BEGIN(); static int is_coordinator = 0; memset(rx_buf, '\0', sizeof(rx_buf)); /* Define process that handles data */ process_start(&rx_data_process ,NULL); /* Initialise UART1 */ uart1_init(UART1_BAUD_RATE); /* Callback received byte */ uart1_set_input(handleRxChar); /* Start network stack */ if(is_coordinator) { uip_ipaddr_t prefix; uip_ip6addr(&prefix, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); rpl_tools_init(&prefix); } else { rpl_tools_init(NULL); } printf("Starting RPL node\n"); rest_init_engine(); rest_activate_resource(&resource_coap_rx_uart1, "UART1-RX"); rest_activate_resource(&resource_coap_tx_uart1, "UART1-TX"); PROCESS_END(); }
void set_net_address(void) { uip_ipaddr_t ipaddr; #if RPL_BORDER_ROUTER rpl_dag_t *dag; #endif uip_ip6addr(&ipaddr, NET_ADDR_A, NET_ADDR_B, NET_ADDR_C, NET_ADDR_D, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_TENTATIVE); //#if !UIP_CONF_ROUTER // uip_ds6_prefix_add(&ipaddr, 64, 0); // For on-link determination. //#else // uip_ds6_prefix_add(&ipaddr, 64, 0, 0, 600, 600); //#endif print_addresses(); #if RPL_BORDER_ROUTER dag = rpl_set_root(RPL_DEFAULT_INSTANCE,&ipaddr); if(dag != NULL) { PRINTF("This node is setted as root of a DAG.\r\n"); } else { PRINTF("Error while setting this node as root of a DAG.\r\n"); } #endif }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_server_process, ev, data) { #if UIP_CONF_ROUTER uip_ipaddr_t ipaddr; #endif /* UIP_CONF_ROUTER */ PROCESS_BEGIN(); PRINTF("UDP server started\n"); #if UIP_CONF_ROUTER uip_ip6addr(&ipaddr, UIP_DS6_DEFAULT_PREFIX, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); #endif /* UIP_CONF_ROUTER */ print_local_addresses(); server_conn = udp_new(NULL, UIP_HTONS(3001), NULL); udp_bind(server_conn, UIP_HTONS(3000)); while(1) { PROCESS_YIELD(); if(ev == tcpip_event) { tcpip_handler(); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_server_process, ev, data) { PROCESS_BEGIN(); PRINTF("UDP server started\n"); #if UIP_CONF_ROUTER uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); uip_netif_addr_add(&ipaddr, 64, 0, AUTOCONF); #endif /* UIP_CONF_ROUTER */ print_local_addresses(); server_conn = udp_new(NULL, HTONS(61617), NULL); udp_bind(server_conn, HTONS(61616)); PRINTF("Created a server connection with remote address "); PRINT6ADDR(&server_conn->ripaddr); PRINTF("local/remote port %u/%u\n", HTONS(server_conn->lport), HTONS(server_conn->rport)); while(1) { PROCESS_YIELD(); if(ev == tcpip_event) { tcpip_handler(); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_client_process, ev, data) { static struct etimer et; uip_ipaddr_t ipaddr; PROCESS_BEGIN(); /* NOTE: Use IPv6 address of server here. */ uip_ip6addr(&ipaddr, 0xfe80, 0x0000, 0x0000, 0x0000, 0x48ad, 0x5dff, 0xfe71, 0x5d9d); /* new connection with remote host */ client_conn = udp_new(&ipaddr, UIP_HTONS(3000), NULL); udp_bind(client_conn, UIP_HTONS(3034)); PRINTF("Created a connection with the server "); PRINT6ADDR(&client_conn->ripaddr); PRINTF(" local/remote port %u/%u\n", UIP_HTONS(client_conn->lport), UIP_HTONS(client_conn->rport)); etimer_set(&et, SEND_INTERVAL); while (1) { PROCESS_YIELD(); if (etimer_expired(&et)) { timeout_handler(); etimer_restart(&et); } else if (ev == tcpip_event) { tcpip_handler(); } } PROCESS_END(); }
/* ----------------------------------------------------------------------------- * * -------------------------------------------------------------------------- */ void xtcpd_connect(int linknum, int port_number, xtcp_ipaddr_t addr, xtcp_protocol_t p) { uip_ipaddr_t uipaddr; #if UIP_CONF_IPV4 uip_ipaddr(&uipaddr, addr.u8[0], addr.u8[1], addr.u8[2], addr.u8[3]); #elif UIP_CONF_IPV6 uip_ip6addr(&uipaddr, addr.u16[0], addr.u16[1], addr.u16[2], addr.u16[3], addr.u16[4], addr.u16[5], addr.u16[6], addr.u16[7]); #endif /* UIP_CONF_IPVx */ if (p == XTCP_PROTOCOL_TCP) { struct uip_conn *conn = uip_connect(&uipaddr, HTONS(port_number)); if (conn != NULL) { xtcpd_state_t *s = (xtcpd_state_t *) &(conn->appstate); s->linknum = linknum; s->s.connect_request = 1; s->conn.connection_type = XTCP_CLIENT_CONNECTION; } } else { struct uip_udp_conn *conn; conn = uip_udp_new(&uipaddr, HTONS(port_number)); if (conn != NULL) { xtcpd_state_t *s = (xtcpd_state_t *) &(conn->appstate); s->linknum = linknum; s->s.connect_request = 1; s->conn.connection_type = XTCP_CLIENT_CONNECTION; } } return; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_server_process, ev, data) { #if UIP_CONF_ROUTER uip_ipaddr_t ipaddr; #endif /* UIP_CONF_ROUTER */ PROCESS_BEGIN(); PRINTF("UDP server started\n"); #if RESOLV_CONF_SUPPORTS_MDNS resolv_set_hostname("contiki-udp-server"); #endif #if UIP_CONF_ROUTER uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); #endif /* UIP_CONF_ROUTER */ print_local_addresses(); server_conn = udp_new(NULL, UIP_HTONS(3001), NULL); udp_bind(server_conn, UIP_HTONS(3000)); while(1) { PROCESS_YIELD(); if(ev == tcpip_event) { tcpip_handler(); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_server_process, ev, data) { // uint16_t ipaddr=(uint16_t) IP_TRANS128; //#if UIP_CONF_ROUTER uip_ipaddr_t ipaddr;//=IP_TRANS128; uip_ip6addr(&ipaddr,0xfe80,0,0,0,0x2001,0x22ff,0xfe33,0x4455); //#endif /* UIP_CONF_ROUTER */ PROCESS_BEGIN(); SENSORS_ACTIVATE(button_sensor);//activate button leds_init(); leds_off(LEDS_ALL); simple_udp_register(&udp_connection, UDP_PORT, NULL, UDP_PORT, receiver); while(1) { // printf("bla1"); PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor); // PROCESS_YIELD(); send_data(&ipaddr); } PROCESS_END(); }
/*----------------------------------------------------------------------------*/ int8_t demo_udp_socket_init(void) { /* The choice of server address determines its 6LoPAN header compression. * (Our address will be compressed Mode 3 since it is derived from our link-local address) * Obviously the choice made here must also be selected in udp-server.c. * * For correct Wireshark decoding using a sniffer, add the /64 prefix to the 6LowPAN protocol preferences, * e.g. set Context 0 to aaaa::. At present Wireshark copies Context/128 and then overwrites it. * (Setting Context 0 to aaaa::1111:2222:3333:4444 will report a 16 bit compressed address of aaaa::1111:22ff:fe33:xxxx) * * Note the IPCMV6 checksum verification depends on the correct uncompressed addresses. */ /* We know destination IP address but we need to properly convert it */ uip_ip6addr(&un_server_ipaddr, un_server_ipaddr.u16[0],un_server_ipaddr.u16[1],\ un_server_ipaddr.u16[2],un_server_ipaddr.u16[3],\ un_server_ipaddr.u16[4],un_server_ipaddr.u16[5],\ un_server_ipaddr.u16[6],un_server_ipaddr.u16[7]); pst_conn = udp_new(NULL, UIP_HTONS(__SERVER_PORT), NULL); udp_bind(pst_conn, UIP_HTONS(__CLIENT_PORT)); LOG_INFO("%s", "Create connection with the server "); //uip_debug_ipaddr_print(&un_server_ipaddr); LOG_RAW("\n\r"); LOG_INFO("local/remote port %u/%u\n\r", UIP_HTONS(pst_conn->lport), UIP_HTONS(pst_conn->rport)); //printf("Set dudp timer %p\n\r",&st_et); etimer_set(&st_et, SEND_INTERVAL, _demo_udp_callback); evproc_regCallback(EVENT_TYPE_TCPIP,_demo_udp_callback); return 1; }/* demo_udp_init() */
//**************************************************************************************************************************************************// PROCESS_THREAD(RSSI_SCAN, ev, data) { static struct etimer rssitimer; static struct rtimer rt; PROCESS_BEGIN(); // Set the local address uip_ip6addr(&my_addr, 0, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&my_addr, &uip_lladdr); uip_ds6_addr_add(&my_addr, 0, ADDR_MANUAL); //listening to port 3001 from beacons and sensors listen_conn = udp_new(NULL, UIP_HTONS(0), NULL); //Server Listen connection is bound too port 4001 udp_bind(listen_conn, UIP_HTONS(RECEIVER_PORT)); while(1) { //printf("inside while\n\r"); //etimer_set(&rssitimer, CLOCK_SECOND/200); //GPIO_SET_PIN(GPIO_C_BASE, GPIO_PIN_MASK(1)); //PROCESS_YIELD(); PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event); if ((ev == tcpip_event)) { recv_handler(); } } PROCESS_END(); }
static unsigned short make_neighbor(void *arg) { struct httpd_state *s = (struct httpd_state *)arg; struct collect_neighbor *n = collect_neighbor_get(s->u.count); if(n == NULL) { return 0; } #if !UIP_CONF_IPV6 return snprintf((char *)uip_appdata, uip_mss(), "<li><a href=\"http://172.16.%d.%d/\">%d.%d</a>\r\n", n->addr.u8[0], n->addr.u8[1], n->addr.u8[0], n->addr.u8[1]); #else #if 0 uip_ipaddr_t ipaddr; char ipaddr_str[41]; uip_ip6addr(&ipaddr, NET_ADDR_A, NET_ADDR_B, NET_ADDR_C, NET_ADDR_D, (uint16_t)(((uint16_t)(n->addr.u8[0]^0x02))<<8 | (uint16_t)n->addr.u8[1]), ((uint16_t)(n->addr.u8[2]))<<8 | (uint16_t)n->addr.u8[3], (uint16_t)(n->addr.u8[4])<<8 | n->addr.u8[5], (uint16_t)(n->addr.u8[6])<<8 | n->addr.u8[7]); httpd_sprint_ip6(ipaddr, ipaddr_str); return snprintf((char *)uip_appdata, uip_mss(), "<li><a href=\"http://%s/\">%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X</a>\r\n", ipaddr_str, n->addr.u8[0], n->addr.u8[1], n->addr.u8[2], n->addr.u8[3], n->addr.u8[4], n->addr.u8[5], n->addr.u8[6], n->addr.u8[7]); #endif /* Automatic generation of node address. Javascript funcion required. * Client-side generation is simpler than server-side, as parsing http header * would be requied. */ return snprintf((char *)uip_appdata, uip_mss(), "<li><a id=node name='%x:%x:%x:%x'>%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X</a>\r\n", (uint16_t)(((uint16_t)(n->addr.u8[0]^0x02))<<8 | (uint16_t)n->addr.u8[1]), ((uint16_t)(n->addr.u8[2]))<<8 | (uint16_t)n->addr.u8[3], (uint16_t)(n->addr.u8[4])<<8 | n->addr.u8[5], (uint16_t)(n->addr.u8[6])<<8 | n->addr.u8[7], n->addr.u8[0], n->addr.u8[1], n->addr.u8[2], n->addr.u8[3], n->addr.u8[4], n->addr.u8[5], n->addr.u8[6], n->addr.u8[7]); #endif /* UIP_CONF_IPV6 */ }
void add_route(int dest, int next) { uip_ipaddr_t ipaddr_dest, ipaddr_next; #if !IN_COOJA uint32_t dest_suffix = get_mote_suffix(dest); uint32_t next_suffix = get_mote_suffix(next); #endif PRINTF("add route %d %d\n", dest, next); #if IN_COOJA uip_ip6addr(&ipaddr_dest, 0xaaaa, 0, 0, 0, 0x0212, 0x7400 | dest, dest, dest<<8 | dest); uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400 | next, next, next<<8 | next); #else uip_ip6addr(&ipaddr_dest, 0xaaaa, 0, 0, 0, 0x0212, 0x7400, (dest_suffix >> 16) & 0xffff, dest_suffix & 0xffff); uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400, (next_suffix >> 16) & 0xffff, next_suffix & 0xffff); #endif uip_ds6_route_add(&ipaddr_dest, 128, &ipaddr_next, 0); }
void set_global_address(void) { uip_ipaddr_t ipaddr; uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); }
/*---------------------------------------------------------------------------*/ void rpl_link_neighbor_callback(const linkaddr_t *addr, int status, int numtx) { uip_ipaddr_t ipaddr; rpl_parent_t *parent; rpl_instance_t *instance; rpl_instance_t *end; uip_ip6addr(&ipaddr, 0xfe80, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, (uip_lladdr_t *)addr); for(instance = &instance_table[0], end = instance + RPL_MAX_INSTANCES; instance < end; ++instance) { if(instance->used == 1 ) { parent = rpl_find_parent_any_dag(instance, &ipaddr); if(parent != NULL) { /* Trigger DAG rank recalculation. */ PRINTF("RPL: rpl_link_neighbor_callback triggering update\n"); parent->flags |= RPL_PARENT_FLAG_UPDATED; if(instance->of->neighbor_link_callback != NULL) { instance->of->neighbor_link_callback(parent, status, numtx); parent->last_tx_time = clock_time(); } } } } }
/*---------------------------------------------------------------------------*/ static uip_ipaddr_t * set_global_address(void) { static uip_ipaddr_t ipaddr; int i; uint8_t state; uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); printf("IPv6 addresses: "); for(i = 0; i < UIP_DS6_ADDR_NB; i++) { state = uip_ds6_if.addr_list[i].state; if(uip_ds6_if.addr_list[i].isused && (state == ADDR_TENTATIVE || state == ADDR_PREFERRED)) { uip_debug_ipaddr_print(&uip_ds6_if.addr_list[i].ipaddr); printf("\n"); if(state == ADDR_TENTATIVE) { uip_ds6_if.addr_list[i].state = ADDR_PREFERRED; } } } return &ipaddr; }
/* Sends a ping packet out the radio */ static void raven_ping6(void) { /* ping ipv6.google.com*/ uip_ip6addr(&ping_addr,0x2001,0x420,0x5FFF,0x7D,0x2D0,0xB7FF,0xFE23,0xE6DB); //uip_ip6addr(&ping_addr, 0x2001, 0x4860, 0, 0x2001, 0, 0, 0, 0x68); //uip_ip6addr(&ping_addr, 0xaaaa, 0, 0, 0, 0, 0, 0, 1); UIP_IP_BUF->vtc = 0x60; UIP_IP_BUF->tcflow = 1; UIP_IP_BUF->flow = 0; UIP_IP_BUF->proto = UIP_PROTO_ICMP6; UIP_IP_BUF->ttl = uip_netif_physical_if.cur_hop_limit; uip_ipaddr_copy(&UIP_IP_BUF->destipaddr, &ping_addr); uip_netif_select_src(&UIP_IP_BUF->srcipaddr, &UIP_IP_BUF->destipaddr); UIP_ICMP_BUF->type = ICMP6_ECHO_REQUEST; UIP_ICMP_BUF->icode = 0; /* set identifier and sequence number to 0 */ memset((void *)UIP_ICMP_BUF + UIP_ICMPH_LEN, 0, 4); uip_len = UIP_ICMPH_LEN + UIP_ICMP6_ECHO_REQUEST_LEN + UIP_IPH_LEN; UIP_IP_BUF->len[0] = (u8_t)((uip_len - 40) >> 8); UIP_IP_BUF->len[1] = (u8_t)((uip_len - 40) & 0x00FF); UIP_ICMP_BUF->icmpchksum = 0; UIP_ICMP_BUF->icmpchksum = ~uip_icmp6chksum(); tcpip_ipv6_output(); }
PROCESS_THREAD(raven_lcd_process, ev, data) { PROCESS_BEGIN(); /* Initialize the sensor data history */ memcpy(last_temp, "20.0", sizeof("20.0")); /*Create a udp connection to the server*/ uip_ip6addr(&server_addr, 0xaaaa, 0, 0, 0, 0, 0, 0, 1); /* set destination parameters */ send_conn = udp_new(&server_addr, SERVER_PORT, NULL); /*set local port */ udp_bind(send_conn, HTONS(0xF0B0+1)); /* Listen to port 0xF0B0 for commands */ node_conn = udp_new(NULL, 0, NULL); udp_bind(node_conn, HTONS(0xF0B0)); if(icmp6_new(NULL) != NULL) { while(1) { PROCESS_YIELD(); raven_gui_loop(ev, data); } } PROCESS_END(); }
static uip_ipaddr_t * lookup(uip_ipaddr_t *destipaddr, uip_ipaddr_t *nexthop) { static rimeaddr_t rimeaddr; struct route_entry *route; int i; for(i = 1; i < sizeof(rimeaddr); i++) { rimeaddr.u8[i] = destipaddr->u8[sizeof(*destipaddr) - sizeof(rimeaddr) + i]; } rimeaddr.u8[0] = 0; PRINTF("rimeroute: looking up "); PRINT6ADDR(destipaddr); PRINTF(" with Rime address "); PRINTRIMEADDR((&rimeaddr)); PRINTF("\n"); route = route_lookup(&rimeaddr); if(route == NULL) { process_post(&rimeroute_process, rimeroute_event, &rimeaddr); return NULL; } uip_ip6addr(nexthop, 0xfe80, 0, 0, 0, 0, 0, 0, 0); uip_netif_addr_autoconf_set(nexthop, (uip_lladdr_t *)&route->nexthop); PRINTF("rimeroute: "); PRINT6ADDR(destipaddr); PRINTF(" can be reached via "); PRINT6ADDR(nexthop); PRINTF("\n"); return nexthop; }
PROCESS_THREAD(raven_lcd_process, ev, data) { u8_t error; PROCESS_BEGIN(); /*Create a udp connection to the IPSOserver*/ //swisscom uip_ip6addr(&udp_addr,0x2001,918,0xfff9,0,0,0,0,1); //HE uip_ip6addr(&udp_addr,0x2001,0x470,0x1f12,0x5ec,0x12,0x13ff,0xfe14,0x1516); uip_ip6addr(&udp_addr,0x2001,0x420,0x5FFF,0x7D,0x2D0,0xB7FF,0xFE23,0xE6DB); /* set destination parameters*/ udp_conn = udp_new(&udp_addr, HTONS(0xF0B0), NULL); /*set local port */ udp_bind(udp_conn, HTONS(0xF0B0+1)); if((error = icmp6_new(NULL)) == 0) { while(1) { PROCESS_YIELD(); raven_gui_loop(ev, data); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static uip_ipaddr_t * set_global_address(void) { static uip_ipaddr_t ipaddr; int i; uint8_t state; /* Assign a unique local address (RFC4193, http://tools.ietf.org/html/rfc4193). */ uip_ip6addr(&ipaddr, 0xfc00, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); printf("IPv6 addresses: "); for(i = 0; i < UIP_DS6_ADDR_NB; i++) { state = uip_ds6_if.addr_list[i].state; if(uip_ds6_if.addr_list[i].isused && (state == ADDR_TENTATIVE || state == ADDR_PREFERRED)) { uip_debug_ipaddr_print(&uip_ds6_if.addr_list[i].ipaddr); printf("\n"); } } return &ipaddr; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(start_app, ev, data) { PROCESS_BEGIN(); static int is_coordinator = 0; /* Switch off dongle leds */ /* Initialise ct timer, but don't let it run yet */ ctimer_set(&ct, TOGGLE_TIME, ct_callback, NULL); ctimer_stop(&ct); /* Start net stack */ if(is_coordinator) { uip_ipaddr_t prefix; uip_ip6addr(&prefix, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); rpl_tools_init(&prefix); } else { rpl_tools_init(NULL); } printf("Starting RPL node\n"); rest_init_engine(); rest_activate_resource(&resource_led_toggle, "Dongle/LED-toggle"); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static void set_own_addresses(void) { int i; uint8_t state; rpl_dag_t *dag; uip_ipaddr_t ipaddr; uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); PRINTF("Our IPv6 addresses:\n"); for(i = 0; i < UIP_DS6_ADDR_NB; i++) { state = uip_ds6_if.addr_list[i].state; if(uip_ds6_if.addr_list[i].isused && (state == ADDR_TENTATIVE || state == ADDR_PREFERRED)) { PRINTF(" "); PRINT6ADDR(&uip_ds6_if.addr_list[i].ipaddr); PRINTF("\n"); if(state == ADDR_TENTATIVE) { uip_ds6_if.addr_list[i].state = ADDR_PREFERRED; } } } /* Become root of a new DODAG with ID our global v6 address */ dag = rpl_set_root(RPL_DEFAULT_INSTANCE, &ipaddr); if(dag != NULL) { rpl_set_prefix(dag, &ipaddr, 64); PRINTF("Created a new RPL dag with ID: "); PRINT6ADDR(&dag->dag_id); PRINTF("\n"); } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_client_process, ev, data) { static struct etimer et; uip_ipaddr_t ipaddr; PROCESS_BEGIN(); PRINTF("UDP client process started\n"); uip_ip6addr(&ipaddr, 0xfe80, 0, 0, 0, 0x0215, 0x2000, 0x0002, 0x2145); /* new connection with remote host */ l_conn = udp_new(&ipaddr, UIP_HTONS(3000), NULL); if(!l_conn) { PRINTF("udp_new l_conn error.\n"); } udp_bind(l_conn, UIP_HTONS(LOCAL_CONN_PORT)); PRINTF("Link-Local connection with "); PRINT6ADDR(&l_conn->ripaddr); PRINTF(" local/remote port %u/%u\n", UIP_HTONS(l_conn->lport), UIP_HTONS(l_conn->rport)); uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0x0215, 0x2000, 0x0002, 0x2145); g_conn = udp_new(&ipaddr, UIP_HTONS(3000), NULL); if(!g_conn) { PRINTF("udp_new g_conn error.\n"); } udp_bind(g_conn, UIP_HTONS(GLOBAL_CONN_PORT)); PRINTF("Global connection with "); PRINT6ADDR(&g_conn->ripaddr); PRINTF(" local/remote port %u/%u\n", UIP_HTONS(g_conn->lport), UIP_HTONS(g_conn->rport)); etimer_set(&et, SEND_INTERVAL); while(1) { PROCESS_YIELD(); if(etimer_expired(&et)) { timeout_handler(); etimer_restart(&et); } else if(ev == tcpip_event) { tcpip_handler(); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static void set_global_address(void) { uip_ipaddr_t ipaddr; #if 0 /* Mode 1 - 64 bits inline */ uip_ip6addr(&server_ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 1); #elif 1 /* Mode 2 - 16 bits inline */ uip_ip6addr(&server_ipaddr, 0x2001, 5, 0, 0, 0x200, 0, 0, 1); #else /* Mode 3 - derived from server link-local (MAC) address */ uip_ip6addr(&server_ipaddr, 0xaaaa, 0, 0, 0, 0x0250, 0xc2ff, 0xfea8, 0xcd1a); //redbee-econotag #endif }
PROCESS_THREAD(raven_relay_process, ev, data) { uip_ipaddr_t ipaddr; PROCESS_POLLHANDLER(pollhandler()); PROCESS_EXITHANDLER(exithandler()); // see: http://senstools.gforge.inria.fr/doku.php?id=contiki:examples PROCESS_BEGIN(); PRINTF("Relay process startup.\r\n"); // wait 3 second, in order to have the IP addresses well configured etimer_set(&udp_periodic_timer, CLOCK_CONF_SECOND*3); // wait until the timer has expired PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_TIMER); // Define Address of the server that receives our heartbeats. // TODO: Make this dynamic #ifdef UDP_ADDR_A uip_ip6addr(&ipaddr, UDP_ADDR_A,UDP_ADDR_B,UDP_ADDR_C,UDP_ADDR_D, UDP_ADDR_E,UDP_ADDR_F,UDP_ADDR_G,UDP_ADDR_H); #else /* UDP_ADDR_A */ uip_ip6addr(&ipaddr,0xbbbb,0,0,0,0xd69a,0x20ff,0xfe07,0x7664); #endif /* UDP_ADDR_A */ udpconn = udp_new(NULL, HTONS(0), NULL); //udpconn = udp_new(&ipaddr, HTONS(0xF0B0+1), NULL); udp_bind(udpconn, HTONS(0xF0B0)); // udp_attach(udpconn, NULL); PRINTF("Created connection with remote peer "); PRINT6ADDR(&udpconn->ripaddr); PRINTF("\r\nlocal/remote port %u/%u\r\n", HTONS(udpconn->lport),HTONS(udpconn->rport)); print_local_addresses(); etimer_set(&udp_periodic_timer, 60*CLOCK_SECOND); while(1){ PRINTF("--- Relay: Waiting for events.\r\n"); // tcpip_poll_udp(udpconn); PROCESS_WAIT_EVENT(); // PROCESS_YIELD(); udphandler(ev, data); } PROCESS_END(); }
PROCESS_THREAD(border_router_process, ev, data) { PROCESS_BEGIN(); PROCESS_PAUSE(); { rpl_dag_t *dag; char buf[sizeof(dag_id)]; memcpy(buf,dag_id,sizeof(dag_id)); dag = rpl_set_root((uip_ip6addr_t *)buf); /* Assign separate addresses to the uip stack and the host network interface, but with the same prefix */ /* E.g. bbbb::ff:fe00:200 to the stack and bbbb::1 to the host *fallback* network interface */ /* Otherwise the host will trap packets intended for the stack, just as the stack will trap packets intended for the host */ /* $ifconfig usb0 -arp on Ubuntu to skip the neighbor solicitations. Add explicit neighbors on other OSs */ if(dag != NULL) { printf("Created a new RPL dag\n"); #if UIP_CONF_ROUTER_RECEIVE_RA //Contiki stack will shut down until assigned an address from the interface RA //Currently this requires changes in the core rpl-icmp6.c to pass the link-local RA broadcast #else void sprint_ip6(uip_ip6addr_t addr); int i; uip_ip6addr_t ipaddr; #ifdef HARD_CODED_ADDRESS uiplib_ipaddrconv(HARD_CODED_ADDRESS, &ipaddr); #else uip_ip6addr(&ipaddr, 0xbbbb, 0, 0, 0, 0, 0, 0, 0x1); #endif uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); rpl_set_prefix(dag, &ipaddr, 64); for (i=0;i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { printf("IPV6 Address: ");sprint_ip6(uip_ds6_if.addr_list[i].ipaddr);printf("\n"); } } #endif } } /* The border router runs with a 100% duty cycle in order to ensure high packet reception rates. */ // NETSTACK_MAC.off(1); while(1) { PROCESS_YIELD(); /* Local and global dag repair can be done from ? */ // rpl_set_prefix(rpl_get_dag(RPL_ANY_INSTANCE), &ipaddr, 64); // rpl_repair_dag(rpl_get_dag(RPL_ANY_INSTANCE)); } PROCESS_END(); }