void eDVBServiceStream::serviceEvent(int event)
{
eDebug("[eDVBServiceStream] STREAM service event %d", event);
if(event == eDVBServicePMTHandler::eventTuneFailed || event == eDVBServicePMTHandler::eventMisconfiguration || event == eDVBServicePMTHandler::eventNoResources)
eventUpdate(event);
switch (event)
{
case eDVBServicePMTHandler::eventTuned:
{
eDebug("[eDVBServiceStream] tuned.. m_state %d m_want_record %d", m_state, m_want_record);
m_tuned = 1;
/* start feeding EIT updates */
ePtr<iDVBDemux> m_demux;
if (!m_service_handler.getDataDemux(m_demux))
{
eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_ref;
m_event_handler.start(m_demux, ref);
}
if (m_state > stateIdle && m_want_record)
doRecord();
break;
}
case eDVBServicePMTHandler::eventTuneFailed:
{
eDebug("stream failed to tune");
tuneFailed();
break;
}
case eDVBServicePMTHandler::eventNewProgramInfo:
{
if (m_state == stateIdle)
doPrepare();
else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
doRecord();
break;
}
case eDVBServicePMTHandler::eventMisconfiguration:
tuneFailed();
break;
case eDVBServicePMTHandler::eventNoResources:
tuneFailed();
break;
}
if(event != eDVBServicePMTHandler::eventTuneFailed && event != eDVBServicePMTHandler::eventMisconfiguration && event != eDVBServicePMTHandler::eventNoResources)
eventUpdate(event);
}
bool doCircle()
{
int curPRI,curINT;
if(!eventUpdate())
return false;
if(get_faultmask())
curPRI = -1;
else if(get_primask())
curPRI = 0;
else if(get_basepri())
curPRI = get_basepri();
else if(getMode()){
curINT = NVIC_ICSR_getINT();
curPRI = NVIC_getPriority(curINT);
}
else
curPRI = 500;
if(curPRI <= Pending->nextINT->priority)
return false;
if(curPRI != 500){
addPending(curINT,1);
NVIC_setPend(curINT);
NVIC_clrActive(curINT);
}
curINT = Pending->nextINT->INT_ID;
delPending(curINT);
NVIC_clrPend(curINT);
NVIC_setActive(curINT);
NVIC_ICSR_setINT(curINT);
return true;
}
void
OPMisc::eventUpdate(const IntEvent& eevent, const PairEventData& PDat)
{
stream(eevent.getdt());
eventUpdate(PDat);
newEvent(eevent.getParticle1ID(), eevent.getType(), getClassKey(eevent));
newEvent(eevent.getParticle2ID(), eevent.getType(), getClassKey(eevent));
}
void
OPMisc::eventUpdate(const System& eevent, const NEventData& NDat, const double& dt)
{
stream(dt);
eventUpdate(NDat);
BOOST_FOREACH(const ParticleEventData& pData, NDat.L1partChanges)
newEvent(pData.getParticleID(), pData.getType(), getClassKey(eevent));
BOOST_FOREACH(const PairEventData& pData, NDat.L2partChanges)
{
newEvent(pData.particle1_.getParticleID(), pData.getType(), getClassKey(eevent));
newEvent(pData.particle2_.getParticleID(), pData.getType(), getClassKey(eevent));
}
}
fmiStatus fmiEventUpdate(fmiComponent c, fmiBoolean intermediateResults, fmiEventInfo* eventInfo) {
ModelInstance* comp = (ModelInstance *)c;
if (invalidState(comp, "fmiEventUpdate", modelInitialized))
return fmiError;
if (nullPointer(comp, "fmiEventUpdate", "eventInfo", eventInfo))
return fmiError;
if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
"fmiEventUpdate: intermediateResults = %d", intermediateResults);
eventInfo->iterationConverged = fmiTrue;
eventInfo->stateValueReferencesChanged = fmiFalse;
eventInfo->stateValuesChanged = fmiFalse;
eventInfo->terminateSimulation = fmiFalse;
eventInfo->upcomingTimeEvent = fmiFalse;
eventUpdate(comp, eventInfo); // to be implemented by the includer of this file
return fmiOK;
}
bool ProjectManager::PushModificationToHistory(bool force)
{
wxDateTime maintenant=wxDateTime::UNow();
if(force || (maintenant-lastHistoryUpdate).GetMilliseconds()>UNDO_HISTORY_TIMESTEP)
{
lastHistoryUpdate=maintenant;
if(this->rootUserConfig->GetElementByLibelle("mainpref")->GetElementByLibelle("history")->GetBoolConfig("keep_modification_history"))
{
if(!force)
wxLogDebug(_("Add modifications in the change log"));
else
wxLogDebug(_("Forced adding changes in the change log."));
this->UpdateXmlFile("",false);
configHistory.Add(new wxXmlDocument(projetConfig));
//Dû à la modification on perd soit la plus vieille modification soit tout les dernieres modifications ( en fonction de l'etat de navigation dans l'historique)
if(currentHistoryNavigation==0)
{
if(configHistory.size()>UNDO_HISTORY_SIZE)
configHistory.RemoveAt(0);
}else{
//L'utilisateur a fait annuler et il a ensuite modifié le projet, l'utilisateur ne peut donc plus utiliser refaire
//Supprime de la version courante jusqu'à la dernière version
configHistory.RemoveAt(configHistory.size()-currentHistoryNavigation,currentHistoryNavigation-1);
currentHistoryNavigation=0;
}
wxCommandEvent eventUpdate( wxEVT_PSPS_MAIN_EVENT, mainFrame->GetId() );
eventUpdate.SetInt(ApplicationConfiguration::MAIN_EVENT_UNDO_REDO_UPDATE);
wxPostEvent(mainFrame,eventUpdate);
return true;
}else{
return false;
}
}else{
return false;
}
}
fmiStatus fmiDoStep(fmiComponent c, fmiReal currentCommunicationPoint,
fmiReal communicationStepSize, fmiBoolean newStep) {
ModelInstance* comp = (ModelInstance *)c;
fmiCallbackLogger log = comp->functions.logger;
double h = communicationStepSize / 10;
int k;
#if NUMBER_OF_EVENT_INDICATORS>0 || NUMBER_OF_REALS>0
int i;
#endif
const int n = 10; // how many Euler steps to perform for one do step
#if NUMBER_OF_REALS>0
double prevState[max(NUMBER_OF_STATES, 1)];
#endif
#if NUMBER_OF_EVENT_INDICATORS>0
double prevEventIndicators[max(NUMBER_OF_EVENT_INDICATORS, 1)];
int stateEvent = 0;
#endif
if (invalidState(comp, "fmiDoStep", modelInitialized))
return fmiError;
if (comp->loggingOn) log(c, comp->instanceName, fmiOK, "log", "fmiDoStep: "
"currentCommunicationPoint = %g, "
"communicationStepSize = %g, "
"newStep = fmi%s",
currentCommunicationPoint, communicationStepSize, newStep ? "True" : "False");
// Treat also case of zero step, i.e. during an event iteration
if (communicationStepSize == 0) {
return fmiOK;
}
#if NUMBER_OF_EVENT_INDICATORS>0
// initialize previous event indicators with current values
for (i=0; i<NUMBER_OF_EVENT_INDICATORS; i++) {
prevEventIndicators[i] = getEventIndicator(comp, i);
}
#endif
// break the step into n steps and do forward Euler.
comp->time = currentCommunicationPoint;
for (k=0; k<n; k++) {
comp->time += h;
#if NUMBER_OF_REALS>0
for (i=0; i<NUMBER_OF_STATES; i++) {
prevState[i] = r(vrStates[i]);
}
for (i=0; i<NUMBER_OF_STATES; i++) {
fmiValueReference vr = vrStates[i];
r(vr) += h * getReal(comp, vr+1); // forward Euler step
}
#endif
#if NUMBER_OF_EVENT_INDICATORS>0
// check for state event
for (i=0; i<NUMBER_OF_EVENT_INDICATORS; i++) {
double ei = getEventIndicator(comp, i);
if (ei * prevEventIndicators[i] < 0) {
if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
"fmiDoStep: state event at %g, z%d crosses zero -%c-", comp->time, i, ei<0 ? '\\' : '/');
stateEvent++;
}
prevEventIndicators[i] = ei;
}
if (stateEvent) {
eventUpdate(comp, &comp->eventInfo);
stateEvent = 0;
}
#endif
// check for time event
if (comp->eventInfo.upcomingTimeEvent && ((comp->time - comp->eventInfo.nextEventTime) > -0.0000000001)) {
if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
"fmiDoStep: time event detected at %g", comp->time);
eventUpdate(comp, &comp->eventInfo);
}
// terminate simulation, if requested by the model
if (comp->eventInfo.terminateSimulation) {
comp->functions.logger(c, comp->instanceName, fmiOK, "log",
"fmiDoStep: model requested termination at t=%g", comp->time);
return fmiError; // enforce termination of the simulation loop
}
}
return fmiOK;
}
