| /* |
| * 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 "contiki/rpl/rpl-private.h" |
| |
| #ifdef CONFIG_NETWORK_IP_STACK_DEBUG_RPL_OF |
| #define DEBUG 1 |
| #endif |
| #include "contiki/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, |
| 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; |
| } |
| |
| /** @}*/ |