946be77248
This is a fix for Contiki RPL so that it fully supports DAO ACK in an end-to-end fashion. When DAO is sent it will be forwarded upwards as before. DAO ACK will be forwarded downwards until it reach the node that initiated the DAO ACK and unlike before it is not a single-hop DAO ACK but it is fully reaching the RPL ROOT before any DAO ACK is sent back. DAO ACK also now fully support different status messages (success / fail).
174 lines
4.6 KiB
C
174 lines
4.6 KiB
C
/*
|
|
* Copyright (c) 2010, 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.
|
|
*/
|
|
|
|
/**
|
|
* \file
|
|
* An implementation of RPL's objective function 0.
|
|
*
|
|
* \author Joakim Eriksson <joakime@sics.se>, Nicolas Tsiftes <nvt@sics.se>
|
|
*/
|
|
|
|
/**
|
|
* \addtogroup uip6
|
|
* @{
|
|
*/
|
|
|
|
#include "net/rpl/rpl-private.h"
|
|
|
|
#define DEBUG DEBUG_NONE
|
|
#include "net/ip/uip-debug.h"
|
|
|
|
static void reset(rpl_dag_t *);
|
|
static rpl_parent_t *best_parent(rpl_parent_t *, rpl_parent_t *);
|
|
static rpl_dag_t *best_dag(rpl_dag_t *, rpl_dag_t *);
|
|
static rpl_rank_t calculate_rank(rpl_parent_t *, rpl_rank_t);
|
|
static void update_metric_container(rpl_instance_t *);
|
|
|
|
rpl_of_t rpl_of0 = {
|
|
reset,
|
|
NULL,
|
|
NULL,
|
|
best_parent,
|
|
best_dag,
|
|
calculate_rank,
|
|
update_metric_container,
|
|
0
|
|
};
|
|
|
|
#define DEFAULT_RANK_INCREMENT RPL_MIN_HOPRANKINC
|
|
|
|
#define MIN_DIFFERENCE (RPL_MIN_HOPRANKINC + RPL_MIN_HOPRANKINC / 2)
|
|
|
|
static void
|
|
reset(rpl_dag_t *dag)
|
|
{
|
|
PRINTF("RPL: Resetting OF0\n");
|
|
}
|
|
|
|
static rpl_rank_t
|
|
calculate_rank(rpl_parent_t *p, rpl_rank_t base_rank)
|
|
{
|
|
rpl_rank_t increment;
|
|
if(base_rank == 0) {
|
|
if(p == NULL) {
|
|
return INFINITE_RANK;
|
|
}
|
|
base_rank = p->rank;
|
|
}
|
|
|
|
increment = p != NULL ?
|
|
p->dag->instance->min_hoprankinc :
|
|
DEFAULT_RANK_INCREMENT;
|
|
|
|
if((rpl_rank_t)(base_rank + increment) < base_rank) {
|
|
PRINTF("RPL: OF0 rank %d incremented to infinite rank due to wrapping\n",
|
|
base_rank);
|
|
return INFINITE_RANK;
|
|
}
|
|
return base_rank + increment;
|
|
|
|
}
|
|
|
|
static rpl_dag_t *
|
|
best_dag(rpl_dag_t *d1, rpl_dag_t *d2)
|
|
{
|
|
if(d1->grounded) {
|
|
if (!d2->grounded) {
|
|
return d1;
|
|
}
|
|
} else if(d2->grounded) {
|
|
return d2;
|
|
}
|
|
|
|
if(d1->preference < d2->preference) {
|
|
return d2;
|
|
} else {
|
|
if(d1->preference > d2->preference) {
|
|
return d1;
|
|
}
|
|
}
|
|
|
|
if(d2->rank < d1->rank) {
|
|
return d2;
|
|
} else {
|
|
return d1;
|
|
}
|
|
}
|
|
|
|
static rpl_parent_t *
|
|
best_parent(rpl_parent_t *p1, rpl_parent_t *p2)
|
|
{
|
|
rpl_rank_t r1, r2;
|
|
rpl_dag_t *dag;
|
|
uip_ds6_nbr_t *nbr1, *nbr2;
|
|
nbr1 = rpl_get_nbr(p1);
|
|
nbr2 = rpl_get_nbr(p2);
|
|
|
|
dag = (rpl_dag_t *)p1->dag; /* Both parents must be in the same DAG. */
|
|
|
|
if(nbr1 == NULL || nbr2 == NULL) {
|
|
return dag->preferred_parent;
|
|
}
|
|
|
|
PRINTF("RPL: Comparing parent ");
|
|
PRINT6ADDR(rpl_get_parent_ipaddr(p1));
|
|
PRINTF(" (confidence %d, rank %d) with parent ",
|
|
nbr1->link_metric, p1->rank);
|
|
PRINT6ADDR(rpl_get_parent_ipaddr(p2));
|
|
PRINTF(" (confidence %d, rank %d)\n",
|
|
nbr2->link_metric, p2->rank);
|
|
|
|
|
|
r1 = DAG_RANK(p1->rank, p1->dag->instance) * RPL_MIN_HOPRANKINC +
|
|
nbr1->link_metric;
|
|
r2 = DAG_RANK(p2->rank, p1->dag->instance) * RPL_MIN_HOPRANKINC +
|
|
nbr2->link_metric;
|
|
/* Compare two parents by looking both and their rank and at the ETX
|
|
for that parent. We choose the parent that has the most
|
|
favourable combination. */
|
|
|
|
if(r1 < r2 + MIN_DIFFERENCE &&
|
|
r1 > r2 - MIN_DIFFERENCE) {
|
|
return dag->preferred_parent;
|
|
} else if(r1 < r2) {
|
|
return p1;
|
|
} else {
|
|
return p2;
|
|
}
|
|
}
|
|
|
|
static void
|
|
update_metric_container(rpl_instance_t *instance)
|
|
{
|
|
instance->mc.type = RPL_DAG_MC_NONE;
|
|
}
|
|
|
|
/** @}*/
|