Merge branch 'rpl' of ssh://ukleos.org:2222/home/git/ukleos
Conflicts: board/msba2-common/tools/src/control_2xxx.c drivers/cc110x/cc1100-interface.h projects/test_rpl/main.c sys/include/vtimer.h sys/net/sixlowpan/rpl/Jamfile sys/net/sixlowpan/rpl/objective_functions.c sys/net/sixlowpan/rpl/objective_functions.h sys/net/sixlowpan/rpl/of0.c sys/net/sixlowpan/rpl/of0.h sys/net/sixlowpan/rpl/rpl.c sys/net/sixlowpan/rpl/rpl_dodag.c sys/net/sixlowpan/rpl/rpl_structs.h sys/net/sixlowpan/rpl/trickle.c sys/net/sixlowpan/sixlowmac.c sys/vtimer/vtimer.cdev/timer
Oliver Hahm
10 years ago
commit
bf85e4902c
@ -0,0 +1,506 @@
|
||||
/*
|
||||
* etx_beaconing.c
|
||||
*
|
||||
* Created on: Feb 26, 2013
|
||||
* Author: stephan
|
||||
*/
|
||||
#include "etx_beaconing.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <hwtimer.h>
|
||||
#include <vtimer.h>
|
||||
#include <thread.h>
|
||||
#include <transceiver.h>
|
||||
|
||||
#include "sys/net/sixlowpan/sixlowmac.h"
|
||||
#include "sys/net/sixlowpan/ieee802154_frame.h"
|
||||
|
||||
//prototytpes
|
||||
static uint8_t etx_count_packet_tx(etx_neighbor_t * candidate);
|
||||
static void etx_set_packets_received(void);
|
||||
static bool etx_equal_id(ipv6_addr_t *id1, ipv6_addr_t *id2);
|
||||
|
||||
//Buffer
|
||||
char etx_beacon_buf[ETX_BEACON_STACKSIZE] = { 0 };
|
||||
char etx_radio_buf[ETX_RADIO_STACKSIZE] = { 0 };
|
||||
char etx_clock_buf[ETX_CLOCK_STACKSIZE] = { 0 };
|
||||
|
||||
uint8_t etx_send_buf[ETX_BUF_SIZE] = { 0 };
|
||||
uint8_t etx_rec_buf[ETX_BUF_SIZE] = { 0 };
|
||||
|
||||
//PIDs
|
||||
int etx_beacon_pid = 0;
|
||||
int etx_radio_pid = 0;
|
||||
int etx_clock_pid = 0;
|
||||
|
||||
/*
|
||||
* xxx If you get a -Wmissing-braces warning here:
|
||||
* A -Wmissing-braces warning at this point is a gcc-bug!
|
||||
* Please delete this information once it's fixed
|
||||
* See: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
|
||||
*/
|
||||
//Message queue for radio
|
||||
msg_t msg_que[ETX_RCV_QUEUE_SIZE] = { 0 };
|
||||
|
||||
/*
|
||||
* The counter for the current 'round'. An ETX beacon is sent every ETX_INTERVAL
|
||||
* u-seconds and a node computes the ETX value by comparing the the received
|
||||
* probes vs the expected probes from a neighbor every ETX_ROUND intervals.
|
||||
*/
|
||||
static uint8_t cur_round = 0;
|
||||
|
||||
/*
|
||||
* If we have not yet reached WINDOW intervals, won't calculate the ETX just yet
|
||||
*/
|
||||
static char reached_window = 0;
|
||||
|
||||
/*
|
||||
* This could (and should) be done differently, once the RPL implementation
|
||||
* deals with candidate neighbors in another way than just defining that every
|
||||
* possible neighbor we hear from is a parent.
|
||||
* Right now, we need to keep track of the ETX values of other nodes without
|
||||
* needing them to be in our parent array, so we have another array here in
|
||||
* which we put all necessary info for up to ETX_MAX_CANDIDATE_NEIHGBORS
|
||||
* candidates.
|
||||
*
|
||||
* xxx If you get a -Wmissing-braces warning here:
|
||||
* A -Wmissing-braces warning at this point is a gcc-bug!
|
||||
* Please delete this information once it's fixed
|
||||
* See: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
|
||||
*/
|
||||
//Candidate array
|
||||
static etx_neighbor_t candidates[ETX_MAX_CANDIDATE_NEIGHBORS] = { 0 };
|
||||
|
||||
/*
|
||||
* Each time we send a beacon packet we need to reset some values for the
|
||||
* current 'round' (a round being the time between each sent beacon packet).
|
||||
*
|
||||
* In this time, no packet may be handled, otherwise it could assume values
|
||||
* from the last round to count for this round.
|
||||
*/
|
||||
mutex_t etx_mutex;
|
||||
//Transceiver command for sending ETX probes
|
||||
transceiver_command_t tcmd;
|
||||
|
||||
//Message to send probes with
|
||||
msg_t mesg;
|
||||
|
||||
//RPL-address
|
||||
static ipv6_addr_t * own_address;
|
||||
|
||||
static etx_probe_t * etx_get_send_buf(void) {
|
||||
return ((etx_probe_t *) &(etx_send_buf[0]));
|
||||
}
|
||||
static etx_probe_t * etx_get_rec_buf(void) {
|
||||
return ((etx_probe_t *) &(etx_rec_buf[0]));
|
||||
}
|
||||
|
||||
void show_candidates(void) {
|
||||
etx_neighbor_t * candidate;
|
||||
etx_neighbor_t *end;
|
||||
|
||||
for (candidate = &candidates[0], end = candidates
|
||||
+ ETX_MAX_CANDIDATE_NEIGHBORS; candidate < end;
|
||||
candidate++) {
|
||||
if (candidate->used == 0) {
|
||||
break;
|
||||
}
|
||||
printf("Candidates Addr:%d\n"
|
||||
"\t cur_etx:%f\n"
|
||||
"\t packets_rx:%d\n"
|
||||
"\t packets_tx:%d\n"
|
||||
"\t used:%d\n", candidate->addr.uint8[ETX_IPV6_LAST_BYTE],
|
||||
candidate->cur_etx, candidate->packets_rx,
|
||||
etx_count_packet_tx(candidate),
|
||||
candidate->used);
|
||||
}
|
||||
}
|
||||
|
||||
void etx_init_beaconing(ipv6_addr_t * address) {
|
||||
mutex_init(&etx_mutex);
|
||||
own_address = address;
|
||||
//set code
|
||||
puts("ETX BEACON INIT");
|
||||
etx_send_buf[0] = ETX_PKT_OPTVAL;
|
||||
|
||||
etx_beacon_pid = thread_create(etx_beacon_buf, ETX_BEACON_STACKSIZE,
|
||||
PRIORITY_MAIN - 1, CREATE_STACKTEST,
|
||||
etx_beacon, "etx_beacon");
|
||||
|
||||
etx_radio_pid = thread_create(etx_radio_buf, ETX_RADIO_STACKSIZE,
|
||||
PRIORITY_MAIN - 1, CREATE_STACKTEST,
|
||||
etx_radio, "etx_radio");
|
||||
|
||||
etx_clock_pid = thread_create(etx_clock_buf, ETX_CLOCK_STACKSIZE,
|
||||
PRIORITY_MAIN - 1, CREATE_STACKTEST,
|
||||
etx_clock, "etx_clock");
|
||||
//register at transceiver
|
||||
transceiver_register(TRANSCEIVER_CC1100, etx_radio_pid);
|
||||
puts("...[DONE]");
|
||||
}
|
||||
|
||||
void etx_beacon(void) {
|
||||
/*
|
||||
* Sends a message every ETX_INTERVAL +/- a jitter-value (default is 10%) .
|
||||
* A correcting variable is needed to stay at a base interval of
|
||||
* ETX_INTERVAL between the wakeups. It takes the old jittervalue in account
|
||||
* and modifies the time to wait accordingly.
|
||||
*/
|
||||
etx_probe_t * packet = etx_get_send_buf();
|
||||
uint8_t p_length = 0;
|
||||
|
||||
/*
|
||||
* xxx If you get a -Wmissing-braces warning here:
|
||||
* A -Wmissing-braces warning at this point is a gcc-bug!
|
||||
* Please delete this information once it's fixed
|
||||
* See: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
|
||||
*/
|
||||
ieee_802154_long_t empty_addr = { 0 };
|
||||
|
||||
while (true) {
|
||||
thread_sleep();
|
||||
mutex_lock(&etx_mutex);
|
||||
//Build etx packet
|
||||
p_length = 0;
|
||||
for (uint8_t i = 0; i < ETX_BEST_CANDIDATES; i++) {
|
||||
if (candidates[i].used != 0) {
|
||||
packet->data[i * ETX_TUPLE_SIZE] =
|
||||
candidates[i].addr.uint8[ETX_IPV6_LAST_BYTE];
|
||||
packet->data[i * ETX_TUPLE_SIZE + ETX_PKT_REC_OFFSET] =
|
||||
etx_count_packet_tx(&candidates[i]);
|
||||
p_length = p_length + ETX_PKT_HDR_LEN;
|
||||
}
|
||||
}
|
||||
packet->length = p_length;
|
||||
send_ieee802154_frame(&empty_addr, &etx_send_buf[0],
|
||||
ETX_DATA_MAXLEN+ETX_PKT_HDR_LEN, 1);
|
||||
DEBUG("sent beacon!\n");
|
||||
etx_set_packets_received();
|
||||
cur_round++;
|
||||
if (cur_round == ETX_WINDOW) {
|
||||
if (reached_window != 1) {
|
||||
//first round is through
|
||||
reached_window = 1;
|
||||
}
|
||||
cur_round = 0;
|
||||
}
|
||||
mutex_unlock(&etx_mutex,0);
|
||||
}
|
||||
}
|
||||
|
||||
etx_neighbor_t * etx_find_candidate(ipv6_addr_t * address) {
|
||||
/*
|
||||
* find the candidate with address address and returns it, or returns NULL
|
||||
* if no candidate having this address was found.
|
||||
*/
|
||||
for (uint8_t i = 0; i < ETX_MAX_CANDIDATE_NEIGHBORS; i++) {
|
||||
if (candidates[i].used
|
||||
&& (etx_equal_id(&candidates[i].addr, address))) {
|
||||
return &candidates[i];
|
||||
}
|
||||
}
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
void etx_clock(void) {
|
||||
/*
|
||||
* Manages the etx_beacon thread to wake up every full second +- jitter
|
||||
*/
|
||||
|
||||
/*
|
||||
* The jittercorrection and jitter variables keep usecond values divided
|
||||
* through 1000 to fit into uint8 variables.
|
||||
*
|
||||
* That is why they are multiplied by 1000 when used for hwtimer_wait.
|
||||
*/
|
||||
uint8_t jittercorrection = ETX_DEF_JIT_CORRECT;
|
||||
uint8_t jitter = (uint8_t) (rand() % ETX_JITTER_MOD);
|
||||
|
||||
while (true) {
|
||||
thread_wakeup(etx_beacon_pid);
|
||||
|
||||
/*
|
||||
* Vtimer is buggy, but I seem to have no hwtimers left, so using this
|
||||
* for now.
|
||||
*/
|
||||
vtimer_usleep(
|
||||
((ETX_INTERVAL - ETX_MAX_JITTER)*MS)+ jittercorrection*MS + jitter*MS - ETX_CLOCK_ADJUST);
|
||||
|
||||
//hwtimer_wait(
|
||||
// HWTIMER_TICKS(((ETX_INTERVAL - ETX_MAX_JITTER)*MS) + jittercorrection*MS + jitter*MS - ETX_CLOCK_ADJUST));
|
||||
|
||||
jittercorrection = (ETX_MAX_JITTER) - jitter;
|
||||
jitter = (uint8_t) (rand() % ETX_JITTER_MOD);
|
||||
}
|
||||
}
|
||||
|
||||
double etx_get_metric(ipv6_addr_t * address) {
|
||||
etx_neighbor_t * candidate = etx_find_candidate(address);
|
||||
if (candidate != NULL ) {
|
||||
if (etx_count_packet_tx(candidate) > 0) {
|
||||
//this means the current etx_value is not outdated
|
||||
return candidate->cur_etx;
|
||||
} else {
|
||||
//The last time I received a packet is too long ago to give a
|
||||
//good estimate of the etx value
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
etx_neighbor_t * etx_add_candidate(ipv6_addr_t * address) {
|
||||
DEBUG("add candidate\n");
|
||||
/*
|
||||
* Pre-Condition: etx_add_candidate should only be called when the
|
||||
* candidate is not yet in the list.
|
||||
* Otherwise the candidate will be added a second time,
|
||||
* leading to unknown behavior.
|
||||
*
|
||||
* Check if there is still enough space to add this candidate
|
||||
*
|
||||
* a)
|
||||
* Space is available:
|
||||
* Add candidate
|
||||
*
|
||||
* b)
|
||||
* Space is not available:
|
||||
* ignore new candidate
|
||||
* This shouldn't really happen though, since we have enough
|
||||
* place in the array.
|
||||
*
|
||||
* Returns the pointer to the candidate if it was added, or a NULL-pointer
|
||||
* otherwise.
|
||||
*/
|
||||
etx_neighbor_t * candidate;
|
||||
etx_neighbor_t * end;
|
||||
|
||||
for (candidate = &candidates[0], end = candidates
|
||||
+ ETX_MAX_CANDIDATE_NEIGHBORS; candidate < end;
|
||||
candidate++) {
|
||||
if (candidate->used) {
|
||||
//skip
|
||||
continue;
|
||||
} else {
|
||||
//We still have a free place add the new candidate
|
||||
memset(candidate, 0, sizeof(*candidate));
|
||||
candidate->addr = *address;
|
||||
candidate->cur_etx = 0;
|
||||
candidate->packets_rx = 0;
|
||||
candidate->used = 1;
|
||||
return candidate;
|
||||
}
|
||||
}
|
||||
return NULL ;
|
||||
}
|
||||
|
||||
void etx_handle_beacon(ipv6_addr_t * candidate_address) {
|
||||
/*
|
||||
* Handle the ETX probe that has been received and update all infos.
|
||||
* If the candidate address is unknown, try to add it to my struct.
|
||||
*/
|
||||
|
||||
DEBUG(
|
||||
"ETX beacon package received with following values:\n"
|
||||
"\tPackage Option:%x\n"
|
||||
"\t Data Length:%u\n"
|
||||
"\tSource Address:%d\n\n", etx_rec_buf[ETX_PKT_OPT], etx_rec_buf[ETX_PKT_LEN],
|
||||
candidate_address->uint8[ETX_IPV6_LAST_BYTE]);
|
||||
|
||||
etx_neighbor_t* candidate = etx_find_candidate(candidate_address);
|
||||
if (candidate == NULL ) {
|
||||
//Candidate was not found in my list, I should add it
|
||||
candidate = etx_add_candidate(candidate_address);
|
||||
if (candidate == NULL ) {
|
||||
puts("[ERROR] Candidate could not get added");
|
||||
puts("Increase the constant ETX_MAX_CANDIDATE_NEIHGBORS");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
//I have received 1 packet from this candidate in this round
|
||||
//This value will be reset by etx_update to 0
|
||||
candidate->tx_cur_round = 1;
|
||||
|
||||
// If i find my address in this probe, update the packet_rx value for
|
||||
// this candidate.
|
||||
etx_probe_t * rec_pkt = etx_get_rec_buf();
|
||||
|
||||
for (uint8_t i = 0; i < rec_pkt->length / ETX_TUPLE_SIZE; i++) {
|
||||
DEBUG("\tIPv6 short Addr:%u\n"
|
||||
"\tPackets f. Addr:%u\n\n", rec_pkt->data[i * ETX_TUPLE_SIZE],
|
||||
rec_pkt->data[i * ETX_TUPLE_SIZE + ETX_PKT_REC_OFFSET]);
|
||||
|
||||
if (rec_pkt->data[i * ETX_TUPLE_SIZE]
|
||||
== own_address->uint8[ETX_IPV6_LAST_BYTE]) {
|
||||
|
||||
candidate->packets_rx = rec_pkt->data[i * ETX_TUPLE_SIZE
|
||||
+ ETX_PKT_REC_OFFSET];
|
||||
}
|
||||
}
|
||||
|
||||
//Last, update the ETX value for this candidate
|
||||
etx_update(candidate);
|
||||
}
|
||||
|
||||
void etx_radio(void) {
|
||||
msg_t m;
|
||||
radio_packet_t *p;
|
||||
|
||||
ieee802154_frame_t frame;
|
||||
|
||||
msg_init_queue(msg_que, ETX_RCV_QUEUE_SIZE);
|
||||
|
||||
ipv6_addr_t ll_address;
|
||||
ipv6_addr_t candidate_addr;
|
||||
|
||||
ipv6_set_ll_prefix(&ll_address);
|
||||
ipv6_get_saddr(&candidate_addr, &ll_address);
|
||||
|
||||
while (1) {
|
||||
msg_receive(&m);
|
||||
if (m.type == PKT_PENDING) {
|
||||
p = (radio_packet_t*) m.content.ptr;
|
||||
|
||||
read_802154_frame(p->data, &frame, p->length);
|
||||
|
||||
if (frame.payload[0] == ETX_PKT_OPTVAL) {
|
||||
//copy to receive buffer
|
||||
memcpy(etx_rec_buf, &frame.payload[0], frame.payload_len);
|
||||
|
||||
//create IPv6 address from radio packet
|
||||
//we can do the cast here since rpl nodes can only have addr
|
||||
//up to 8 bits
|
||||
candidate_addr.uint8[ETX_IPV6_LAST_BYTE] = (uint8_t) p->src;
|
||||
//handle the beacon
|
||||
mutex_lock(&etx_mutex);
|
||||
etx_handle_beacon(&candidate_addr);
|
||||
mutex_unlock(&etx_mutex,1);
|
||||
}
|
||||
|
||||
p->processing--;
|
||||
}
|
||||
else if (m.type == ENOBUFFER) {
|
||||
puts("Transceiver buffer full");
|
||||
}
|
||||
else {
|
||||
//packet is not for me, whatever
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void etx_update(etx_neighbor_t * candidate) {
|
||||
DEBUG("update!\n");
|
||||
/*
|
||||
* Update the current ETX value of a candidate
|
||||
*/
|
||||
double d_f;
|
||||
double d_r;
|
||||
|
||||
if (reached_window != 1 || candidate == NULL ) {
|
||||
//We will wait at least ETX_WINDOW beacons until we decide to
|
||||
//calculate an ETX value, so that we have a good estimate
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Calculate d_f (the forward PDR) from ME to this candidate.
|
||||
*/
|
||||
d_f = candidate->packets_rx / (double) ETX_WINDOW;
|
||||
|
||||
/*
|
||||
* Calculate d_r (the backwards PDR) from this candidate to ME
|
||||
*/
|
||||
d_r = etx_count_packet_tx(candidate) / (double) ETX_WINDOW;
|
||||
|
||||
/*
|
||||
* Calculate the current ETX value for my link to this candidate.
|
||||
*/
|
||||
if (d_f * d_r != 0) {
|
||||
candidate->cur_etx = 1 / (d_f * d_r);
|
||||
} else {
|
||||
candidate->cur_etx = 0;
|
||||
}
|
||||
|
||||
DEBUG(
|
||||
"Estimated ETX Metric is %f for candidate w/ addr %d\n"
|
||||
"Estimated PDR_forward is %f\n"
|
||||
"Estimated PDR_backwrd is %f\n"
|
||||
"\n"
|
||||
"Received Packets: %d\n"
|
||||
"Sent Packets : %d\n\n",
|
||||
candidate->cur_etx, candidate->addr.uint8[ETX_IPV6_LAST_BYTE],
|
||||
d_f, d_r, candidate->packets_rx, etx_count_packet_tx(candidate));
|
||||
}
|
||||
|
||||
static uint8_t etx_count_packet_tx(etx_neighbor_t * candidate) {
|
||||
/*
|
||||
* Counts the number of packets that were received for this candidate
|
||||
* in the last ETX_WINDOW intervals.
|
||||
*/
|
||||
DEBUG("counting packets");
|
||||
uint8_t pkt_count = 0;
|
||||
DEBUG("[");
|
||||
for (uint8_t i = 0; i < ETX_WINDOW; i++) {
|
||||
if (i != cur_round) {
|
||||
pkt_count = pkt_count + candidate->packets_tx[i];
|
||||
#ifdef ENABLE_DEBUG
|
||||
DEBUG("%d",candidate->packets_tx[i]);
|
||||
if (i < ETX_WINDOW - 1) {
|
||||
DEBUG(",");
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
//Check if I received something for the current round
|
||||
if (candidate->tx_cur_round == 0) {
|
||||
//Didn't receive a packet, zero the field and don't add
|
||||
candidate->packets_tx[i] = 0;
|
||||
#ifdef ENABLE_DEBUG
|
||||
DEBUG("%d!",candidate->packets_tx[i]);
|
||||
if (i < ETX_WINDOW - 1) {
|
||||
DEBUG(",");
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
//Add 1 and set field
|
||||
pkt_count = pkt_count + 1;
|
||||
candidate->packets_tx[i] = 1;
|
||||
#ifdef ENABLE_DEBUG
|
||||
DEBUG("%d!",candidate->packets_tx[i]);
|
||||
if (i < ETX_WINDOW - 1) {
|
||||
DEBUG(",");
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
DEBUG("]\n");
|
||||
return pkt_count;
|
||||
}
|
||||
|
||||
static void etx_set_packets_received(void) {
|
||||
/*
|
||||
* Set for all candidates if they received a packet this round or not
|
||||
*/
|
||||
for (uint8_t i = 0; i < ETX_MAX_CANDIDATE_NEIGHBORS; i++) {
|
||||
if (candidates[i].used) {
|
||||
if (candidates[i].tx_cur_round != 0) {
|
||||
candidates[i].packets_tx[cur_round] = 1;
|
||||
candidates[i].tx_cur_round = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool etx_equal_id(ipv6_addr_t *id1, ipv6_addr_t *id2){
|
||||
for(uint8_t i=0;i<4;i++){
|
||||
if(id1->uint32[i] != id2->uint32[i]){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
|
||||
}
|
||||
@ -0,0 +1,119 @@
|
||||
/*
|
||||
* Header for the ETX-beaconing module
|
||||
* etx_beaconing.h
|
||||
*
|
||||
* Created on: Feb 26, 2013
|
||||
* Author: stephan
|
||||
*/
|
||||
|
||||
#ifndef ETX_BEACONING_H_
|
||||
#define ETX_BEACONING_H_
|
||||
|
||||
#include "sys/net/sixlowpan/sixlowip.h"
|
||||
|
||||
//For debugging purposes
|
||||
#define ENABLE_DEBUG
|
||||
#include <debug.h>
|
||||
|
||||
#ifdef ENABLE_DEBUG
|
||||
#define ETX_BEACON_STACKSIZE 4500
|
||||
#define ETX_RADIO_STACKSIZE 4500
|
||||
#define ETX_CLOCK_STACKSIZE 500
|
||||
#else
|
||||
#define ETX_BEACON_STACKSIZE 2500 //TODO optimize, maybe 2000 is enough
|
||||
#define ETX_RADIO_STACKSIZE 2500 //TODO optimize, maybe 2000 is enough
|
||||
#define ETX_CLOCK_STACKSIZE 500 //TODO optimize, maybe 250 is enough
|
||||
#endif
|
||||
|
||||
//[option|length|ipaddr.|packetcount] with up to 15 ipaddr|packetcount pairs
|
||||
// 1 Byte 1 Byte 1 Byte 1 Byte
|
||||
#define ETX_BUF_SIZE (32)
|
||||
|
||||
#define ETX_RCV_QUEUE_SIZE (128)
|
||||
|
||||
/*
|
||||
* Default 40, should be enough to get all messages for neighbors.
|
||||
* In my tests, the maximum count of neighbors was around 30-something
|
||||
*/
|
||||
#ifdef ENABLE_DEBUG
|
||||
#define ETX_MAX_CANDIDATE_NEIGHBORS 15 //Stacksizes are huge in debug mode, so memory is rare
|
||||
#else
|
||||
#define ETX_MAX_CANDIDATE_NEIGHBORS 40
|
||||
#endif
|
||||
//ETX Interval parameters
|
||||
#define MS 1000
|
||||
|
||||
/*
|
||||
* ETX_INTERVAL
|
||||
*
|
||||
* Given in ms, the default is 1 second.
|
||||
* Should be divisible through 2 (For ETX_DEF_JIT_CORRECT)
|
||||
* and 5 (For ETX_MAX_JITTER) unless those values are adjusted too.
|
||||
*/
|
||||
#define ETX_INTERVAL (1000)
|
||||
#define ETX_WINDOW (10) //10 is the default value
|
||||
#define ETX_BEST_CANDIDATES (15) //Sent only 15 candidates in a beaconing packet
|
||||
#define ETX_TUPLE_SIZE (2) //1 Byte for Addr, 1 Byte for packets rec.
|
||||
#define ETX_PKT_REC_OFFSET (ETX_TUPLE_SIZE - 1) //Offset in a tuple of (addr,pkt_rec), will always be the last byte
|
||||
#define ETX_IPV6_LAST_BYTE (15) //The last byte for an ipv6 address
|
||||
#define ETX_MAX_JITTER (ETX_INTERVAL / 5) //The default value is 20% of ETX_INTERVAL
|
||||
#define ETX_JITTER_MOD (ETX_MAX_JITTER + 1) //The modulo value for jitter computation
|
||||
#define ETX_DEF_JIT_CORRECT (ETX_MAX_JITTER / 2) //Default Jitter correction value (normally ETX_MAX_JITTER / 2)
|
||||
#define ETX_CLOCK_ADJUST (52500) //Adjustment for clockthread computations to stay close/near ETX_INTERVAL
|
||||
|
||||
/*
|
||||
* The ETX beaconing packet consists of:
|
||||
*
|
||||
* 0 1 2
|
||||
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
|
||||
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- - - - - - - -
|
||||
* | Option Type | Option Length | Data
|
||||
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- - - - - - - -
|
||||
* Option type: Set to 0x20
|
||||
*
|
||||
* Option Length: The length of the Data sent with this packet
|
||||
*
|
||||
* Option Data: 2-Octet Pairs of 8 bit for addresses and a positive integer
|
||||
* denoting the amount of packets received from that IP address
|
||||
*
|
||||
* We only need 1 octet for the ip address since RPL for now only allows for
|
||||
* 255 different addresses.
|
||||
*
|
||||
* If the length of this packet says 0, it has received no other beaconing
|
||||
* packets itself so far.
|
||||
*
|
||||
* The packet is always 32bytes long, but may contain varying amounts of
|
||||
* information.
|
||||
* The information processed shall not exceed the value set in Option Length.
|
||||
*/
|
||||
typedef struct __attribute__((packed)) etx_probe_t{
|
||||
uint8_t code;
|
||||
uint8_t length;
|
||||
uint8_t data[30];
|
||||
} etx_probe_t;
|
||||
|
||||
typedef struct etx_neighbor_t {
|
||||
ipv6_addr_t addr; //The address of this node
|
||||
uint8_t tx_cur_round; //The indicator for receiving a packet from this candidate this round
|
||||
uint8_t packets_tx[ETX_WINDOW]; //The packets this node has transmitted TO ME
|
||||
uint8_t packets_rx; //The packets this node has received FROM ME
|
||||
double cur_etx; //The currently calculated ETX-value
|
||||
uint8_t used; //The indicator if this node is active or not
|
||||
} etx_neighbor_t;
|
||||
|
||||
//prototypes
|
||||
void etx_init_beaconing(ipv6_addr_t * address);
|
||||
void etx_beacon(void);
|
||||
void etx_clock(void);
|
||||
double etx_get_metric(ipv6_addr_t * address);
|
||||
void etx_update(etx_neighbor_t * neighbor);
|
||||
void etx_radio(void);
|
||||
|
||||
#define ETX_PKT_OPT (0) //Position of Option-Type-Byte
|
||||
#define ETX_PKT_OPTVAL (0x20) //Non-standard way of saying this is an ETX-Packet.
|
||||
#define ETX_PKT_LEN (1) //Position of Length-Byte
|
||||
#define ETX_DATA_MAXLEN (30) //max length of the data
|
||||
#define ETX_PKT_HDR_LEN (2) //Option type + Length (1 Byte each)
|
||||
#define ETX_PKT_DATA (2) //Begin of Data Bytes
|
||||
|
||||
#endif /* ETX_BEACONING_H_ */
|
||||
@ -1,7 +0,0 @@
|
||||
#include "objective_functions.h"
|
||||
|
||||
void of0(void)
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
@ -1,3 +0,0 @@
|
||||
#include <stdio.h>
|
||||
|
||||
void of0(void);
|
||||
@ -0,0 +1,160 @@
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "of_mrhof.h"
|
||||
|
||||
#include "etx_beaconing.h"
|
||||
|
||||
// Function Prototypes
|
||||
static uint16_t calc_rank(rpl_parent_t *, uint16_t);
|
||||
static rpl_parent_t *which_parent(rpl_parent_t *, rpl_parent_t *);
|
||||
static rpl_dodag_t *which_dodag(rpl_dodag_t *, rpl_dodag_t *);
|
||||
static void reset(rpl_dodag_t *);
|
||||
static uint16_t calc_path_cost(rpl_parent_t * parent);
|
||||
|
||||
uint16_t cur_min_path_cost = MAX_PATH_COST;
|
||||
rpl_parent_t * cur_preferred_parent = NULL;
|
||||
|
||||
rpl_of_t rpl_of_mrhof = {
|
||||
0x1,
|
||||
calc_rank,
|
||||
which_parent,
|
||||
which_dodag,
|
||||
reset,
|
||||
NULL
|
||||
};
|
||||
|
||||
rpl_of_t * rpl_get_of_mrhof(void) {
|
||||
return &rpl_of_mrhof;
|
||||
}
|
||||
|
||||
void reset(rpl_dodag_t *dodag) {
|
||||
}
|
||||
|
||||
static uint16_t calc_path_cost(rpl_parent_t * parent) {
|
||||
puts("calc_pathcost");
|
||||
/*
|
||||
* Calculates the path cost through the parent, for now, only for ETX
|
||||
*/
|
||||
if (parent == NULL ) {
|
||||
// Shouldn't ever happen since this function is supposed to be always
|
||||
// run with a parent. If it does happen, we can assume a root called it.
|
||||
puts("[WARNING] calc_path_cost called without parent!");
|
||||
return DEFAULT_MIN_HOP_RANK_INCREASE;
|
||||
}
|
||||
|
||||
double etx_value = etx_get_metric(&(parent->addr));
|
||||
printf("Metric for parent returned: %f", etx_value);
|
||||
if (etx_value != 0) {
|
||||
/*
|
||||
* (ETX_for_link_to_neighbor * 128) + Rank_of_that_neighbor
|
||||
*
|
||||
* This means I get the rank of that neighbor (which is the etx
|
||||
* of the whole path from him to the root node) plus my ETX to
|
||||
* that neighbor*128, which would be the 'rank' of the single link
|
||||
* from me to that neighbor
|
||||
*
|
||||
*/
|
||||
if (etx_value * ETX_RANK_MULTIPLIER > MAX_LINK_METRIC) {
|
||||
// Disallow links with an estimated ETX of 4 or higher
|
||||
return MAX_PATH_COST;
|
||||
}
|
||||
|
||||
if (etx_value * ETX_RANK_MULTIPLIER + parent->rank
|
||||
< parent->rank) {
|
||||
//Overflow
|
||||
return MAX_PATH_COST;
|
||||
}
|
||||
//TODO runden
|
||||
return etx_value * ETX_RANK_MULTIPLIER
|
||||
+ parent->rank;
|
||||
} else {
|
||||
// IMPLEMENT HANDLING OF OTHER METRICS HERE
|
||||
// if it is 0, it hasn't been computed, thus we cannot compute a path
|
||||
// cost
|
||||
return MAX_PATH_COST;
|
||||
}
|
||||
}
|
||||
|
||||
static uint16_t calc_rank(rpl_parent_t * parent, uint16_t base_rank) {
|
||||
puts("calc_rank");
|
||||
/*
|
||||
* Return the rank for this node.
|
||||
*
|
||||
* For now, there is no metric-selection or specification, so the rank com-
|
||||
* putation will always be assumed to be done for the ETX metric.
|
||||
* Baserank is pretty much only used to find out if a node is a root or not.
|
||||
*/
|
||||
if (parent == NULL ) {
|
||||
if (base_rank == 0) {
|
||||
//No parent, no rank, a root node would have a rank != 0
|
||||
return INFINITE_RANK;
|
||||
}
|
||||
|
||||
/*
|
||||
* No parent, base_rank != 0 means this is a root node or a node which
|
||||
* is recalculating.
|
||||
* Since a recalculating node must have a parent in this implementation
|
||||
* (see rpl.c, function global_repair), we can assume this node is root.
|
||||
*/
|
||||
return DEFAULT_MIN_HOP_RANK_INCREASE;
|
||||
} else {
|
||||
/*
|
||||
* We have a parent and are a non-root node, calculate the path cost for
|
||||
* the parent and choose the maximum of that value and the advertised
|
||||
* rank of the parent + minhoprankincrease for our rank.
|
||||
*/
|
||||
uint16_t calculated_pcost = calc_path_cost(parent);
|
||||
|
||||
if (calculated_pcost < MAX_PATH_COST) {
|
||||
if ((parent->rank + parent->dodag->minhoprankincrease)
|
||||
> calculated_pcost) {
|
||||
return parent->rank + parent->dodag->minhoprankincrease;
|
||||
} else {
|
||||
return calculated_pcost;
|
||||
}
|
||||
} else {
|
||||
//Path costs are greater than allowed
|
||||
return INFINITE_RANK;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static rpl_parent_t * which_parent(rpl_parent_t * p1, rpl_parent_t * p2) {
|
||||
puts("which_parent");
|
||||
/*
|
||||
* Return the parent with the lowest path cost.
|
||||
* Before returning any of the two given parents, make sure that a switch is
|
||||
* desirable.
|
||||
*
|
||||
*/
|
||||
uint16_t path_p1 = calc_path_cost(p1);
|
||||
uint16_t path_p2 = calc_path_cost(p2);
|
||||
|
||||
if(cur_preferred_parent != NULL){
|
||||
//test if the parent from which we got this path is still active
|
||||
if(cur_preferred_parent->used != 0){
|
||||
// Test, if the current best path is better than both parents given
|
||||
if(cur_min_path_cost < path_p1 + PARENT_SWITCH_THRESHOLD
|
||||
&& cur_min_path_cost < path_p2 + PARENT_SWITCH_THRESHOLD){
|
||||
return cur_preferred_parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (path_p1 < path_p2) {
|
||||
/*
|
||||
* Return the current best parent, and set it as current best parent
|
||||
*/
|
||||
cur_min_path_cost = path_p1;
|
||||
cur_preferred_parent = p1;
|
||||
return p1;
|
||||
}
|
||||
cur_min_path_cost = path_p2;
|
||||
cur_preferred_parent = p2;
|
||||
return p2;
|
||||
}
|
||||
|
||||
//Not used yet, as the implementation only makes use of one dodag for now.
|
||||
static rpl_dodag_t * which_dodag(rpl_dodag_t *d1, rpl_dodag_t *d2) {
|
||||
return d1;
|
||||
}
|
||||
@ -0,0 +1,40 @@
|
||||
//For debugging purposes
|
||||
#define ENABLE_DEBUG
|
||||
#include <debug.h>
|
||||
|
||||
|
||||
#include "rpl_structs.h"
|
||||
|
||||
/*
|
||||
* Disallow links with greater than 4 expected
|
||||
* transmission counts on the selected path.
|
||||
*/
|
||||
#define MAX_LINK_METRIC (512)
|
||||
|
||||
/*
|
||||
* Disallow paths with greater than 256
|
||||
* expected transmission counts.
|
||||
*/
|
||||
#define MAX_PATH_COST (0x8000)
|
||||
|
||||
/*
|
||||
* Switch to a new path only if it is
|
||||
* expected to require at least 1.5 fewer transmissions than the
|
||||
* current path.
|
||||
*/
|
||||
#define PARENT_SWITCH_THRESHOLD (192)
|
||||
|
||||
/*
|
||||
* Do not allow a node to become a floating root.
|
||||
* (Currently unused, since the RPL-implementation does not allow for floating
|
||||
* roots).
|
||||
*/
|
||||
#define ALLOW_FLOATING_ROOT (0)
|
||||
|
||||
/*
|
||||
* While assigning Rank when using ETX, use the representation of ETX described
|
||||
* in [RFC6551], i.e., assign Rank equal to ETX * 128.
|
||||
*/
|
||||
#define ETX_RANK_MULTIPLIER (0x80)
|
||||
|
||||
rpl_of_t *rpl_get_of_mrhof();
|
||||
Loading…
Reference in New Issue