/******************************************************************************* * * * Société de Transports de Montréal. * * 2012 * * * * Projet Zones Tests * * * * * * * *******************************************************************************/ /* Description: Cette classe est considérée comme l'instance du programme qui initialise et démarre tous les objets nécessaires. Elle assure aussi la synchronisation de ces derniers à l'aide de sa machine à états. */ /* ************************************************************************** */ /* Revision: ### 20121214 JFM Verision d'origine. ### YYYYMMDD Description du besoin ou du bug Description du changement. */ /* ************************************************************************** */ #include "Zonetest.h" //#include "MainPanel.h" #include "ZTconfigmgr.h" #include #include "EngLog.h" #include #include "Angrignon.h" #include "BerriUQAM.h" #include "CoteVertu.h" #include "HenriBourassa.h" #include "HonoreBeaugrand.h" #include "Longueuil.h" #include "Montmorency.h" #include "Montmorency1012.h" #include "Montmorency1022.h" #include "SaintMichel.h" #include "Snowdon.h" #include "DuCollege.h" #include "SimulatorIOManager.h" #include "SimulatorLazerProbesMgr.h" #include "SimulatorPCIIO.h" #include #include "ZTLog.h" #include "RamMonitor.h" #include "PCI1756Interface.h" #include "USB4704Interface.h" #include "ZTVersion.h" #include "ModbusCCDefs.h" #include "ModbusTKTransport.h" #include "ModbusSEIDefs.h" #include #include "PIHistorianDefs.h" #ifdef USE_NETWORKING #include "NetworkManager.h" #endif #include "qextserialport.h" CZoneTest::CZoneTest(): mZTStation(0), mZtState(ZT_INIT_STATE) { mZTStartDateTime = QDateTime::currentDateTime(); mZTStateMachineTimer = new QTimer(); connect(mZTStateMachineTimer, SIGNAL(timeout()), this, SLOT(SMTimerExpired())); panel.installEventFilter(this); //Install an event filter for CZoneTest to manage some events from GUI mZTStateMachine = new CZTStateMachine(this); mZTSimulator = 0; mIOManager = 0; mLazerProbesManager = 0; mAnalogModule = 0; mTKTransportInterface = 0; mCCModbusRepository = 0; mModbusCCMgr = 0; mModbusSEIMgr = 0; mSimulationON = false; mWatchdogEnabled = true; mZTSettings = new CZTSettingsData(); mEventMgr = new CEventMgr(); mLogMgr = new CLogMgr(); mUSBDriveInterface = new CUSBDriveInterface(); mExtIOWorkerThread = new CExtIOThread; mExtIOThread = new QThread; mExtIOWorkerThread->moveToThread(mExtIOThread); connect(mExtIOThread,SIGNAL(started()),mExtIOWorkerThread,SLOT(DoAcquisition())); mPIHistorianManager = 0; } CZoneTest::~CZoneTest() { delete mLogMgr; delete mEventMgr; delete mUSBDriveInterface; delete mLazerProbesManager; delete mZTStateMachine; delete mIOManager; delete mPCIIO; delete mZTStation; delete mZTSettings; delete mExtIOThread; delete mExtIOWorkerThread; delete mInternalWatchdog; if(mTKTransportInterface != 0) delete mTKTransportInterface; if(mCCModbusRepository != 0) delete mCCModbusRepository; if(mModbusCCMgr != 0) { delete mModbusCCMgr; } if(mModbusSEIMgr != 0) { delete mModbusSEIMgr; } if(mAnalogModule != 0) delete mAnalogModule; if(mPIHistorianManager != 0) delete mPIHistorianManager; } unsigned int CZoneTest::ExecStateMachine(eZTSMEvents_t) { switch(mZtState) { case ZT_INIT_STATE: { mZTStateMachineTimer->stop(); mZtState = ZT_RUN_STATE; mWatchdogTimer.start(); mZTStateMachineTimer->setSingleShot(false); int ret = InitZT(); mInternalWatchdog->StartWatchdog(); if(ret == RET_OK) { mZTStateMachineTimer->start(0); mExtIOWorkerThread->SetOutputFlags(mZTStation->GetOutputMasks()->OutputWatchdogMask); mWatchdogTimer.start(); } break; } case ZT_RUN_STATE: { static bool sExtWatchdogFlag = true; mZTStateMachine->ZTStateMachine(ZT_TICK_EVENT); mInternalWatchdog->KickWatchdog(); if(mWatchdogEnabled) { if(sExtWatchdogFlag == true) { if(mWatchdogTimer.elapsed() >= ZT_EXTERNAL_WATCHDOG_PULSE_TIME) { mExtIOWorkerThread->ClearOutputFlags(mZTStation->GetOutputMasks()->OutputWatchdogMask); mWatchdogTimer.start(); sExtWatchdogFlag = false; } } else { if(mWatchdogTimer.elapsed() >= ZT_EXTERNAL_WATCHDOG_TIMEOUT) { mExtIOWorkerThread->SetOutputFlags(mZTStation->GetOutputMasks()->OutputWatchdogMask); mWatchdogTimer.start(); sExtWatchdogFlag = true; } } } break; } case ZT_DEADLOCK_STATE: { //Stay in this state after a fatal error happened. mInternalWatchdog->KickWatchdog(); if(mWatchdogEnabled) { if(mWatchdogTimer.elapsed() >= ZT_EXTERNAL_WATCHDOG_TIMEOUT) { mExtIOWorkerThread->ToggleOutputFlags(mZTStation->GetOutputMasks()->OutputWatchdogMask); mWatchdogTimer.start(); } } break; } case ZT_EXIT_APPLICATION_STATE: { mZTStateMachineTimer->stop(); mInternalWatchdog->StopWatchdog(); QApplication::exit(78); //Quit the application break; } case ZT_POWER_BUTTON_EXIT_STATE: { mZTStateMachineTimer->stop(); mInternalWatchdog->StopWatchdog(); //Initiate a system shutdown system("shutdown -h -P now"); QApplication::exit(79); //Quit the application break; } case ZT_SYSTEM_REBOOT_EXIT_STATE: { //Initiate a system reboot mZTStateMachineTimer->stop(); mInternalWatchdog->StopWatchdog(); //Initiate a system reboot system("shutdown -r now"); //system("reboot"); //Not working well all the times QApplication::exit(80); //Quit the application break; } default: { } } return RET_OK; } void CZoneTest::SMTimerExpired() { ExecStateMachine(ZT_SM_TICK_EVENT); } unsigned int CZoneTest::Start() { //init some pointers... mWelcomePagePtr = panel.mWelcomePage; panel.mProgramHandle = this; panel.mZTMainPage->mProgramHandle = this; panel.mOptionsPage->mProgramHandle = this; panel.mFunctionSelectPage->mProgramHandle = this; // panel.mFunctionSelectPage->SetConfig(mZTSettings->mDetectionFunctionSettings); panel.mZTMainPage->SetEventListPtr(&mEventMgr->mEventsList); panel.mLogsListPage->mProgramHandle = this; panel.mLogsListPage->mLogMgrHandle = mLogMgr; panel.mLogViewPage->mProgramHandle = this; panel.mMaintenancePage->mProgramHandle = this; panel.mGeneralSettingsPage->mProgramHandle = this; panel.mModbusSettingsPage->mProgramHandle = this; panel.mSEISettingsPage->mProgramHandle = this; panel.mZTLogViewerPage->mProgramHandle = this; panel.mModbusDisplayPage->mProgramHandle = this; panel.mHistorienDisplayPage->mProgramHandle = this; panel.mEngineeringPage->mDisablePassword = mDisablePassword; mInternalWatchdog = new CWatchdogCtrl(mUseWatchdog); #ifdef USE_NETWORKING CNetworkManager::instance()->BindPointers(this); #endif mEventMgr->mProgramPTr = this; mEventMgr->mMainPagePtr = panel.mZTMainPage; // mEventMgr->UpdateEvents(mZTSettings->mDetectionFunctionSettings); mZTStateMachine->mZTDetectionConfig = mZTSettings->mDetectionFunctionSettings; connect(mZTStateMachine,SIGNAL(NewTrainLogSaved(QString,bool)),panel.mLogsListPage,SLOT(NewTrainLogFileSaved(QString,bool))); // connect(mZTStateMachine,SIGNAL(NewTrainLogSaved(QString,bool)),&mNetworkDriveMgr,SLOT(NewTrainFileSaved(QString,bool))); //JFM déplacé plus bas, connect seulement si NetworkDrive est activé CZTLog::instance()->mProgramHandle = this; //Show Graphic User Interface. panel.setWindowTitle("ZoneTest"); if(mFullScreen) { panel.showFullScreen(); } else { panel.show(); } mWelcomePagePtr->ClearTextBoxWidget(); mWelcomePagePtr->InsertTextBoxString("Application Zone Tests"); mWelcomePagePtr->InsertTextBoxString(QString().sprintf("Version: %s",ZT_SOFT_VERSION)); mWelcomePagePtr->ShowTextboxWidget(); mZTStateMachineTimer->setSingleShot(false); mZTStateMachineTimer->start(1000); return RET_OK; } unsigned int CZoneTest::InitZT() { //mWelcomePagePtr->ClearTextBoxWidget(); CheckAndCreateDirectories(); CZTLog::instance()->Init(); //Load the config file if(CZTConfigMgr::instance()->LoadZTConfig() != ZT_CONFIG_OK) { mWelcomePagePtr->InsertTextBoxString("Erreur d'ouverture du fichier de configuration"); mWelcomePagePtr->InsertTextBoxString("Vérifier la présence du fichier ZT.conf"); // mWelcomePagePtr->InsertTextBoxString("L'exécution du logiciel va se terminer."); EnterDeadlockState(); return RET_ERROR; } //Create engineering log if defined in config file. if(CZTConfigMgr::instance()->GetEngLog() != -1) { CEngLog::instance()->Init(CZTConfigMgr::instance()->GetEngLog()); } else qDebug("Engineering Log disabled"); //Load the ZoneTest settings mZTSettingsFileMgr.LoadSettings(mZTSettings); mEventMgr->UpdateEvents(mZTSettings->mDetectionFunctionSettings); panel.mFunctionSelectPage->SetConfig(mZTSettings->mDetectionFunctionSettings); mLogMgr->SetMaxLogFilesCount(mZTSettings->mMaxLogCount); mLogMgr->KeepAllMPM10Logs(mZTSettings->mKeepMPM10Logs); mLogMgr->KeepAllZT1Logs(mZTSettings->mKeepAllZT1Logs); mLogMgr->KeepAllZT2Logs(mZTSettings->mKeepAllZT2Logs); panel.mEngineeringPage->ZTLogFilesSettings(mZTSettings->mMaxLogCount,mZTSettings->mKeepMPM10Logs,mZTSettings->mKeepAllZT1Logs,mZTSettings->mKeepAllZT2Logs); connect(&mACPISocket,SIGNAL(connected()),this,SLOT(ACPISocketConnected())); connect(&mACPISocket,SIGNAL(readyRead()),this,SLOT(ACPISocketEvent())); mACPISocket.connectToServer("/var/run/acpid.socket",QIODevice::ReadOnly); //Check if we must enter simulated mode if(CZTConfigMgr::instance()->GetSimulatorEnabled() == true) { mSimulationON = true; CZTLog::instance()->AddLogString("Mode Simulation détecté.",true); //Create simulated I/O objects mIOManager = new CSimulatorIOManager(); mLazerProbesManager = new CSimulatorLazerProbesMgr(); mPCIIO = new CSimulatorPCIIO(); mZTSimulator = new CZTSimulator((CSimulatorIOManager*)mIOManager); // mZTSimulator->Init(panel.mZTMainPage); panel.mZTMainPage->SetZTSimulator(mZTSimulator); mZTSimulator->SetPGTreshold(mZTSettings->mPGTreshold); } else { #ifndef WINDOWS_OS //Create actual I/O objects mIOManager = new CExternalIOMgr(); if(mSimulateLazerProbes) { mLazerProbesManager = new CSimulatorLazerProbesMgr(); } else { mLazerProbesManager = new CLazerProbesMgr(); } #ifdef USE_DAQNAVI_LIB mPCIIO = new CPCI1756Interface(); #else mPCIIO = new CComediLibInterface(); #endif #endif } //Open the external IO modules connection and create instances of //the modules as they are configured in the config file. if(mIOManager->InitIO() != EXTIO_MGR_RET_OK) { mWelcomePagePtr->InsertTextBoxString(QString("Impossible d'initialiser les modules externes")); mWelcomePagePtr->InsertTextBoxString(QString("Vérifier le fichier de configuration et la connexion au module maître.")); CZTLog::instance()->AddLogString("Impossible d'initialiser les modules externes",true); mWatchdogEnabled=false; EnterDeadlockState(); return RET_ERROR; } mWelcomePagePtr->InsertTextBoxString(QString("Initialisation des modules externes: OK")); mAnalogModule = 0; //Open advantech USB-4704 analog acquisition module. CUSB4704Interface *USBAnalogModule = new CUSB4704Interface(); if(USBAnalogModule->OpenInterface() == RET_OK) { mAnalogModule = USBAnalogModule; } #ifndef NO_PCI_CARD_INSTALLED //Open an check internal PCI inputs/outputs adapter card. if(mPCIIO->OpenPCIInterface() != PCIIO_OK) { mWelcomePagePtr->InsertTextBoxString(QString("Impossible d'initialiser la carte PCI")); CZTLog::instance()->AddLogString(QString("Impossible d'initialiser la carte PCI"),true); EnterDeadlockState(); return RET_ERROR; } mWelcomePagePtr->InsertTextBoxString(QString("Initialisation de la carte PCI: OK")); #else mWelcomePagePtr->InsertTextBoxString(QString("Carte PCI Ignorée. (NO_PCI_CARD_INSTALLED)")); #endif //Open the lazer probes as configured in the config file if(mLazerProbesManager->InitLazerProbes() != LAZERPROBES_MGR_RET_OK) { mWelcomePagePtr->InsertTextBoxString(QString("Impossible d'initialiser une ou plusieurs sondes laser")); CZTLog::instance()->AddLogString(QString("Impossible d'initialiser une ou plusieurs sondes laser"),true); EnterDeadlockState(); return RET_ERROR; } mWelcomePagePtr->InsertTextBoxString(QString("Initialisation des sondes laser: OK")); //Instantiate the station according to the physical key if(InitStation() == RET_ERROR) { EnterDeadlockState(); return RET_ERROR; } mZTSettingsFileMgr.SetStationName(GetStationTextualName()); mOutputModule = (COutputModule*)mIOManager->GetModule(IO_MODULE_OUTPUT_TYPE,1); mExtIOWorkerThread->BindPointers((CInputModule*)mIOManager->GetModule(IO_MODULE_INPUT_TYPE,1), (COutputModule*)mIOManager->GetModule(IO_MODULE_OUTPUT_TYPE,1), (CAnalogInputModule*)mIOManager->GetModule(IO_MODULE_MIXED_TYPE,1), mZTStation->GetAnalogAcqChannels()->SDFAcquisitionChannel); mExtIOThread->start(QThread::NormalPriority); bool UseModbusInterface = mZTSettings->mUseModbusCC; if(UseModbusInterface == true) { int ModbusCCPort = CZTConfigMgr::instance()->GetModbusCCPort(); int CCDevID = CZTConfigMgr::instance()->GetModbusCCDevID(); int ModbusSEIPort = CZTConfigMgr::instance()->GetModbusSEIPort(); int SEIDevID = CZTConfigMgr::instance()->GetModbusSEIDevID(); mWatchdogEnabled=false; if(CCDevID >= 255) { mWelcomePagePtr->InsertTextBoxString(QString("Valeur DevID Modbus CC invalide (%1)").arg(CCDevID)); CEngLog::instance()->AddLogString(QString("Valeur DevID Modbus CC invalide (%1)").arg(CCDevID),1); EnterDeadlockState(); return RET_ERROR; } if(SEIDevID >= 255) { mWelcomePagePtr->InsertTextBoxString(QString("Valeur DevID Modbus SEI invalide (%1)").arg(SEIDevID)); CEngLog::instance()->AddLogString(QString("Valeur DevID Modbus SEI invalide (%1)").arg(SEIDevID),1); EnterDeadlockState(); return RET_ERROR; } mCCModbusRepository = new CModbusRepository; mCCModbusRepository->AddHRDataMap(MODBUS_ZT_DATA_BASE_REG,MODBUS_ZT_TABLE_DATA_SIZE); //Add the ZT data map mCCModbusRepository->AddHRDataMap(MODBUS_CC_DATA_BASE_REG_ADD,MODBUS_ZT_TABLE_DATA_SIZE); //Add the CC data map if(mModbusCCMgr == 0) { mModbusCCMgr = new CModbusCCMgr(mCCModbusRepository,ModbusCCPort,CCDevID); } mModbusCCMgr->StartModbusCCServer(); mSEIModbusRepository = new CModbusRepository; mSEIModbusRepository->AddHRDataMap(SEI_MODBUS_ZT_DATA_BASE_REG,SEI_MODBUS_ZT_TABLE_DATA_SIZE); //Add the ZT data map mSEIModbusRepository->AddHRDataMap(SEI_MODBUS_SEI_DATA_BASE_REG,SEI_MODBUS_SEI_TABLE_DATA_SIZE); //Add the SEI data map if(mModbusSEIMgr == 0) { mModbusSEIMgr = new CModbusSEIMgr(mSEIModbusRepository,mCCModbusRepository,mZTSettings->mSEIModbusHostAddress,ModbusSEIPort,SEIDevID); } mModbusSEIMgr->StartSEICommunication(); connect(mModbusSEIMgr,SIGNAL(ModbusMasterConnected(qint32,qint32)),panel.mSEISettingsPage,SLOT(ModbusSEIConnected(qint32,qint32))); connect(mModbusSEIMgr,SIGNAL(ModbusMasterDisconnected()),panel.mSEISettingsPage,SLOT(ModbusSEIDisconnected())); connect(mModbusSEIMgr,SIGNAL(SEIModbusLinkLost()),panel.mSEISettingsPage,SLOT(ModbusSEILinkDown())); connect(mModbusSEIMgr,SIGNAL(SEIModbusLinkRecovered()),panel.mSEISettingsPage,SLOT(ModbusSEILinkUP())); connect(mModbusSEIMgr,SIGNAL(SEIModbusLinkRecovered()),panel.mZTMainPage,SLOT(ModbusSEIConnected())); connect(mModbusSEIMgr,SIGNAL(SEIModbusLinkLost()),panel.mZTMainPage,SLOT(ModbusSEIDisconnected())); panel.mModbusDisplayPage->mSEIRepoHandle = mSEIModbusRepository; panel.mModbusDisplayPage->mCCRepoHandle = mCCModbusRepository; panel.mZTMainPage->ModbusSEIDisconnected(); CModbusTKTransport *TransportInterface = new CModbusTKTransport(mCCModbusRepository,mSEIModbusRepository); mTKTransportInterface = (CTKTransportInterface*)TransportInterface; connect(mModbusCCMgr,SIGNAL(RepoHasChanged()),TransportInterface,SLOT(ModbusCCUpdated())); connect(mModbusSEIMgr,SIGNAL(SEIAlarmClearUpdate(bool,bool)),TransportInterface,SLOT(ModbusSEIClearUpdate(bool,bool))); mZTStateMachine->BindModbusCCMgrPtr(mModbusCCMgr); connect(mModbusCCMgr,SIGNAL(ModbusCCLinkRecovered()),panel.mZTMainPage,SLOT(ModbusCCConnected())); connect(mModbusCCMgr,SIGNAL(ModbusCCLinkLost()),panel.mZTMainPage,SLOT(ModbusCCDisconnected())); connect(mModbusCCMgr,SIGNAL(ModbusDateTimeReceived(QDateTime*)),this,SLOT(ModbusDateTimeUpdate(QDateTime*))); connect(mModbusCCMgr,SIGNAL(ModbusCCConnected(qint32,qint32)),panel.mModbusSettingsPage,SLOT(ModbusCCConnected(qint32,qint32))); connect(mModbusCCMgr,SIGNAL(ModbusCCDisconnected()),panel.mModbusSettingsPage,SLOT(ModbusCCDisconnected())); connect(mModbusCCMgr,SIGNAL(ModbusCCLinkLost()),panel.mModbusSettingsPage,SLOT(ModbusCCLinkDown())); connect(mModbusCCMgr,SIGNAL(ModbusCCLinkRecovered()),panel.mModbusSettingsPage,SLOT(ModbusCCLinkUP())); connect(TransportInterface,SIGNAL(TKUpdated()),mModbusSEIMgr,SLOT(ZTTKUpdated())); panel.mZTMainPage->ModbusCCDisconnected(); panel.mZTMainPage->mZT1Stats->Init(true); panel.mZTMainPage->mZT2Stats->Init(true); bool UseNetworkDrive = CZTConfigMgr::instance()->GetSAMBADriveActivated(); QString SAMBAMountPoint = CZTConfigMgr::instance()->GetSAMBAMountPoint(); QString SAMBALogin = CZTConfigMgr::instance()->GetSAMBALogin(); QString SAMBAPassword = CZTConfigMgr::instance()->GetSAMBAPassword(); QString SAMBADomain = CZTConfigMgr::instance()->GetSAMBADomain(); mNetworkDriveMgr.InitNetDriveMgr(UseNetworkDrive,SAMBAMountPoint,SAMBALogin,SAMBAPassword,SAMBADomain,mZTStation->GetStationShortName()); if(UseNetworkDrive == true) { connect(mZTStateMachine,SIGNAL(NewTrainLogSaved(QString,bool)),&mNetworkDriveMgr,SLOT(NewTrainFileSaved(QString,bool))); } } else { CDiscreteTKTransport *TransportInterface = new CDiscreteTKTransport; mTKTransportInterface = (CTKTransportInterface*)TransportInterface; TransportInterface->BindPointers(mZTStation->GetOutputMasks(),mExtIOWorkerThread); panel.mZTMainPage->mZT1Stats->Init(false); panel.mZTMainPage->mZT2Stats->Init(false); mNetworkDriveMgr.InitNetDriveMgr(false,"","","","",""); } connect(mTKTransportInterface,SIGNAL(TKOutputStatesChanged(bool,bool)),panel.mMaintenancePage,SLOT(TKOutputChanged(bool,bool))); //Start SFTP file copy service bool EnableSFTPClient = CZTConfigMgr::instance()->GetSFTPActivated(); QString SFTPLogin = CZTConfigMgr::instance()->GetSFTPLogin(); QString SFTPPassword = CZTConfigMgr::instance()->GetSFTPPassword(); QString SFTPServerAddress = CZTConfigMgr::instance()->GetSFTPServerAddress(); QString SFTPRemoteDir = CZTConfigMgr::instance()->GetSFTPServerRemoteDir(); bool UseEngLog = CZTConfigMgr::instance()->GetEngLog() != -1; mSFTPManager.InitFTPServerManager(EnableSFTPClient,SFTPLogin,SFTPPassword,SFTPServerAddress,SFTPRemoteDir,mZTStation->GetStationShortName(),UseEngLog); if(EnableSFTPClient == true) { connect(mZTStateMachine,SIGNAL(NewTrainLogSaved(QString,bool)),&mSFTPManager,SLOT(NewTrainFileSaved(QString,bool))); } //Start Historien PI server bool EnableHistorian = CZTConfigMgr::instance()->GetPIHistorianEnabled(); int PIHistorianPort = CZTConfigMgr::instance()->GetPIHistorianModbusPort(); int PIHistorianDevID = CZTConfigMgr::instance()->GetPIHistorianModbusDevID(); if(EnableHistorian == true) { mPIHistorianRepository = new CModbusRepository; mPIHistorianRepository->AddHRDataMap(HISTORIAN_ZT_DATA_BASE_REG,HISTORIAN_MODBUS_ZT_TABLE_DATA_SIZE); //Add the ZT data map mPIHistorianManager = new CPIHistorianManager(mPIHistorianRepository,PIHistorianPort,PIHistorianDevID); panel.mHistorienDisplayPage->mHistorienRepoHandle = mPIHistorianRepository; if(UseModbusInterface) { connect(mModbusCCMgr,SIGNAL(ModbusCCConnected(qint32,qint32)),mPIHistorianManager,SLOT(HPCConnected(qint32,qint32))); connect(mModbusCCMgr,SIGNAL(ModbusCCDisconnected()),mPIHistorianManager,SLOT(HPCDisconnected())); connect(mModbusSEIMgr,SIGNAL(ModbusMasterConnected(qint32,qint32)),mPIHistorianManager,SLOT(SEIConnected(qint32,qint32))); connect(mModbusSEIMgr,SIGNAL(ModbusMasterDisconnected()),mPIHistorianManager,SLOT(SEIDisconnected())); } connect(mPIHistorianManager,SIGNAL(HistorianConnected()),panel.mZTMainPage,SLOT(ModbusHistorienConnected())); connect(mPIHistorianManager,SIGNAL(HistorianDisconnected()),panel.mZTMainPage,SLOT(ModbusHistorienDisconnected())); panel.mZTMainPage->ModbusHistorienDisconnected(); mPIHistorianManager->UpdateDetectionFunctions(mZTSettings->mDetectionFunctionSettings); mPIHistorianManager->UpdatePGTreshold(mZTSettings->mPGTreshold); mPIHistorianManager->UpdateMaintenanceMode(false); mPIHistorianManager->SetSystemStartDateTime(mZTStartDateTime); mPIHistorianManager->StartPIHistorian(); } if(mSimulationON == true) { #ifdef USE_REAL_ANALOG_EXTERNAL_MODULE mZTSimulator->Init(panel.mZTMainPage,mZTStation,mIOManager,mPCIIO,mLazerProbesManager,mUSBDriveInterface,mAnalogModule); #else mZTSimulator->Init(panel.mZTMainPage,mZTStation,mIOManager,mPCIIO,mLazerProbesManager,mUSBDriveInterface); #endif mZTStateMachine->BindPointers(mZTStation, mExtIOWorkerThread, mExtIOWorkerThread, panel.mZTMainPage, mPCIIO, mLazerProbesManager->GetLazerProbeHandle(LAZER_PROBE_TYPE_INTERNAL,1), mLazerProbesManager->GetLazerProbeHandle(LAZER_PROBE_TYPE_EXTERNAL,1), mLogMgr, mTKTransportInterface, mZTSimulator, mAnalogModule); } else { mZTStateMachine->BindPointers(mZTStation, mExtIOWorkerThread, mExtIOWorkerThread, panel.mZTMainPage, mPCIIO, mLazerProbesManager->GetLazerProbeHandle(LAZER_PROBE_TYPE_INTERNAL,1), mLazerProbesManager->GetLazerProbeHandle(LAZER_PROBE_TYPE_EXTERNAL,1), mLogMgr, mTKTransportInterface, 0, mAnalogModule); } mZTStateMachine->SetPGTreshold(mZTSettings->mPGTreshold); panel.mEngineeringPage->BindPointers(this, mExtIOWorkerThread, mExtIOWorkerThread, mPCIIO, mZTSettings, mUSBDriveInterface, mZTStation, mAnalogModule); connect(mZTStateMachine,SIGNAL(PGCalibrationFinished(int)),panel.mEngineeringPage,SLOT(PGCalibFinished(int))); connect(mZTStateMachine,SIGNAL(PGCalibrationStatus(int,int)),panel.mEngineeringPage,SLOT(PGCalibUpdate(int,int))); connect(mZTStateMachine,SIGNAL(MaintenancePPActivated(uint)),panel.mMaintenancePage,SLOT(PPActivated(uint))); panel.mEngineeringPage->Init(); if(mSimulationON == false) { connect((CLazerProbe*)mLazerProbesManager->GetLazerProbeHandle(LAZER_PROBE_TYPE_INTERNAL,1),SIGNAL(NewProbeData(unsigned int,unsigned int)),panel.mEngineeringPage,SLOT(LazerProbeDataAvailable(uint,uint))); connect((CLazerProbe*)mLazerProbesManager->GetLazerProbeHandle(LAZER_PROBE_TYPE_EXTERNAL,1),SIGNAL(NewProbeData(unsigned int,unsigned int)),panel.mEngineeringPage,SLOT(LazerProbeDataAvailable(uint,uint))); } else { connect((CSimulatorLazerProbe*)mLazerProbesManager->GetLazerProbeHandle(LAZER_PROBE_TYPE_INTERNAL,1),SIGNAL(NewProbeData(unsigned int,unsigned int)),panel.mEngineeringPage,SLOT(LazerProbeDataAvailable(uint,uint))); connect((CSimulatorLazerProbe*)mLazerProbesManager->GetLazerProbeHandle(LAZER_PROBE_TYPE_EXTERNAL,1),SIGNAL(NewProbeData(unsigned int,unsigned int)),panel.mEngineeringPage,SLOT(LazerProbeDataAvailable(uint,uint))); } panel.mZTMainPage->SetZT2Presence(mZTStation->StationHasZT2()); mZTStateMachine->SetZT2Presence(mZTStation->StationHasZT2()); mWelcomePagePtr->InsertTextBoxString(QString("Chargement des fichiers de passage de trains...")); mLogMgr->ParseLogs(); mWelcomePagePtr->InsertTextBoxString(QString("Chargement des fichiers de passage de trains: OK")); mZTStateMachine->SetAutoExportZT1CSV(mZTSettings->mAutoExportZT1CSV); mZTStateMachine->SetAutoExportZT2CSV(mZTSettings->mAutoExportZT2CSV); panel.mGeneralSettingsPage->UseNetworkTime(mZTSettings->mUseNetworkTime,true); panel.mLogsListPage->BindPointers(mUSBDriveInterface); mUSBDriveInterface->Start(); // if(mDI710Module != 0) // mDI710Module->StartAcquisition(); #ifdef USE_NETWORKING CNetworkManager::instance()->StartServer(); #endif //CRamMonitor::instance()->StartTimer(); CEngLog::instance()->AddLogString("Initialisation de la Zone Test réussie"); panel.HideWelcomePage(); panel.ShowMainPage(); return RET_OK; } unsigned int CZoneTest::Run() { return RET_OK; } unsigned int CZoneTest::InitStation() { CEngLog::instance()->AddLogString("CZoneTest::InitStation. Initialisation de la station"); QString StationName = CZTConfigMgr::instance()->GetStationName(); if(mSimulationON == false && mIgnoreStationPhysicalKey == false) //Do not check station physical key in sim mode or if IgnoreKey switch activated. { CInputModule *inputmodule = (CInputModule*)mIOManager->GetModule(IO_MODULE_INPUT_TYPE,1); //Access the module directly since the thread is not yet started... unsigned int key = inputmodule->GetInputs(); if((key & ANGRIGNON_IN_STATION_ID_MASK) == ANGRIGNON_STATION_KEY) { StationName = "ANGRIGNON"; } else if((key & BERRIUQAM_IN_STATION_ID_MASK) == BERRIUQAM_STATION_KEY) { StationName = "BERRI_UQAM"; } else if((key & COTEVERTU_IN_STATION_ID_MASK) == COTEVERTU_STATION_KEY) { StationName = "COTE_VERTU"; } else if((key & HENRIBOURASSA_IN_STATION_ID_MASK) == HENRIBOURASSA_STATION_KEY) { StationName = "HENRI_BOURASSA"; } else if((key & HONOREBEAUGRAND_IN_STATION_ID_MASK) == HONOREBEAUGRAND_STATION_KEY) { StationName = "HONORE_BEAUGRAND"; } else if((key & LONGUEUIL_IN_STATION_ID_MASK) == LONGUEUIL_STATION_KEY) { StationName = "LONGUEIL"; } else if((key & MONTMORENCY_IN_STATION_ID_MASK) == MONTMORENCY_STATION_KEY) { StationName = "MONTMORENCY"; } // else if((key & MONTMORENCY1012_IN_STATION_ID_MASK) == MONTMORENCY1012_STATION_KEY) // { // StationName = "MONTMORENCY_10_12"; // } else if((key & MONTMORENCY1022_IN_STATION_ID_MASK) == MONTMORENCY1022_STATION_KEY) { StationName = "MONTMORENCY_10_22"; } else if((key & SAINTMICHEL_IN_STATION_ID_MASK) == SAINTMICHEL_STATION_KEY) { StationName = "SAINT_MICHEL"; } else if((key & SNOWDON_IN_STATION_ID_MASK) == SNOWDON_STATION_KEY) { StationName = "SNOWDON_L5"; } else if((key & DUCOLLEGE_IN_STATION_ID_MASK) == DUCOLLEGE_STATION_KEY) { StationName = "DU_COLLEGE"; } else { CEngLog::instance()->AddLogString(QString("ERREUR. Clef électrique de station inconnue: ") + StationName,2); CEngLog::instance()->AddLogString(QString("Impossible d'initialiser la station"),1); mWelcomePagePtr->InsertTextBoxString("Erreur: Station non reconnue"); mWelcomePagePtr->InsertTextBoxString("Vérifier la clef électrique"); return RET_ERROR; } } if(StationName == "HONORE_BEAUGRAND") { mZTStation = new CHonoreBeaugrandStation(); } else if(StationName == "ANGRIGNON") { mZTStation = new CAngrignonStation(); } else if(StationName == "HENRI_BOURASSA") { mZTStation = new CHenriBourassaStation(); } else if(StationName == "COTE_VERTU") { mZTStation = new CCoteVertuStation(); } else if(StationName == "BERRI_UQAM") { mZTStation = new CBerriUQAMStation(); } else if(StationName == "LONGUEIL") { mZTStation = new CLongueuilStation(); } else if(StationName == "SAINT_MICHEL") { mZTStation = new CSaintMichelStation(); } else if(StationName == "SNOWDON_L5") { mZTStation = new CSnowdonStation(); } else if(StationName == "MONTMORENCY") { mZTStation = new CMontmorencyStation(); } else if(StationName == "MONTMORENCY_10_12") { mZTStation = new CMontmorency1012Station(); } else if(StationName == "MONTMORENCY_10_22") { mZTStation = new CMontmorency1022Station(); } else if(StationName == "DU_COLLEGE") { mZTStation = new CDuCollegeStation(); } else { CEngLog::instance()->AddLogString(QString("ERREUR. Nom de station invalide : ") + StationName,2); CEngLog::instance()->AddLogString(QString("Impossible d'initialiser la station"),1); mWelcomePagePtr->InsertTextBoxString("Erreur. Vérifier le fichier de configuration"); mWelcomePagePtr->InsertTextBoxString(QString("Nom de station invalide : ") + StationName); return RET_ERROR; } // mZTStation->InitStation(mIOManager,mLazerProbesManager); mZTStation->BuildCDVList(); panel.mZTMainPage->SetStationName(mZTStation->GetStationTextualName()); panel.mZTMainPage->SetCDVList(mZTStation->GetCDVList()); CZTLog::instance()->AddLogString(QString("Station initialisée : ") + mZTStation->GetStationTextualName(),true); mWelcomePagePtr->InsertTextBoxString(QString("Station initialisée : ") + mZTStation->GetStationTextualName()); return RET_OK; } void CZoneTest::EnterDeadlockState() { //TODO: Set flags, Alarms, etc.. CZTLog::instance()->AddLogString(QString("L'exécution de l'application est terminée. DEADLOCK"),true); mZtState = ZT_DEADLOCK_STATE; } //Catch and manage some events from the graphics user interface //like the keyboard Exit sequence (Ctrl-F10) bool CZoneTest::eventFilter(QObject *obj, QEvent *event) { if(obj == &panel) //Check if event is coming from the GUI { if(event->type() == QEvent::KeyPress) { QKeyEvent *KeyEvent = static_cast(event); //Check if we received CTRL-F10 if(KeyEvent->key() == Qt::Key_F10 && KeyEvent->modifiers() == Qt::ControlModifier) { CZTLog::instance()->AddLogString("CTRL-F10...",true); if(mDisablePassword == true) { CZTLog::instance()->AddLogString("Mot de passe désactivé. Sortie du programme.",true); ApplicationQuit(EXIT_REASON_USER_REQUEST); } else { CZTLog::instance()->AddLogString("Demande du mot de passe.",true); panel.mZTMainPage->RequestExitPassword(); } return true; //keep the keystroke } else if(KeyEvent->key() == Qt::Key_F4) //F4 Key toggles the Modbus data display page { if(mZTSettings->mUseModbusCC == true) { if(panel.mModbusDisplayPage->isVisible()) { panel.mModbusDisplayPage->hide(); } else { panel.mModbusDisplayPage->show(); } } } else if(KeyEvent->key() == Qt::Key_F3) //F3 Key toggles the Historien data display page { if(CZTConfigMgr::instance()->GetPIHistorianEnabled()) { if(panel.mHistorienDisplayPage->isVisible()) { panel.mHistorienDisplayPage->HideHistorienPage(); } else { panel.mHistorienDisplayPage->show(); } } } } } return QObject::eventFilter(obj,event); } ////Messages from Options page void CZoneTest::ZTFunctionsOptionSelected() { panel.mOptionsPage->hide(); panel.mFunctionSelectPage->show(); } void CZoneTest::ZTMaintenanceOptionSeleced() { panel.mOptionsPage->hide(); panel.mMaintenancePage->show(); if(mModbusCCMgr != 0) { mModbusCCMgr->SetActivatedITI(mZTStation->GetCurrentITI()); //Fetch and update the activated ITI for alarm simulation } } /////////////// ////Messages from Main ZT Page void CZoneTest::OptionsMenuPageSelected() { panel.mOptionsPage->show(); } void CZoneTest::LogsPageSelected() { panel.mLogsListPage->RefreshList(); panel.mLogsListPage->show(); } void CZoneTest::ProgramExitRequest() { CZTLog::instance()->AddLogString("Mot de passe valide. Fin du programme.",true); ApplicationQuit(EXIT_REASON_USER_REQUEST); QApplication::exit(79); } ///////////////// ////Messages from Detection Functions select page unsigned int CZoneTest::DetectionFunctionsConfigChanged(CZTDetectionFunctionConfig *NewConfig) { *mZTSettings->mDetectionFunctionSettings = *NewConfig; mZTSettingsFileMgr.SaveSettings(mZTSettings); mEventMgr->UpdateEvents(mZTSettings->mDetectionFunctionSettings); if(mPIHistorianManager != 0) mPIHistorianManager->UpdateDetectionFunctions(NewConfig); return RET_OK; } /////Messages from Logs list page void CZoneTest::LogViewRequest(CLogElement *element) { panel.mLogsListPage->hide(); panel.mZTMainPage->hide(); panel.mLogViewPage->SetLogData(element); panel.mLogViewPage->show(); } QString CZoneTest::GetStationShortName() { return mZTStation->GetStationShortName(); } QString CZoneTest::GetStationTextualName() { return mZTStation->GetStationTextualName(); } /// Messages from logs display page void CZoneTest::LogViewCloseRequest() { panel.mLogViewPage->hide(); panel.mLogsListPage->show(); panel.mZTMainPage->show(); } /// Messages from engineering page void CZoneTest::OpenEngineeringPageRequest() { panel.mOptionsPage->hide(); panel.mEngineeringPage->ShowPage(); } void CZoneTest::CloseEngineeringPageRequest() { panel.mEngineeringPage->hide(); // panel.mOptionsPage->show(); } void CZoneTest::SaveAutoExportCSVSettings(bool AutoExportZT1CSV, bool AutoExportZT2CSV) { mZTSettings->mAutoExportZT1CSV = AutoExportZT1CSV; mZTSettings->mAutoExportZT2CSV = AutoExportZT2CSV; mZTSettingsFileMgr.SaveSettings(mZTSettings); mZTStateMachine->SetAutoExportZT1CSV(AutoExportZT1CSV); mZTStateMachine->SetAutoExportZT2CSV(AutoExportZT2CSV); } void CZoneTest::TrainFilesChanged() { mLogMgr->ParseLogs(); } bool CZoneTest::StartPGCalibrationRequest(int NbPassages) { if(mZTStateMachine->EnterPGCalibrationMode(NbPassages) == true) { mEventMgr->AddSingleEvent(EVENT_CA_PG); return true; } return false; } bool CZoneTest::StopPGCalibrationRequest() { if(mZTStateMachine->QuitPGCalibrationMode() == true) { mEventMgr->RemoveSingleEvent(EVENT_CA_PG); return true; } return false; } void CZoneTest::HighResLogging(bool HighResON) { mZTStateMachine->SetLogResolution(HighResON); } int CZoneTest::GetPGTreshold() { return mZTSettings->mPGTreshold; } void CZoneTest::KeepAllMPM10Logs(bool Keep) { mZTSettings->mKeepMPM10Logs = Keep; mZTSettingsFileMgr.SaveSettings(mZTSettings); mLogMgr->KeepAllMPM10Logs(Keep); } void CZoneTest::SetLogFilesNumber(int NbLogFiles) { mZTSettings->mMaxLogCount = NbLogFiles; mZTSettingsFileMgr.SaveSettings(mZTSettings); mLogMgr->SetMaxLogFilesCount(NbLogFiles); } void CZoneTest::KeepAllZT1Logs(bool keep) { mZTSettings->mKeepAllZT1Logs = keep; mZTSettingsFileMgr.SaveSettings(mZTSettings); mLogMgr->KeepAllZT1Logs(keep); } void CZoneTest::KeepAllZT2Logs(bool keep) { mZTSettings->mKeepAllZT2Logs = keep; mZTSettingsFileMgr.SaveSettings(mZTSettings); mLogMgr->KeepAllZT2Logs(keep); } unsigned int CZoneTest::SetPGTreshold(int NewTreshold) { mZTStateMachine->SetPGTreshold(NewTreshold); if(mSimulationON) mZTSimulator->SetPGTreshold(NewTreshold); mZTSettings->mPGTreshold = NewTreshold; mZTSettingsFileMgr.SaveSettings(mZTSettings); if(mPIHistorianManager != 0) mPIHistorianManager->UpdatePGTreshold(NewTreshold); return RET_OK; } ///Messages from Maintenance page bool CZoneTest::EnterMaintenanceModeRequest() { if(mZTStateMachine->EnterMaintenanceMode() == RET_OK) { mEventMgr->AddSingleEvent(EVENT_MAINTENANCE); if(mPIHistorianManager != 0) { mPIHistorianManager->UpdateMaintenanceMode(true); } return true; } else return false; } void CZoneTest::ExitMaintenanceModeRequest() { if(mZTSettings->mUseModbusCC == true) { mModbusCCMgr->SetZTWatchdogEnabled(true); } else { mWatchdogEnabled = true; } mZTStateMachine->QuitMaintenanceMode(); mEventMgr->RemoveSingleEvent(EVENT_MAINTENANCE); if(mPIHistorianManager != 0) { mPIHistorianManager->UpdateMaintenanceMode(false); } } unsigned int CZoneTest::ClearMaintenanceCurTKRequest() { return mZTStateMachine->ClearMaintenanceCurrentTK(); } unsigned int CZoneTest::SendTKToPCC(int DetectionID, int Rank) { return mZTStateMachine->SendTKToPCC(DetectionID,Rank); } //THIS IS NOT FOR CPU WATCHDOG BUT FOR EXTERNAL WATCHDOG "VIGIE" INSIDE THE T.A. void CZoneTest::SetWatchdogEnabled(bool Enabled) { if(mZTSettings->mUseModbusCC == true) { mModbusCCMgr->SetZTWatchdogEnabled(Enabled); } else { mWatchdogEnabled = Enabled; mExtIOWorkerThread->ClearOutputFlags(mZTStation->GetOutputMasks()->OutputWatchdogMask); } } void CZoneTest::CloseMaintenancePageRequest() { panel.mMaintenancePage->hide(); panel.mOptionsPage->show(); } ///Messages from general settings page void CZoneTest::OpenGeneralSettingsPage() { panel.mGeneralSettingsPage->show(); panel.mOptionsPage->hide(); } void CZoneTest::CloseGeneralSettingsPage() { panel.mGeneralSettingsPage->hide(); } void CZoneTest::UseNetworkTime(bool UseNetworkTime) { mZTSettings->mUseNetworkTime = UseNetworkTime; mZTSettingsFileMgr.SaveSettings(mZTSettings); } ///Messages from Modbus settings page void CZoneTest::OpenModbusSettingsPage() { panel.mModbusSettingsPage->SetActualSettings(mZTSettings->mUseModbusCC,mZTSettings->mModbusCCHostAddress); panel.mModbusSettingsPage->show(); panel.mOptionsPage->hide(); } void CZoneTest::CloseModbusSettingsPage() { panel.mModbusSettingsPage->hide(); } void CZoneTest::ModbusSettingsChangedReboot(bool UseModbus, QHostAddress CCHostAdd) { mZTSettings->mUseModbusCC = UseModbus; mZTSettings->mModbusCCHostAddress = CCHostAdd; mZTSettingsFileMgr.SaveSettings(mZTSettings); if(mNetworkCfgMgr.SetTRCPNetworkAddress(CCHostAdd) == RET_OK) { if(mDoNotReboot == false) { ApplicationQuit(EXIT_REASON_SYSTEM_REBOOT); } } } //Messages from SEI settings page void CZoneTest::OpenSEISettingsPage() { panel.mSEISettingsPage->SetActualSettings(mZTSettings->mSEIModbusHostAddress); panel.mSEISettingsPage->show(); panel.mOptionsPage->hide(); } void CZoneTest::CloseSEISettingsPage() { panel.mSEISettingsPage->hide(); } void CZoneTest::ApplySEISettings(QHostAddress SEIHostAdd) { mZTSettings->mSEIModbusHostAddress = SEIHostAdd; mZTSettingsFileMgr.SaveSettings(mZTSettings); mModbusSEIMgr->SEISettingsChanged(SEIHostAdd,CZTConfigMgr::instance()->GetModbusSEIPort(),CZTConfigMgr::instance()->GetModbusSEIDevID()); //TODO: apply changes and reconnect. } ///Messages from ZTLog viewer page void CZoneTest::ShowZTLogViewerPage() { panel.mZTLogViewerPage->show(); panel.mOptionsPage->hide(); } void CZoneTest::HideZTLogViewerPage() { panel.mZTLogViewerPage->hide(); } void CZoneTest::ResetTriggerCount() { mZTStateMachine->ResetNbTriggers(); } void CZoneTest::ResetNbPassages() { mZTStateMachine->ResetNbPassages(); } void CZoneTest::LogZTSettingsRequest(bool LogStationName) { mZTSettingsFileMgr.LogSettings(mZTSettings,LogStationName); } void CZoneTest::OpenModbusDataPageRequest() { panel.mEngineeringPage->hide(); panel.mModbusDisplayPage->show(); } void CZoneTest::CloseModbusDataPageRequest() { panel.mModbusDisplayPage->hide(); panel.mEngineeringPage->show(); } void CZoneTest::OpenHistorienDataPageRequest() { panel.mModbusDisplayPage->hide(); panel.mHistorienDisplayPage->show(); } void CZoneTest::CloseHistorienDataPageRequest() { panel.mHistorienDisplayPage->hide(); panel.mEngineeringPage->show(); } void CZoneTest::CheckAndCreateDirectories() { QDir dir("./Trains"); if(dir.exists() == false) { QDir().mkdir("./Trains"); } dir = QDir("./ING"); if(dir.exists() == false) { QDir().mkdir("./ING"); } dir = QDir("./LOG"); if(dir.exists() == false) { QDir().mkdir("./LOG"); } dir = QDir("./Configuration"); if(dir.exists() == false) { QDir().mkdir("./Configuration"); } } ///Messages from network interface CTCPZTStatus *CZoneTest::GetTCPStatusRequest() { CTCPZTStatus *status = new CTCPZTStatus; status->mZT1Status = (quint32)mZTStateMachine->GetZT1ActiveStatus(); status->mZT2Status = (quint32)mZTStateMachine->GetZT2ActiveStatus(); status->mNbPass = (quint32)mZTStateMachine->GetNbPassages(); status->mNbTrigs = (quint32)mZTStateMachine->GetNbTriggers(); status->mZTStartDateTime = mZTStartDateTime; status->mActualDateTime = QDateTime::currentDateTime(); status->mPGTreshold = (qint32)mZTSettings->mPGTreshold; status->mModeMaintenanceON = mZTStateMachine->IsInMaintenance(); status->mCalibModeON = mZTStateMachine->IsInPGCalibration(); status->mFNTKActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_FN].TKActive; status->mFNAnalysisActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_FN].AnalysisActive; status->mPGTKActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PG].TKActive; status->mPGAnalysisActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PG].AnalysisActive; status->mPP1TKActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP].TKActive; status->mPP1AnalysisActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP].AnalysisActive; status->mPP2TKActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP2].TKActive; status->mPP2AnalysisActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP2].AnalysisActive; status->mZT1TKActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT1].TKActive; status->mZT1AnalysisActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT1].AnalysisActive; status->mZT2TKActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT2].TKActive; status->mZT2AnalysisActive = mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT2].AnalysisActive; status->mUSBKeyConnected = mUSBDriveInterface->IsDriveDetected(); return status; //HAVE TO BE DELETED BY CALLER !!! } QString *CZoneTest::GetZTLogTextRequest() { QString *string = new QString(CZTLog::instance()->GetEntireLogFile()); return string; //HAVE TO BE DELETED BY CALLER !!! } QFileInfoList CZoneTest::GetTrainLogsFileListRequest() { return mLogMgr->GetLogsFilenameList(); } unsigned int CZoneTest::DeleteZTLogRequest() { return CZTLog::instance()->DeleteLogFile(); } unsigned int CZoneTest::PauseInternalWatchdog() { mInternalWatchdog->StopWatchdog(); return RET_OK; } unsigned int CZoneTest::ResumeInternalWatchdog() { mInternalWatchdog->StartWatchdog(); return RET_OK; } bool CZoneTest::IsZT2PresentInStation() { return mZTStation->StationHasZT2(); } unsigned int CZoneTest::SetZTFunctionsConfig(const CTCPZTFunctionsStatus &FunctionsConfig) { if(FunctionsConfig.mZT1AnalysisActive != mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT1].AnalysisActive) { mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_FN].AnalysisActive = FunctionsConfig.mZT1AnalysisActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PG].AnalysisActive = FunctionsConfig.mZT1AnalysisActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP].AnalysisActive = FunctionsConfig.mZT1AnalysisActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT1].AnalysisActive = FunctionsConfig.mZT1AnalysisActive; } else { mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_FN].AnalysisActive = FunctionsConfig.mFNAnalysisActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PG].AnalysisActive = FunctionsConfig.mPGAnalysisActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP].AnalysisActive = FunctionsConfig.mPP1AnalysisActive; } if(FunctionsConfig.mZT2AnalysisActive != mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT2].AnalysisActive) { mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP2].AnalysisActive = FunctionsConfig.mZT2AnalysisActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT2].AnalysisActive = FunctionsConfig.mZT2AnalysisActive; } else { mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP2].AnalysisActive = FunctionsConfig.mPP2AnalysisActive; } if(FunctionsConfig.mZT1TKActive != mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT1].TKActive) { mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_FN].TKActive = FunctionsConfig.mZT1TKActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PG].TKActive = FunctionsConfig.mZT1TKActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP].TKActive = FunctionsConfig.mZT1TKActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT1].TKActive = FunctionsConfig.mZT1TKActive; } else { mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_FN].TKActive = FunctionsConfig.mFNTKActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PG].TKActive = FunctionsConfig.mPGTKActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP].TKActive = FunctionsConfig.mPP1TKActive; } if(FunctionsConfig.mZT2TKActive != mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT2].TKActive) { mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP2].TKActive = FunctionsConfig.mZT2TKActive; mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_ZT2].TKActive = FunctionsConfig.mZT2TKActive; } else { mZTSettings->mDetectionFunctionSettings->mZTDetectionConfig[DETECTION_FCT_PP2].TKActive = FunctionsConfig.mPP2TKActive; } mZTSettingsFileMgr.SaveSettings(mZTSettings); panel.mFunctionSelectPage->SetConfig(mZTSettings->mDetectionFunctionSettings); mEventMgr->UpdateEvents(mZTSettings->mDetectionFunctionSettings); return RET_OK; } int CZoneTest::SetZT1InhibitionState(bool InhibitionON) { if(InhibitionON) { mEventMgr->AddSingleEvent(EVENT_ZT1_INHIBITION); } else { mEventMgr->RemoveSingleEvent(EVENT_ZT1_INHIBITION); } return RET_OK; } int CZoneTest::SetZT2InhibitionState(bool InhibitionON) { if(InhibitionON) { mEventMgr->AddSingleEvent(EVENT_ZT2_INHIBITION); } else { mEventMgr->RemoveSingleEvent(EVENT_ZT2_INHIBITION); } return RET_OK; } int CZoneTest::NewZT1Passage(CZTPassageInfo ZT1PassageInfo) { if(mPIHistorianManager != 0) { mPIHistorianManager->NewZT1Passage(ZT1PassageInfo); } return RET_OK; } int CZoneTest::NewZT2Passage(CZTPassageInfo ZT2PassageInfo) { if(mPIHistorianManager != 0) { mPIHistorianManager->NewZT2Passage(ZT2PassageInfo); } return RET_OK; } void CZoneTest::ApplicationQuit(int Reason) { if(Reason == EXIT_REASON_USER_REQUEST) { mZtState = ZT_EXIT_APPLICATION_STATE; } else if(Reason == EXIT_REASON_POWER_BUTTON) { mZtState = ZT_POWER_BUTTON_EXIT_STATE; } else if(Reason == EXIT_REASON_SYSTEM_REBOOT) { CZTLog::instance()->AddLogString("Redémarrage de l'ordinateur suite à un changement de paramètres."); mZtState = ZT_SYSTEM_REBOOT_EXIT_STATE; } else { qDebug("Trying to exit app with unknown reason... Ignoring"); return; } mExtIOWorkerThread->SetOutput((quint32)0); mExtIOWorkerThread->StopAcquisition(); //Wait for the thread to stop while(mExtIOWorkerThread->IsThreadRunning() == true) { usleep(1000); } // if(mDI710Module != 0) // { // mDI710Module->StopThread(); // while(mDI710Module->IsThreadRunning() == true) // { // usleep(1000); // } // } // mDataQThread->quit(); // if(mDataQThread->wait(1000) == false) // { // qDebug("DataqThread wait = false"); // } if(mModbusCCMgr != 0) { if(mModbusCCMgr->CloseModbusCCServer() != 0) { qDebug("Modbus server closed"); } } // qDebug("Creating escape file..."); system("echo exit > ./Escape.ZT"); //Crée un fichier vide pour informer le script de ne pas redémarrer l'application system("sync"); mExtIOThread->quit(); if(mExtIOThread->wait(1000) == false) { qDebug("ExtIOThread wait = false"); } } void CZoneTest::ACPISocketConnected() { CEngLog::instance()->AddLogString("Socket ACPI connecté"); } void CZoneTest::ACPISocketEvent() { QString Res(mACPISocket.readAll()); if(Res.contains("button/power")) { CZTLog::instance()->AddLogString("Activation du bouton << Power >>, sortie du programme",true); mACPISocket.close(); ApplicationQuit(EXIT_REASON_POWER_BUTTON); } else { Res.prepend("Événement ACPI inconnu: "); CZTLog::instance()->AddLogString(Res); } } void CZoneTest::ModbusDateTimeUpdate(QDateTime *NewDateTime) { if(mZTSettings->mUseNetworkTime == true) { if(*NewDateTime != QDateTime::currentDateTime()) { CEngLog::instance()->AddLogString("Synchronisation de l'heure avec le SACL"); //CZTLog::instance()->AddLogString("Synchronisation de l'heure avec le SACL"); SetSystemDateTime(NewDateTime); } } } int CZoneTest::SetSystemDateTime(QDateTime *DateTime) { time_t time_data = time(0); struct tm* tm_ptr = localtime(&time_data); tm_ptr->tm_min = DateTime->time().minute(); tm_ptr->tm_hour = DateTime->time().hour(); tm_ptr->tm_mday = DateTime->date().day(); tm_ptr->tm_mon = DateTime->date().month()-1; tm_ptr->tm_year = DateTime->date().year()-1900; const struct timeval tv = {mktime(tm_ptr),0}; if(settimeofday(&tv,0) < 0) { qDebug("Settimeofday failed"); CZTLog::instance()->AddLogString("Échec du changement de la date & de l'heure",true); return RET_ERROR; } else { if ( system("/sbin/hwclock --systohc") < 0 ) { //qDebug("hwclock sync failed"); CZTLog::instance()->AddLogString("Échec du changement de la date & de l'heure (hwsync failure)",true); return RET_ERROR; } else { CEngLog::instance()->AddLogString(QString().sprintf("Changement de date & heure: %s %s",DateTime->date().toString("yyyy/MM/dd").toUtf8().data(),DateTime->time().toString("hh:mm").toUtf8().data())); // CZTLog::instance()->AddLogString(QString().sprintf("Changement de date & heure: %s %s",DateTime->date().toString("yyyy/MM/dd").toUtf8().data(),DateTime->time().toString("hh:mm").toUtf8().data()),true); } } return RET_OK; }