/* ************************************************** */ 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 add_neighbor(call_t *c, struct routing_header *header) { struct nodedata *nodedata = get_node_private_data(c); struct neighbor *neighbor = NULL; /* check wether neighbor already exists */ das_init_traverse(nodedata->neighbors); while ((neighbor = (struct neighbor *) das_traverse(nodedata->neighbors)) != NULL) { if (neighbor->id == header->src) { neighbor->position.x = header->src_pos.x; neighbor->position.y = header->src_pos.y; neighbor->position.z = header->src_pos.z; neighbor->time = get_time(); return; } } neighbor = (struct neighbor *) malloc(sizeof(struct neighbor)); neighbor->id = header->src; neighbor->position.x = header->src_pos.x; neighbor->position.y = header->src_pos.y; neighbor->position.z = header->src_pos.z; neighbor->time = get_time(); das_insert(nodedata->neighbors, (void *) neighbor); 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); }
/* ************************************************** */ void rx_xy_hello(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct xy_hello_p *hello = (struct xy_hello_p *) (packet->data + nodedata->overhead); struct xy_neighbor *neighbor; /* check for existing neighbors */ das_init_traverse(nodedata->neighbors); while ((neighbor = (struct xy_neighbor *) das_traverse(nodedata->neighbors)) != NULL) { if (neighbor->id == hello->src) { neighbor->position.x = hello->position.x; neighbor->position.y = hello->position.y; neighbor->position.z = hello->position.z; neighbor->time = get_time(); packet_dealloc(packet); return; } } /* new neighbor */ neighbor = (struct xy_neighbor *) malloc(sizeof(struct xy_neighbor)); neighbor->id = hello->src; neighbor->position.x = hello->position.x; neighbor->position.y = hello->position.y; neighbor->position.z = hello->position.z; neighbor->time = get_time(); das_insert(nodedata->neighbors, (void *) neighbor); packet_dealloc(packet); 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); }
/* Find all the neighbors (i.e. nodes in range) of the current node */ int find_neighbors(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct neighbor *neighbor = NULL; nodeid_t i; double dist = 0; int nb_neigh = 0; /* Parse all the nodes in the simulation: and find the ones * that are in range of that node */ for(i = 0; i < get_node_count(); i++) { /* Do not include myself */ if (i == c->node) { continue; } dist = distance(get_node_position(c->node), get_node_position(i)); if (dist <= nodedata->range) { /* Add the node in the list of neighbors */ neighbor = (struct neighbor *) malloc(sizeof(struct neighbor)); neighbor->id = i; neighbor->position.x = get_node_position(i)->x; neighbor->position.y = get_node_position(i)->y; neighbor->position.z = get_node_position(i)->z; neighbor->time = get_time(); //PRINT_ROUTING("Node %d is added to neighbor list of node %d\n", // neighbor->id, c->node); das_insert(nodedata->neighbors, (void *) neighbor); nb_neigh++; } } return nb_neigh; }
// ENVOI DE PACKET HELLO int init_one_hop(call_t *c, void *args) { struct nodedata *nodedata = get_node_private_data(c); //recuperer le support de communication DOWN entityid_t *down = get_entity_links_down(c); call_t c0 = {down[0], c->node}; //destination de paquet destination_t destination = {BROADCAST_ADDR, {-1, -1, -1}}; //creation de paquet et initialisation de son data packet_t *packet = packet_alloc(c, nodedata->overhead[0] + sizeof(struct packet_hello)); struct packet_hello *hello = (struct packet_hello *) (packet->data + nodedata->overhead[0]); //initilailser les données hello->type=HELLO; hello->source=c->node; if (SET_HEADER(&c0, packet, &destination) == -1) { packet_dealloc(packet); return -1; } DEBUG; /*printf("Node %d (%lf %lf %lf) broadcast a packet hello, at %lf\n", c->node, //id de Noeud get_node_position(c->node)->x,get_node_position(c->node)->y,get_node_position(c->node)->z, //la postion x, y,z de Noeud get_time_now_second());//*/ //l'instant d'envoi. //L'envoi TX(&c0,packet); //tous c'est bien passé return 1; }
double get_range_Tr(call_t *c) { array_t *mac=get_mac_entities(c); call_t c0 = {mac->elts[0], c->node, c->entity}; struct macnodedata* macdata = get_node_private_data(&c0); return macdata->range; }
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 bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); nodedata->tx_busy = -1; nodedata->rx_busy = -1; nodedata->rxdBm = MIN_DBM; return 0; }
/* ************************************************** */ double get_noise(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); entityid_t *down = get_entity_links_down(c); c->from = down[0]; return MEDIA_GET_NOISE(c, nodedata->channel); }
/* ************************************************** */ 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 rx(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct _802_15_4_header *header = (struct _802_15_4_header *) packet->data; array_t *up = get_entity_bindings_up(c); int i = up->size; /* cf p171 ref 802.15.4-2006: discard packet while in backoff */ if (nodedata->state != STATE_IDLE) { packet_dealloc(packet); return; } if ((header->dst != c->node) && (header->dst != BROADCAST_ADDR)) { packet_dealloc(packet); return; } 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; }
/* ************************************************** */ void rx(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); packet_PROTOCOLE *data = (packet_PROTOCOLE *) (packet->data + nodedata->overhead); /*******************************HELLO 1 voisinage***************************/ switch(data->type) { case HELLO: { rx_hello(c,packet); break; } case RBOP: { if(list_recherche(data->destinations,c->node)) { SHOW_GRAPH("G: %d %d\n",data->redirected_by,c->node); if(list_PACKET_recherche_tout(nodedata->paquets,data->src,data->seq)==0) PROTOCOLE_reception(c,packet); } break; } default: printf("J'ai recu un packet de type %d NON reconnu\n", data->type); break; } }
/* Greedy geographic routing => computing the nexthop */ struct xy_neighbor *xy_next_hop(call_t *c, position_t *position) { struct nodedata *nodedata = get_node_private_data(c); struct xy_neighbor *neighbor = NULL, *n_hop = NULL; double dist = distance(get_node_position(c->node), position); double d = dist; uint64_t clock = get_time(); /* parse neighbors */ das_init_traverse(nodedata->neighbors); while ((neighbor = (struct xy_neighbor *) das_traverse(nodedata->neighbors)) != NULL) { #ifdef CHECK_ACTIVE_NODE if ( !is_node_alive(neighbor->id) || ((nodedata->h_timeout > 0) && (clock - neighbor->time) >= nodedata->h_timeout) ) { continue; } #else if ((nodedata->h_timeout > 0) && (clock - neighbor->time) >= nodedata->h_timeout ) { continue; } #endif /* choose next hop */ if ((d = distance(&(neighbor->position), position)) < dist) { dist = d; n_hop = neighbor; } } return n_hop; }
double setRangeToFarestNeighbour(call_t *c, graphe* g, arbre* bipTree) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); // calcul de la distance entre ce noeud et son voisin 1-hop (dans l'arbre de BIP) le plus eloigne list *fils = 0; double distMax = 0, dist; position_t pos; arbre_get_fils(&fils, bipTree, c->node); while(fils != 0) { pos = listeNodes_getPos(nodedata->oneHopNeighbourhood, fils->val); dist = distance(get_node_position(c->node), &pos); if(dist > distMax) { distMax = dist; } fils = fils->suiv; } // set le range du module propagation a la valeur desiree set_range_Tr(c, distMax); //printf("rayon d'emission de %d fixe a %lf\n", c->node, macdata->range); return distMax; }
/* ************************************************** */ void rx(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); array_t *up = get_entity_bindings_up(c); int i = up->size; struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead); /* Forward packet if node is not the recipient */ if ((header->dst != BROADCAST_ADDR) && (header->dst != c->node) ) { forward(c, packet); return; } 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; }
void set_range_Tr(call_t *c, double range) { range = (floor(range*10)+1)/10.0; array_t *mac=get_mac_entities(c); call_t c0 = {mac->elts[0], c->node, c->entity}; struct macnodedata* macdata = get_node_private_data(&c0); macdata->range = range; }
/* ************************************************** */ void rx(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); array_t *up = get_entity_bindings_up(c); int i = up->size; /* radio sleep */ if (nodedata->sleep) { packet_dealloc(packet); return; } /* half-duplex */ if (nodedata->tx_busy != -1) { packet_dealloc(packet); return; } /* handle carrier sense */ if (nodedata->rx_busy == packet->id) { nodedata->rx_busy = -1; nodedata->rxdBm = MIN_DBM; /* log rx */ PRINT_REPLAY("radio-rx1 %"PRId64" %d\n", get_time(), c->node); /* consume energy */ battery_consume_rx(c, packet->duration); } else { packet_dealloc(packet); return; } /* check wether the reception has killed us */ if (!is_node_alive(c->node)) { packet_dealloc(packet); return; } /* drop packet depending on the FER */ if (get_random_double() < packet->PER) { packet_dealloc(packet); return; } /* forward to upper layers */ 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; }
/* ************************************************** */ int neighbor_timeout(void *data, void *arg) { struct neighbor *neighbor = (struct neighbor *) data; call_t *c = (call_t *) arg; struct nodedata *nodedata = get_node_private_data(c); if ((get_time() - neighbor->time) >= nodedata->timeout) { return 1; } 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 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; }
//RECEPTION et REPONDRE AU PACKET HELLO int rx_one_hop(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); //RECEPTION DE PACKET HELLO struct packet_hello *hello = (struct packet_hello *) (packet->data + nodedata->overhead[0]); DEBUG; /*printf("NOde %d a recu un HELLO de %d (%lf %lf %lf) at %lf\n",c->node, hello->source, get_node_position(hello->source)->x,get_node_position(hello->source)->y,get_node_position(hello->source)->z, get_time_now_second());//*/ //l'ajoute de voisin if(!list_recherche(nodedata->N1,hello->source)) list_insert(&nodedata->N1,hello->source); //REPONSE DE PAKET HELLO //recuperer le support de communication MAC entityid_t *down = get_entity_links_down(c); call_t c0 = {down[0], c->node}; //destination de paquet destination_t destination = {hello->source, {get_node_position(hello->source)->x,get_node_position(hello->source)->y,get_node_position(hello->source)->z}}; //creation de paquet et initialisation de son data packet_t *rpacket = packet_alloc(c, nodedata->overhead[0] + sizeof(struct packet_hello)); struct packet_hello *rhello = (struct packet_hello *) (rpacket->data + nodedata->overhead[0]); //initilailser les données rhello->type = REP_HELLO; rhello->source = c->node; if (SET_HEADER(&c0, rpacket, &destination) == -1) { packet_dealloc(rpacket); return -1; } DEBUG; /*printf("Node %d (%lf %lf %lf) repond a %d packet hello, at %lf\n", c->node, //id de Noeud de noeud encours get_node_position(c->node)->x,get_node_position(c->node)->y,get_node_position(c->node)->z, //la postion x, y,z de Noeud hello->source, //id de noued de destination get_time_now_second()); //*/ //l'instant d'envoi. //L'envoi TX(&c0,rpacket); //liberer le packet packet_dealloc(packet); //tous c'est bien passé return 1; }
/* ************************************************** */ void tx(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); das_insert(nodedata->packets, (void *) packet); if (nodedata->state == STATE_IDLE) { nodedata->clock = get_time(); state_machine(c,NULL); } }
int unsetnode(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct neighbor *neighbor; while ((neighbor = (struct neighbor *) das_pop(nodedata->neighbors)) != NULL) { free(neighbor); } das_destroy(nodedata->neighbors); free(nodedata); return 0; }
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); }
/* ************************************************** */ int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); PRINT_REPLAY("mobility %"PRId64" %d %lf %lf %lf\n", get_time(), c->node, get_node_position(c->node)->x, get_node_position(c->node)->y, get_node_position(c->node)->z); nodedata->lupdate = get_time(); nodedata->nupdate = get_time() + nodedata->pausetime; return 0; }
/* ************************************************** */ void xy_stats(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); position_t *position = get_node_position(c->node); if (nodedata->type == INLINE_NODE) { printf("INLINE node %d (%lf,%lf,%lf) Group_id=%d Neighbors=%d\n", c->node, position->x, position->y, position->z, nodedata->group_id, das_getsize(nodedata->neighbors)); } else { printf("SENSOR node %d (%lf,%lf,%lf) Neighbors=%d\n", c->node, position->x, position->y, position->z, das_getsize(nodedata->neighbors)); } }
/* ************************************************** */ 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); }