void CheckStatPlan::openPlan ()
{
DEFINE_QUERY (qry);
qry.setSQL (" SELECT "
" Plan_id,"
" app_type,"
" stat_name,"
" interval_type,"
" time_interval,"
" nvl(next_run_time, sysdate) next_run_time,"
" nvl(run_parameter,'') run_parameter, "
" nvl(state,'END') state,"
" nvl(debug_flag,0) debug_flag, "
" nvl(data_time_offset, 0) offset, "
" file_directory "
" From B_Check_Stat_Plan"
" where open_state=1 and nvl(state,'END')<>'NUL' and Plan_id>0 "
" order by plan_id desc"
);
qry.open();
if (m_pPlan)
delete m_pPlan;
while (qry.next ())
{
PlanItem *p = new PlanItem ();
p->m_iPlanID = qry.field("Plan_id").asInteger();
p->m_iAppType = qry.field("app_type").asInteger();
strcpy (p->m_sStatName, qry.field("stat_name").asString());
p->m_iIntervalType = qry.field("interval_type").asInteger();
strcpy (p->m_sTimeInterval, qry.field("time_interval").asString());
strcpy (p->m_sNextRunTime, qry.field("next_run_time").asString());
strcpy (p->m_sParameter, qry.field("run_parameter").asString());
strcpy (p->m_sState, qry.field("state").asString());
p->m_iDebugFlag = qry.field("debug_flag").asInteger();
p->m_iDataTimeOffset = qry.field("offset").asInteger();
if (p->m_iDataTimeOffset < 0)
p->m_iDataTimeOffset = 0;
strncpy(p->m_sDirectory, qry.field("file_directory").asString(), 1000);
parsePlan (p);
p->m_pNext = m_pPlan;
m_pPlan = p;
}
qry.close ();
}
/**
* Constructor takes a string where a plan is contained and a pointer to a domain object, parses the plan and sets up unrolled arrays for streaming to DFE
*/
AirfoilDFEInterface::AirfoilDFEInterface(std::string planfile, AirfoilDFEDomain * domain_) {
domain = domain_;
nEdgeComputeDFE = (*domain).nedgecomputedfe;
nCellComputeDFE = (*domain).ncellcomputedfe;
maxfile = airfoildfe_init();
engine = max_load(maxfile,"*");
memAddresses = (int * ) malloc(sizeof(int)*(MEM_ADDRESS_ITEMS+1));
parsePlan(planfile);
int cumulativeAddress = 0;
memAddresses[adtDx] = cumulativeAddress*burstSize;
int floatBits = max_get_constant_uint64t(maxfile,"floatBits");
int adtDxBursts = getNBursts(floatBits, nCellComputeDFE*12);
cumulativeAddress += adtDxBursts;
memAddresses[resReadOnly] = cumulativeAddress*burstSize;
int resReadOnlyBursts = getNBursts(resReadOnlyBits, nEdgeComputeDFE);
cumulativeAddress += resReadOnlyBursts;
memAddresses[q] = cumulativeAddress*burstSize;
int qBursts = getNBursts(floatBits, nCellComputeDFE*4);
cumulativeAddress += qBursts;
memAddresses[qold] = cumulativeAddress*burstSize;
cumulativeAddress += qBursts;
memAddresses[MEM_ADDRESS_ITEMS] = cumulativeAddress*burstSize;
qpadtPortWidth = max_get_constant_uint64t(maxfile, "qpadtPortPCIeWidthInBytes");
;
printf("Generated lmem addresses, sizes:\n");
for (int i = 0; i < MEM_ADDRESS_ITEMS; i++) printf("%d,%d\n",memAddresses[i], memAddresses[i+1]- memAddresses[i]);
printf("\n");
}
//! Load a plan into the vehicle
//! @param[in] plan_id name of the plan
//! @param[in] arg argument which may either be a maneuver or a plan specification
//! @param[in] plan_startup true if a plan will start right after
//! @return true if plan is successfully loaded
bool
loadPlan(const std::string& plan_id, const IMC::Message* arg,
bool plan_startup = false)
{
if ((initMode() && !plan_startup) || execMode())
{
onFailure(DTR("cannot load plan now"));
return false;
}
std::string info;
if (!parseArg(plan_id, arg, info))
{
changeMode(IMC::PlanControlState::PCS_READY,
DTR("plan load failed: ") + info);
return false;
}
IMC::PlanStatistics ps;
if (!parsePlan(plan_startup, ps))
{
changeMode(IMC::PlanControlState::PCS_READY,
DTR("plan parse failed: ") + m_reply.info);
return false;
}
// reply with statistics
m_reply.arg.set(ps);
m_reply.plan_id = m_spec.plan_id;
m_pcs.plan_id = m_spec.plan_id;
onSuccess(DTR("plan loaded"), false);
return true;
}
//! Load a plan into the vehicle
//! @param[in] plan_id name of the plan
//! @param[in] arg argument which may either be a maneuver or a plan specification
//! @param[in] plan_startup true if a plan will start right after
//! @return true if plan is successfully loaded
bool
loadPlan(const std::string& plan_id, const IMC::Message* arg,
bool plan_startup = false)
{
if ((initMode() && !plan_startup) || execMode())
{
onFailure(DTR("cannot load plan now"));
return false;
}
if (arg)
{
if (arg->getId() == DUNE_IMC_PLANSPECIFICATION)
{
const IMC::PlanSpecification* given_plan = static_cast<const IMC::PlanSpecification*>(arg);
m_spec = *given_plan;
m_spec.setSourceEntity(getEntityId());
}
else
{
// Quick plan
IMC::PlanManeuver spec_man;
const IMC::Maneuver* man = static_cast<const IMC::Maneuver*>(arg);
if (man)
{
spec_man.maneuver_id = arg->getName();
spec_man.data.set(*man);
m_spec.clear();
m_spec.maneuvers.setParent(&m_spec);
m_spec.plan_id = plan_id;
m_spec.start_man_id = arg->getName();
m_spec.maneuvers.push_back(spec_man);
}
else
{
changeMode(IMC::PlanControlState::PCS_READY,
DTR("plan load failed: undefined maneuver or plan"));
return false;
}
}
}
else
{
// Search DB
m_spec.clear();
if (!lookForPlan(plan_id, m_spec))
{
changeMode(IMC::PlanControlState::PCS_READY,
DTR("plan load failed: ") + m_reply.info);
return false;
}
}
if (!parsePlan(plan_startup))
{
changeMode(IMC::PlanControlState::PCS_READY,
DTR("plan validation failed: ") + m_reply.info);
return false;
}
m_pcs.plan_id = m_spec.plan_id;
if (plan_startup)
onSuccess(DTR("plan loaded"), false);
else
changeMode(IMC::PlanControlState::PCS_READY, DTR("plan loaded"));
return true;
}
