From 7b0606cd58751f15e54b0942f0d1b228d923da24 Mon Sep 17 00:00:00 2001 From: adamdunkels Date: Fri, 19 Mar 2010 13:17:00 +0000 Subject: [PATCH] Renamed the neighbor module to collect-neighbor, as it is only used by the collect module and is not a generic neighbor module --- core/net/rime/collect-neighbor.c | 354 +++++++++++++++++++++++++++++++ core/net/rime/collect-neighbor.h | 89 ++++++++ core/net/rime/collect.c | 81 ++++--- 3 files changed, 490 insertions(+), 34 deletions(-) create mode 100644 core/net/rime/collect-neighbor.c create mode 100644 core/net/rime/collect-neighbor.h diff --git a/core/net/rime/collect-neighbor.c b/core/net/rime/collect-neighbor.c new file mode 100644 index 000000000..b09ca7314 --- /dev/null +++ b/core/net/rime/collect-neighbor.c @@ -0,0 +1,354 @@ +/** + * \addtogroup rimecollect_neighbor + * @{ + */ + +/* + * Copyright (c) 2006, Swedish Institute of Computer Science. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + * + * $Id: collect-neighbor.c,v 1.1 2010/03/19 13:17:00 adamdunkels Exp $ + */ + +/** + * \file + * Radio neighborhood management + * \author + * Adam Dunkels + */ + +#include +#include + +#include "contiki.h" +#include "lib/memb.h" +#include "lib/list.h" +#include "net/rime/collect-neighbor.h" +#include "net/rime/ctimer.h" +#include "net/rime/collect.h" + +#ifdef COLLECT_NEIGHBOR_CONF_MAX_COLLECT_NEIGHBORS +#define MAX_COLLECT_NEIGHBORS COLLECT_NEIGHBOR_CONF_MAX_COLLECT_NEIGHBORS +#else /* COLLECT_NEIGHBOR_CONF_MAX_COLLECT_NEIGHBORS */ +#define MAX_COLLECT_NEIGHBORS 8 +#endif /* COLLECT_NEIGHBOR_CONF_MAX_COLLECT_NEIGHBORS */ + +#define RTMETRIC_MAX COLLECT_MAX_DEPTH + +MEMB(collect_neighbors_mem, struct collect_neighbor, MAX_COLLECT_NEIGHBORS); +LIST(collect_neighbors_list); + +/*static struct collect_neighbor collect_neighbors[MAX_COLLECT_NEIGHBORS];*/ + +static struct ctimer t; + +static int max_time = 2400; + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#else +#define PRINTF(...) +#endif + + +/*---------------------------------------------------------------------------*/ +static void +periodic(void *ptr) +{ + struct collect_neighbor *n, *next; + + /* Go through all collect_neighbors and remove old ones. */ + for(n = list_head(collect_neighbors_list); n != NULL; n = next) { + next = NULL; + /* for(i = 0; i < MAX_COLLECT_NEIGHBORS; ++i) {*/ + if(!rimeaddr_cmp(&n->addr, &rimeaddr_null) && + n->time < max_time) { + n->time++; + if(n->time == max_time) { + n->rtmetric = RTMETRIC_MAX; + PRINTF("%d.%d: removing old collect_neighbor %d.%d\n", + rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1], + n->addr.u8[0], n->addr.u8[1]); + rimeaddr_copy(&n->addr, &rimeaddr_null); + next = n->next; + list_remove(collect_neighbors_list, n); + memb_free(&collect_neighbors_mem, n); + } + } + if(next == NULL) { + next = n->next; + } + } + /* PRINTF("collect_neighbor periodic\n");*/ + ctimer_set(&t, CLOCK_SECOND, periodic, NULL); +} +/*---------------------------------------------------------------------------*/ +void +collect_neighbor_init(void) +{ + static uint8_t initialized = 0; + if(initialized == 0) { + initialized = 1; + memb_init(&collect_neighbors_mem); + list_init(collect_neighbors_list); + ctimer_set(&t, CLOCK_SECOND, periodic, NULL); + } +} +/*---------------------------------------------------------------------------*/ +struct collect_neighbor * +collect_neighbor_find(const rimeaddr_t *addr) +{ + struct collect_neighbor *n; + for(n = list_head(collect_neighbors_list); n != NULL; n = n->next) { + if(rimeaddr_cmp(&n->addr, addr)) { + return n; + } + } + return NULL; +} +/*---------------------------------------------------------------------------*/ +void +collect_neighbor_update(struct collect_neighbor *n, uint8_t rtmetric) +{ + if(n != NULL) { + PRINTF("%d.%d: collect_neighbor_update %d.%d rtmetric %d\n", + rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], + n->addr.u8[0], n->addr.u8[1], rtmetric); + n->rtmetric = rtmetric; + n->time = 0; + } +} +/*---------------------------------------------------------------------------*/ +void +collect_neighbor_timedout_etx(struct collect_neighbor *n, uint8_t etx) +{ + if(n != NULL) { + n->etxs[n->etxptr] += etx; + if(n->etxs[n->etxptr] > RTMETRIC_MAX / COLLECT_NEIGHBOR_ETX_SCALE) { + n->etxs[n->etxptr] = RTMETRIC_MAX / COLLECT_NEIGHBOR_ETX_SCALE; + } + n->etxptr = (n->etxptr + 1) % COLLECT_NEIGHBOR_NUM_ETXS; + } +} +/*---------------------------------------------------------------------------*/ +void +collect_neighbor_update_etx(struct collect_neighbor *n, uint8_t etx) +{ + if(n != NULL) { + n->etxs[n->etxptr] = etx; + n->etxptr = (n->etxptr + 1) % COLLECT_NEIGHBOR_NUM_ETXS; + n->time = 0; + } +} +/*---------------------------------------------------------------------------*/ +uint8_t +collect_neighbor_etx(struct collect_neighbor *n) +{ + int i, etx; + + etx = 0; + for(i = 0; i < COLLECT_NEIGHBOR_NUM_ETXS; ++i) { + etx += n->etxs[i]; + } + return COLLECT_NEIGHBOR_ETX_SCALE * etx / COLLECT_NEIGHBOR_NUM_ETXS; +} +/*---------------------------------------------------------------------------*/ +void +collect_neighbor_add(const rimeaddr_t *addr, uint8_t nrtmetric, uint8_t netx) +{ + uint16_t rtmetric; + uint16_t etx; + struct collect_neighbor *n, *max; + int i; + + PRINTF("collect_neighbor_add: adding %d.%d\n", addr->u8[0], addr->u8[1]); + + /* Check if the collect_neighbor is already on the list. */ + for(n = list_head(collect_neighbors_list); n != NULL; n = n->next) { + if(rimeaddr_cmp(&n->addr, &rimeaddr_null) || + rimeaddr_cmp(&n->addr, addr)) { + PRINTF("collect_neighbor_add: already on list %d.%d\n", addr->u8[0], addr->u8[1]); + break; + } + } + + /* If the collect_neighbor was not on the list, we try to allocate memory + for it. */ + if(n == NULL) { + PRINTF("collect_neighbor_add: not on list, allocating %d.%d\n", addr->u8[0], addr->u8[1]); + n = memb_alloc(&collect_neighbors_mem); + if(n != NULL) { + list_add(collect_neighbors_list, n); + } + } + + /* If we could not allocate memory, we try to recycle an old + collect_neighbor */ + if(n == NULL) { + PRINTF("collect_neighbor_add: not on list, not allocated, recycling %d.%d\n", addr->u8[0], addr->u8[1]); + /* Find the first unused entry or the used entry with the highest + rtmetric and highest etx. */ + rtmetric = 0; + etx = 0; + max = NULL; + + for(n = list_head(collect_neighbors_list); n != NULL; n = n->next) { + if(!rimeaddr_cmp(&n->addr, &rimeaddr_null)) { + if(n->rtmetric > rtmetric) { + rtmetric = n->rtmetric; + etx = collect_neighbor_etx(n); + max = n; + } else if(n->rtmetric == rtmetric) { + if(collect_neighbor_etx(n) > etx) { + rtmetric = n->rtmetric; + etx = collect_neighbor_etx(n); + max = n; + /* PRINTF("%d: found worst collect_neighbor %d with rtmetric %d, signal %d\n", + node_id, collect_neighbors[n].nodeid, rtmetric, signal);*/ + } + } + } + } + n = max; + } + + + /* PRINTF("%d: adding collect_neighbor %d with rtmetric %d, signal %d at %d\n", + node_id, collect_neighbors[n].nodeid, rtmetric, signal, n);*/ + if(n != NULL) { + n->time = 0; + rimeaddr_copy(&n->addr, addr); + n->rtmetric = nrtmetric; + for(i = 0; i < COLLECT_NEIGHBOR_NUM_ETXS; ++i) { + n->etxs[i] = netx; + } + n->etxptr = 0; + } +} +/*---------------------------------------------------------------------------*/ +void +collect_neighbor_remove(const rimeaddr_t *addr) +{ + struct collect_neighbor *n; + + for(n = list_head(collect_neighbors_list); n != NULL; n = n->next) { + if(rimeaddr_cmp(&n->addr, addr)) { + PRINTF("%d.%d: removing %d.%d\n", + rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], + addr->u8[0], addr->u8[1]); + rimeaddr_copy(&n->addr, &rimeaddr_null); + n->rtmetric = RTMETRIC_MAX; + list_remove(collect_neighbors_list, n); + memb_free(&collect_neighbors_mem, n); + return; + } + } + /* int i; + + for(i = 0; i < MAX_COLLECT_NEIGHBORS; ++i) { + if(rimeaddr_cmp(&collect_neighbors[i].addr, addr)) { + PRINTF("%d: removing %d @ %d\n", rimeaddr_node_addr.u16[0], addr->u16[0], i); + rimeaddr_copy(&collect_neighbors[i].addr, &rimeaddr_null); + collect_neighbors[i].rtmetric = RTMETRIC_MAX; + return; + } + }*/ +} +/*---------------------------------------------------------------------------*/ +struct collect_neighbor * +collect_neighbor_best(void) +{ + int found; + /* int lowest, best;*/ + struct collect_neighbor *n, *best; + uint16_t rtmetric; + + rtmetric = RTMETRIC_MAX; + best = NULL; + found = 0; + + /* PRINTF("%d: ", node_id);*/ + + /* Find the lowest rtmetric. */ + for(n = list_head(collect_neighbors_list); n != NULL; n = n->next) { + PRINTF("collect_neighbor_best: checking %d.%d with rtmetric %d + %d\n", + n->addr.u8[0], n->addr.u8[1], + n->rtmetric, collect_neighbor_etx(n)); + if(!rimeaddr_cmp(&n->addr, &rimeaddr_null) && + rtmetric > n->rtmetric + collect_neighbor_etx(n)) { + rtmetric = n->rtmetric + collect_neighbor_etx(n); + best = n; + } + } + + return best; +} +/*---------------------------------------------------------------------------*/ +void +collect_neighbor_set_lifetime(int seconds) +{ + max_time = seconds; +} +/*---------------------------------------------------------------------------*/ +int +collect_neighbor_num(void) +{ + PRINTF("collect_neighbor_num %d\n", list_length(collect_neighbors_list)); + return list_length(collect_neighbors_list); +} +/*---------------------------------------------------------------------------*/ +struct collect_neighbor * +collect_neighbor_get(int num) +{ + int i; + struct collect_neighbor *n; + + PRINTF("collect_neighbor_get %d\n", num); + + i = 0; + for(n = list_head(collect_neighbors_list); n != NULL; n = n->next) { + if(i == num) { + PRINTF("collect_neighbor_get found %d.%d\n", n->addr.u8[0], n->addr.u8[1]); + return n; + } + i++; + } + return NULL; +} +/*---------------------------------------------------------------------------*/ +void +collect_neighbor_purge(void) +{ + memb_init(&collect_neighbors_mem); + list_init(collect_neighbors_list); +} +/*---------------------------------------------------------------------------*/ +/** @} */ diff --git a/core/net/rime/collect-neighbor.h b/core/net/rime/collect-neighbor.h new file mode 100644 index 000000000..3c3a9639c --- /dev/null +++ b/core/net/rime/collect-neighbor.h @@ -0,0 +1,89 @@ +/** + * \addtogroup rime + * @{ + */ +/** + * \defgroup rimeneighbor Rime neighbor management + * @{ + * + * The neighbor module manages the neighbor table. + */ +/* + * Copyright (c) 2006, Swedish Institute of Computer Science. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + * + * $Id: collect-neighbor.h,v 1.1 2010/03/19 13:17:00 adamdunkels Exp $ + */ + +/** + * \file + * Header file for the Contiki radio neighborhood management + * \author + * Adam Dunkels + */ + +#ifndef __COLLECT_NEIGHBOR_H__ +#define __COLLECT_NEIGHBOR_H__ + +#include "net/rime/rimeaddr.h" + +#define COLLECT_NEIGHBOR_ETX_SCALE 16 +#define COLLECT_NEIGHBOR_NUM_ETXS 4 + +struct collect_neighbor { + struct collect_neighbor *next; + uint16_t time; + rimeaddr_t addr; + uint16_t rtmetric; + uint8_t etxptr; + uint8_t etxs[COLLECT_NEIGHBOR_NUM_ETXS]; +}; + +void collect_neighbor_init(void); +/*void collect_neighbor_periodic(int max_time);*/ + +void collect_neighbor_add(const rimeaddr_t *addr, uint8_t rtmetric, uint8_t etx); +void collect_neighbor_update(struct collect_neighbor *n, uint8_t rtmetric); +void collect_neighbor_update_etx(struct collect_neighbor *n, uint8_t etx); +void collect_neighbor_timedout_etx(struct collect_neighbor *n, uint8_t etx); +void collect_neighbor_remove(const rimeaddr_t *addr); +struct collect_neighbor *collect_neighbor_find(const rimeaddr_t *addr); +struct collect_neighbor *collect_neighbor_best(void); +void collect_neighbor_set_lifetime(int seconds); + +uint8_t collect_neighbor_etx(struct collect_neighbor *n); + +int collect_neighbor_num(void); +struct collect_neighbor *collect_neighbor_get(int num); + +void collect_neighbor_purge(void); + +#endif /* __COLLECT_NEIGHBOR_H__ */ +/** @} */ +/** @} */ diff --git a/core/net/rime/collect.c b/core/net/rime/collect.c index 36eceee22..6a7e355df 100644 --- a/core/net/rime/collect.c +++ b/core/net/rime/collect.c @@ -33,7 +33,7 @@ * * This file is part of the Contiki operating system. * - * $Id: collect.c,v 1.40 2010/03/16 18:12:34 adamdunkels Exp $ + * $Id: collect.c,v 1.41 2010/03/19 13:17:00 adamdunkels Exp $ */ /** @@ -46,7 +46,7 @@ #include "contiki.h" #include "net/rime.h" -#include "net/rime/neighbor.h" +#include "net/rime/collect-neighbor.h" #include "net/rime/collect.h" #include "net/rime/packetqueue.h" @@ -119,7 +119,7 @@ static void retransmit_callback(void *ptr); static void update_rtmetric(struct collect_conn *tc) { - struct neighbor *n; + struct collect_neighbor *n; PRINTF("update_rtmetric: tc->rtmetric %d\n", tc->rtmetric); @@ -127,7 +127,7 @@ update_rtmetric(struct collect_conn *tc) if(tc->rtmetric != SINK) { /* Find the neighbor with the lowest rtmetric. */ - n = neighbor_best(); + n = collect_neighbor_best(); /* If n is NULL, we have no best neighbor. */ if(n == NULL) { @@ -148,23 +148,28 @@ update_rtmetric(struct collect_conn *tc) } else { /* We set our rtmetric to the rtmetric of our best neighbor plus the expected transmissions to reach that neighbor. */ - if(n->rtmetric + neighbor_etx(n) != tc->rtmetric) { + if(n->rtmetric + collect_neighbor_etx(n) != tc->rtmetric) { uint16_t old_rtmetric = tc->rtmetric; - tc->rtmetric = n->rtmetric + neighbor_etx(n); + tc->rtmetric = n->rtmetric + collect_neighbor_etx(n); #if ! COLLECT_ANNOUNCEMENTS /* If we get a significantly better rtmetric than we had before, we call neighbor_discovery_start to start a new period. */ - if(old_rtmetric >= tc->rtmetric + NEIGHBOR_ETX_SCALE + NEIGHBOR_ETX_SCALE / 2) { + if(old_rtmetric >= tc->rtmetric + COLLECT_NEIGHBOR_ETX_SCALE + COLLECT_NEIGHBOR_ETX_SCALE / 2 || + old_rtmetric == SINK) { neighbor_discovery_start(&tc->neighbor_discovery_conn, tc->rtmetric); } else { neighbor_discovery_set_val(&tc->neighbor_discovery_conn, tc->rtmetric); } #else /* ! COLLECT_ANNOUNCEMENTS */ announcement_set_value(&tc->announcement, tc->rtmetric); + if(old_rtmetric >= tc->rtmetric + COLLECT_NEIGHBOR_ETX_SCALE + COLLECT_NEIGHBOR_ETX_SCALE / 2 || + old_rtmetric == SINK) { + announcement_bump(&tc->announcement); + } #endif /* ! COLLECT_ANNOUNCEMENTS */ PRINTF("%d.%d: new rtmetric %d\n", @@ -186,7 +191,7 @@ update_rtmetric(struct collect_conn *tc) if(tc->rtmetric == RTMETRIC_MAX) { strcpy(buf, " "); } else { - sPRINTF(buf, "%.1f", (float)tc->rtmetric / NEIGHBOR_ETX_SCALE); + PRINTF(buf, "%.1f", (float)tc->rtmetric / COLLECT_NEIGHBOR_ETX_SCALE); } ether_set_text(buf); } @@ -197,7 +202,7 @@ static void send_queued_packet(void) { struct queuebuf *q; - struct neighbor *n; + struct collect_neighbor *n; struct packetqueue_item *i; struct collect_conn *c; @@ -234,15 +239,15 @@ send_queued_packet(void) rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]); queuebuf_to_packetbuf(q); - n = neighbor_best(); + n = collect_neighbor_best(); while(n != NULL && rimeaddr_cmp(&n->addr, packetbuf_addr(PACKETBUF_ADDR_SENDER))) { PRINTF("%d.%d: avoiding fowarding loop to %d.%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], n->addr.u8[0], n->addr.u8[1]); - neighbor_remove(&n->addr); + collect_neighbor_remove(&n->addr); update_rtmetric(c); - n = neighbor_best(); + n = collect_neighbor_best(); } /* Don't send to the neighbor if it is the same neighbor that sent @@ -304,7 +309,7 @@ handle_ack(struct collect_conn *tc) { struct ack_msg *msg; uint16_t rtmetric; - struct neighbor *n; + struct collect_neighbor *n; if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_SENDER), &tc->current_receiver) && @@ -313,9 +318,9 @@ handle_ack(struct collect_conn *tc) msg = packetbuf_dataptr(); memcpy(&rtmetric, &msg->rtmetric, sizeof(uint16_t)); - n = neighbor_find(packetbuf_addr(PACKETBUF_ADDR_SENDER)); + n = collect_neighbor_find(packetbuf_addr(PACKETBUF_ADDR_SENDER)); if(n != NULL) { - neighbor_update(n, rtmetric); + collect_neighbor_update(n, rtmetric); update_rtmetric(tc); } @@ -387,7 +392,7 @@ node_packet_received(struct unicast_conn *c, const rimeaddr_t *from) struct collect_conn *tc = (struct collect_conn *) ((char *)c - offsetof(struct collect_conn, unicast_conn)); int i; - struct neighbor *n; + struct collect_neighbor *n; /* To protect against sending duplicate packets, we keep a list of recently forwarded packet seqnos. If the seqno of the current @@ -426,9 +431,9 @@ node_packet_received(struct unicast_conn *c, const rimeaddr_t *from) packetbuf_attr(PACKETBUF_ATTR_EPACKET_ID), packetbuf_addr(PACKETBUF_ADDR_SENDER)->u8[0], packetbuf_addr(PACKETBUF_ADDR_SENDER)->u8[1]); - n = neighbor_find(&recent_packets[i].sent_to); + n = collect_neighbor_find(&recent_packets[i].sent_to); if(n != NULL) { - neighbor_update_etx(n, neighbor_etx(n) / NEIGHBOR_ETX_SCALE + 4); + collect_neighbor_update_etx(n, collect_neighbor_etx(n) / COLLECT_NEIGHBOR_ETX_SCALE + 4); update_rtmetric(tc); } break; @@ -437,10 +442,10 @@ node_packet_received(struct unicast_conn *c, const rimeaddr_t *from) recent_packets[recent_packet_ptr].seqno = packetbuf_attr(PACKETBUF_ATTR_EPACKET_ID); rimeaddr_copy(&recent_packets[recent_packet_ptr].originator, packetbuf_addr(PACKETBUF_ADDR_ESENDER)); - /* n = neighbor_best();*/ + /* n = collect_neighbor_best();*/ if(tc->rtmetric != SINK) { - n = neighbor_best(); + n = collect_neighbor_best(); rimeaddr_copy(&recent_packets[recent_packet_ptr].sent_to, &n->addr); } else { @@ -551,7 +556,7 @@ node_packet_sent(struct unicast_conn *c, int status, int transmissions) /* Update ETX with the number of transmissions. */ PRINTF("Updating ETX with %d transmissions (punished %d)\n", tc->transmissions, tx); - neighbor_update_etx(neighbor_find(&tc->current_receiver), tx); + collect_neighbor_update_etx(collect_neighbor_find(&tc->current_receiver), tx); update_rtmetric(tc); } } @@ -564,7 +569,7 @@ timedout(struct collect_conn *tc) tc->max_rexmits); tc->sending = 0; - neighbor_timedout_etx(neighbor_find(&tc->current_receiver), tc->transmissions); + collect_neighbor_timedout_etx(collect_neighbor_find(&tc->current_receiver), tc->transmissions); update_rtmetric(tc); send_next_packet(tc); @@ -591,14 +596,14 @@ adv_received(struct neighbor_discovery_conn *c, const rimeaddr_t *from, { struct collect_conn *tc = (struct collect_conn *) ((char *)c - offsetof(struct collect_conn, neighbor_discovery_conn)); - struct neighbor *n; + struct collect_neighbor *n; - n = neighbor_find(from); + n = collect_neighbor_find(from); if(n == NULL) { - neighbor_add(from, rtmetric, 1); + collect_neighbor_add(from, rtmetric, 1); } else { - neighbor_update(n, rtmetric); + collect_neighbor_update(n, rtmetric); PRINTF("%d.%d: updating neighbor %d.%d, etx %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], n->addr.u8[0], n->addr.u8[1], rtmetric); @@ -613,17 +618,17 @@ received_announcement(struct announcement *a, const rimeaddr_t *from, { struct collect_conn *tc = (struct collect_conn *) ((char *)a - offsetof(struct collect_conn, announcement)); - struct neighbor *n; + struct collect_neighbor *n; - n = neighbor_find(from); + n = collect_neighbor_find(from); if(n == NULL) { - neighbor_add(from, value, 1); + collect_neighbor_add(from, value, 1); PRINTF("%d.%d: new neighbor %d.%d, etx %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], from->u8[0], from->u8[1], value); } else { - neighbor_update(n, value); + collect_neighbor_update(n, value); PRINTF("%d.%d: updating neighbor %d.%d, etx %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], n->addr.u8[0], n->addr.u8[1], value); @@ -648,7 +653,7 @@ collect_open(struct collect_conn *tc, uint16_t channels, channel_set_attributes(channels + 1, attributes); tc->rtmetric = RTMETRIC_MAX; tc->cb = cb; - neighbor_init(); + collect_neighbor_init(); packetqueue_init(&sending_queue); #if !COLLECT_ANNOUNCEMENTS @@ -661,7 +666,6 @@ collect_open(struct collect_conn *tc, uint16_t channels, #else /* !COLLECT_ANNOUNCEMENTS */ announcement_register(&tc->announcement, channels, tc->rtmetric, received_announcement); - /* announcement_listen(2);*/ #endif /* !COLLECT_ANNOUNCEMENTS */ } /*---------------------------------------------------------------------------*/ @@ -684,6 +688,8 @@ collect_set_sink(struct collect_conn *tc, int should_be_sink) PRINTF("collect_set_sink: tc->rtmetric %d\n", tc->rtmetric); #if !COLLECT_ANNOUNCEMENTS neighbor_discovery_start(&tc->neighbor_discovery_conn, tc->rtmetric); +#else + announcement_bump(&tc->announcement); #endif /* !COLLECT_ANNOUNCEMENTS */ } else { tc->rtmetric = RTMETRIC_MAX; @@ -697,7 +703,7 @@ collect_set_sink(struct collect_conn *tc, int should_be_sink) int collect_send(struct collect_conn *tc, int rexmits) { - struct neighbor *n; + struct collect_neighbor *n; packetbuf_set_attr(PACKETBUF_ATTR_EPACKET_ID, tc->eseqno++); packetbuf_set_addr(PACKETBUF_ADDR_ESENDER, &rimeaddr_node_addr); @@ -723,7 +729,7 @@ collect_send(struct collect_conn *tc, int rexmits) return 1; } else { update_rtmetric(tc); - n = neighbor_best(); + n = collect_neighbor_best(); if(n != NULL) { #if CONTIKI_TARGET_NETSIM ether_set_line(n->addr.u8[0], n->addr.u8[1]); @@ -763,4 +769,11 @@ collect_depth(struct collect_conn *tc) return tc->rtmetric; } /*---------------------------------------------------------------------------*/ +void +collect_purge(struct collect_conn *tc) +{ + collect_neighbor_purge(); + update_rtmetric(tc); +} +/*---------------------------------------------------------------------------*/ /** @} */