434 lines
14 KiB
C++
434 lines
14 KiB
C++
/*******************************************************************************
|
|
* *
|
|
* Gros Gin électronique *
|
|
* 2023 *
|
|
* *
|
|
* Project: Otarcik CAN *
|
|
* *
|
|
* *
|
|
* *
|
|
*******************************************************************************/
|
|
/*
|
|
Description:
|
|
This is our main program
|
|
|
|
*/
|
|
|
|
#include "OtarcikCan.h"
|
|
#include "PCANBasic.h"
|
|
#include "QtEndian"
|
|
|
|
|
|
COtarcikCan::COtarcikCan(QObject *parent) : QObject(parent)
|
|
{
|
|
mGPTimer = new QTimer;
|
|
connect(mGPTimer,SIGNAL(timeout()),this,SLOT(GPTimerExpired()));
|
|
// mCANBusMQTTClient.mProgramPtr = this;
|
|
mWatchdogTimer = new QTimer;
|
|
connect(mWatchdogTimer,&QTimer::timeout,this,&COtarcikCan::WatchdogUpdateTimerExpired);
|
|
mWatchdogTimer->setSingleShot(false);
|
|
mWatchdogTimer->setInterval(1000);
|
|
|
|
mMQTTDataTransmitTimer = new QTimer;
|
|
connect(mMQTTDataTransmitTimer,&QTimer::timeout,this,&COtarcikCan::MQTTDataTransmitTimerExpired);
|
|
mMQTTDataTransmitTimer->setInterval(10000);
|
|
mMQTTDataTransmitTimer->setSingleShot(false);
|
|
}
|
|
|
|
COtarcikCan::~COtarcikCan()
|
|
{
|
|
qDebug("Destruction");
|
|
|
|
|
|
while (!mCANDevicesList.isEmpty())
|
|
{
|
|
delete mCANDevicesList.takeFirst();
|
|
}
|
|
mCANDevicesList.clear();
|
|
|
|
while(!mCANBusMQTTClientList.isEmpty())
|
|
{
|
|
|
|
mCANBusMQTTClientList.first()->DisconnectFromBroker();
|
|
delete mCANBusMQTTClientList.takeFirst();
|
|
}
|
|
|
|
// mCANBusMQTTClient.DisconnectFromBroker();
|
|
|
|
|
|
delete mGPTimer;
|
|
delete mWatchdogTimer;
|
|
}
|
|
|
|
int COtarcikCan::Start()
|
|
{
|
|
mMainWindow.mCANbusSettingsPage->mProgramPtr = this;
|
|
mMainWindow.mDataLoggingSettingsPage->mProgramHandle = this;
|
|
mMainWindow.mGeneralStatusPage->mProgramPtr = this;
|
|
// mMainWindow.mGeneralStatusPage->mCPUInterface = &mCPUInterface; //JFM 2024-08-27 disable Axiomtek driver
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
mMainWindow.mGeneralStatusPage->SetCPUInterfaceHandle(&mCPUInterface);
|
|
#endif
|
|
mLANDevicesPresenceMonitor.mProgramPtr = this;
|
|
// mMainWindow.mCANWatchdogSettingsPage->mProgramHandle = this;
|
|
|
|
mMainWindow.show();
|
|
|
|
mSysLogger.Start("10.8.0.6",514);
|
|
CGeneralMessagesLogDispatcher::instance()->BindGuiPageHandle(mMainWindow.mGeneralStatusPage);
|
|
CGeneralMessagesLogDispatcher::instance()->Init(&mSysLogger);
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
mCPUInterface.Init();
|
|
#endif
|
|
|
|
if(mSystemConfig.LoadConfig() == RET_OK)
|
|
{
|
|
|
|
|
|
QList<CCANDeviceConfig*> *CANDeviceConfigList;
|
|
CANDeviceConfigList = mSystemConfig.GetCANDevicesConfigList();
|
|
if(CANDeviceConfigList != 0)
|
|
{
|
|
PopulateCANDevicesList(CANDeviceConfigList);
|
|
}
|
|
mMainWindow.mCANbusSettingsPage->SetDevicesList(&mCANDevicesList);
|
|
mMainWindow.mCANViewerPage->InitCANTable(&mCANDevicesList);
|
|
|
|
mCloudLoggingParamsList = mSystemConfig.GetCloudParams();
|
|
mMainWindow.mDataLoggingSettingsPage->SetCloudParams(mCloudLoggingParamsList);
|
|
for(int i = 0; i < mCloudLoggingParamsList->size(); i++)
|
|
{
|
|
if(mCloudLoggingParamsList->at(i)->mMQTTBrokerActive == true)
|
|
{
|
|
CMQTTClientWrapper *NewMQTTWrapper = new CMQTTClientWrapper;
|
|
NewMQTTWrapper->mProgramPtr = this;
|
|
NewMQTTWrapper->SetMQTTParams(mCloudLoggingParamsList->at(i));
|
|
NewMQTTWrapper->SetCANDevicesList(&mCANDevicesList);
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
NewMQTTWrapper->SetCPUInterface(&mCPUInterface);
|
|
#endif
|
|
NewMQTTWrapper->SetMQTTServerPresenceCANBit(mSystemConfig.GetDeviceDetectionConfig()->mMQTTDetectionCANStatusBit);
|
|
mCANBusMQTTClientList.append(NewMQTTWrapper);
|
|
}
|
|
}
|
|
mMQTTDataTransmitTimer->setInterval(mCloudLoggingParamsList->at(0)->mMQTTTransmitTimeout); //Use the first
|
|
|
|
mGeneralSystemParams = *mSystemConfig.GetGeneralSystemSettings();
|
|
mMainWindow.mDataLoggingSettingsPage->SetGeneralSettingsParams(&mGeneralSystemParams);
|
|
CGeneralMessagesLogDispatcher::instance()->SetLogVerbosities(mGeneralSystemParams.mLogFileVerbosity,mGeneralSystemParams.mLocalLogVerbosity);
|
|
|
|
mCPUWatchdogParams = *mSystemConfig.GetCPUWatchdogSettings();
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
mCPUInterface.SetWatchdogSettings(&mCPUWatchdogParams);
|
|
#endif
|
|
mMainWindow.mDataLoggingSettingsPage->SetCPUWatchdogSettings(mSystemConfig.GetCPUWatchdogSettings());
|
|
|
|
mDeviceDetectionConfigParams = *mSystemConfig.GetDeviceDetectionConfig();
|
|
mMainWindow.mDataLoggingSettingsPage->SetDeviceConfigSettings(mSystemConfig.GetDeviceDetectionConfig());
|
|
|
|
mInternetMonitor.Start(mSystemConfig.GetDeviceDetectionConfig()->mInternetDetectionCANStatusBit);
|
|
mLANDevicesPresenceMonitor.Start(mSystemConfig.GetDeviceDetectionConfig()->GetLANDevicesConfigList());
|
|
|
|
//mSystemConfig.mDeviceDetectionParams.SetCANPresenceMonitors(&mCANBusMQTTClient,&mLANDevicesPresenceMonitor,&mInternetMonitor); TODO: Add a bit for each MQTT client?
|
|
mSystemConfig.mDeviceDetectionParams.SetCANPresenceMonitors(mCANBusMQTTClientList.at(0),&mLANDevicesPresenceMonitor,&mInternetMonitor);
|
|
for(int i = 0; i < mCANDevicesList.size(); i++)
|
|
{
|
|
mCANDevicesList.at(i)->StartWatchdog(mSystemConfig.GetDeviceDetectionConfig());
|
|
}
|
|
// mMainWindow.mCANWatchdogSettingsPage->SetCANWatchdogConfig(mSystemConfig.GetCANWatchdogConfig());
|
|
|
|
// mGPTimer->setSingleShot(false);
|
|
// mGPTimer->start(5000);
|
|
|
|
|
|
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
mCPUInterface.StartCPUWatchdog();
|
|
mWatchdogTimer->start();
|
|
mMainWindow.mGeneralStatusPage->UpdateBoardStatusTimerExpired();
|
|
#endif
|
|
|
|
}
|
|
else
|
|
{
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
mCPUInterface.StartCPUWatchdog();
|
|
mWatchdogTimer->start();
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
|
|
CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Démarrage du logiciel OtarcikCAN"),"CPCANInterface");
|
|
|
|
for(int i = 0; i < mCANBusMQTTClientList.size(); i++)
|
|
{
|
|
mCANBusMQTTClientList.at(i)->StartMQTTClient();
|
|
}
|
|
mMQTTDataTransmitTimer->start();
|
|
mMainWindow.mCANbusSettingsPage->SetDevicesList(&mCANDevicesList);
|
|
|
|
connect(&mInternetMonitor,&CInternetMonitor::InternetStateChanged,mMainWindow.mGeneralStatusPage,&CGeneralStatusPage::InternetStatusChanged);
|
|
connect(&mInternetMonitor,&CInternetMonitor::InternetStateChanged,mMainWindow.mDataLoggingSettingsPage,&CLoggingSettingsPage::SetInternetPresenceStatus);
|
|
mInternetMonitor.Start(mSystemConfig.mDeviceDetectionParams.mInternetDetectionCANStatusBit);
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
int COtarcikCan::UpdateCANViewerDataRequest(QList<CCANMessage *> *MsgList)
|
|
{
|
|
return mMainWindow.mCANViewerPage->UpdateCANTable(MsgList);
|
|
|
|
}
|
|
|
|
|
|
//The device configuration has been modified directly in the master list
|
|
//Just save it and refresh display.
|
|
int COtarcikCan::SaveCANDevicesConfigRequest(QList<CCANDeviceConfig *> *DevicesConfigList)
|
|
{
|
|
|
|
if(DevicesConfigList == 0)
|
|
{
|
|
return RET_GENERAL_ERROR;
|
|
}
|
|
|
|
if(mSystemConfig.SetCANDevicesConfigList(DevicesConfigList) != RET_OK)
|
|
{
|
|
return RET_GENERAL_ERROR;
|
|
}
|
|
|
|
if(mSystemConfig.SaveConfig() == RET_OK)
|
|
{
|
|
//Config saving is successful. To apply changes we need to reload the devices.
|
|
//The easiest way is to delete everything and reload.
|
|
mMainWindow.mGeneralStatusPage->ClearCANModuleStatusTable();
|
|
PopulateCANDevicesList(DevicesConfigList);
|
|
mMainWindow.mCANbusSettingsPage->SetDevicesList(&mCANDevicesList);
|
|
mMainWindow.mCANViewerPage->InitCANTable(&mCANDevicesList);
|
|
|
|
}
|
|
else
|
|
{
|
|
return RET_GENERAL_ERROR;
|
|
}
|
|
|
|
return RET_OK;
|
|
}
|
|
|
|
|
|
int COtarcikCan::PopulateCANDevicesList(QList<CCANDeviceConfig *> *CANDeviceConfigList)
|
|
{
|
|
if(CANDeviceConfigList == 0)
|
|
{
|
|
return RET_GENERAL_ERROR;
|
|
}
|
|
|
|
while(mCANDevicesList.size() != 0)
|
|
{
|
|
delete mCANDevicesList.takeFirst();
|
|
}
|
|
|
|
for(int i = 0; i < CANDeviceConfigList->size(); i++)
|
|
{
|
|
CCANDevice *NewDevice = new CCANDevice(*CANDeviceConfigList->at(i),mSystemConfig.mCloudLoggingParamsList[0]->mMQTTTopicPrefix); //TODO fix the cloud
|
|
NewDevice->mProgramPtr = this;
|
|
NewDevice->Init();
|
|
mCANDevicesList.append(NewDevice);
|
|
}
|
|
|
|
|
|
|
|
return RET_OK;
|
|
}
|
|
|
|
int COtarcikCan::SaveCloudLoggingConfigRequest(QList<CCloudParams *> *CloudParams)
|
|
{
|
|
if(CloudParams == 0)
|
|
{
|
|
return RET_GENERAL_ERROR;
|
|
}
|
|
|
|
|
|
mSystemConfig.SetCloudParamsList(CloudParams);
|
|
mCloudLoggingParamsList = mSystemConfig.GetCloudParams();
|
|
|
|
while(!mCANBusMQTTClientList.isEmpty())
|
|
{
|
|
mCANBusMQTTClientList.first()->DisconnectFromBroker();
|
|
delete mCANBusMQTTClientList.takeFirst();
|
|
}
|
|
for(int i = 0; i < CloudParams->size(); i++)
|
|
{
|
|
if(mCloudLoggingParamsList->at(i)->mMQTTBrokerActive == true)
|
|
{
|
|
CMQTTClientWrapper *NewMQTTWrapper = new CMQTTClientWrapper;
|
|
NewMQTTWrapper->mProgramPtr = this;
|
|
NewMQTTWrapper->SetMQTTParams(CloudParams->at(i));
|
|
NewMQTTWrapper->SetCANDevicesList(&mCANDevicesList);
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
NewMQTTWrapper->SetCPUInterface(&mCPUInterface);
|
|
#endif
|
|
NewMQTTWrapper->SetMQTTServerPresenceCANBit(mSystemConfig.GetDeviceDetectionConfig()->mMQTTDetectionCANStatusBit);
|
|
mCANBusMQTTClientList.append(NewMQTTWrapper);
|
|
|
|
NewMQTTWrapper->StartMQTTClient();
|
|
}
|
|
}
|
|
mSystemConfig.mDeviceDetectionParams.SetCANPresenceMonitors(mCANBusMQTTClientList.at(0),&mLANDevicesPresenceMonitor,&mInternetMonitor);
|
|
//mCANBusMQTTClient.SetMQTTParams(mCloudLoggingParamsList->at(0)); //TODO: Fix
|
|
|
|
if(mSystemConfig.SaveConfig() == RET_OK)
|
|
{
|
|
|
|
|
|
//TODO: Reset the MQTT driver with new parameters.
|
|
}
|
|
else
|
|
{
|
|
return RET_GENERAL_ERROR;
|
|
}
|
|
|
|
return RET_OK;
|
|
}
|
|
|
|
int COtarcikCan::SaveGeneralParametersSettingsRequest(CGeneralSystemParams *GeneralParams)
|
|
{
|
|
mGeneralSystemParams = *GeneralParams;
|
|
mSystemConfig.SetGeneralSystemParams(&mGeneralSystemParams);
|
|
if(mSystemConfig.SaveConfig() == RET_OK)
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
return RET_GENERAL_ERROR;
|
|
}
|
|
CGeneralMessagesLogDispatcher::instance()->SetLogVerbosities(mGeneralSystemParams.mLogFileVerbosity,mGeneralSystemParams.mLocalLogVerbosity);
|
|
|
|
return RET_OK;
|
|
}
|
|
|
|
int COtarcikCan::SaveCPUWatchdogSettingsRequest(CCPUWatchdogConfig *CPUWatchdogParams)
|
|
{
|
|
mCPUWatchdogParams = *CPUWatchdogParams;
|
|
mSystemConfig.SetCPUWatchdogPArams(&mCPUWatchdogParams);
|
|
mSystemConfig.SaveConfig();
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
mCPUInterface.SetWatchdogSettings(&mCPUWatchdogParams);
|
|
mCPUInterface.StopCPUWatchdog();
|
|
if(mCPUWatchdogParams.mWatchdogEnabled == true)
|
|
{
|
|
mCPUInterface.StartCPUWatchdog();
|
|
}
|
|
#endif
|
|
return RET_OK;
|
|
}
|
|
|
|
int COtarcikCan::SaveDeviceDetectionSettingsRequest(CDeviceDetectionConfig *DeviceDetectconfig)
|
|
{
|
|
mDeviceDetectionConfigParams = *DeviceDetectconfig;
|
|
mSystemConfig.SetDeviceDetectionConfig(DeviceDetectconfig);
|
|
mSystemConfig.SaveConfig();
|
|
mLANDevicesPresenceMonitor.Stop();
|
|
mLANDevicesPresenceMonitor.Start(DeviceDetectconfig->GetLANDevicesConfigList());
|
|
mInternetMonitor.UpdateCANReportingBit(DeviceDetectconfig->mInternetDetectionCANStatusBit);
|
|
for(int i = 0; i < mCANBusMQTTClientList.size(); i++)
|
|
{
|
|
mCANBusMQTTClientList.at(i)->SetMQTTServerPresenceCANBit(DeviceDetectconfig->mMQTTDetectionCANStatusBit);
|
|
}
|
|
// mCANBusMQTTClient.SetMQTTServerPresenceCANBit(DeviceDetectconfig->mMQTTDetectionCANStatusBit);
|
|
return RET_OK;
|
|
}
|
|
|
|
void COtarcikCan::GPTimerExpired()
|
|
{
|
|
// mCANBusMQTTClient.SendMQTTTestMessage();
|
|
}
|
|
|
|
int COtarcikCan::SetCANConnectionStatusRequest(bool Connected)
|
|
{
|
|
return mMainWindow.mGeneralStatusPage->SetCANConnectionStatus(Connected);
|
|
}
|
|
|
|
int COtarcikCan::SetMQTTConnectionSatusRequest(bool Connected)
|
|
{
|
|
QString MQTTStates("Clients MQTT:\n");
|
|
for(int i = 0; i < mCANBusMQTTClientList.size(); i++)
|
|
{
|
|
CMQTTClientWrapper *Wrapper = mCANBusMQTTClientList.at(i);
|
|
MQTTStates.append(Wrapper->GetMQTTClientConnectionState());
|
|
MQTTStates.append("\n");
|
|
|
|
}
|
|
mMainWindow.mDataLoggingSettingsPage->SetMQTTPresenceStatus(Connected);
|
|
mMainWindow.mGeneralStatusPage->SetMQTTConnectionStatus(MQTTStates);
|
|
|
|
return RET_OK;
|
|
}
|
|
|
|
int COtarcikCan::UpdateCANModuleStatusRequest(QString ModuleName, QString ModuleStatus, QString Buffer)
|
|
{
|
|
return mMainWindow.mGeneralStatusPage->UpdateCANModuleStatus(ModuleName,ModuleStatus,Buffer);
|
|
}
|
|
|
|
int COtarcikCan::UpdateMQTTBufferingStatusRequest(QString BufferingMode, QString FIFOSize, QString RemainingTime)
|
|
{
|
|
mMainWindow.mGeneralStatusPage->UpdateMQTTBufferingStatus(BufferingMode,FIFOSize,RemainingTime);
|
|
return RET_OK;
|
|
}
|
|
|
|
int COtarcikCan::UpdateLANDevicesPresenceStatusRequest(QList<bool> LanDevicesStatus)
|
|
{
|
|
mMainWindow.mDataLoggingSettingsPage->SetLANDevicesPresenceStatus(LanDevicesStatus);
|
|
return RET_OK;
|
|
}
|
|
|
|
int COtarcikCan::SaveCANWatchdogSettingsRequest(CCANWatchdogConfig *CANWatchdogConfig)
|
|
{
|
|
mSystemConfig.SetCANWatchdogConfig(CANWatchdogConfig);
|
|
return mSystemConfig.SaveConfig();
|
|
}
|
|
|
|
void COtarcikCan::MQTTDataTransmitTimerExpired()
|
|
{
|
|
QList<CMQTTMessage> *MQTTMsgList;
|
|
for(int i = 0; i< mCANDevicesList.size(); i++)
|
|
{
|
|
MQTTMsgList = mCANDevicesList.at(i)->GetMQTTMessagesList();
|
|
for(int i = 0; i < mCANBusMQTTClientList.size(); i++)
|
|
{
|
|
mCANBusMQTTClientList.at(i)->SendMQTTMessages(MQTTMsgList);
|
|
}
|
|
}
|
|
}
|
|
|
|
void COtarcikCan::WatchdogUpdateTimerExpired() //Time to kick the CPU watchdog
|
|
{
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
mCPUInterface.KickCPUWatchdog();
|
|
#endif
|
|
}
|
|
|
|
void COtarcikCan::QuitApplicationRequest()
|
|
{
|
|
qDebug("Quit app request");
|
|
mWatchdogTimer->stop();
|
|
#ifdef ENABLE_CHIPSET_DRIVER
|
|
mCPUInterface.StopCPUWatchdog();
|
|
mCPUInterface.DeInit();
|
|
#endif
|
|
|
|
QCoreApplication::exit(69);
|
|
}
|
|
|
|
#ifdef ENABLE_DEVELOPMENT_DEBUG_TOOLS
|
|
|
|
int COtarcikCan::ForceMQTTDisconnect(bool Disconnect)
|
|
{
|
|
// mCANBusMQTTClient.ForceMQTTClientDisconnection(Disconnect);
|
|
}
|
|
|
|
#endif
|