自学教程：C++ tcpip_handler函数代码示例

/*---------------------------------------------------------------------------*/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_plug_process, ev, data){	static struct etimer et;	PROCESS_BEGIN();	  	PRINTF("UDP server started/r/n");	#if DEV_BOARD  	leds_on(LEDS_RED | LEDS_GREEN);	SENSORS_ACTIVATE(button_sensor);#else	leds_on(LEDS_GREEN);	#ifdef HAS_PIR_SENSOR		pir_state = PIR_DISPATCH;		etimer_set(&pir_timer, PIR_INIT_TIME);	#endif#endif#if HAS_TEMP_SENSOR	start_temp_conv();#endif#if HAS_LIGHT_SENSOR	light_sensor_init();#endif	udp_conn = udp_new(NULL, UIP_HTONS(0), NULL);	udp_bind(udp_conn, UIP_HTONS(PLUG_PORT));	PRINTF("listening on udp port %u/r/n",UIP_HTONS(udp_conn->lport));	etimer_set(&et, SEND_INTERVAL);	while(1) {		PROCESS_YIELD();		if(etimer_expired(&et)) {			timeout_handler();			etimer_restart(&et);		}#ifdef HAS_PIR_SENSOR				if((pir_state == PIR_DISPATCH)&&(etimer_expired(&pir_timer))) {			SENSORS_ACTIVATE(button_sensor);			pir_state = PIR_READY;		}#endif				if(ev == tcpip_event) {			PRINTF("Calling tcpip_Handler/r/n");			tcpip_handler();		}				if (ev == sensors_event && data == &button_sensor) {#ifndef DEV_BOARD  			handle_pir_event();#endif			PRINTF("Button Pressed/r/n");		}	}  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(mcast_sink_process, ev, data){  PROCESS_BEGIN();  PRINTF("Multicast Engine: '%s'/n", UIP_MCAST6.name);  if(join_mcast_group() == NULL) {    PRINTF("Failed to join multicast group/n");    PROCESS_EXIT();  }  count = 0;  sink_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(sink_conn, UIP_HTONS(MCAST_SINK_UDP_PORT));  PRINTF("Listening: ");  PRINT6ADDR(&sink_conn->ripaddr);  PRINTF(" local/remote port %u/%u/n",        UIP_HTONS(sink_conn->lport), UIP_HTONS(sink_conn->rport));  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  PROCESS_BEGIN();  PROCESS_PAUSE();  set_global_address();  PRINTF("UDP client process started/n");  print_local_addresses();  /* new connection with remote host */  client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);  udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));  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));  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();}

/* --------------------------------------------------------------- */PROCESS_THREAD(node_process, ev, data){    // All the process start with this    PROCESS_BEGIN();    PRINTF("# Starting.../n");    // Configure the network    network_config();    if (!conn) {         printf("E01/n");         PROCESS_EXIT();    }    #if IS_RPL_ROOT    create_dag();    #endif    // Main, infinite, loop of the process    PRINTF("# Ready!/n");    while (1) {        // Wait, block the process, until an event happens.        // Meanwhile, other process will continue running.        PROCESS_WAIT_EVENT();        // Check the type of event that unblock the process        if (ev == tcpip_event)            tcpip_handler();        else if (ev == serial_line_event_message)            input_handler((char*)data);    }    // All the process ends with this    PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_server_process, ev, data){  static struct etimer timer;  PROCESS_BEGIN();  PRINTF("UDP server started/n");  // wait 3 second, in order to have the IP addresses well configured  etimer_set(&timer, CLOCK_CONF_SECOND*5);  // wait until the timer has expired  PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_TIMER);  print_local_addresses();  server_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(server_conn, UIP_HTONS(3000));  PRINTF("Server listening on UDP port %u/n", UIP_HTONS(server_conn->lport));  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/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_client_process, ev, data){  static struct etimer et;  uip_ipaddr_t ipaddr;  PROCESS_BEGIN();  PRINTF("UDP client process started/n");  print_local_addresses();  set_connection_address(&ipaddr);  /* new connection with remote host */  client_conn = udp_new(&ipaddr, UIP_HTONS(3000), NULL);  udp_bind(client_conn, UIP_HTONS(3001));  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();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  static struct etimer periodic;  static struct ctimer backoff_timer;#if WITH_COMPOWER  static int print = 0;#endif  PROCESS_BEGIN();  PROCESS_PAUSE();  set_global_address();    PRINTF("UDP client process started/n");  print_local_addresses();  /* new connection with remote host */  client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);   if(client_conn == NULL) {    PRINTF("No UDP connection available, exiting the process!/n");    PROCESS_EXIT();  }  udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));   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));#if WITH_COMPOWER  powertrace_sniff(POWERTRACE_ON);#endif  etimer_set(&periodic, SEND_INTERVAL);  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }        if(etimer_expired(&periodic)) {      etimer_reset(&periodic);      ctimer_set(&backoff_timer, SEND_TIME, send_packet, NULL);#if WITH_COMPOWER      if (print == 0) {	powertrace_print("#P");      }      if (++print == 3) {	print = 0;      }#endif    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_server_process, ev, data){  PROCESS_BEGIN();  putstring("Starting UDP server/n");#if BUTTON_SENSOR_ON  putstring("Button 1: Print RIME stats/n");#endif#if SERVER_RPL_ROOT  create_dag();#endif  server_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(server_conn, UIP_HTONS(3000));  PRINTF("Listen port: 3000, TTL=%u/n", server_conn->ttl);  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();#if (BUTTON_SENSOR_ON && (DEBUG==DEBUG_PRINT))    } else if(ev == sensors_event && data == &button_sensor) {      print_stats();#endif /* BUTTON_SENSOR_ON */    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_server_process, ev, data){    uip_ipaddr_t ipaddr;    struct uip_ds6_addr *root_if;    PROCESS_BEGIN();    PROCESS_PAUSE();    SENSORS_ACTIVATE(button_sensor);    PRINTF("UDP server started/n");#if UIP_CONF_ROUTER    uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 1);    /* uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); */    uip_ds6_addr_add(&ipaddr, 0, ADDR_MANUAL);    root_if = uip_ds6_addr_lookup(&ipaddr);    if(root_if != NULL) {        rpl_dag_t *dag;        rpl_set_root((uip_ip6addr_t *)&ipaddr);        dag = rpl_get_dag(RPL_ANY_INSTANCE);        uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0);        rpl_set_prefix(dag, &ipaddr, 64);        PRINTF("created a new RPL dag/n");    } else {        PRINTF("failed to create a new RPL DAG/n");    }#endif /* UIP_CONF_ROUTER */    print_local_addresses();    /* The data sink runs with a 100% duty cycle in order to ensure high       packet reception rates. */    NETSTACK_RDC.off(1);    server_conn = udp_new(NULL, UIP_HTONS(UDP_CLIENT_PORT), NULL);    udp_bind(server_conn, UIP_HTONS(UDP_SERVER_PORT));    PRINTF("Created a server connection with remote address ");    PRINT6ADDR(&server_conn->ripaddr);    PRINTF(" local/remote port %u/%u/n", UIP_HTONS(server_conn->lport),           UIP_HTONS(server_conn->rport));    while(1) {        PROCESS_YIELD();        if(ev == tcpip_event) {            tcpip_handler();        } else if (ev == sensors_event && data == &button_sensor) {            PRINTF("Initiaing global repair/n");            rpl_repair_dag(rpl_get_dag(RPL_ANY_INSTANCE));        }    }    PROCESS_END();}

/*--------------------------------------------------------*/void udp_client_process(void){     /******************** lock the Scheduler ************************/      cyg_scheduler_lock();/****************************************************************/        static struct ctimer backoff_timer; 	 PRINTF("UDP client started/n");	          set_global_address();   	 	 	 print_local_addresses();	 	       client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);      udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));     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));     ctimer_set(&backoff_timer,SEND_TIME,send_packet,NULL);	 //      PRINTF(" local/remote port %u/%u/n", client_conn->lport, client_conn->rport);	 	        void* message = NULL;                                 /******************** unlock the Scheduler ************************/        cyg_scheduler_unlock();/****************************************************************/          while(1){                    // cyg_thread_yield();		     message = cyg_mbox_tryget (mbox_out_tcpip_handle);		     MyEvent_t* msg_local = message ;			 if (  message != NULL){                               cyg_handle_t* event_handlePtr;                              event_handlePtr = (cyg_handle_t*) msg_local-> dataPtr;                              if( cyg_thread_self() == *event_handlePtr){			 			                            tcpip_handler();			                    }  				                             }                          cyg_thread_yield();                     }}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  static struct etimer et, wake_timer, periodic_timer;  uip_ipaddr_t ipaddr;  PROCESS_BEGIN();  PRINTF("UDP client process started/n");#if UIP_CONF_ROUTER  set_global_address();#endif  print_local_addresses();  set_connection_address(&ipaddr);  /* new connection with remote host */  client_conn = udp_new(&ipaddr, UIP_HTONS(3000), NULL);  udp_bind(client_conn, UIP_HTONS(3001));  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, CLOCK_SECOND*10);  PROCESS_WAIT_UNTIL(etimer_expired(&et)); // Wait for DAD and Router Discovery procedure to end.  etimer_set(&et, SEND_INTERVAL);  etimer_set(&wake_timer, AWAKE_INTERVAL);  etimer_set(&periodic_timer, 1);  while(1) {    PROCESS_YIELD();    if(etimer_expired(&wake_timer)){  // if timer hasn't expired do not go in deep sleep, in order to receive a response.		printf("Sleeping.../r/n");		sensorsPowerDown();		sleep_seconds(SLEEP_INTERVAL_SECONDS); // Put system in deep sleep mode for a while.		sensorsPowerUp();		printf("Awake/r/n");    }    if(etimer_expired(&et)) {      timeout_handler();      etimer_restart(&et);      etimer_restart(&wake_timer);    } else if(ev == tcpip_event) {      tcpip_handler();    }    /* Make the process be called almost immediately,     * so that it can force the system to go into deep sleep. */    etimer_restart(&periodic_timer);  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  static struct etimer periodic;  static struct ctimer backoff_timer;  PROCESS_BEGIN();  /* Start powertracing, once every 60 seconds. */  //powertrace_start(CLOCK_SECOND * 60);  PROCESS_PAUSE();  set_global_address();    PRINTF("UDP Client process started/n");  print_local_addresses();  /* new connection with remote host */  client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);   if(client_conn == NULL) {    PRINTF("No UDP connection available, exiting the process!/n");    PROCESS_EXIT();  }  udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));   PRINTF("Created a connection with the server ");  PRINT6ADDR(&client_conn->ripaddr);  PRINTF("/nlocal/remote port %u/%u/n",	UIP_HTONS(client_conn->lport), UIP_HTONS(client_conn->rport));  etimer_set(&periodic, SEND_INTERVAL);  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }        // send sensor data to root periodically.    if(etimer_expired(&periodic)) {      etimer_reset(&periodic);      ctimer_set(&backoff_timer, SEND_TIME, send_packet, NULL);    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  static struct etimer et;  uip_ipaddr_t ipaddr;  int port = 3000; /* Default to 3000 if not using service discovery. */  PROCESS_BEGIN();  PRINTF("UDP client process started/n");#if UIP_CONF_ROUTER  set_global_address();#endif  print_local_addresses();  static resolv_status_t status = RESOLV_STATUS_UNCACHED;  while(status != RESOLV_STATUS_CACHED) {#if RESOLV_CONF_SUPPORTS_MDNS && RESOLV_CONF_SUPPORTS_DNS_SD    status = set_connection_address(&ipaddr, &port);#else    status = set_connection_address(&ipaddr, NULL);#endif    if(status == RESOLV_STATUS_RESOLVING) {      PROCESS_WAIT_EVENT_UNTIL(ev == resolv_event_found);    } else if(status != RESOLV_STATUS_CACHED) {      PRINTF("Can't get connection address./n");      PROCESS_YIELD();    }  }  /* new connection with remote host */  client_conn = udp_new(&ipaddr, UIP_HTONS(port), NULL);  udp_bind(client_conn, UIP_HTONS(port + 1));  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();}

