int cthd_topology::check_temperature(int index)
{
ssize_t retval;
char pathname[64];
char temp_str[10];
int fd;
unsigned int temperature;
int current_moving_average;
if(index >= no_sensors)
return 0;
sprintf(pathname, "/sys/devices/platform/coretemp.0/temp%d_input", index);
fd = open(pathname, O_RDONLY);
if(fd < 0)
return - 1;
retval = pread(fd, temp_str, sizeof(temp_str), 0);
temperature = atoi(temp_str);
current_moving_average = moving_average(temp_data, index, temperature);
temp_data[index].last_moving_average = current_moving_average;
thd_log_debug("DTS sensor %d mov average %u \n", index, current_moving_average)
;
close(fd);
return temperature;
}
LookupTable* SetCounter::to_ruby(VM* state) {
LookupTable* tbl = LookupTable::create(state);
tbl->store(state, stats::total(state), Integer::from(state, total_));
tbl->store(state, stats::max(state), Integer::from(state, max()));
tbl->store(state, stats::min(state), Integer::from(state, min()));
tbl->store(state, stats::average(state), Float::create(state, moving_average()));
return tbl;
}
//////////////////////////////////////////////////////////////////////////
//cross entropy
float CrossEntropyFunctor::getLoss(const std::shared_ptr<DataBucket> labelDataBucket,
const std::shared_ptr<DataBucket> outputDataBucket)
{
const auto outputSize = outputDataBucket->getSize();
const float* labelData = labelDataBucket->getData().get();
const float* outputData = outputDataBucket->getData().get();
float loss = 0.0f;
for (size_t i = 0; i < outputSize.totalSize(); i++)
{
const float curLoss = -labelData[i] * std::log(outputData[i]);
loss = moving_average(loss, i+1, curLoss);
}
return loss*outputSize._3DSize();
}
void localization_node::distCallback(const distance_publisher::IrDistance &dist)
{
median_lf[0] = median_lf[1]; median_lf[1] = median_lf[2]; median_lf[2] = median_lf[3]; //Shift
median_lf[3] = dist.left_front_distance;
median_lb[0] = median_lb[1]; median_lb[1] = median_lb[2]; median_lb[2] = median_lb[3]; //Shift
median_lb[3] = dist.left_back_distance;
median_rf[0] = median_rf[1]; median_rf[1] = median_rf[2]; median_rf[2] = median_rf[3]; //Shift
median_rf[3] = dist.right_front_distance;
median_rb[0] = median_rb[1]; median_rb[1] = median_rb[2]; median_rb[2] = median_rb[3]; //Shift
median_rb[3] = dist.right_back_distance;
median_fr[0] = median_fr[1]; median_fr[1]=median_fr[2]; median_fr[2] = median_fr[3];
median_fr[3] = dist.front_right_distance;
median_fl[0] = median_fl[1]; median_fl[1]=median_fl[2]; median_fl[2] = median_fl[3];
median_fl[3] = dist.front_left_distance;
calculated_distance_fl_=moving_average(median_fl);
calculated_distance_fr_=moving_average(median_fr);
calculated_distance_lf_ = moving_average(median_lf);
calculated_distance_lb_ = moving_average(median_lb);
calculated_distance_rf_ = moving_average(median_rf);
calculated_distance_rb_ = moving_average(median_rb);
/*
calculated_distance_fl_= dist.front_left_distance;
calculated_distance_fr_ = dist.front_right_distance;
calculated_distance_lf_= dist.left_front_distance;
calculated_distance_lb_ = dist.left_back_distance;
calculated_distance_rf_= dist.right_front_distance;
calculated_distance_rb_ = dist.right_back_distance;
*/
}
/*---------------------------------------------------------------------------*/
void
rpl_process_dio(uip_ipaddr_t *from, rpl_dio_t *dio)
{
rpl_instance_t *instance;
rpl_dag_t *dag, *previous_dag;
rpl_parent_t *p;
if(dio->mop != RPL_MOP_DEFAULT) {
// PRINTF("RPL: Ignoring a DIO with an unsupported MOP: %d\n", dio->mop);
return;
}
dag = get_dag(dio->instance_id, &dio->dag_id);
instance = rpl_get_instance(dio->instance_id);
if(dag != NULL && instance != NULL) {
if(lollipop_greater_than(dio->version, dag->version)) {
if(dag->rank == ROOT_RANK(instance)) {
// PRINTF("RPL: Root received inconsistent DIO version number\n");
dag->version = dio->version;
RPL_LOLLIPOP_INCREMENT(dag->version);
rpl_reset_dio_timer(instance);
} else {
// PRINTF("RPL: Global Repair\n");
if(dio->prefix_info.length != 0) {
if(dio->prefix_info.flags & UIP_ND6_RA_FLAG_AUTONOMOUS) {
// PRINTF("RPL : Prefix announced in DIO\n");
rpl_set_prefix(dag, &dio->prefix_info.prefix, dio->prefix_info.length);
}
}
global_repair(from, dag, dio);
}
return;
}
if(lollipop_greater_than(dag->version, dio->version)) {
/* The DIO sender is on an older version of the DAG. */
// PRINTF("RPL: old version received => inconsistency detected\n");
if(dag->joined) {
rpl_reset_dio_timer(instance);
return;
}
}
}
if(instance == NULL) {
// PRINTF("RPL: New instance detected: Joining...\n");
rpl_join_instance(from, dio);
return;
}
if(dag == NULL) {
// PRINTF("RPL: Adding new DAG to known instance.\n");
rpl_add_dag(from, dio);
return;
}
if(dio->rank < ROOT_RANK(instance)) {
// PRINTF("RPL: Ignoring DIO with too low rank: %u\n", (unsigned)dio->rank);
return;
} else if(dio->rank == INFINITE_RANK && dag->joined) {
rpl_reset_dio_timer(instance);
}
/* Prefix Information Option treated to add new prefix */
if(dio->prefix_info.length != 0) {
if(dio->prefix_info.flags & UIP_ND6_RA_FLAG_AUTONOMOUS) {
// PRINTF("RPL : Prefix announced in DIO\n");
rpl_set_prefix(dag, &dio->prefix_info.prefix, dio->prefix_info.length);
}
}
if(dag->rank == ROOT_RANK(instance)) {
if(dio->rank != INFINITE_RANK) {
instance->dio_counter++;
}
return;
}
/*
* At this point, we know that this DIO pertains to a DAG that
* we are already part of. We consider the sender of the DIO to be
* a candidate parent, and let rpl_process_parent_event decide
* whether to keep it in the set.
*/
p = rpl_find_parent(dag, from);
if (p!=NULL)
{
p->rssi= moving_average(p->rssi, cc2420_last_rssi-45);
p->update_time = clock_seconds();
if (p->rank < dag->rank && p->flag==NBR)
p->flag=PRNT;
if (p->rank >= dag->rank && p->flag==PRNT)
p->flag=NBR;
//PRINTF("process_dio-update prnt: p->update_time=%lu,p->rssi=%d \n",p->update_time, p->rssi);
//PRINTF("ID=%02x%02x \n",((uint8_t *)from)[14], ((uint8_t *)from)[15]);
}
if(p == NULL) {
previous_dag = find_parent_dag(instance, from);
if(previous_dag == NULL) {
/* Add the DIO sender as a candidate parent. */
p = rpl_add_parent(dag, dio, from);
if(p == NULL) {
// PRINTF("RPL: Failed to add a new parent (");
// PRINT6ADDR(from);
// PRINTF(")\n");
return;
}
// PRINTF("RPL: New candidate parent with rank %u: ", (unsigned)p->rank);
// PRINT6ADDR(from);
// PRINTF("\n");
} else {
p = rpl_find_parent(previous_dag, from);
if(p != NULL) {
rpl_move_parent(previous_dag, dag, p);
}
}
} else {
if(p->rank == dio->rank) {
// PRINTF("RPL: Received consistent DIO\n");
if(dag->joined) {
instance->dio_counter++;
}
} else {
p->rank=dio->rank;
}
}
// PRINTF("RPL: preferred DAG ");
// PRINT6ADDR(&instance->current_dag->dag_id);
// PRINTF(", rank %u, min_rank %u, ",instance->current_dag->rank, instance->current_dag->min_rank);
// PRINTF("parent rank %u, parent etx %u, link metric %u, instance etx %u\n",p->rank, -1/*p->mc.obj.etx*/, p->link_metric, instance->mc.obj.etx);
/* We have allocated a candidate parent; process the DIO further. */
#if RPL_DAG_MC != RPL_DAG_MC_NONE
memcpy(&p->mc, &dio->mc, sizeof(p->mc));
#endif /* RPL_DAG_MC != RPL_DAG_MC_NONE */
if(rpl_process_parent_event(instance, p) == 0) {
// PRINTF("RPL: The candidate parent is rejected\n");
return;
}
/* We don't use route control, so we can have only one official parent. */
if(dag->joined && p == dag->preferred_parent) {
if(should_send_dao(instance, dio, p)) {
RPL_LOLLIPOP_INCREMENT(instance->dtsn_out);
rpl_schedule_dao(instance);
}
/* We received a new DIO from our preferred parent.
* Call uip_ds6_defrt_add to set a fresh value for the lifetime counter */
uip_ds6_defrt_add(from, RPL_LIFETIME(instance, instance->default_lifetime));
}
p->dtsn = dio->dtsn;
}
