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

/*---------------------------------------------------------------------------*/static u8_tudphandler(process_event_t ev, process_data_t data){  if(etimer_expired(&udp_periodic_timer)) {    printf("Event timer expired/r/n");    count=0;  }  if(ev == tcpip_event) {    if(uip_newdata()) {      ((char *)uip_appdata)[uip_datalen()] = 0;      printf("Sender received: '%s'/r/n", uip_appdata);    }  }  if(count < UDP_NB) {    count++;    printf("Sender sending to: ");    PRINT6ADDR(&udpconn->ripaddr);    printf("/r/n");#if SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION    uip_udp_packet_send(udpconn, "Sender says Hi!", UIP_APPDATA_SIZE);#else /* SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION */    uip_udp_packet_send(udpconn, "Sender says Hi!", strlen("Sender says Hi!"));#endif /* SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION */  }  etimer_set(&udp_periodic_timer, 13*CLOCK_SECOND + random_rand()%(4*CLOCK_SECOND));  return 0;}

static void dhcp_send_packet(struct uip_udp_conn *conn, const char *name,			     DhcpPacket *out, DhcpPacket *in){	// Send the outbound packet.	printf("Sending %s... ", name);	uip_udp_packet_send(conn, out, sizeof(*out));	printf("done./n");	// Prepare for the reply.	printf("Waiting for reply... ");	dhcp_in = in;	dhcp_out = out;	dhcp_in_ready = 0;	// Poll network driver until we get a reply. Resend periodically.	net_set_callback(&dhcp_callback);	for (;;) {		uint64_t start = timer_us(0);		do {			net_poll();		} while (!dhcp_in_ready &&			 timer_us(start) < DhcpRespTimeoutUs);		if (dhcp_in_ready)			break;		// No response, try again.		uip_udp_packet_send(conn, out, sizeof(*out));	}	net_set_callback(NULL);	printf("done./n");}

/*---------------------------------------------------------------------------*/static voidtimeout_handler(void){#if CONTIKI_TARGET_AVR_RAVEN  char buf[48];  strlcpy_P(buf, ntpmsg, 48);  uip_udp_packet_send(ntp_conn, buf, 48);#else  uip_udp_packet_send(ntp_conn, ntpmsg, 48);#endifprintf("send ntp packet /n");}

static voidtimeout_handler(void){  static int seq_id;  printf("Client sending to: ");  PRINT6ADDR(&client_conn->ripaddr);  sprintf(buf, "Hello %d from the client", ++seq_id);  printf(" (msg: %s)/n", buf);#if SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION  uip_udp_packet_send(client_conn, buf, UIP_APPDATA_SIZE);#else /* SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION */  uip_udp_packet_send(client_conn, buf, strlen(buf));#endif /* SEND_TOO_LARGE_PACKET_TO_TEST_FRAGMENTATION */}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  memset(buf, 0, MAX_PAYLOAD_LEN);  if(uip_newdata()) {    len = uip_datalen();    memcpy(buf, uip_appdata, len);    PRINTF("%u bytes from [", len);    PRINT6ADDR(&UIP_IP_BUF->srcipaddr);    PRINTF("]:%u/n", UIP_HTONS(UIP_UDP_BUF->srcport));    len = read_sensor(buf);    if( len ) {      server_conn->rport = UIP_UDP_BUF->srcport;      uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);      uip_udp_packet_send(server_conn, buf, len);      PRINTF("Sent %u bytes/n", len);    }    /* Restore server connection to allow data from any node */    uip_create_unspecified(&server_conn->ripaddr);    server_conn->rport = 0;  }  return;}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  memset(buf, 0, MAX_PAYLOAD_LEN);  if(uip_newdata()) {    leds_on(LEDS_RED);    len = uip_datalen();    memcpy(buf, uip_appdata, len);    PRINTF("%u bytes from [", len);    PRINT6ADDR(&UIP_IP_BUF->srcipaddr);    PRINTF("]:%u", UIP_HTONS(UIP_UDP_BUF->srcport));    PRINTF(" V=%u", *buf);    PRINTF(" I=%u", *(buf + 1));    PRINTF(" T=%u", *(buf + 2));    PRINTF(" Val=%u/n", *(uint16_t *)(buf + 3));#if SERVER_REPLY    uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);    server_conn->rport = UIP_UDP_BUF->srcport;    uip_udp_packet_send(server_conn, buf, len);    /* Restore server connection to allow data from any node */    uip_create_unspecified(&server_conn->ripaddr);    server_conn->rport = 0;#endif  }  leds_off(LEDS_RED);  PRINTF("sent/n");  return;}

static voidsend_unicast(uip_ipaddr_t *dest, char *buf, int size){    uip_ipaddr_copy(&client_conn->ripaddr, dest);    uip_udp_packet_send(client_conn, buf, size);    uip_create_unspecified(&client_conn->ripaddr);}

/*---------------------------------------------------------------------------*/static voidtimeout_handler(void){  static int seq_id;  struct uip_udp_conn *this_conn;  leds_on(LEDS_RED);  memset(buf, 0, MAX_PAYLOAD_LEN);  seq_id++;  /* evens / odds */  if(seq_id & 0x01) {    this_conn = l_conn;  } else {    this_conn = g_conn;    if(uip_ds6_get_global(ADDR_PREFERRED) == NULL) {      return;    }  }  PRINTF("Client to: ");  PRINT6ADDR(&this_conn->ripaddr);  memcpy(buf, &seq_id, sizeof(seq_id));  PRINTF(" Remote Port %u,", UIP_HTONS(this_conn->rport));  PRINTF(" (msg=0x%04x), %u bytes/n", *(uint16_t *) buf, sizeof(seq_id));  uip_udp_packet_send(this_conn, buf, sizeof(seq_id));  leds_off(LEDS_RED);}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  static int seq_id;  char buf[MAX_PAYLOAD_LEN];  if(uip_newdata()) {    ((char *)uip_appdata)[uip_datalen()] = 0;    PRINTF("Server received: '%s' from ", (char *)uip_appdata);    PRINT6ADDR(&UDP_IP_BUF->srcipaddr);    PRINTF("/n");    uip_ipaddr_copy(&server_conn->ripaddr, &UDP_IP_BUF->srcipaddr);    server_conn->rport = UDP_IP_BUF->srcport;    PRINTF("Responding with message: ");    sprintf(buf, "Hello from the server! (%d)", ++seq_id);    PRINTF("%s/n", buf);    uip_udp_packet_send(server_conn, buf, strlen(buf));    /* Restore server connection to allow data from any node */    memset(&server_conn->ripaddr, 0, sizeof(server_conn->ripaddr));    server_conn->rport = 0;  }}

static voidtcpip_handler(void){  static int seq_id;  char buf[MAX_PAYLOAD_LEN];  if(uip_newdata()) {    ((char *)uip_appdata)[uip_datalen()] = 0;    PRINTF("Server received: '%s' from ", (char *)uip_appdata);    PRINT6ADDR(&UIP_IP_BUF->srcipaddr);    PRINTF("/n");#if CETIC_NODE_INFO    node_info_t *node = node_info_lookup(&UIP_IP_BUF->srcipaddr);    if(node == NULL) {      node = node_info_add(&UIP_IP_BUF->srcipaddr);    }    if(node != NULL) {      node->last_lookup = clock_time();      strncpy(node->my_info, (char *)uip_appdata, sizeof(node->my_info) - 1);    }#endif    uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);    PRINTF("Responding with message: ");    sprintf(buf, "Hello from the server! (%d)", ++seq_id);    PRINTF("%s/n", buf);    uip_udp_packet_send(server_conn, buf, strlen(buf));    /* Restore server connection to allow data from any node */    memset(&server_conn->ripaddr, 0, sizeof(server_conn->ripaddr));  }}

static voidsend_rreq(uip_ipaddr_t *addr){  struct uaodv_msg_rreq *rm = (struct uaodv_msg_rreq *)uip_appdata;  int len;  print_debug("send RREQ for %d.%d.%d.%d/n", uip_ipaddr_to_quad(addr));  rm->type = UAODV_RREQ_TYPE;  rm->dest_seqno = last_known_seqno(addr);  if(rm->dest_seqno == 0)    rm->flags = UAODV_RREQ_UNKSEQNO;  else    rm->flags = 0;  rm->reserved = 0;  rm->hop_count = 0;  rm->rreq_id = uip_htonl(rreq_id++);  uip_ipaddr_copy(&rm->dest_addr, addr);  uip_gethostaddr(&rm->orig_addr);  my_hseqno++;			/* Always */  rm->orig_seqno = uip_htonl(my_hseqno);  bcastconn->ttl = MY_NET_DIAMETER;  len = sizeof(struct uaodv_msg_rreq);  len += add_rreq_extensions(rm + 1);  uip_udp_packet_send(bcastconn, rm, len);}

/*---------------------------------------------------------------------------*/static voidhandle_incoming_rerr(void){  struct uaodv_msg_rerr *rm = (struct uaodv_msg_rerr *)uip_appdata;  struct uaodv_rt_entry *rt;  print_debug("RERR %d.%d.%d.%d -> %d.%d.%d.%d"	      " unreach=%d.%d.%d.%d seq=%lu/n",	      uip_ipaddr_to_quad(&BUF->srcipaddr),	      uip_ipaddr_to_quad(&BUF->destipaddr),	      uip_ipaddr_to_quad((uip_ipaddr_t *)&rm->unreach[0]),	      uip_ntohl(rm->unreach[0].seqno));  if(uip_ipaddr_cmp(&rm->unreach[0].addr, &uip_hostaddr))    return;  rt = uaodv_rt_lookup_any(&rm->unreach[0].addr);  if(rt != NULL && uip_ipaddr_cmp(&rt->nexthop, uip_udp_sender())) {    if((rm->flags & UAODV_RERR_UNKNOWN) || rm->unreach[0].seqno == 0       || SCMP32(rt->hseqno, uip_ntohl(rm->unreach[0].seqno)) <= 0) {      rt->is_bad = 1;      if(rm->flags & UAODV_RERR_UNKNOWN) {	rm->flags &= ~UAODV_RERR_UNKNOWN;	rm->unreach[0].seqno = uip_htonl(rt->hseqno);      }      print_debug("RERR rebroadcast/n");      uip_udp_packet_send(bcastconn, rm, sizeof(struct uaodv_msg_rerr));    }  }}

static voidsend_data(void){  char buf[MAX_PAYLOAD_LEN];  if (init_buffer(COAP_DATA_BUFF_SIZE)) {    int data_size = 0;    coap_packet_t* request = (coap_packet_t*)allocate_buffer(sizeof(coap_packet_t));    init_packet(request);    coap_set_method(request, COAP_POST);    request->tid = xact_id++;    request->type = MESSAGE_TYPE_NON;    coap_set_header_uri(request, service_url);    data_size = serialize_packet(request, buf);//    PRINTF("Client sending request to:[");//    PRINT6ADDR(&client_conn->ripaddr);//    PRINTF("]:%u/%s/n", (uint16_t)REMOTE_PORT, service_urls[service_id]);    uip_udp_packet_send(client_conn, buf, data_size);    delete_buffer();  }}

PROCESS_THREAD(udp_process, ev, data){  static struct uip_udp_conn *s;  static struct etimer et;  PROCESS_BEGIN();  uart0_set_br(1000000);  /* setup udp connection             */  s = udp_broadcast_new(UIP_HTONS(2020),NULL); // incoming  udp_bind(s,UIP_HTONS(2020));                 // outgoing  /* start estimator process and init psock connection handler */  process_start(&ahrs_process, NULL);  etimer_set(&et, SEND_INTERVAL);  while(1) {    PROCESS_WAIT_EVENT_UNTIL(ev==PROCESS_EVENT_TIMER);    uip_udp_packet_send(s,msg,strlen(msg));    etimer_restart(&et);  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  char *appdata;  char buf[10];  if(uip_newdata()) {    packets++;    rssi_packets++;    rssi_rec += packetbuf_attr(PACKETBUF_ATTR_RSSI) - 45;    appdata = (char *)uip_appdata;    appdata[uip_datalen()] = 0;    PRINTF("DATA recv '%s' from ", appdata);    PRINTF("%d",           UIP_IP_BUF->srcipaddr.u8[sizeof(UIP_IP_BUF->srcipaddr.u8) - 1]);    PRINTF("/n");    if(rssi_packets == 3) {    	/*PRINTF("packets_received = %d/n", packets);*/      sprintf(buf, "%d %u", rssi_rec / rssi_packets, packets);      /*PRINTF("RSSI: %d, %d/n",rssi/rssi_packets, packets);*/      uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);      uip_udp_packet_send(server_conn, buf, strlen(buf));      uip_create_unspecified(&server_conn->ripaddr);      rssi_packets = 0;      rssi_rec = 0;    }  }}

/*---------------------------------------------------------------------------*/static voidtrickle_tx(void *ptr, uint8_t suppress){  /* *ptr is a pointer to the trickle_timer that triggered this callback. In   * his example we know that ptr points to tt. However, we pretend that we did   * not know (which would be the case if we e.g. had multiple trickle timers)   * and cast it to a local struct trickle_timer* */  struct trickle_timer *loc_tt = (struct trickle_timer *)ptr;  if(suppress == TRICKLE_TIMER_TX_SUPPRESS) {    return;  }  leds_on(LEDS_RED);  PRINTF("At %lu (I=%lu, c=%u): ",         (unsigned long)clock_time(), (unsigned long)loc_tt->i_cur,         loc_tt->c);  PRINTF("Trickle TX token 0x%02x/n", token);  /* Instead of changing ->ripaddr around by ourselves, we could have used   * uip_udp_packet_sendto which would have done it for us. However it puts an   * extra ~20 bytes on stack and the cc2x3x micros hate it, so we stick with   * send() */  /* Destination IP: link-local all-nodes multicast */  uip_ipaddr_copy(&trickle_conn->ripaddr, &ipaddr);  uip_udp_packet_send(trickle_conn, &token, sizeof(token));  /* Restore to 'accept incoming from any IP' */  uip_create_unspecified(&trickle_conn->ripaddr);  leds_off(LEDS_RED);}

/* Subscribe to the specified topic */void mqtt_msg_publish(const char *topic, const char *data){    uint8_t header_size = 7;    int i;    uint8_t topic_id = 0;    printf("Publish : %s %s/n", topic, data);    if (mqtt.state != MQTT_STATE_CONNECTED)        return;    for (i = 0; i < mqtt.nb_topics; i++)    {        if (!strcmp(topic, mqtt.topics[i].name))        {            topic_id = mqtt.topics[i].id;            printf("topic_id found : %d/n", topic_id);        }    }    mqtt.data[0] = (strlen(topic) + header_size);    mqtt.data[1] = MQTT_MSG_PUBLISH;    mqtt.data[2] = 0;    mqtt.data[3] = (topic_id & 0xff00) >> 8;    mqtt.data[4] = (topic_id & 0x00ff);    mqtt.data[5] = 0;    mqtt.data[6] = 0;    memcpy(mqtt.data + header_size, data, strlen(data));    mqtt.len = (strlen(data) + header_size);    mqtt.pending_msg = MQTT_MSG_PUBLISH;    printf("Send packet topicid : %d/n", topic_id);    uip_udp_packet_send(mqtt.udp_connection, mqtt.data, mqtt.len);}

/* Subscribe to the specified topic */void mqtt_subscribe(const char *topic){    uint8_t header_size = 5;    int i;    printf("Subscribe : %s/n", topic);    if (mqtt.state != MQTT_STATE_CONNECTED)        return;    for (i = 0; i < mqtt.nb_topics; i++)    {        if (!strcmp(topic, mqtt.topics[i].name))        {            printf("Topic alread registered with id : %d/n", mqtt.topics[i].id);            return;        }    }    printf("Nb topics : %d/n", mqtt.nb_topics);    mqtt.data[0] = (strlen(topic) + header_size);    mqtt.data[1] = MQTT_MSG_SUBSCRIBE;    mqtt.data[2] = 0;    mqtt.data[3] = (0 & 0xff00) >> 8;    mqtt.data[4] = (0 & 0x00ff);    memcpy(mqtt.data + header_size, topic, strlen(topic));    mqtt.len = (strlen(topic) + header_size);    mqtt.pending_msg = MQTT_MSG_SUBSCRIBE;    strcpy(mqtt.topics[mqtt.nb_topics].name, topic);    printf("Send packet/n");    uip_udp_packet_send(mqtt.udp_connection, mqtt.data, mqtt.len);}

static voidsend_broadcast(unsigned char *buf, int size){    printf("In send broadcast: /n");    uip_create_linklocal_allnodes_mcast(&udp_bconn->ripaddr);    uip_udp_packet_send(udp_bconn, buf, size);    uip_create_unspecified(&udp_bconn->ripaddr);}

/*----------------------------------------------------------------------------*/static void _demo_udp_sendMsg(uint64_t seqID){	char 		pc_buf[MAX_S_PAYLOAD_LEN];	sprintf(pc_buf, "%d | OK", seqID);	LOG_INFO("Respond with message: %s/n/r",pc_buf);	uip_ipaddr_copy(&pst_conn->ripaddr, &UIP_IP_BUF->srcipaddr);	uip_udp_packet_send(pst_conn, pc_buf, strlen(pc_buf));	uip_create_unspecified(&pst_conn->ripaddr);} /* _demo_udp_sendMsg */

PROCESS_THREAD(mqtt_process, ev, data){    char *str;    static struct etimer periodic_timer;    PROCESS_BEGIN();    topiclist = NULL;    onewire_init();    while(1)    {        /* connect to the server */        PRINTF("mqtt: connecting.../n");        /* Create a new udp connection */        mqtt.udp_connection = udp_new(&mqtt.address, mqtt.port, NULL);        if (mqtt.udp_connection != NULL)        {            PRINTF("Created a connection with the server ");            PRINT6ADDR(&mqtt.udp_connection->ripaddr);            PRINTF(" local/remote port %u/%u/n",                   UIP_HTONS(mqtt.udp_connection->lport), UIP_HTONS(mqtt.udp_connection->rport));        }        else        {            PRINTF("Could not open connection/n");        }        /* Send a connect message to the broker */        mqtt_msg_connect_send(&mqtt);        PRINTF("send message CONNECT/n");        uip_udp_packet_send(mqtt.udp_connection, mqtt.data, mqtt.len);        /* Initialize timer for keepalive */        printf("Keepalive : %d/n", mqtt.keepalive);        etimer_set(&periodic_timer, mqtt.keepalive);        /* We are not yet connected so disable keepalive timer for now */        //etimer_stop(&ping_timer);        while(1)        {            PROCESS_WAIT_EVENT();            if (ev == tcpip_event && uip_newdata())            {                str = uip_appdata;                str[uip_datalen()] = '/0';                handle_mqtt_input(str);            }            else if (ev == PROCESS_EVENT_TIMER && data == &periodic_timer)            {                printf("PERIODIC/n");                periodic_timer_cb();                etimer_reset(&periodic_timer);            }        }    }    PROCESS_END();}

void plug_send_message(uip_ipaddr_t *dest, void *data, uint8_t length){	uip_ipaddr_copy(&udp_conn->ripaddr, dest);	udp_conn->rport = UIP_HTONS(PLUG_PORT);		uip_udp_packet_send(udp_conn, data, length);		udp_conn->rport = 0;	memset(&udp_conn->ripaddr, 0, sizeof(udp_conn->ripaddr));}

static void periodic_timer_cb(void){    mqtt_event_data_t event_data;    uint8_t val, frac;    uint16_t temp;    printf("Ping timer %d/n", mqtt.keepalive_error);    if (mqtt.state != MQTT_STATE_CONNECTED)    {        /* Not connected : try to reconnect */        printf("Try to reconnect/n");        mqtt_msg_connect_send(&mqtt);        uip_udp_packet_send(mqtt.udp_connection, mqtt.data, mqtt.len);        return;    }    if (mqtt.keepalive_error >= MAX_KEEPALIVE_ERROR)    {        PRINTF("DISCONNECTED/n");        mqtt.state = MQTT_STATE_CONNECTION_IN_PROGRESS;        event_data.type = MQTT_EVENT_TYPE_DISCONNECTED;        process_post_synch(mqtt.calling_process, mqtt_event, &event_data);        return;    }    else    {        mqtt.keepalive_error++;    }    temp = onewire_temp_read();    val = temp / 100;    frac = temp % 100;    sprintf(temperature, "%d.%d", val, frac);    printf("temperature : %s/n", temperature);    mqtt_msg_publish(topic_name, temperature);    mqtt_msg_ping_send(&mqtt, MQTT_MSG_PINGREQ);    uip_udp_packet_send(mqtt.udp_connection, mqtt.data, mqtt.len);}

/*---------------------------------------------------------------------------*/static voidtimeout_handler(void){  cur_time++;  buf[0] = 'P';  uip_create_linklocal_allnodes_mcast(&conn->ripaddr);  conn->rport = UIP_HTONS(3000);  uip_udp_packet_send(conn, buf, 1);  uip_create_unspecified(&conn->ripaddr);  conn->rport = 0;}

/*---------------------------------------------------------------------------*/static voidsend_handler(process_event_t ev, process_data_t data){  pkt_data.counter++;  pkt_data.seq_no++;  PRINTF("Sending UDP!!! packet/n");  uip_udp_packet_send(client_conn, (uint8_t*) &pkt_data, sizeof(pkt_data_t));  PRINTF("After sent udp packet./n");}

static voidtimeout_handler(void){  static int seq_id;  printf("Client sending to: ");  PRINT6ADDR(&client_conn->ripaddr);  sprintf(buf, "Hello %d from the client", ++seq_id);  printf(" (msg: %s)/n", buf);  uip_udp_packet_send(client_conn, buf, strlen(buf));}

/*---------------------------------------------------------------------------*/intudp_socket_send(struct net_buf *buf, struct udp_socket *c,                const void *data, uint16_t datalen){  if(c == NULL || c->udp_conn == NULL) {    return -1;  }  uip_udp_packet_send(buf, c->udp_conn, data, datalen);  return datalen;}

static voidudp_handler(void){  static uint8_t tries = 10;  static camera_size_t camera_size;  static uint16_t index, count, len;  static uint32_t size;  char temp[MAX_PAYLOAD_LEN];  if (uip_newdata()) {    uip_ipaddr_copy(&server_conn->ripaddr, &UDP_HDR->srcipaddr);    server_conn->rport = UDP_HDR->srcport;    if (1 == uip_datalen()) {      camera_size = camera_parse_size(((char*)uip_appdata)[0]);      camera_take_picture(camera_size, DEFAULT_CAMERA_PACKET_SIZE, &size, &count);      /* Send picture size and packet count. */      /* The first 2 bytes are packet_no. */      /* Here set packet_no to 0 as this packet is not a real packet. */      temp[0] = temp[1] = 0;      temp[2] = size;      /* The next 4 bytes are size. */      temp[3] = size >> 8;      temp[4] = size >> 16;      temp[5] = size >> 24;      /* The coming is count. */      temp[6] = count;      temp[7] = count >> 8;      uip_udp_packet_send(server_conn, temp, 8);      /* Send picture packet by packet. */      for (index = 1; index <= count; index++) {        len = camera_try_get_packet(index, buffer, tries);        /* The first 2 bytes are packet_no. */        temp[0] = index;        temp[1] = index >> 8;        /* Copy the picture data next to packet_no. */        memcpy(temp + 2, buffer, len);        uip_udp_packet_send(server_conn, temp, len + 2);      }    } else {

/* Send a UDP packet to the specified destination */static voidsend_packet(uip_ipaddr_t *dest, uint16_t destport, void *data, int data_size){    if(send_conn != NULL) {        uip_ipaddr_copy(&send_conn->ripaddr, dest);        send_conn->rport = destport;        PRINTF("[APP] Sending UPD packet %s (%d) to", (char *)data, data_size);        PRINT6ADDR(dest);        PRINTF("/n");        uip_udp_packet_send(send_conn, data, data_size);    }}