/*---------------------------------------------------------------------------*/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();}

PROCESS_THREAD(udp_server_process, ev, data){  PROCESS_BEGIN();  PRINTF("UDP server started/n");  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){#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)  static struct sensors_sensor *b1;  static struct sensors_sensor *b2;#endif  PROCESS_BEGIN();  putstring("Starting UDP server/n");#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)  putstring("Button 1: Print RIME stats/n");  putstring("Button 2: Reboot/n");#endif#if SERVER_RPL_ROOT  create_dag();#endif  server_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(server_conn, UIP_HTONS(3000));  PRINTF("Listen port: 3000, TTL=%u/n", server_conn->ttl);#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)  b1 = sensors_find(BUTTON_1_SENSOR);  b2 = sensors_find(BUTTON_2_SENSOR);#endif  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)    } else if(ev == sensors_event && data != NULL) {      if(data == b1) {        print_stats();      } else if(data == b2) {        watchdog_reboot();      }#endif /* (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON) */    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(viztool_process, ev, data){  PROCESS_BEGIN();  server_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(server_conn, UIP_HTONS(VIZTOOL_UDP_PORT));  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(ntpd_process, ev, data){  static struct etimer et;  static uip_ipaddr_t ipaddr;  PROCESS_BEGIN();  PRINTF("ntpd process started/n");  set_connection_address(&ipaddr);  /* find the IP of router */  //etimer_set(&et, CLOCK_SECOND);  //while(1){  //  if(uip_ds6_defrt_choose()){  //    uip_ipaddr_copy(&ipaddr, uip_ds6_defrt_choose());  //    break;  //  }  //  etimer_set(&et, CLOCK_SECOND);  //  PROCESS_YIELD_UNTIL(etimer_expired(&et));  //}  /* new connection with remote host */  ntp_conn = udp_new(&ipaddr, UIP_HTONS(NTPD_PORT), NULL);  etimer_set(&et, SEND_INTERVAL * CLOCK_SECOND);  while(1) {    PROCESS_YIELD();    if(etimer_expired(&et)) {      timeout_handler();            if((clock_seconds() > 4294967290U) || (clock_seconds() < 20)){	SEND_INTERVAL = 2 * CLOCK_SECOND;	etimer_set(&et, SEND_INTERVAL);      } else {	if(SEND_INTERVAL <= 512 && (getCurrTime() != 0)) {	  SEND_INTERVAL = 2 * SEND_INTERVAL;	}	etimer_set(&et, SEND_INTERVAL * CLOCK_SECOND);      }    } else if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

PROCESS_THREAD(sender_process, ev, data){        static struct etimer periodic;    static struct ctimer backoff_timer;    PROCESS_BEGIN();//    PROCESS_PAUSE();    set_global_address();        PRINTF("The sender process begins./n");        print_local_addresses();    /* new connection with remote host */    sender_conn = udp_new(NULL, UIP_HTONS(UDP_SINK_PORT), NULL);    if(sender_conn == NULL)    {        PRINTF("No UDP connection available, exiting the process!/n");        PROCESS_EXIT();    }    udp_bind(sender_conn, UIP_HTONS(UDP_SENDER_PORT));    PRINTF("Created a connection with the server ");    PRINT6ADDR(&sender_conn->ripaddr);    PRINTF(" local/remote port %u/%u/n", UIP_HTONS(sender_conn->lport),                UIP_HTONS(sender_conn->rport));    etimer_set(&periodic, SEND_INTERVAL * CLOCK_SECOND);    while(1) {        PROCESS_YIELD();        if(ev == tcpip_event)          tcpip_handler();        if(etimer_expired(&periodic))        {            etimer_reset(&periodic);            ctimer_set(&backoff_timer, RANDWAIT * CLOCK_SECOND, send_packet, NULL);        }    }    PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  static struct etimer et;  uip_ipaddr_t ipaddr;  PROCESS_BEGIN();  PRINTF("UDP client process started/n");#if UIP_CONF_ROUTER  set_global_address();#endif  print_local_addresses();  set_connection_address(&ipaddr);  /* new connection with remote host */  SENSORS_ACTIVATE(button_sensor);//activate button  //client_conn = udp_new(&ipaddr, UIP_HTONS(3000), NULL);   simple_udp_register(&udp_connection, UDP_PORT, NULL, UDP_PORT,    receiver); // udp_bind(client_conn, UIP_HTONS(3001));  //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();    PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor);   // if(etimer_expired(&et)) {      timeout_handler();    //  etimer_restart(&et);    //} else     if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(trickle_protocol_process, ev, data){  PROCESS_BEGIN();  PRINTF("Trickle protocol started/n");  uip_create_linklocal_allnodes_mcast(&ipaddr); /* Store for later */  trickle_conn = udp_new(NULL, UIP_HTONS(TRICKLE_PROTO_PORT), NULL);  udp_bind(trickle_conn, UIP_HTONS(TRICKLE_PROTO_PORT));  PRINTF("Connection: local/remote port %u/%u/n",         UIP_HTONS(trickle_conn->lport), UIP_HTONS(trickle_conn->rport));  token = 0;  trickle_timer_config(&tt, IMIN, IMAX, REDUNDANCY_CONST);  trickle_timer_set(&tt, trickle_tx, &tt);  /*   * At this point trickle is started and is running the first interval. All   * nodes 'agree' that token == 0. This will change when one of them randomly   * decides to generate a new one   */  etimer_set(&et, NEW_TOKEN_INTERVAL);  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    } else if(etimer_expired(&et)) {      /* Periodically (and randomly) generate a new token. This will trigger       * a trickle inconsistency */      if((random_rand() % NEW_TOKEN_PROB) == 0) {        token++;        PRINTF("At %lu: Generating a new token 0x%02x/n",               (unsigned long)clock_time(), token);        trickle_timer_reset_event(&tt);      }      etimer_set(&et, NEW_TOKEN_INTERVAL);    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(tcp_server_process, ev, data){  static uip_ipaddr_t ipaddr;  PROCESS_BEGIN();  PRINTF("TCP server started/r/n");  print_local_addresses();  tcp_listen(HTONS(3000));  while(1) {    PROCESS_YIELD();  // or PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);    if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(receive_process, ev, data){     static struct etimer et;  PROCESS_BEGIN();server_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(server_conn, UIP_HTONS(5885));  while(1)  {    PROCESS_YIELD();    if(ev == tcpip_event)    {      tcpip_handler();    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  PROCESS_BEGIN();  PROCESS_PAUSE();  set_global_address();  PRINTF("UDP client process started/n");  print_local_addresses();  /* new connection with remote host */  client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);  udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));  /* One socket to act as sever */  server_conn = udp_new(NULL, UIP_HTONS(UDP_CLIENT_PORT), NULL);  udp_bind(server_conn, UIP_HTONS(UDP_SERVER_PORT));  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));    /* Starting of the node is anonymous */  /* user with the help of serial command line argument set the region of the node */  region = ANONYMOUS;  /* number of neighbor in the starting is always zero */  cur_nbr = 0;  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  static struct etimer periodic;  static struct ctimer backoff_timer;  PROCESS_BEGIN();  PROCESS_PAUSE();  set_global_address();    PRINTF("UDP client process started/n");  print_local_addresses();  /* new connection with remote host */  client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);   udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));   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(&periodic, SEND_INTERVAL);  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }        if(etimer_expired(&periodic)) {      etimer_reset(&periodic);      ctimer_set(&backoff_timer, SEND_TIME, send_packet, NULL);    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_server_process, ev, data){#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)  static struct sensors_sensor *b1;  static struct sensors_sensor *b2;#endif  PROCESS_BEGIN();  putstring("Starting UDP server/n");#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)  putstring("Button X: Toggle LED X/n");#endif  server_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(server_conn, UIP_HTONS(SERVER_PORT));#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)  b1 = sensors_find(BUTTON_1_SENSOR);  b2 = sensors_find(BUTTON_2_SENSOR);#endif  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)    } else if(ev == sensors_event && data != NULL) {      if(data == b1) {        leds_toggle(LEDS_GREEN);      } else if(data == b2) {        leds_toggle(LEDS_RED);      }#endif /* (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON) */    }  }  PROCESS_END();}