static void * ThreadFunc(void * pv) //Thread for Signal Hound setup and sweeping
{
sched_param param;
param.sched_priority = 51;
pthread_attr_setschedparam(&tattr,¶m);
pthread_setschedparam(pthread_self(),SCHED_RR,¶m);
usleep(10000);
if(g_bSettingsChanged) //If settings have cahnged since last sweep...
{
pMyHound->m_settings.m_refLevel = gRefLevel;
pMyHound->SetCenterAndSpan(gCenterFreq,gSpanFreq);
pMyHound->SetupForSweep();
g_bSettingsChanged = false;
}
usleep(10000);
int errorcode = pMyHound->DoSweep(); //Do the sweep
usleep(10000);
int peakidx=0;
for(int i=1; i<pMyHound->m_traceSize; i++)
{
if(pMyHound->pDataMax[i] > pMyHound->pDataMax[peakidx]) peakidx = i;//Find peak
}
sprintf(debugstr,"pk %d, %.1f dBm",peakidx,mW2dBm(pMyHound->pDataMax[peakidx])); //Display peak index and amplitude
if(errorcode)
sprintf(debugstr,"error %d",errorcode);
g_bHasTrace = true; //Indicate that there is valid data to display
g_bDirty = true; //Indicate the disply needs to be updated
return NULL;
}
/* ************************************************** */
double compute_tworayground(struct entitydata *entitydata, nodeid_t src, nodeid_t dst, double rxdBm) {
/*
* Cross over distance:
*
* 4 * pi * ht * hr
* dc = ------------------
* lambda
* Pt * Gt * Gr * (ht * hr)^2
* Case 1: d >= dc => Pr(d) = -----------------------------
* d^4 * L
*
* Pt * Gt * Gr * lambda^2
* Case 2: d < dc => Pr(d) = -------------------------
* (4 * pi * d)^2 * L
*
* Note: rxmW = Pt * Gt * Gr, and L = 1
*
* cf p89 ref "Wireless Communications: Principles and Practice", Theodore Rappaport, 1996.
*
*/
double dist;
dist = distance(get_node_position(src), get_node_position(dst));
if (dist == 0) {
return rxdBm;
}
else if (dist < entitydata->crossover_distance) {
/* uses friis formula for distance < crossover distance or if (ht == hr == 0) */
return (rxdBm + 2 * mW2dBm(entitydata->factor / dist));
}
else {
/* else two-ray ground model is more accurate for distance > crossover distance */
return (rxdBm + mW2dBm(entitydata->ht * entitydata->ht *
entitydata->hr * entitydata->hr / pow(dist, 4.0)));
}
}
/* ************************************************** */
int init(call_t *c, void *params) {
struct entitydata *entitydata = malloc(sizeof(struct entitydata));
param_t *param;
double frequency = 868;
/* default values */
entitydata->pathloss = 2.0;
/* get parameters */
das_init_traverse(params);
while ((param = (param_t *) das_traverse(params)) != NULL) {
if (!strcmp(param->key, "frequency_MHz")) {
if (get_param_double(param->value, &(frequency))) {
goto error;
}
}
if (!strcmp(param->key, "pathloss")) {
if (get_param_double(param->value, &(entitydata->pathloss))) {
goto error;
}
}
}
/*
* Compute attenuation at reference distance d=1 with reference power Pt=1 :
*
* Pt * Gt * Gr * lambda^2
* Pr(d) = -------------------------
* (4 * pi * d)^2 * L
*
* Note: rxmW = Pt * Gt * Gr, and L = 1
*
* cf p71 ref "Wireless Communications: Principles and Practice", Theodore Rappaport, 1996.
*
*/
entitydata->Pr0 = mW2dBm((300 / (4 * M_PI * frequency)) * (300 / (4 * M_PI * frequency)));
set_entity_private_data(c, entitydata);
return 0;
error:
free(entitydata);
return -1;
}
/* ************************************************** */
double compute_freespace(struct entitydata *entitydata, nodeid_t src, nodeid_t dst, double rxdBm) {
/*
* Pt * Gt * Gr * lambda^2
* Pr(d) = -------------------------
* (4 * pi * d)^2 * L
*
* Note: rxdBm = [Pt + Gt + Gr]_dBm, and L = 1
*
* cf p71 ref "Wireless Communications: Principles and Practice", Theodore Rappaport, 1996.
*
*/
double dist = distance(get_node_position(src), get_node_position(dst));
if (dist == 0) {
return (rxdBm);
} else {
return (rxdBm + 2 * mW2dBm(entitydata->factor / dist));
}
}
/* ************************************************** */
double compute_logdistance_pathloss(struct entitydata *entitydata, nodeid_t src, nodeid_t dst, double rxdBm) {
/*
* Pr_dBm(d) = Pr_dBm(d0) - 10 * beta * log10(d/d0)
*
* Note: rxdBm = [Pt + Gt + Gr]_dBm, and L = 1
*
* cf p102-104 ref "Wireless Communications: Principles and Practice", Theodore Rappaport, 1996.
*
*/
double dist;
if (rxdBm != entitydata->last_rxdBm) {
entitydata->Pr0 = freespace(entitydata, entitydata->dist0, dBm2mW(rxdBm));
entitydata->last_rxdBm = rxdBm;
}
dist = distance(get_node_position(src), get_node_position(dst));
return mW2dBm(entitydata->Pr0) - 10.0 * entitydata->pathloss * log10(dist/entitydata->dist0);
}
/* ************************************************** */
double propagation(call_t *c, packet_t *packet, nodeid_t src, nodeid_t dst, double rxdBm) {
struct entitydata *entitydata = get_entity_private_data(c);
double dist, powerloss_dbm;
/*
* Pr_dBm(d) = Pr_dBm(d0) - 10 * beta * log10(d/d0) + X
*
* Note: rxdBm = [Pt + Gt + Gr]_dBm, L = 1, and X a normal distributed RV (in dBm)
*
* cf p104-105 ref "Wireless Communications: Principles and Practice", Theodore Rappaport, 1996.
*
*/
if (rxdBm != entitydata->last_rxdBm) {
entitydata->Pr0 = freespace(c, packet, entitydata->dist0, dBm2mW(rxdBm));
entitydata->last_rxdBm = rxdBm;
}
dist = distance(get_node_position(src), get_node_position(dst));
powerloss_dbm = -10.0 * entitydata->pathloss * log10(dist/entitydata->dist0) + normal(0.0, entitydata->deviation);
return mW2dBm(entitydata->Pr0) + powerloss_dbm;
}
/**
* Retransmit data to nodes
**/
int worldsens_nodes_rx(call_t *c, packet_t *packet){
ws_rdv_t *next_rdv = worldsens_rdv_see_next();
if(next_rdv->clock == get_time()){ /* just send data (no rdv)*/
union _worldsens_pkt pkt_rx;
/* compute sinr */
double sinr = packet->rxdBm - mW2dBm(*(packet->noise_mW));
/* put doubles into uint64_t variables for swap */
uint64_t *prxdBm = (uint64_t *) &(packet->rxdBm);
uint64_t *pworldsens_freq = (uint64_t *) &(packet->worldsens_freq);
uint64_t *psinr = (uint64_t *) &(sinr);
/* forge msg */
pkt_rx.byte_rx.type = WORLDSENS_S_BYTE_RX;
pkt_rx.byte_rx.seq = ws_seq++;
pkt_rx.byte_rx.antenna_id = packet->antenna;
pkt_rx.byte_rx.wsim_mod_id = packet->worldsens_mod;
pkt_rx.byte_rx.freq = *pworldsens_freq;
pkt_rx.byte_rx.data = *(packet->data);
pkt_rx.byte_rx.node_id = worldsens_get_wsim_node_id(c->node);
pkt_rx.byte_rx.power_dbm = *prxdBm;
pkt_rx.byte_rx.sinr = *psinr;
/* send data */
worldsens_packet_display(&pkt_rx);
worldsens_packet_hton (&pkt_rx);
if(wsens_srv_msend((char *) &pkt_rx, sizeof(struct _worldsens_s_byte_rx))){
return -1;
}
WSNET_S_DBG_DBG("WSNET2:: --> RX (dest ip:%d, data:0x%02x, freq:%ghz, wsim modul:%d, power:%gdbm)\n", worldsens_get_wsim_node_id(c->node), (*(packet->data)) & 0xff, packet->worldsens_freq, packet->worldsens_mod, packet->rxdBm);
packet_dealloc(packet);
}
else { /* program new rdv and send data */
union _worldsens_pkt pkt_sr_rx;
/* compute sinr */
double sinr = packet->rxdBm - mW2dBm(*(packet->noise_mW));
/* put doubles into uint64_t variables for swap */
uint64_t *prxdBm = (uint64_t *) &(packet->rxdBm);
uint64_t *pworldsens_freq = (uint64_t *) &(packet->worldsens_freq);
uint64_t *psinr = (uint64_t *) &(sinr);
/* update next rdv */
ws_nsync = next_rdv->clock;
ws_nsyncseq++;
ws_synched = 0;
ws_rp_updated = 1;
/* forge msg */
pkt_sr_rx.byte_sr_rx.type = WORLDSENS_S_BYTE_SR_RX;
pkt_sr_rx.byte_sr_rx.seq = ws_seq++;
pkt_sr_rx.byte_sr_rx.rp_next = ws_nsyncseq;
pkt_sr_rx.byte_sr_rx.rp_duration = ws_nsync - ws_csync;
pkt_sr_rx.byte_sr_rx.antenna_id = packet->antenna;
pkt_sr_rx.byte_sr_rx.wsim_mod_id = packet->worldsens_mod;
pkt_sr_rx.byte_sr_rx.freq = *pworldsens_freq;
pkt_sr_rx.byte_sr_rx.data = *(packet->data);
pkt_sr_rx.byte_sr_rx.node_id = worldsens_get_wsim_node_id(c->node);
pkt_sr_rx.byte_sr_rx.power_dbm = *prxdBm;
pkt_sr_rx.byte_sr_rx.sinr = *psinr;
/* send data */
worldsens_packet_display(&pkt_sr_rx);
worldsens_packet_hton (&pkt_sr_rx);
if(wsens_srv_msend((char *) &pkt_sr_rx, sizeof(struct _worldsens_s_byte_sr_rx))){
return -1;
}
WSNET_S_DBG_DBG("WSNET2:: --> RX (dest ip:%d, data:0x%02x, freq:%ghz, wsim modul:%d, power:%gdbm)\n", worldsens_get_wsim_node_id(c->node), (*(packet->data)) & 0xff, packet->worldsens_freq, packet->worldsens_mod, packet->rxdBm);
WSNET_S_DBG_DBG("WSNET2:: --> RP (seq: %"PRId64") (rp seq: %"PRId64", period: %"PRId64", rp:%"PRId64")\n", ws_seq - 1, ws_nsyncseq, ws_nsync - ws_csync, ws_nsync);
packet_dealloc(packet);
}
return 0;
}
