//! Stop current plan being executed
//! @param[in] plan_startup true if a plan will start right after this stop
//! @return false if a plan is still running after this
bool
stopPlan(bool plan_startup = false)
{
if (initMode() || execMode())
{
if (!plan_startup)
{
// stop maneuver only if we are not executing a plan afterwards
vehicleRequest(IMC::VehicleCommand::VC_STOP_MANEUVER);
m_reply.plan_id = m_spec.plan_id;
m_pcs.last_outcome = IMC::PlanControlState::LPO_FAILURE;
changeMode(IMC::PlanControlState::PCS_READY, DTR("plan stopped"));
}
else
{
m_pcs.last_outcome = IMC::PlanControlState::LPO_FAILURE;
debug("switching to new plan");
return false;
}
}
else
{
if (!plan_startup)
{
onFailure(DTR("no plan is running, request ignored"));
m_reply.plan_id = "";
}
}
return true;
}
void
consume(const IMC::VehicleCommand* vc)
{
if (vc->type == IMC::VehicleCommand::VC_REQUEST)
return;
if ((vc->getDestination() != getSystemId()) ||
(vc->getDestinationEntity() != getEntityId()) ||
(m_vreq_ctr != vc->request_id))
return;
if (!pendingReply())
return;
m_vc_reply_deadline = -1;
bool error = vc->type == IMC::VehicleCommand::VC_FAILURE;
// Ignore failure if it failed to stop calibration
if (error && (vc->command == IMC::VehicleCommand::VC_STOP_CALIBRATION))
{
debug("%s", vc->info.c_str());
error = false;
}
if (initMode() || execMode())
{
if (error)
changeMode(IMC::PlanControlState::PCS_READY, vc->info, false);
return;
}
}
WedgePlatform::WedgePlatform()
: productInfo_(FLAGS_fruid_filepath) {
productInfo_.initialize();
initMode();
auto config = loadConfig();
BcmAPI::init(config);
initLocalMac();
hw_.reset(new BcmSwitch(this, mode_ == LC ?
BcmSwitch::HALF_HASH : BcmSwitch::FULL_HASH));
}
//! Report progress
void
reportProgress(void)
{
// Must be executing or calibrating to be able to compute progress
if (m_plan == NULL || (!execMode() && !initMode()))
return;
m_pcs.plan_progress = m_plan->updateProgress(&m_mcs);
m_pcs.plan_eta = (int32_t)m_plan->getETA();
}
//! Change the current plan control state mode
//! @param[in] s plan control state to switch to
//! @param[in] event_desc description of the event that motivated the change
//! @param[in] nid id of the maneuver if any
//! @param[in] maneuver pointer to maneuver message
//! @param[in] print true if the messages should be printed to output
void
changeMode(IMC::PlanControlState::StateEnum s, const std::string& event_desc,
const std::string& nid, const IMC::Message* maneuver, bool print = true)
{
double now = Clock::getSinceEpoch();
if (print)
war("%s", event_desc.c_str());
m_last_event = event_desc;
if (s != m_pcs.state)
{
debug(DTR("now in %s state"), DTR(c_state_desc[s]));
bool was_in_plan = initMode() || execMode();
m_pcs.state = s;
bool is_in_plan = initMode() || execMode();
if (was_in_plan && !is_in_plan)
{
m_plan->planStopped();
changeLog("");
}
}
if (maneuver)
{
m_pcs.man_id = nid;
m_pcs.man_type = maneuver->getId();
}
else
{
m_pcs.man_id.clear();
m_pcs.man_type = 0xFFFF;
}
m_pcs.setTimeStamp(now);
dispatch(m_pcs, DF_KEEP_TIME);
}
//! Get current plan
void
getPlan(void)
{
if (!initMode() && !execMode())
{
onFailure(DTR("no plan is running"));
return;
}
m_reply.arg.set(m_spec);
m_reply.plan_id = m_spec.plan_id;
onSuccess();
}
void
onVehicleCalibration(const IMC::VehicleState* vs)
{
(void)vs;
if (initMode())
return;
if (!blockedMode())
{
changeMode(IMC::PlanControlState::PCS_BLOCKED,
DTR("vehicle in CALIBRATION mode"), false);
}
}
void
consume(const IMC::VehicleState* vs)
{
if (getEntityState() == IMC::EntityState::ESTA_BOOT)
return;
m_last_vstate = Clock::get();
switch (vs->op_mode)
{
case IMC::VehicleState::VS_SERVICE:
onVehicleService(vs);
break;
case IMC::VehicleState::VS_CALIBRATION:
onVehicleCalibration(vs);
break;
case IMC::VehicleState::VS_ERROR:
case IMC::VehicleState::VS_BOOT:
onVehicleError(vs);
break;
case IMC::VehicleState::VS_MANEUVER:
onVehicleManeuver(vs);
break;
case IMC::VehicleState::VS_EXTERNAL:
onVehicleExternalControl(vs);
break;
}
// update calibration status
if (m_plan != NULL && initMode())
{
m_plan->updateCalibration(vs);
if (m_plan->isCalibrationDone())
{
if ((vs->op_mode == IMC::VehicleState::VS_CALIBRATION) &&
!pendingReply())
{
IMC::PlanManeuver* pman = m_plan->loadStartManeuver();
startManeuver(pman);
}
}
else if (m_plan->hasCalibrationFailed())
{
onFailure(m_plan->getCalibrationInfo());
m_reply.plan_id = m_spec.plan_id;
changeMode(IMC::PlanControlState::PCS_READY, m_plan->getCalibrationInfo());
}
}
}
//! Start a given plan
//! @param[in] plan_id name of the plan to execute
//! @param[in] spec plan specification message if any
//! @param[in] flags plan control flags
//! @return false if previously executing maneuver was not stopped
bool
startPlan(const std::string& plan_id, const IMC::Message* spec, uint16_t flags)
{
bool stopped = stopPlan(true);
changeMode(IMC::PlanControlState::PCS_INITIALIZING,
DTR("plan initializing: ") + plan_id);
if (!loadPlan(plan_id, spec, true))
return stopped;
changeLog(plan_id);
// Flag the plan as starting
if (initMode() || execMode())
{
if (!stopped)
m_plan->planStopped();
m_plan->planStarted();
}
dispatch(m_spec);
if ((flags & IMC::PlanControl::FLG_CALIBRATE) &&
m_args.do_calib)
{
if (!startCalibration())
return stopped;
}
else
{
IMC::PlanManeuver* pman = m_plan->loadStartManeuver();
startManeuver(pman);
if (execMode())
{
onSuccess(m_last_event);
}
else
{
onFailure(m_last_event);
return stopped;
}
}
return true;
}
void GxsGroupDialog::init()
{
// connect up the buttons.
connect(ui.buttonBox, SIGNAL(accepted()), this, SLOT(submitGroup()));
connect(ui.buttonBox, SIGNAL(rejected()), this, SLOT(cancelDialog()));
connect(ui.pubKeyShare_cb, SIGNAL(clicked()), this, SLOT(setShareList()));
connect(ui.groupLogo, SIGNAL(clicked() ), this , SLOT(addGroupLogo()));
connect(ui.addLogoButton, SIGNAL(clicked() ), this , SLOT(addGroupLogo()));
ui.typePublic->setChecked(true);
ui.distributionValueLabel->setText(tr("Public"));
updateCircleOptions();
connect(ui.typePublic, SIGNAL(clicked()), this , SLOT(updateCircleOptions()));
connect(ui.typeGroup, SIGNAL(clicked()), this , SLOT(updateCircleOptions()));
connect(ui.typeLocal, SIGNAL(clicked()), this , SLOT(updateCircleOptions()));
if (!ui.pubKeyShare_cb->isChecked())
{
ui.contactsdockWidget->hide();
this->resize(this->size().width() - ui.contactsdockWidget->size().width(), this->size().height());
}
/* initialize key share list */
ui.keyShareList->setHeaderText(tr("Contacts:"));
ui.keyShareList->setModus(FriendSelectionWidget::MODUS_CHECK);
ui.keyShareList->start();
/* Setup Reasonable Defaults */
ui.idChooser->loadIds(0,RsGxsId());
ui.circleComboBox->loadCircles(GXS_CIRCLE_CHOOSER_EXTERNAL, RsGxsCircleId());
ui.localComboBox->loadCircles(GXS_CIRCLE_CHOOSER_PERSONAL, RsGxsCircleId());
ui.groupDesc->setPlaceholderText(tr("Set a descriptive description here"));
ui.personal_ifnopub->hide() ;
ui.personal_required->hide() ;
ui.personal_required->setChecked(true) ; // this is always true
initMode();
}
//! 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;
}
GridDisplay::GridDisplay(int winSize, Tracklist *tracklist, Grid* grid_, QWidget *parent)
: MyDisplay(tracklist, parent), _winSize(winSize)
{
this->grid_ = grid_;
_cellSize = grid_->getCellSize(_winSize);
setMinimumSize(winSize, winSize);
setMouseTracking(true);
setAcceptDrops(true);
squareHasInitialized.resize(grid_->getHeight() * grid_->getWidth());
for(int i = 0; i < grid_->getHeight() * grid_->getWidth(); i++)
squareHasInitialized[i] = false;
oldXPos = -1;
oldYPos = -1;
oldX1Pos = -1;
oldY1Pos = -1;
fullScreenMouseOn = false;
initDone = false;
fullScreenTimer = new QTimer(this);
fullScreenTimer->setInterval(150);
colourMapMode_ = false;
connect(this, SIGNAL(clearMode()), grid_, SLOT(clearMode()));
connect(this, SIGNAL(extractMode()), grid_, SLOT(setExtractMode()));
connect(this, SIGNAL(trainMode()), grid_, SLOT(setTrainMode()));
connect(this, SIGNAL(predictMode()), grid_, SLOT(setPredictMode()));
connect(this, SIGNAL(initMode()), grid_, SLOT(setInitMode()));
connect(this, SIGNAL(savePredictionGridSignal(QString)), grid_, SLOT(savePredictionGrid(QString)));
connect(this, SIGNAL(openPredictionGridSignal(QString)), grid_, SLOT(openPredictionGrid(QString)));
connect(grid_, SIGNAL(repaintSignal()), this, SLOT(repaintSlot()));
connect(this, SIGNAL(cancelButtonPressed()), grid_, SLOT(cancelPressed()));
connect(this, SIGNAL(hashLoadPressed()), grid_, SLOT(openHash()));
connect(fullScreenTimer, SIGNAL(timeout()), this, SLOT(fullScreenMouseMove()));
connect(grid_, SIGNAL(errorBox(QString)), this, SLOT(showErrorMessage(QString)));
connect(this, SIGNAL(resetGridAction()), grid_, SLOT(resetGridSlot()));
}
void
onVehicleError(const IMC::VehicleState* vs)
{
std::string err_ents = DTR("vehicle errors: ") + vs->error_ents;
std::string edesc = vs->last_error_time < 0 ? err_ents : vs->last_error;
if (execMode())
{
onFailure(edesc);
m_reply.plan_id = m_spec.plan_id;
}
// there are new error entities
if (edesc != m_last_event)
{
if (initMode())
{
onFailure(edesc);
m_reply.plan_id = m_spec.plan_id;
}
changeMode(IMC::PlanControlState::PCS_BLOCKED, edesc, false);
}
}
void GridDisplay::init()
{
emit initMode();
grid_->buttonPressed.wakeAll();
initDone = 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;
}