基于Contiki 3.0实现RPL多首选父节点的技术问题咨询

我刚好之前在Contiki的RPL模块里折腾过类似的多父节点需求，给你几个可行的解决方案，避开你遇到的「无法获取次优节点」和「不能返回两个值」的问题：

方案1：扩展目标函数（OF）接口，用结构体封装返回前两名节点 #

直接返回两个指针在C里行不通，但可以用自定义结构体来打包结果：

首先，在合适的头文件（比如rpl.h）里定义一个存储前两名父节点的结构体：

typedef struct {
  rpl_parent_t *first;  // 最优父节点
  rpl_parent_t *second; // 次优父节点
} rpl_top_parents_t;

然后修改mrhof.c里的逻辑，新增一个用来更新前两名的函数（或者直接替换原有的best_parent）：

static rpl_top_parents_t update_top_two(rpl_top_parents_t current_top, rpl_parent_t *new_p) {
  rpl_top_parents_t result = current_top;

  // 先和当前最优比，如果新节点更优，把原来的最优挤到次优位置
  if(result.first == NULL || compare_parents(new_p, result.first) > 0) {
    result.second = result.first;
    result.first = new_p;
  } 
  // 再和当前次优比，如果新节点比次优好但不如最优，替换次优
  else if(result.second == NULL || compare_parents(new_p, result.second) > 0) {
    result.second = new_p;
  }

  return result;
}

接下来在rpl-dag.c的父节点选择逻辑里，初始化这个结构体，遍历所有邻居时逐个更新：

rpl_top_parents_t top_parents = {NULL, NULL};
rpl_parent_t *p;

// 遍历所有可用父节点
for(p = list_head(dag->parents); p != NULL; p = list_item_next(p)) {
  top_parents = update_top_two(top_parents, p);
}

// 现在top_parents.first和second就是你要的最优两个父节点了

这个方案的好处是逻辑清晰，一次遍历就能完成筛选，效率高。

方案2：收集所有候选父节点后，两次筛选出前两名 #

如果不想修改MRHOF的核心代码，这个侵入性更小的方法更适合：

• 第一步：遍历所有邻居，把符合条件的父节点先收集到一个临时列表/数组里
• 第二步：调用原有的best_parent函数遍历列表，选出最优节点best1
• 第三步：再次遍历列表，排除best1，调用best_parent选出次优节点best2

示例代码大概是这样：

#define MAX_PARENTS 10  // 根据你的网络规模调整
rpl_parent_t *candidates[MAX_PARENTS];
int candidate_count = 0;
rpl_parent_t *p, *best1 = NULL, *best2 = NULL;

// 收集所有候选父节点
for(p = list_head(dag->parents); p != NULL && candidate_count < MAX_PARENTS; p = list_item_next(p)) {
  if(/* 这里可以加父节点的筛选条件，比如符合RPL的可达性要求 */) {
    candidates[candidate_count++] = p;
  }
}

// 选出最优节点best1
for(int i = 0; i < candidate_count; i++) {
  if(best1 == NULL || dag->instance->of->best_parent(best1, candidates[i]) == candidates[i]) {
    best1 = candidates[i];
  }
}

// 选出次优节点best2（排除best1）
for(int i = 0; i < candidate_count; i++) {
  if(candidates[i] == best1) continue;
  if(best2 == NULL || dag->instance->of->best_parent(best2, candidates[i]) == candidates[i]) {
    best2 = candidates[i];
  }
}

这个方法不用修改原有OF的代码，但需要两次遍历候选列表，适合邻居数量不多的场景。

方案3：修改原best_parent函数，通过输出参数返回被淘汰节点 #

如果你想复用原有的比较逻辑，可以给mrhof.c里的best_parent函数加一个输出参数，用来返回被淘汰的节点：

static rpl_parent_t *best_parent(rpl_parent_t *p1, rpl_parent_t *p2, rpl_parent_t **loser) {
  // 原有的MRHOF比较逻辑，比如基于ETX、节点排名等
  int cmp = compare_parents(p1, p2);

  if(cmp > 0) { // p1更优
    if(loser != NULL) *loser = p2;
    return p1;
  } else { // p2更优
    if(loser != NULL) *loser = p1;
    return p2;
  }
}

然后在rpl-dag.c里，维护一个临时的候选池，每次比较后把被淘汰的节点存起来，最后从候选池里再选出最优的作为次优父节点：

rpl_parent_t *best = NULL;
rpl_parent_t *loser;
list_t losers = LIST_INIT(losers);

for(p = list_head(dag->parents); p != NULL; p = list_item_next(p)) {
  if(best == NULL) {
    best = p;
  } else {
    rpl_parent_t *new_best = dag->instance->of->best_parent(best, p, &loser);
    if(new_best != best) {
      list_add(losers, best); // 把原来的best加入淘汰池
      best = new_best;
    } else {
      list_add(losers, loser); // 把新的p加入淘汰池
    }
  }
}

// 从淘汰池里选出次优节点best2
rpl_parent_t *best2 = NULL;
for(p = list_head(losers); p != NULL; p = list_item_next(p)) {
  if(best2 == NULL || dag->instance->of->best_parent(best2, p) == p) {
    best2 = p;
  }
}

额外注意事项 #

• 实现多父节点后，别忘了适配RPL的路由更新逻辑（比如DAO消息的发送、路由表的维护），原Contiki RPL是单父设计，需要确保多父的路由条目能被正确管理。
• 修改核心代码后，一定要测试单父场景是否仍然正常工作，避免引入新的bug。
• 如果是低功耗设备，要注意内存占用，比如方案2里的候选数组不要开太大。

内容的提问来源于stack exchange，提问作者Sara