Check-in pré-voyage

Sources/Sprinkler/Sprinkler.cpp

@@ -0,0 +1,62 @@
+#include "Sprinkler.h"
+
+
+CSprinkler::CSprinkler(CSprinklerGui *GUI)
+{
+    mNetworkInterface = new CSprinklerMasterCtrlInterface(this);
+    mGui = GUI;
+
+    CSprinklerDevice *Sprinkler = new CSprinklerDevice();
+    mSprinklers.append(Sprinkler);
+}
+
+CSprinkler::~CSprinkler()
+{
+    for(int i = 0; i < mSprinklers.size(); i++)
+    {
+        delete mSprinklers[i];
+    }
+    mSprinklers.clear();
+}
+
+CSprinklerDevice* CSprinkler::FindSprinkler(int DeviceAddress)
+{
+    for(int i = 0; i < mSprinklers.size(); i++)
+    {
+        if(mSprinklers.at(i)->mDeviceAddress == DeviceAddress)
+        {
+            return mSprinklers[i];
+        }
+    }
+    return 0;
+}
+
+int CSprinkler::SetSprinklerState(int DeviceAddress, unsigned char State)
+{
+    CSprinklerDevice *Dev = FindSprinkler(DeviceAddress);
+    if(Dev != 0)
+    {
+        Dev->SetSprinklerState((SprinklerState)State);
+    }
+    else
+    {
+        return 0;
+    }
+
+    return 1;
+}
+
+int CSprinkler::SetSprinklerFlow(int DeviceAddress, unsigned short Flow)
+{
+    CSprinklerDevice *Dev = FindSprinkler(DeviceAddress);
+    if(Dev != 0)
+    {
+        Dev->SetFlow(Flow);
+    }
+    else
+    {
+        return 0;
+    }
+
+    return 1;
+}

Sources/Sprinkler/Sprinkler.h

@@ -0,0 +1,34 @@
+#ifndef SPRINKLER_H
+#define SPRINKLER_H
+
+#include <QObject>
+#include <QList>
+#include "SprinklerMasterCtrlInterface.h"
+#include "SprinklerGui.h"
+#include "SprinklerDevice.h"
+
+
+class CSprinkler : public QObject
+{
+    Q_OBJECT
+
+public:
+    CSprinkler(CSprinklerGui *GUI);
+    ~CSprinkler();
+
+    int SetSprinklerState(int DeviceAddress, unsigned char State);
+    int SetSprinklerFlow(int DeviceAddress, unsigned short Flow);
+
+private:
+    CSprinklerDevice *FindSprinkler(int DeviceAddress);
+
+public:
+
+    CSprinklerMasterCtrlInterface *mNetworkInterface;
+    CSprinklerGui *mGui;
+    QList<CSprinklerDevice*> mSprinklers;
+
+
+};
+
+#endif // SPRINKLER_H

Sources/Sprinkler/SprinklerDevice.cpp

@@ -0,0 +1,32 @@
+#include "SprinklerDevice.h"
+
+
+CSprinklerDevice::CSprinklerDevice()
+{
+    mDeviceLocation = "Backyard";
+    mDeviceAddress = 1;
+    mSprinklerState = SPRINKLER_UNKNOWN_STATE;
+    mFlowMeter = 0;
+}
+
+int CSprinklerDevice::SetSprinklerState(SprinklerState State)
+{
+    mSprinklerState = State;
+    return 1;
+}
+
+SprinklerState CSprinklerDevice::GetSprinklerState()
+{
+    return mSprinklerState;
+}
+
+int CSprinklerDevice::SetFlow(unsigned short flow)
+{
+    mFlowMeter = flow;
+    return 1;
+}
+
+unsigned short CSprinklerDevice::GetFlow()
+{
+    return mFlowMeter;
+}

Sources/Sprinkler/SprinklerDevice.h

@@ -0,0 +1,27 @@
+#ifndef CSPRINKLERDEVICE_H
+#define CSPRINKLERDEVICE_H
+#include <QString>
+
+typedef enum eSprinklerState
+{
+    SPRINKLER_OFF_STATE = 0,
+    SPRINKLER_ON_STATE,
+    SPRINKLER_UNKNOWN_STATE
+}SprinklerState;
+
+class CSprinklerDevice
+{
+public:
+    CSprinklerDevice();
+    int SetSprinklerState(SprinklerState State);
+    SprinklerState GetSprinklerState();
+    int SetFlow(unsigned short flow);
+    unsigned short GetFlow();
+
+    SprinklerState mSprinklerState;
+    int mDeviceAddress;
+    QString mDeviceLocation;
+    unsigned short mFlowMeter;
+};
+
+#endif // CSPRINKLERDEVICE_H

Sources/Sprinkler/SprinklerGui.cpp

@@ -5,6 +5,8 @@ CSprinklerGui::CSprinklerGui(QWidget *parent) :
     QWidget(parent)
 {
     setupUi(this);
+    mValveSwitch->setCheckable(true);
+    mValveSwitch->setChecked(false);
 }
 
 CSprinklerGui::~CSprinklerGui()

Sources/Sprinkler/SprinklerGui.ui

@@ -16,8 +16,8 @@
   <widget class="QLabel" name="label">
    <property name="geometry">
     <rect>
-     <x>0</x>
-     <y>-10</y>
+     <x>20</x>
+     <y>10</y>
      <width>201</width>
      <height>51</height>
     </rect>
