Ajouté console audio + chalet dev LTE

MasterCtrl.pro

@@ -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
 

Sources/AvReceiver/AVReceiverDevice.cpp

@@ -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;
 }

Sources/AvReceiver/AVReceiverDevice.h

@@ -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;

Sources/AvReceiver/AvReceiverConsoleInterface.cpp

@@ -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;
+
+}

Sources/AvReceiver/AvReceiverConsoleInterface.h

@@ -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

Sources/AvReceiver/AvReceiverData.cpp

@@ -13,21 +13,67 @@ QByteArray CAvReceiverMainStatus::ToByteArray()
 
     QByteArray Output;
     Output.clear();
-    QDataStream Strm(&Output,QIODevice::WriteOnly);
+//    QDataStream Strm(&Output,QIODevice::WriteOnly);
 
-    Strm << mMainPwrStatus;
+////    Strm << mMainPwrStatus;
-    Strm <<  mMainSleepStatus;
+////    Strm <<  mMainSleepStatus;
-    Strm <<  mMainVolume;
+////    Strm <<  mMainVolume;
-    Strm <<  mIsMute;
+////    Strm <<  mIsMute;
-    Strm <<  mInput;
+////    Strm <<  mInput;
-    Strm <<  mProgram;
+////    Strm <<  mProgram;
 
-    Strm <<  mDataValid;
+////    Strm <<  mDataValid;
-    Strm <<  mReceiverOnline;
+////    Strm <<  mReceiverOnline;
-    Strm << mSyncZonesVolumes;
+////    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

Sources/AvReceiver/AvReceiverData.h

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

Sources/Chalet/ChaletDevice.cpp

@@ -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)

Sources/Chalet/ChaletDevice.h

@@ -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;

Sources/Chalet/ChaletHomeServerInterface.cpp

@@ -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);
+
+}

Sources/Chalet/ChaletHomeServerInterface.h

@@ -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

Sources/EthernetNetworkServer.cpp

@@ -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;

Sources/MasterCtrl.cpp

@@ -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();
 

Sources/NetworkDevicesMgr.cpp

@@ -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());

Sources/NetworkDevicesMgr.h

@@ -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);

Sources/ProtocolDefs.h

@@ -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