bool currentRadarFaultStatus::setFaulty(int rdr,
int faultno,
char* faultstr,
time_t fault_time)
{
lock->get_lock();
bool changed = false;
map<int, radarFaultStatus>::iterator iter = faultStatus.find(rdr);
if (iter == faultStatus.end())
{
faultStatus[rdr].setRadar(rdr);
iter = faultStatus.find(rdr);
changed = true;
}
if (iter != faultStatus.end()) // an entry exists for this stn
{
changed |= iter->second.setFaulty(faultno, faultstr, fault_time);
faultySet.set(rdr, faultno != 0);
}
else // an entry for this doesn't exist for some reason, should never happen
{
cout << "currentRadarFaultStatus::setFaulty - ERROR - FAILED TO CREATE ENTRY FOR RADAR=" << rdr << " *****\n";
}
lock->rel_lock();
if (changed)
{
dumpStatus();
}
return changed;
}
inline
void dumpSimpleNode(std::ostream &file, const SimpleNode &node,
std::string title = "", int indent = 0)
{
std::ostringstream ss{title};
ss << "{" << node.moveDescriptor.p1 << ", " << node.moveDescriptor.p2 << "}";
dumpStatus(file, node.status, ss.str(), indent);
}
std::deque<std::shared_ptr<Node>> Preprocessor::calculateBlockList(
const Status& status)
{
std::deque<std::shared_ptr<Node>> result = solver_->solve(status);
if (result.empty()) {
std::size_t threadId = *util::ThreadPool::getCurrentThreadId();
calculationInfos_[threadId]->blockList_.push_back(status);
dumpStatus(status, nullptr, "Blocked");
}
return result;
}
void runRmtTest() {
ESP_LOGD(tag, ">> runRmtTest");
rmt_config_t config;
config.rmt_mode = RMT_MODE_TX;
config.channel = RMT_CHANNEL_0;
config.gpio_num = 21;
config.mem_block_num = 1;
config.tx_config.loop_en = 0;
config.tx_config.carrier_en = 0;
config.tx_config.idle_output_en = 1;
config.tx_config.idle_level = 0;
config.tx_config.carrier_duty_percent = 50;
config.tx_config.carrier_freq_hz = 10000;
config.tx_config.carrier_level = 1;
config.clk_div = 80;
ESP_ERROR_CHECK(rmt_config(&config));
ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, 0));
dumpStatus(config.channel);
rmt_item32_t items[3];
items[0].duration0 = 10000;
items[0].level0 = 1;
items[0].duration1 = 10000;
items[0].level1 = 0;
items[1].duration0 = 10000;
items[1].level0 = 1;
items[1].duration1 = 5000;
items[1].level1 = 0;
items[2].duration0 = 0;
items[2].level0 = 1;
items[2].duration1 = 0;
items[2].level1 = 0;
while(1) {
ESP_ERROR_CHECK(rmt_write_items(config.channel, items,
3, /* Number of items */
1 /* wait till done */));
vTaskDelay(1000/portTICK_PERIOD_MS);
}
ESP_LOGD(tag, "<< runRmtTest");
}
void Preprocessor::calculateHeurList(const Status& status, std::size_t index)
{
std::size_t threadId = *util::ThreadPool::getCurrentThreadId();
auto& calculationInfo = calculationInfos_[threadId];
++calculationInfo->callNum_;
std::deque<std::shared_ptr<Node>> result = calculateBlockList(status);
if (!result.empty()) {
float heur = incrementalCalculator_->calculateStatus(status);
float cost = result.back()->cost();
float difference = cost - heur;
if (difference > 0) {
calculationInfo->dump_ <<
heur << " --> " << cost << "(" << difference << ")\n";
dumpStatus(status, nullptr, "Added heur");
HeurInfo heurInfo{status, cost};
calculationInfo->heurList_.push_back(
IncrementInfo{std::move(heurInfo), difference});
}
}
calculationInfo->maxIndex_ = index;
}