@@ -26,7 +26,25 @@
     <string>Sprinklers</string>
    </property>
   </widget>
+  <widget class="CToggleSwitch" name="mValveSwitch" native="true">
+   <property name="geometry">
+    <rect>
+     <x>220</x>
+     <y>90</y>
+     <width>91</width>
+     <height>81</height>
+    </rect>
+   </property>
+  </widget>
  </widget>
+ <customwidgets>
+  <customwidget>
+   <class>CToggleSwitch</class>
+   <extends>QWidget</extends>
+   <header>ToggleSwitch.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
  <resources/>
  <connections/>
 </ui>

Sources/Sprinkler/SprinklerMasterCtrlInterface.cpp

@@ -0,0 +1,111 @@
+#include "SprinklerMasterCtrlInterface.h"
+#include <QByteArray>
+#include <QDataStream>
+#include <QBuffer>
+#include "SystemGui.h"
+#include "Sprinkler.h"
+
+
+
+CSprinklerMasterCtrlInterface::CSprinklerMasterCtrlInterface(CSprinkler *ProgramHandle)
+{
+    mDeviceAddress = 1;
+    mNetworkPort = 2182;
+    mMasterCtrlAddress = "127.0.0.1";
+//    mNetworkPort = 6463;
+//    mMasterCtrlAddress = "192.168.0.112";
+    mNetworkCommSocket = 0;
+    mMyDeviceID = ID_SPRINKLER_INTERFACE;
+
+    mProgramHandle = ProgramHandle;
+}
+
+CSprinklerMasterCtrlInterface::~CSprinklerMasterCtrlInterface()
+{
+//    if(mNetworkCommSocket !=0)
+//    {
+////        mNetworkCommSocket->disconnectFromHost();
+//   //     delete mNetworkCommSocket;
+//    }
+}
+
+int CSprinklerMasterCtrlInterface::DeviceConnectedToMaster(bool Connected)
+{
+    if(Connected)
+    {
+         mNetworkCommSocket->write(GetTxPacket(SPRINKLER_INTERFACE_GET_SPRINKLERS_REQUEST,0,0,0,1,ID_MASTER,mMyDeviceID,mDeviceAddress));
+    }
+    else
+    {
+        //???
+    }
+    return RET_OK;
+}
+
+int CSprinklerMasterCtrlInterface::DeviceFrameReceived(int TargetDeviceID, int TargetDeviceAddress, int SenderDeviceID, int SenderAddress, int MessageID, int DataSize, QByteArray Data)
+{
+    Q_UNUSED(DataSize)
+
+
+    if(TargetDeviceID == mMyDeviceID && (TargetDeviceAddress == BROADCAST_VALUE || TargetDeviceAddress == mDeviceAddress))
+    {
+        switch(MessageID)
+        {
+            case SPRINKLER_INTERFACE_ACK:
+            {
+                break;
+            }
+            case SPRINKLER_INTERFACE_STATUS_REQUEST:
+            {
+                QByteArray Frame,ResponseData;
+                ResponseData.append(ACK);
+                ResponseData.append((char)SPRINKLER_INTERFACE_STATUS_RESPONSE);
+                Frame = GetTxPacket(SPRINKLER_INTERFACE_STATUS_RESPONSE,0,ResponseData.data(),ResponseData.size(),1,ID_MASTER,ID_SPRINKLER_INTERFACE,mDeviceAddress);
+                mNetworkCommSocket->write(Frame);
+                break;
+            }
+            case SPRINKLER_INTERFACE_GET_SPRINKLERS_RESPONSE:
+            {
+                break;
+            }
+            case SPRINKLER_INTERFACE_GET_SPRINKLER_DATA_RESPONSE:
+            {
+                break;
+            }
+            case SPRINKLER_INTERFACE_SET_SPRINKLER_DATA_ACK:
+            {
+                break;
+            }
+            case SPRINKLER_INTERFACE_GET_SPRINKLER_STATE_RESPONSE:
+            {
+                for(int i = 0; i < Data.at(0); i++)
+                {
+
+                }
+                break;
+            }
+            case SPRINKLER_INTERFACE_SET_SPRINKLER_STATE_ACK:
+            {
+                QByteArray Frame,RequestData;
+                RequestData.append(1);  //device address
+                Frame = GetTxPacket(SPRINKLER_INTERFACE_GET_SPRINKLER_STATE_REQUEST,0,RequestData.data(),RequestData.size(),1,ID_MASTER,ID_SPRINKLER_INTERFACE,mDeviceAddress);
+                mNetworkCommSocket->write(Frame);
+                break;
+            }
+            case SPRINKLER_INTERFACE_STATUS_RESPONSE:
+            case SPRINKLER_INTERFACE_GET_SPRINKLERS_REQUEST:
+            case SPRINKLER_INTERFACE_GET_SPRINKLER_DATA_REQUEST:
+            case SPRINKLER_INTERFACE_SET_SPRINKLER_DATA_REQUEST:
+            case SPRINKLER_INTERFACE_GET_SPRINKLER_STATE_REQUEST:
+            case SPRINKLER_INTERFACE_SET_SPRINKLER_STATE_REQUEST:
+            default:
+            {
+                qDebug("Sprinkler: Invalid Ethernet MSg received: %d",MessageID);
+                break;
+            }
+
+        }
+    }
+
+    return RET_OK;
+}