jfmartel/Masterctrl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ajouté console audio + chalet dev LTE

Browse Source
This commit is contained in:
jfmartel 2025-07-10 18:11:27 -04:00
parent bf31303763
commit b56ee96941
16 changed files with 577 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
MasterCtrl.pro
View File

@ -58,7 +58,9 @@ HEADERS += \
Sources/NetworkCommIFSurrogate.h \
Sources/LoraModuleInterface/LoraModuleInterfaceData.h \
Sources/LoraModuleInterface/LoraModuleInterfaceInterface.h \
Sources/Chalet/ChaletDevice.h
Sources/Chalet/ChaletDevice.h \
Sources/AvReceiver/AvReceiverConsoleInterface.h \
Sources/Chalet/ChaletHomeServerInterface.h
SOURCES += \
Sources/Chalet/ChaletData.cpp \
@ -109,7 +111,9 @@ SOURCES += \
Sources/NetworkCommIFSurrogate.cpp \
Sources/LoraModuleInterface/LoraModuleInterfaceData.cpp \
Sources/LoraModuleInterface/LoraModuleInterfaceInterface.cpp \
Sources/Chalet/ChaletDevice.cpp
Sources/Chalet/ChaletDevice.cpp \
Sources/AvReceiver/AvReceiverConsoleInterface.cpp \
Sources/Chalet/ChaletHomeServerInterface.cpp
DEFINES -= Q_OS_UNIX

74
Sources/AvReceiver/AVReceiverDevice.cpp
View File

@ -400,6 +400,24 @@ QByteArray CAVReceiverDevice::GetReceiverStatus()
return StatusArray;
}
QByteArray CAVReceiverDevice::GetReceiverStatusForConsole()
{
QByteArray StatusArray;
StatusArray = mReceiverStatus.ToConsoleStatusByteArray();
StatusArray.append(mZone2Status.ToConsoleStatusByteArray());
if(mReceiverStatus.mSyncZonesVolumes == true &&
( (mReceiverStatus.mMainVolume != mLastMainZoneVolume) ||
(mReceiverStatus.mMainVolume != mZone2Status.mMainVolume)))
{
SetZone2Volume(mReceiverStatus.mMainVolume);
}
mLastMainZoneVolume = mReceiverStatus.mMainVolume;
return StatusArray;
}
int CAVReceiverDevice::SelectScene(char Zone, char Scene)
{
QString Cmd;
@ -469,4 +487,60 @@ int CAVReceiverDevice::SetSyncZ2withZ1(bool Sync)
SetZone2Volume(mReceiverStatus.mMainVolume);
}
// qDebug("Sync Z2 with Z1: %d",Sync);
return RET_OK;
}
int CAVReceiverDevice::IncrementMainVolume(bool Increment)
{
float NewVolume = mReceiverStatus.mMainVolume;
if(Increment)
{
if(NewVolume >= RECEIVER_MAXIMUM_VOLUME)
{
return RET_OK;
}
NewVolume += RECEIVER_VOLUME_INCREMENT_STEP;
SetMainVolume(NewVolume);
}
else
{
if((NewVolume - RECEIVER_VOLUME_INCREMENT_STEP) < RECEIVER_MINIMUM_VOLUME)
{
return RET_OK;
}
NewVolume -= RECEIVER_VOLUME_INCREMENT_STEP;
SetMainVolume(NewVolume);
}
mReceiverStatus.mMainVolume = NewVolume;
return RET_OK;
}
int CAVReceiverDevice::IncrementZ2Volume(bool Increment)
{
float NewVolume = mZone2Status.mMainVolume;
if(Increment)
{
if(NewVolume >= RECEIVER_MAXIMUM_VOLUME)
{
return RET_OK;
}
NewVolume += RECEIVER_VOLUME_INCREMENT_STEP;
SetZone2Volume(NewVolume);
}
else
{
if((NewVolume - RECEIVER_VOLUME_INCREMENT_STEP) < RECEIVER_MINIMUM_VOLUME)
{
return RET_OK;
}
NewVolume -= RECEIVER_VOLUME_INCREMENT_STEP;
SetZone2Volume(NewVolume);
}
mZone2Status.mMainVolume = NewVolume;
return RET_OK;
}

