/* ************************************************** */ void tx(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); array_t *down = get_entity_bindings_down(c); int i = down->size; /* radio sleep */ if (nodedata->sleep) { packet_dealloc(packet); return; } /* radio activity */ cs_init(c); nodedata->tx_busy = packet->id; /* log tx */ PRINT_REPLAY("radio-tx0 %"PRId64" %d 50\n", get_time(), c->node); /* transmit to antenna */ while (i--) { packet_t *packet_down; if (i > 0) { packet_down = packet_clone(packet); } else { packet_down = packet; } c->from = down->elts[i]; MEDIA_TX(c, packet_down); } return; }
/* ************************************************** */ void tx(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; nodedata->data_tx++; TX(&c0, packet); }
/* ************************************************** */ int set_header(call_t *c, packet_t *packet, destination_t *dst) { struct nodedata *nodedata = get_node_private_data(c); struct neighbor *n_hop = get_nexthop(c, &(dst->position)); destination_t destination; struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* if no route, return -1 */ if (dst->id != BROADCAST_ADDR && n_hop == NULL) { nodedata->data_noroute++; return -1; } else if (dst->id == BROADCAST_ADDR) { n_hop->id = BROADCAST_ADDR; } /* set routing header */ header->dst = dst->id; header->dst_pos.x = dst->position.x; header->dst_pos.y = dst->position.y; header->dst_pos.z = dst->position.z; header->src = c->node; header->src_pos.x = get_node_position(c->node)->x; header->src_pos.y = get_node_position(c->node)->y; header->src_pos.z = get_node_position(c->node)->z; header->type = DATA_PACKET; header->hop = nodedata->hop; /* Set mac header */ destination.id = n_hop->id; destination.position.x = -1; destination.position.y = -1; destination.position.z = -1; return SET_HEADER(&c0, packet, &destination); }
void rx_source_adv(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct source_adv_p *source = (struct source_adv_p *) (packet->data + nodedata->overhead); struct sensor_adv_p *sensor; packet_t *packet0; destination_t dst = {BROADCAST_ADDR, {-1, -1, -1}}; call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* check adv sequence */ if (source->s_seq <= nodedata->s_seq[source->source]) { /* old request */ packet_dealloc(packet); return; } nodedata->s_seq[source->source] = source->s_seq; /* reply */ packet0 = packet_create(c, nodedata->overhead + sizeof(struct sensor_adv_p), -1); sensor = (struct sensor_adv_p *) (packet0->data + nodedata->overhead); if (SET_HEADER(&c0, packet0, &dst) == -1) { packet_dealloc(packet); packet_dealloc(packet0); return; } sensor->type = SENSOR_ADV_TYPE; sensor->sensor = c->node; sensor->source = source->source; sensor->s_seq = source->s_seq; TX(&c0, packet0); packet_dealloc(packet); return; }
/* ************************************************** */ int set_header(call_t *c, packet_t *packet, destination_t *dst) { struct nodedata *nodedata = get_node_private_data(c); struct neighbor *n_hop = get_nexthop(c, dst->id); destination_t destination; struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* No route available */ if (dst->id != BROADCAST_ADDR && n_hop == NULL) { return -1; } /* Set routing header */ header->dst = dst->id; header->src = c->node; header->hop = nodedata->hop; /* Set MAC header */ if (dst->id == BROADCAST_ADDR) { destination.id = BROADCAST_ADDR; } else { destination.id = n_hop->id; } destination.position.x = -1; destination.position.y = -1; destination.position.z = -1; return SET_HEADER(&c0, packet, &destination); }
int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* get overhead */ nodedata->overhead = GET_HEADER_SIZE(&c0); return 0; }
/* *********************************************** */ int set_header( call_t *c , packet_t * packet , destination_t * dst ) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata =get_entity_private_data(c); packet_PROTOCOLE *data = (packet_PROTOCOLE *) (packet->data + nodedata->overhead); //augmenter le nbr d'evenement nodedata->nbr_evenement++; if(entitydata->debug) DBG("RBOP - %d SET HEADER \n",c->node); //Fixé le rayon if(nodedata->range<0) { listeNodes *tmp=nodedata->oneHopNeighbourhood; position_t pos1 = *get_node_position(c->node); double distMax = 0; while(tmp) { if(list_recherche(nodedata->RNG,tmp->values.node)) { position_t pos2= {tmp->values.x,tmp->values.y,tmp->values.z}; double dist=distance(&pos1,&pos2); if(distMax<dist) distMax=dist; } tmp=tmp->suiv; } set_range_Tr(c,distMax); nodedata->range=get_range_Tr(c); if(entitydata->debug) DBG("RBOP - %d FIXE RANGE TO %.2lf \n",c->node,get_range_Tr(c)); } //remplissage de data data->type=RBOP; data->src=c->node; data->src_pos=*get_node_position(c->node); data->seq=nodedata->nbr_evenement; data->redirected_by=c->node; data->destinations=Nullptr(list); list_copy(&data->destinations,nodedata->RNG); list_PACKET_insert_tout(&nodedata->paquets,data->src,data->seq,data->redirected_by); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; destination_t destination = {BROADCAST_ADDR, {-1, -1, -1}}; return SET_HEADER(&c0, packet, &destination); }
int get_header_real_size(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); if (nodedata->overhead == -1) { call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; nodedata->overhead = GET_HEADER_REAL_SIZE(&c0); } return nodedata->overhead + sizeof(struct routing_header); }
void tx( call_t *c , packet_t * packet ) { struct nodedata *nodedata = get_node_private_data(c); packet_PROTOCOLE *data = (packet_PROTOCOLE *) (packet->data + nodedata->overhead); //printf("DLBIP - Paquet de type %d envoye depuis %d par %d a %d (at %lf s).\n", data->type, data->src, c->node, data->dst, get_time_now_second()); //retransmettre call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; TX(&c0,packet); }
/* ************************************************** */ int check_channel_busy(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; if (nodedata->cs && (radio_get_cs(&c0) >= nodedata->EDThreshold)) { return 1; } if (nodedata->cca && (radio_get_noise(&c0) >= nodedata->EDThreshold)) { return 1; } return 0; }
int get_header_size( call_t * c ) { struct nodedata *nodedata = get_node_private_data(c); if (nodedata->overhead == -1) { call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; nodedata->overhead = GET_HEADER_SIZE(&c0); } return nodedata->overhead + sizeof(packet_PROTOCOLE); }
/* ************************************************** */ void forward(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead); struct neighbor *n_hop = get_nexthop(c, &(header->dst_pos)); destination_t destination; /* delivers packet to application layer */ if (n_hop == NULL) { array_t *up = get_entity_bindings_up(c); int i = up->size; while (i--) { call_t c_up = {up->elts[i], c->node, c->entity}; packet_t *packet_up; if (i > 0) { packet_up = packet_clone(packet); } else { packet_up = packet; } RX(&c_up, packet_up); } return; } /* update hop count */ header->hop--; if (header->hop == 0) { nodedata->data_hop++; packet_dealloc(packet); return; } /* set mac header */ destination.id = n_hop->id; destination.position.x = -1; destination.position.y = -1; destination.position.z = -1; if (SET_HEADER(&c0, packet, &destination) == -1) { packet_dealloc(packet); return; } /* forwarding packet */ nodedata->data_tx++; TX(&c0, packet); }
/* ************************************************** */ int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; int nb_neigh = 0; nb_neigh=nb_neigh; /* Get mac header overhead */ nodedata->overhead = GET_HEADER_SIZE(&c0); /* Find all the node's neighbors (i.e. the one in range) */ nb_neigh = find_neighbors(c); PRINT_ROUTING("Node %d has %d neighbors\n", c->node, nb_neigh); return 0; }
/* ************************************************** */ int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* get mac header overhead */ nodedata->overhead = GET_HEADER_SIZE(&c0); /* hello packet */ if (nodedata->period > 0) { uint64_t start = get_time() + nodedata->start + get_random_double() * nodedata->period; scheduler_add_callback(start, c, advert_callback, NULL); } return 0; }
/* ************************************************** */ int set_header(call_t *c, packet_t *packet, destination_t *dst) { struct nodedata *nodedata = get_node_private_data(c); struct route *route = hadas_get(nodedata->routes, (void *) ((unsigned long) (dst->id))); struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; destination_t n_hop; if (route == NULL) { return -1; } header->dst = dst->id; header->src = c->node; n_hop.id = route->n_hop; return SET_HEADER(&c0, packet, &n_hop); }
int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* get mac header overhead */ nodedata->overhead = GET_HEADER_SIZE(&c0); broadcast_hello(c, NULL); uint64_t at=get_time_now()+time_seconds_to_nanos(3); scheduler_add_callback(at, c, init_rbop, NULL); return 0; }
void rx_source_data(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct source_data_p *data = (struct source_data_p *) (packet->data + nodedata->overhead); struct gossip_data_p *gossip; packet_t *packet0; destination_t dst = {BROADCAST_ADDR, {-1, -1, -1}}; call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* check sensor */ if (data->sensor != c->node) { /* not for us */ packet_dealloc(packet); return; } /* check data sequence */ if (data->d_seq <= nodedata->d_seq[data->metadata]) { /* old data */ packet_dealloc(packet); return; } nodedata->d_seq[data->metadata] = data->d_seq; nodedata->d_source[data->metadata] = data->source; nodedata->d_value[data->metadata] = data->d_value; /* start gossip */ packet0 = packet_create(c, nodedata->overhead + sizeof(struct gossip_data_p), -1); gossip = (struct gossip_data_p *) (packet0->data + nodedata->overhead); if (SET_HEADER(&c0, packet0, &dst) == -1) { packet_dealloc(packet); packet_dealloc(packet0); return; } gossip->type = GOSSIP_DATA_TYPE; gossip->source = data->source; gossip->metadata = data->metadata; gossip->d_seq = data->d_seq; gossip->d_value = data->d_value; TX(&c0, packet0); packet_dealloc(packet); return; }
/* ************************************************** */ void forward(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead); struct route *route = hadas_get(nodedata->routes, (void *) ((unsigned long) (header->dst))); destination_t destination; if (route == NULL) { packet_dealloc(packet); return; } destination.id = route->n_hop; if (SET_HEADER(&c0, packet, (void *) &destination) == -1) { packet_dealloc(packet); return; } TX(&c0, packet); }
void rx_sink_adv(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct sink_adv_p *sink = (struct sink_adv_p *) (packet->data + nodedata->overhead); struct sensor_data_p *data; packet_t *packet0; destination_t dst = {BROADCAST_ADDR, {-1, -1, -1}}; call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* check request sequence */ if (sink->r_seq <= nodedata->r_seq[sink->sink]) { /* old request */ packet_dealloc(packet); return; } nodedata->r_seq[sink->sink] = sink->r_seq; /* check wether we have the data */ if (sink->d_seq > nodedata->d_seq[sink->metadata]) { /* our data is not up to date */ packet_dealloc(packet); return; } /* reply */ packet0 = packet_create(c, nodedata->overhead + sizeof(struct sensor_data_p), -1); data = (struct sensor_data_p *) (packet0->data + nodedata->overhead); if (SET_HEADER(&c0, packet0, &dst) == -1) { packet_dealloc(packet); packet_dealloc(packet0); return; } data->type = SENSOR_DATA_TYPE; data->metadata = sink->metadata; data->sink = sink->sink; data->r_seq = sink->r_seq; data->source = nodedata->d_source[sink->metadata]; data->d_seq = nodedata->d_seq[sink->metadata]; data->d_value = nodedata->d_value[sink->metadata]; TX(&c0, packet0); packet_dealloc(packet); return; }
void forward(call_t* c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); array_t *down = get_entity_bindings_down(c); packet_PROTOCOLE *data = (packet_PROTOCOLE *) (packet->data + nodedata->overhead); //printf("%d doit relayer depuis %d\n", c->node, data->pred); // construire le bip tree pour relayer a partir des infos du paquet int indice = listeNodes_get_index(data->askedToRedirect, c->node); graphe* g = purgeGraphe(c, listeNodes_get(data->needsToBeCovered, indice), data->src, data->pred); arbre* bipTree = computeBIPtree(c, g, data->askedToRedirect, data->needsToBeCovered, 0); if(entitydata->debug) { printf("%d relai depuis %d :\n", c->node, data->pred); arbre_affiche(bipTree); } // relayer le paquet destination_t dst = {-1,{-1,-1,-1}}; double cout = setRangeToFarestNeighbour(c, g, bipTree); //listeNodes_detruire(&data->askedToRedirect); data->askedToRedirect = 0; //listeNodes_detruire(&data->needsToBeCovered); data->needsToBeCovered = 0; data->pred = c->node; //call_t c0 = {-1,c->node,-1}; //data->energyRem = battery_remaining(&c0) - cout; //nodedata->energiesRem[c->node] = data->energyRem; setRelayNodes(c, g, bipTree, &data->askedToRedirect, &data->needsToBeCovered, c->node); call_t c_down = {down->elts[0], c->node, c->entity}; SET_HEADER(&c_down, packet, &dst); tx(c, packet); arbre_detruire(&bipTree); deleteGraphe(g); free(g); }
int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* get mac header overhead */ nodedata->overhead = GET_HEADER_SIZE(&c0); int i; for(i = 0 ; i < get_node_count() ; i++) { nodedata->lastIDs[i] = -1; nodedata->energiesRem[i] = battery_remaining(c) - 2*getCoutFromDistance(getRange(c), entitydata->alpha, entitydata->c); } broadcast_hello(c, NULL); uint64_t at=get_time_now()+time_seconds_to_nanos(2); scheduler_add_callback(at, c, broadcast_hello2, NULL); return 0; }
/* ************************************************** */ void forward(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead); struct neighbor *n_hop = get_nexthop(c, header->dst); destination_t destination; /* No route available */ if (n_hop == NULL) { packet_dealloc(packet); return; } /* Update hop count */ header->hop--; /* Hop count reached */ if (header->hop == 0) { packet_dealloc(packet); return; } /* Set MAC header */ destination.id = n_hop->id; destination.position.x = -1; destination.position.y = -1; destination.position.z = -1; if (SET_HEADER(&c0, packet, &destination) == -1) { packet_dealloc(packet); return; } /* Forwarding packet */ PRINT_ROUTING("forward: Node %d forwards a packet " "(from %d to %d, hop limit %d)\n", c->node, header->src, header->dst, header->hop); TX(&c0, packet); }
void rx_gossip_data(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct gossip_data_p *data = (struct gossip_data_p *) (packet->data + nodedata->overhead); destination_t dst = {BROADCAST_ADDR, {-1, -1, -1}}; call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* check data sequence */ if (data->d_seq <= nodedata->d_seq[data->metadata]) { /* old data */ packet_dealloc(packet); return; } nodedata->d_seq[data->metadata] = data->d_seq; nodedata->d_source[data->metadata] = data->source; nodedata->d_value[data->metadata] = data->d_value; /* forward gossip */ if (SET_HEADER(&c0, packet, &dst) == -1) { packet_dealloc(packet); return; } TX(&c0, packet); }
int advert_callback(call_t *c, void *args) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; destination_t destination = {BROADCAST_ADDR, {-1, -1, -1}}; packet_t *packet = packet_create(c, nodedata->overhead + sizeof(struct routing_header), -1); struct routing_header *header = (struct routing_header*) (packet->data + nodedata->overhead); /* set mac header */ if (SET_HEADER(&c0, packet, &destination) == -1) { packet_dealloc(packet); return -1; } /* set routing header */ header->dst = BROADCAST_ADDR; header->dst_pos.x = -1; header->dst_pos.y = -1; header->dst_pos.z = -1; header->src = c->node; header->src_pos.x = get_node_position(c->node)->x; header->src_pos.y = get_node_position(c->node)->y; header->src_pos.z = get_node_position(c->node)->z; header->type = HELLO_PACKET; header->hop = 1; /* send hello */ TX(&c0, packet); nodedata->hello_tx++; /* check neighbors timeout */ das_selective_delete(nodedata->neighbors, neighbor_timeout, (void *) c); /* schedules hello */ scheduler_add_callback(get_time() + nodedata->period, c, advert_callback, NULL); return 0; }
int state_machine(call_t *c, void *args) { struct nodedata *nodedata = get_node_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; uint64_t timeout; uint64_t backoff; packet_t *packet; if (nodedata->clock != get_time()) { return 0; } switch (nodedata->state) { case STATE_IDLE: if (nodedata->txbuf == NULL) { nodedata->txbuf = (packet_t *) das_pop_FIFO(nodedata->packets); if (nodedata->txbuf == NULL) { return 0; } } if (nodedata->MaxCSMABackoffs != 0) { nodedata->state = STATE_BACKOFF; nodedata->BE = nodedata->MinBE; nodedata->NB = 0; backoff = get_random_double() * (pow(2, nodedata->BE) - 1) * aUnitBackoffPeriod; nodedata->clock = get_time() + backoff; scheduler_add_callback(nodedata->clock, c, state_machine, NULL); return 0; } else { nodedata->state = STATE_TX; nodedata->clock = get_time(); scheduler_add_callback(nodedata->clock, c, state_machine, NULL); return 0; } case STATE_BACKOFF: if (check_channel_busy(c)) { if ((++nodedata->BE) > nodedata->MaxBE) { nodedata->BE = nodedata->MaxBE; } if (++nodedata->NB >= nodedata->MaxCSMABackoffs) { packet_dealloc(nodedata->txbuf); nodedata->txbuf = NULL; nodedata->state = STATE_IDLE; nodedata->clock = get_time(); state_machine(c,NULL); return 0; } backoff = get_random_double() * (pow(2, nodedata->BE) - 1) * aUnitBackoffPeriod; nodedata->clock = get_time() + backoff; scheduler_add_callback(nodedata->clock, c, state_machine, NULL); return 0; } nodedata->state = STATE_TX; nodedata->clock = get_time(); state_machine(c,NULL); return 0; case STATE_TX: packet = nodedata->txbuf; nodedata->txbuf = NULL; timeout = packet->size * 8 * radio_get_Tb(&c0) + macMinSIFSPeriod; TX(&c0, packet); nodedata->state = STATE_TXING; nodedata->clock = get_time() + timeout; scheduler_add_callback(nodedata->clock, c, state_machine, NULL); return 0; case STATE_TXING: nodedata->state = STATE_IDLE; nodedata->clock = get_time(); state_machine(c,NULL); return 0; default: break; } return 0; }
/* ************************************************** */ void tx(call_t *c, packet_t *packet) { call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; TX(&c0, packet); }