6
Sources/AvReceiver/AVReceiverDevice.h
View File

@ -11,6 +11,9 @@
#define RECEIVER_PORT 50000
#define RECEIVER_IP_ADDRESS "192.168.50.101"
#define RECEIVER_STATE_UPDATE_TIMEOUT 3000
#define RECEIVER_MINIMUM_VOLUME -80.5
#define RECEIVER_MAXIMUM_VOLUME 16.5
#define RECEIVER_VOLUME_INCREMENT_STEP 0.5
enum eReceiverSpkStatus
{
@ -89,7 +92,10 @@ public:
int SetZone2Volume(float Volume);
int SetZone2Input(QString InputString);
int SetSyncZ2withZ1(bool Sync);
int IncrementMainVolume(bool Increment);
int IncrementZ2Volume(bool Increment);
QByteArray GetReceiverStatus();
QByteArray GetReceiverStatusForConsole();
private:
QTcpSocket *mReceiverSocket;

132
Sources/AvReceiver/AvReceiverConsoleInterface.cpp Normal file
View File

@ -0,0 +1,132 @@
#include "AvReceiverConsoleInterface.h"
#include "ProtocolDefs.h"
#include "AVReceiverDevice.h"
#include <QDataStream>
CAvReceiverConsoleInterface::CAvReceiverConsoleInterface(int Address, CAbstractNetworkCommIF *NetworkInterface , CAVReceiverDevice *DevicePtr):
CNetworkDevice(ID_AVRECEIVER_INTERFACE,Address,NetworkInterface)
{
mAvReceiverDevice = DevicePtr;
}
int CAvReceiverConsoleInterface::NewDeviceFrameReceived(int DeviceID, int DeviceAddress, int MessageID, int DataSize, QByteArray Data)
{
Q_UNUSED(DeviceID)
Q_UNUSED(DeviceAddress)
Q_UNUSED(DataSize)
Q_UNUSED(Data)
switch(MessageID)
{
case AV_RECEIVER_INTERFACE_ACK:
{
break;
}
case AV_RECEIVER_INTERFACE_GENERAL_STATUS_REQUEST:
{
QByteArray data = mAvReceiverDevice->GetReceiverStatusForConsole();
mNetworkInterfacePtr->SendNetworkMessage(ID_AVRECEIVER_CONSOLE_INTERFACE,mDeviceAddress,AV_RECEIVER_INTERFACE_GENERAL_STATUS_RESPONSE,data.size(),&data);
break;
}
case AV_RECEIVER_INTERFACE_SET_MAIN_POWER_REQUEST:
{
bool SpkStatus = (bool)Data[0];
mAvReceiverDevice->SetMainZone(SpkStatus);
break;
}
case AV_RECEIVER_INTERFACE_SET_ZONE2_REQUEST:
{
bool SpkStatus = (bool)Data[0];
mAvReceiverDevice->SetZone2(SpkStatus);
break;
}
case AV_RECEIVER_INTERFACE_SET_MAIN_ZONE_REQUEST:
{
bool SpkStatus = (bool)Data[0];
mAvReceiverDevice->SetMainZone(SpkStatus);
break;
}
case AV_RECEIVER_INTERFACE_SET_SPEAKERS_REQUEST:
{
break;
}
case AV_RECEIVER_INTERFACE_SEND_DIRECT_CMD_REQUEST:
{
break;
}
case AV_RECEIVER_INTERFACE_SELECT_SCENE_REQUEST:
{
mAvReceiverDevice->SelectScene(Data[0],Data[1]);
break;
}
case AV_RECEIVER_INTERFACE_SET_MAIN_VOLUME_REQUEST:
{
char VolumeData;
VolumeData = Data[0];
float Volume = (VolumeData/2) - 80.5;
mAvReceiverDevice->SetMainVolume(Volume);
break;
}
case AV_RECEIVER_INTERFACE_SET_ZONE2_VOLUME_REQUEST:
{
char VolumeData;
VolumeData = Data[0];
float Volume = (VolumeData/2) - 80.5;
qDebug("Volume 2 %d, %f",VolumeData, Volume);
mAvReceiverDevice->SetZone2Volume(Volume);
break;
}
case AV_RECEIVER_INTERFACE_SET_ZONE2_INPUT_REQUEST:
{
QString Source(Data);
mAvReceiverDevice->SetZone2Input(Source);
break;
}
case AV_RECEIVER_INTERFACE_SET_SYNC_Z2_WITH_Z1_REQUEST:
{
bool Sync = (bool)Data[0];
mAvReceiverDevice->SetSyncZ2withZ1(Sync);
break;
}
case AV_RECEIVER_INTERFACE_INCREMENT_MAIN_VOLUME_REQUEST:
{
bool Increment = (bool)Data[0];
mAvReceiverDevice->IncrementMainVolume(Increment);
break;
}
case AV_RECEIVER_INTERFACE_INCREMENT_Z2_VOLUME_REQUEST:
{
bool Increment = (bool)Data[0];
mAvReceiverDevice->IncrementZ2Volume(Increment);
break;
}
case AV_RECEIVER_INTERFACE_GENERAL_STATUS_RESPONSE:
case AV_RECEIVER_INTERFACE_SET_MAIN_POWER_RESPONSE:
case AV_RECEIVER_INTERFACE_SET_ZONE2_RESPONSE:
case AV_RECEIVER_INTERFACE_SEND_DIRECT_CMD_RESPONSE:
case AV_RECEIVER_INTERFACE_SET_SPEAKERS_RESPONSE:
case AV_RECEIVER_INTERFACE_SET_MAIN_ZONE_RESPONSE:
case AV_RECEIVER_INTERFACE_SELECT_SCENE_RESPONSE:
case AV_RECEIVER_INTERFACE_SET_MAIN_VOLUME_RESPONSE:
case AV_RECEIVER_INTERFACE_SET_ZONE2_VOLUME_RESPONSE:
case AV_RECEIVER_INTERFACE_SET_ZONE2_INPUT_RESPONSE:
case AV_RECEIVER_INTERFACE_SET_SYNC_Z2_WITH_Z1_RESPONSE:
default:
{
qDebug("Received invalid msg from Sprinkler Interface");
break;
}
}
return 0;
}

19
Sources/AvReceiver/AvReceiverConsoleInterface.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef AVRECEIVERCONSOLEINTERFACE_H
#define AVRECEIVERCONSOLEINTERFACE_H
#include "NetworkDevice.h"
class CAVReceiverDevice;
class CAvReceiverConsoleInterface: public QObject, public CNetworkDevice
{
Q_OBJECT
public:
CAvReceiverConsoleInterface(int Address, CAbstractNetworkCommIF *NetworkInterface, CAVReceiverDevice *DevicePtr );
virtual int NewDeviceFrameReceived(int DeviceID, int DeviceAddress, int MessageID, int DataSize, QByteArray Data);
private:
CAVReceiverDevice *mAvReceiverDevice;
};
#endif // AVRECEIVERCONSOLEINTERFACE_H

128
Sources/AvReceiver/AvReceiverData.cpp
View File

@ -13,21 +13,67 @@ QByteArray CAvReceiverMainStatus::ToByteArray()
QByteArray Output;
Output.clear();
QDataStream Strm(&Output,QIODevice::WriteOnly);
// QDataStream Strm(&Output,QIODevice::WriteOnly);
Strm << mMainPwrStatus;
Strm << mMainSleepStatus;
Strm << mMainVolume;
Strm << mIsMute;
Strm << mInput;
Strm << mProgram;
//// Strm << mMainPwrStatus;
//// Strm << mMainSleepStatus;
//// Strm << mMainVolume;
//// Strm << mIsMute;
//// Strm << mInput;
//// Strm << mProgram;
Strm << mDataValid;
Strm << mReceiverOnline;
Strm << mSyncZonesVolumes;
//// Strm << mDataValid;
//// Strm << mReceiverOnline;
//// Strm << mSyncZonesVolumes;
}
QByteArray CAvReceiverMainStatus::ToConsoleStatusByteArray()
{
QByteArray Output;
if(mMainPwrStatus == true) //0
Output.append(0x01);
else
Output.append((char)0x00);
if(mMainSleepStatus == true) //1
Output.append(0x01);
else
Output.append((char)0x00);
// int Volume = ((mMainVolume + 80.5) * 2);
// char VolArray[4];
// memcpy(VolArray,&Volume,4); //2-5
// Output.append(VolArray,4);
char Volume = ((mMainVolume + 80.5) * 2); //2
Output.append(Volume);
if(mIsMute == true) //3
Output.append(0x01);
else
Output.append((char)0x00);
if(mDataValid == true) //4
Output.append(0x01);
else
Output.append((char)0x00);
if(mReceiverOnline == true) //5
Output.append(0x01);
else
Output.append((char)0x00);
if(mSyncZonesVolumes == true) //6
Output.append(0x01);
else
Output.append((char)0x00);
return Output;
}
int CAvReceiverMainStatus::FromByteArray(QByteArray Data)
@ -46,9 +92,69 @@ int CAvReceiverMainStatus::FromByteArray(QByteArray Data)
Strm >> mReceiverOnline;
Strm >> mSyncZonesVolumes;
return RET_OK;
}
int CAvReceiverMainStatus::FromConsoleStatusByteArray(QByteArray Data)
{
if(Data.at(0) == 1)
mMainPwrStatus = true;
else
mMainPwrStatus = false;
if(Data.at(1) == 1)
mMainSleepStatus = true;
else
mMainSleepStatus = false;
char VolArray[4];
VolArray[0] = Data[2];
VolArray[1] = Data[3];
VolArray[2] = Data[4];
VolArray[3] = Data[5];
memcpy(&mMainVolume,VolArray,4);
if(Data.at(6) == 1)
mIsMute = true;
else
mIsMute = false;
// char String[50];
// for(int i= 0; i < 50; i++)
// {
// String[i] = Data[i+7];
// }
// mInput.clear();
// mInput.append(String);
// for(int i= 0; i < 50; i++)
// {
// String[i] = Data[i+57];
// }
// mProgram.clear();
// mProgram.append(String);
if(Data.at(7) == 1)
mDataValid = true;
else
mDataValid = false;
if(Data.at(8) == 1)
mReceiverOnline = true;
else
mReceiverOnline = false;
if(Data.at(9) == 1)
mSyncZonesVolumes = true;
else
mSyncZonesVolumes = false;
return RET_OK;
}
QDataStream &operator<<(QDataStream &out, const CAvReceiverMainStatus &source)
{
out << source.mMainPwrStatus

2
Sources/AvReceiver/AvReceiverData.h
View File

@ -16,7 +16,9 @@ class CAvReceiverMainStatus
public:
QByteArray ToByteArray();
QByteArray ToConsoleStatusByteArray();
int FromByteArray(QByteArray Data);
int FromConsoleStatusByteArray(QByteArray Data);
CAvReceiverMainStatus();

20
Sources/Chalet/ChaletDevice.cpp
View File

@ -23,6 +23,7 @@ CChaletDevice::CChaletDevice(int Address, CAbstractNetworkCommIF *NetworkInterfa
mDeviceWiFiParameters.fill(0xFF);
mDeviceFirmwareVersion.fill(0xFF);
mHomeServerInterface = 0;
ResetCommStats();
}
@ -30,13 +31,21 @@ CChaletDevice::CChaletDevice(int Address, CAbstractNetworkCommIF *NetworkInterfa
CChaletDevice::~CChaletDevice()
{
delete mChaletStatusTimer;
if(mHomeServerInterface != 0)
{
delete mHomeServerInterface;
}
}
int CChaletDevice::Start()
{
ScheduleChaletStatusRequest();
mChaletStatusTimer->start(1000);
mThingsBoardInterface.RegisterThingsboardRPC();
// mThingsBoardInterface.RegisterThingsboardRPC();
if(mHomeServerInterface != 0)
{
mHomeServerInterface->Start();
}
return RET_OK;
}
@ -122,7 +131,12 @@ int CChaletDevice::NewDeviceFrameReceived(int DeviceID, int DeviceAddress, int M
// mThingsBoardInterface.UpdateChaletVoltage(mChaletMainStatus.mBatteryVoltage);
//mThingsBoardInterface.UpdateChaletData(mChaletMainStatus.mInverterRelayStatus,mChaletMainStatus.mWiFiModuleStatus,mChaletMainStatus.mCurrentSensorStatus,mChaletMainStatus.mBatteryVoltage,mChaletMainStatus.mBatteryCurrent,mChaletMainStatus.mBatterySOC,mChaletMainStatus.mIsOnline);
mThingsBoardInterface.UpdateChaletData(&mChaletMainStatus);
//mThingsBoardInterface.UpdateChaletData(&mChaletMainStatus);
if(mHomeServerInterface != 0)
{
mHomeServerInterface->UpdateChaletData(&mChaletMainStatus);
}
// mChaletModbusRepo.WriteSingleReg(CHALET_MODBUS_ONLINE_STATE_REG,(quint16)mChaletMainStatus.mIsOnline);
@ -430,7 +444,7 @@ int CChaletDevice::CmdResponseReceived(int CmdID)
int CChaletDevice::ScheduleChaletStatusRequest()
{
return ScheduleChaletCommand(CHALET_GENERAL_STATUS_REQUEST,0,QByteArray());
ScheduleChaletCommand(CHALET_GENERAL_STATUS_REQUEST,0,QByteArray());
}
int CChaletDevice::ScheduleChaletCommand(int CmdID, int DataSize, QByteArray Data)

2
Sources/Chalet/ChaletDevice.h
View File

@ -15,6 +15,7 @@
#include "ThingsBoardInterface.h"
#include "ChaletModbusServer.h"
#include "ModbusRepository.h"
#include "ChaletHomeServerInterface.h"
#define LORA_MAGIC_WORD 0xBAADCAFE
@ -52,6 +53,7 @@ public:
QList<CChaletNetworkMessage> mPendingNetworkMsgList;
CChaletDataLogger mChaletDataLogger;
CChaletJFUbidotsInterface *mJFUbidotsInterface;
CChaletHomeServerInterface *mHomeServerInterface;
unsigned long long int mNbLostRequest, mTotalNbRequest;
float mLostRequestPercentage;

123
Sources/Chalet/ChaletHomeServerInterface.cpp Normal file
View File

@ -0,0 +1,123 @@
#include "ChaletHomeServerInterface.h"
CChaletHomeServerInterface::CChaletHomeServerInterface()
{
mConnectionTimer = new QTimer;
connect(&mMQTTClient,&QMqttClient::stateChanged,this,&CChaletHomeServerInterface::StateChanged);
connect(&mMQTTClient,&QMqttClient::errorChanged,this,&CChaletHomeServerInterface::MQTTClientError);
connect(mConnectionTimer,&QTimer::timeout,this,&CChaletHomeServerInterface::ConnectionTimerExpired);
mConnectionTimer->setSingleShot(true);
}
CChaletHomeServerInterface::~CChaletHomeServerInterface()
{
DisconnectFromServer();
delete mConnectionTimer;
}
int CChaletHomeServerInterface::Start()
{
mConnectionTimer->start(1000);
return RET_OK;
}
int CChaletHomeServerInterface::UpdateChaletData(CChaletMainStatus *Data)
{
QByteArray JsonByteArray;
qint64 TimeStamp = QDateTime::currentDateTime().toMSecsSinceEpoch()/1000;
JsonByteArray.append(QString("{\"timestamp\":%1, ").arg(TimeStamp));
JsonByteArray.append("\"Bat_Voltage\":");
JsonByteArray.append((QString("%1, ").arg(Data->mBatteryVoltage)).toUtf8().data());
JsonByteArray.append("\"Bat_SOC\":");
JsonByteArray.append((QString("%1, ").arg(Data->mBatterySOC)).toUtf8().data());
JsonByteArray.append("\"WiFi_State\":");
JsonByteArray.append((QString("%1, ").arg(Data->mWiFiModuleStatus)).toUtf8().data());
JsonByteArray.append("\"CurrentSensor_State\":");
JsonByteArray.append((QString("%1, ").arg(Data->mCurrentSensorStatus)).toUtf8().data());
JsonByteArray.append("\"Bat_Current\":");
JsonByteArray.append((QString("%1, ").arg(Data->mBatteryCurrent)).toUtf8().data());
JsonByteArray.append("\"LoRa_State\":");
JsonByteArray.append((QString("%1, ").arg(Data->mIsOnline)).toUtf8().data());
JsonByteArray.append("\"Inverter_State\":");
JsonByteArray.append((QString("%1, ").arg(Data->mInverterRelayStatus)).toUtf8().data());
JsonByteArray.append("\"Temperature_Sensor\":");
JsonByteArray.append((QString("%1}").arg(Data->mChaletTemperature)).toUtf8().data());
// qDebug("%s",qPrintable(JsonByteArray));
mMQTTClient.publish(QString("chalet/telemetry"),JsonByteArray,0,true);
return RET_OK;
}
int CChaletHomeServerInterface::ConnectToServer()
{
//Setup the client before connecting.
mMQTTClient.setAutoKeepAlive(true);
mMQTTClient.setClientId("LeChalet");
mMQTTClient.setHostname(MQTT_SERVER_IP);
mMQTTClient.setPort(MQTT_SERVER_PORT);
mMQTTClient.setPassword(MQTT_SERVER_PWD);
mMQTTClient.setUsername(MQTT_SERVER_LOGIN);
qDebug("Trying to connect Chalet MQTT client...");
mMQTTClient.connectToHost();
return RET_OK;
}
int CChaletHomeServerInterface::DisconnectFromServer()
{
mMQTTClient.disconnectFromHost();
return RET_OK;
}
void CChaletHomeServerInterface::MQTTClientError(QMqttClient::ClientError error)
{
qDebug(qPrintable(QString("Erreur du client Chalet MQTT: %1").arg(error)));
}
void CChaletHomeServerInterface::StateChanged()
{
switch(mMQTTClient.state())
{
case QMqttClient::Disconnected:
{
qDebug("Chalet MQTT client disconnected");
mConnectionTimer->start(1000);
mConnectionTimer->stop();
break;
}
case QMqttClient::Connected:
{
qDebug("Chalet MQTT client connected!");
mConnectionTimer->stop();
break;
}
case QMqttClient::Connecting:
{
mConnectionTimer->start(20000);
qDebug("Chalet MQTT client is connecting");
break;
}
}
}
void CChaletHomeServerInterface::ConnectionTimerExpired()
{
qDebug("connection timer expired");
DisconnectFromServer();
ConnectToServer();
mConnectionTimer->start(15000);
}

41
Sources/Chalet/ChaletHomeServerInterface.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef CHALETHOMESERVERINTERFACE_H
#define CHALETHOMESERVERINTERFACE_H
#include <QtMqtt/QtMqtt>
#include <QMqttClient>
#include "ChaletData.h"
#include <QTimer>
#define MQTT_SERVER_IP "192.168.51.32"
#define MQTT_SERVER_PORT 1883
#define MQTT_SERVER_LOGIN "jfmartel"
#define MQTT_SERVER_PWD "roland"
class CChaletHomeServerInterface : public QObject
{
Q_OBJECT
public:
CChaletHomeServerInterface();
~CChaletHomeServerInterface();
int UpdateChaletData(CChaletMainStatus *Data);
int ConnectToServer();
int DisconnectFromServer();
int Start();
QMqttClient mMQTTClient;
QTimer *mConnectionTimer;
public slots:
void MQTTClientError(QMqttClient::ClientError error);
// void MQTTMessageSent(qint32 MsgID);
// void MQTTMessageStatusChanged(qint32 id, QMqtt::MessageStatus s, const QMqttMessageStatusProperties &properties);
void StateChanged();
void ConnectionTimerExpired();
};
#endif // CHALETHOMESERVERINTERFACE_H

14
Sources/EthernetNetworkServer.cpp
View File

@ -236,6 +236,20 @@ void CEthernetNetworkServer::DeviceSocketDataAvail()
}
break;
}
case ID_AVRECEIVER_CONSOLE_INTERFACE:
{
if(mDevicesMgrHandle->CreateNewAVReceiverConsoleInterface(DeviceAddress,(CAbstractNetworkCommIF*)NetworkIF) == RET_OK)
{
Result = RES_CREATION_SUCCESS;
qDebug("Created new AV Receiver Console Interface");
}
else
{
Result = RES_CREATION_FAILED;
qDebug("Could not create AV Receiver Interface in ethernet server");
}
break;
}
default:
{
Result = RES_CREATION_UNKNOWN_DEVICE;

2
Sources/MasterCtrl.cpp
View File

@ -1,6 +1,7 @@
#include "MasterCtrl.h"
#include <QApplication>
#include "EthernetNetworkCommIF.h"
#include "ChaletHomeServerInterface.h"
// #include <QByteArray>
//#include <QBuffer>
@ -146,6 +147,7 @@ void CMasterCtrl::Start()
mChaletLoraDevice->Start();
mChaletLTEDevice->mHomeServerInterface = new CChaletHomeServerInterface;
mChaletLTEDevice->mChaletName = "Chalet LTE";
mChaletLTEDevice->Start();

13
Sources/NetworkDevicesMgr.cpp
View File

@ -138,6 +138,19 @@ int CNetworkDevicesMgr::BindNetworkChaletDevice(int Address, CAbstractNetworkCom
return RET_OK;
}
int CNetworkDevicesMgr::CreateNewAVReceiverConsoleInterface(int Address, CAbstractNetworkCommIF *NetworkIF)
{
if(mAvReceiverDevice == 0)
{
return RET_ERROR;
}
CAvReceiverConsoleInterface *AvReceiverConsoleInterface = new CAvReceiverConsoleInterface(Address,NetworkIF,mAvReceiverDevice);
mNetworkDevicesList.append((CNetworkDevice*)AvReceiverConsoleInterface);
return RET_OK;
}
void CNetworkDevicesMgr::EthernetNetworkDeviceDisconnected(CNetworkDevice *Device)
{
qDebug("Device disconnected. ID: %d, Address: %d",Device->GetDeviceID(),Device->GetDeviceAddress());

3
Sources/NetworkDevicesMgr.h
View File

@ -10,6 +10,7 @@
#include "ChaletInterface.h"
#include "IspindelInterface.h"
#include "LoraModuleInterfaceInterface.h"
#include "AvReceiverConsoleInterface.h"
#include "QList"
#include <QObject>
@ -23,6 +24,7 @@ class CChaletDevice;
class CIspindelDevice;
class CLoraModuleInterface;
class CNetworkDevicesMgr: public QObject
{
Q_OBJECT
@ -41,6 +43,7 @@ public:
int CreateNewIspindleInterface(int Address, CAbstractNetworkCommIF *NetworkIF);
int CreateNewLoraInterfaceInterface(int Address, CAbstractNetworkCommIF *NetworkIF);
int BindNetworkChaletDevice(int Address, CAbstractNetworkCommIF *NetworkIF);
int CreateNewAVReceiverConsoleInterface(int Address, CAbstractNetworkCommIF *NetworkIF);
int FindDeviceByPtr(CNetworkDevice *Device);
CNetworkDevice *GetDevice(int DeviceID, int Address);

6
Sources/ProtocolDefs.h
View File

@ -63,6 +63,8 @@ enum DEVICES_IDS
ID_ISPINDEL_INTERFACE,
ID_LORA_INTERFACE_DEVICE,
ID_LORA_INTERFACE_INTERFACE,
ID_AVRECEIVER_CONSOLE_INTERFACE,
ID_AVRECEIVER_CONSOLE_DEVICE,
ID_NB_DEVICE_ID
};
@ -256,6 +258,10 @@ enum AV_RECEIVER_INTERFACE_CMDS
AV_RECEIVER_INTERFACE_SET_ZONE2_INPUT_RESPONSE,
AV_RECEIVER_INTERFACE_SET_SYNC_Z2_WITH_Z1_REQUEST,
AV_RECEIVER_INTERFACE_SET_SYNC_Z2_WITH_Z1_RESPONSE,
AV_RECEIVER_INTERFACE_INCREMENT_MAIN_VOLUME_REQUEST,
AV_RECEIVER_INTERFACE_INCREMENT_MAIN_VOLUME_RESPONSE,
AV_RECEIVER_INTERFACE_INCREMENT_Z2_VOLUME_REQUEST,
AV_RECEIVER_INTERFACE_INCREMENT_Z2_VOLUME_RESPONSE,
MAX_AV_RECEIVER_INTERFACE_CMD