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

Dev Lora

Browse Source
This commit is contained in:
jfmartel
2020-09-13 13:47:47 -04:00
parent d3d6e095d7
commit 02e968c724
24 changed files with 4096 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/Chalet/ChaletData.cpp
+53
View File
@@ -0,0 +1,53 @@
#include "ChaletData.h"
#include <QDataStream>
CChaletMainStatus::CChaletMainStatus()
{
mInverterRelayStatus = UNKNOWN_STATE;
mWiFiModuleStatus = UNKNOWN_STATE;
mBatteryCurrent = 0;
mBatteryVoltage = 0;
mIsOnline = false;
mHarakiriDone = false;
}
//int CChaletMainStatus::FromByteArray(QByteArray Data)
//{
//// QDataStream Strm(Data);
//// Strm.device()->seek(0);
//// mInverterRelayStatus >> Data;
//// mWiFiModuleStatus = Data[1];
//// ChaletStatus[0] = GetChaletPowerRelayState(); //Inverter relay status
//// ChaletStatus[1] = GetWiFiSate(); //Wifi Module state
//// ChaletStatus[2] = 3; //Battery Voltage 1
//// ChaletStatus[3] = 4; //Battery voltage 2
//// ChaletStatus[4] = 5; //Battery current 1
//// ChaletStatus[5] = 6; //Batgtery current 2
//// ChaletStatus[6] = 7; //Battery SOC
//// ChaletStatus[7] = 8; //Snatch
//// ChaletStatus[8] = 9;
//// ChaletStatus[9] = 10;
// return RET_OK;
//}
QByteArray CChaletMainStatus::ToByteArray()
{
QByteArray Data;
Data.clear();
QDataStream Strm(&Data,QIODevice::WriteOnly);
Strm << mInverterRelayStatus;
Strm << mWiFiModuleStatus;
Strm << mBatteryVoltage;
Strm << mBatteryCurrent;
Strm << mBatterySOC;
return Data;
}
Sources/Chalet/ChaletData.h
+34
View File
@@ -0,0 +1,34 @@
#ifndef CHALETDATA_H
#define CHALETDATA_H
#include <QString>
#include "GlobalDefine.h"
#include <QDateTime>
#include <QByteArray>
class CChaletMainStatus
{
public:
QByteArray ToByteArray();
// int FromByteArray(QByteArray Data);
CChaletMainStatus();
quint8 mInverterRelayStatus;
quint8 mWiFiModuleStatus;
float mBatteryVoltage;
float mBatteryCurrent;
float mBatterySOC;
bool mHarakiriDone;
bool mIsOnline;
QDateTime mLastLoraStatus;
};
#endif // CHALETDATA_H
Sources/Chalet/ChaletInterface.cpp
+95
View File
@@ -0,0 +1,95 @@
#include "ChaletInterface.h"
CChaletInterface::CChaletInterface(int Address, CAbstractNetworkCommIF *NetworkInterface, CChaletLoraDevice *DevicePtr):
CNetworkDevice(ID_CHALET_INTERFACE,Address,NetworkInterface)
{
mChaletLoraDevice = DevicePtr;
}
int CChaletInterface::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 CHALET_INTERFACE_ACK:
{
break;
}
case CHALET_INTERFACE_GENERAL_STATUS_REQUEST:
{
QByteArray data = mChaletLoraDevice->GetChaletMainStatus().ToByteArray();
mNetworkInterfacePtr->SendNetworkMessage(ID_CHALET_INTERFACE,mDeviceAddress,CHALET_INTERFACE_GENERAL_STATUS_RESPONSE,data.size(),data);
break;
}
case CHALET_INTERFACE_AC_POWER_STATE_STATUS_REQUEST:
{
break;
}
case CHALET_INTERFACE_AC_POWER_SET_STATE_REQUEST:
{
qDebug("AC power state set request received from interface");
if(Data[0] == (char)1)
{
mChaletLoraDevice->SendInverterPowerRelayState(true);
}
else if(Data[0] == (char)0)
{
mChaletLoraDevice->SendInverterPowerRelayState(false);
}
break;
}
case CHALET_INTERFACE_BATTERY_VOLTAGE_REQUEST:
{
break;
}
case CHALET_INTERFACE_WIFI_SET_STATE_REQUEST:
{
qDebug("WiFi state set request received from interface");
if(Data[0] == (char)1)
{
mChaletLoraDevice->SendWiFiModuleSetState(true);
}
else if(Data[0] == (char)0)
{
mChaletLoraDevice->SendWiFiModuleSetState(false);
}
break;
}
case CHALET_INTERFACE_DO_HARAKIRI_REQUEST:
{
mChaletLoraDevice->SendDOHarakiri();
break;
}
case CHALET_INTERFACE_REBOOT_CPU_REQUEST:
{
mChaletLoraDevice->SendRebootCmd();
break;
}
case CHALET_INTERFACE_GENERAL_STATUS_RESPONSE:
case CHALET_INTERFACE_AC_POWER_STATE_STATUS_RESPONSE:
case CHALET_INTERFACE_AC_POWER_SET_STATE_RESPONSE:
case CHALET_INTERFACE_BATTERY_VOLTAGE_RESPONSE:
case CHALET_INTERFACE_WIFI_SET_STATE_RESPONSE:
{
break;
}
}
return RET_OK;
}
Sources/Chalet/ChaletInterface.h
+21
View File
@@ -0,0 +1,21 @@
#ifndef CCHALETINTERFACE_H
#define CCHALETINTERFACE_H
#include "NetworkDevice.h"
#include "ChaletLoraDevice.h"
class CChaletInterface: public QObject, public CNetworkDevice
{
Q_OBJECT
public:
CChaletInterface(int Address, CAbstractNetworkCommIF *NetworkInterface, CChaletLoraDevice *DevicePtr);
virtual int NewDeviceFrameReceived(int DeviceID, int DeviceAddress, int MessageID, int DataSize, QByteArray Data);
private:
CChaletLoraDevice *mChaletLoraDevice;
};
#endif // CCHALETINTERFACE_H
Sources/Chalet/ChaletLoraDevice.cpp
+260 -56
View File
@@ -1,84 +1,288 @@
#include "ChaletLoraDevice.h"
#include <QSerialPortInfo>
#include <QObject>
#include "GlobalDefine.h"
CChaletLoraDevice::CChaletLoraDevice()
CChaletLoraDevice::CChaletLoraDevice(int Address, CAbstractNetworkCommIF *NetworkInterface):
CNetworkDevice(ID_CHALET_DEVICE,Address,NetworkInterface)
{
mMyLoraAddress = 5;
mMyLoraChannel = 4;
NetworkInterface->mDevicePtr = this;
mDeviceAddress = Address;
mDeviceID = ID_CHALET_DEVICE;
QByteArray Test;
Test.resize(4);
Test[0] = 0xDE;
Test[1] = 0xAD;
Test[2] = 0xBE;
Test[3] = 0xEF;
GetLoraFrame(4,4,Test);
mLoraStatusRefreshTimer = new QTimer;
mLoraStatusRefreshTimer->setInterval(1000);
mLoraStatusRefreshTimer->setSingleShot(false);
connect(mLoraStatusRefreshTimer,SIGNAL(timeout()),this,SLOT(LoraStatusRefreshTimerExpired()));
mLoraStatusRefreshTimer->start();
mChaletStatusTimer = new QTimer();
mChaletStatusTimer->setInterval(1000);
mChaletStatusTimer->setSingleShot(true);
connect(mChaletStatusTimer,SIGNAL(timeout()),this,SLOT(CommTimerExpired()));
}
CChaletLoraDevice::~CChaletLoraDevice()
{
mLoraStatusRefreshTimer->stop();
delete mLoraStatusRefreshTimer;
delete mChaletStatusTimer;
}
int CChaletLoraDevice::Init()
int CChaletLoraDevice::Start()
{
QList<QSerialPortInfo> PortsList = QSerialPortInfo::availablePorts();
ScheduleChaletStatusRequest();
mChaletStatusTimer->start(1000);
return RET_OK;
}
for(int i = 0; i < PortsList.size(); i++)
int CChaletLoraDevice::NewDeviceFrameReceived(int DeviceID, int DeviceAddress, int MessageID, int DataSize, QByteArray Data)
{
switch(MessageID)
{
qDebug("Port found: %s - %s",qPrintable(PortsList.at(i).portName()),qPrintable(PortsList.at(i).description()));
case CHALET_ACK:
{
CmdResponseReceived(CHALET_ACK);
break;
}
case CHALET_GENERAL_STATUS_RESPONSE:
{
float temp;
qDebug("Chalet Status RX");
char VoltageArray[4];
mChaletMainStatus.mInverterRelayStatus = Data[0];
mChaletMainStatus.mWiFiModuleStatus = Data[1];
VoltageArray[0] = Data[2];
VoltageArray[1] = Data[3];
VoltageArray[2] = Data[4];
VoltageArray[3] = Data[5];
memcpy(&temp,VoltageArray,4);
mChaletMainStatus.mBatteryVoltage = temp;
CmdResponseReceived(CHALET_GENERAL_STATUS_REQUEST);
qDebug("voltage: %f",mChaletMainStatus.mBatteryVoltage);
break;
}
case CHALET_AC_POWER_STATE_STATUS_RESPONSE:
{
mChaletMainStatus.mInverterRelayStatus = Data[0];
CmdResponseReceived(CHALET_AC_POWER_SET_STATE_RESPONSE);
break;
}
case CHALET_AC_POWER_SET_STATE_RESPONSE:
{
qDebug("Lora set Inverter Power response : 0x%d",(int)Data[0]);
mChaletMainStatus.mInverterRelayStatus = Data[0];
CmdResponseReceived(CHALET_AC_POWER_SET_STATE_REQUEST);
break;
}
case CHALET_BATTERY_VOLTAGE_RESPONSE:
{
CmdResponseReceived(CHALET_BATTERY_VOLTAGE_REQUEST);
break;
}
case CHALET_BATTERY_CURRENT_RESPONSE:
{
CmdResponseReceived(CHALET_BATTERY_CURRENT_REQUEST);
break;
}
case CHALET_WIFI_STATUS_RESPONSE:
{
mChaletMainStatus.mWiFiModuleStatus = Data[0];
CmdResponseReceived(CHALET_WIFI_STATUS_REQUEST);
break;
}
case CHALET_WIFI_SET_STATE_RESPONSE:
{
qDebug("Lora set WiFi response : 0x%d",(int)Data[0]);
mChaletMainStatus.mWiFiModuleStatus = Data[0];
CmdResponseReceived(CHALET_WIFI_SET_STATE_REQUEST);
break;
}
case CHALET_DO_HARAKIRI_CONFIRMATION:
{
if(Data[0] == (char)1)
{
qDebug("ChaletDuino has commited suicide (HARAKIRI)");
mChaletMainStatus.mHarakiriDone = true;
}
else
{
qDebug("HARAKIRI magic word invalid.");
}
CmdResponseReceived(CHALET_DO_HARAKIRI_REQUEST);
break;
}
case CHALET_REBOOT_CPU_RESPONSE:
{
if(Data[0] == (char)1)
{
qDebug("ChaletDuino is rebooting");
}
else
{
qDebug("Reboot magic word invalid");
}
CmdResponseReceived(CHALET_DO_HARAKIRI_REQUEST);
break;
}
default:
{
return RET_ERROR;
break;
}
}
return RET_OK;
}
mLoraModuleSerialPort.setPortName("COM3");
mLoraModuleSerialPort.setBaudRate(QSerialPort::Baud9600);
mLoraModuleSerialPort.setDataBits(QSerialPort::Data8);
mLoraModuleSerialPort.setParity(QSerialPort::NoParity);
mLoraModuleSerialPort.setFlowControl(QSerialPort::NoFlowControl);
if(mLoraModuleSerialPort.open(QIODevice::ReadWrite) == false)
void CChaletLoraDevice::CommTimerExpired()
{
if(mPendingNetworkMsgList.isEmpty())
{
qDebug("Could not open Chalet Lora serial port");
return RET_ERROR;
qDebug("Empty command list in comm timer ");
ScheduleChaletStatusRequest();
mChaletStatusTimer->start(1000);
return;
}
if(mPendingNetworkMsgList.first().PendingResponse == true)
{
//The current command is still waiting for a response. Check how many times we tried to send it
qDebug("Cmd 0x%x timetout... retrying",mPendingNetworkMsgList.first().mMessageID);
if(mPendingNetworkMsgList.first().ResendCounter >= 5)
{
//TODO: manage this. Module offline?
}
else
{
mPendingNetworkMsgList[0].ResendCounter++;
}
}
QByteArray Test;
Test.resize(5);
Test[0] = 0xDE;
Test[1] = 0xAD;
Test[2] = 0xBE;
Test[3] = 0xEF;
Test[4] = '\r';
qDebug("Sending chalet request 0x%x",mPendingNetworkMsgList.at(0).mMessageID);
GetLoraFrame(4,4,Test);
mPendingNetworkMsgList[0].PendingResponse = true;
SendChaletCommand(mPendingNetworkMsgList.at(0).mMessageID,mPendingNetworkMsgList.at(0).mData.size(),mPendingNetworkMsgList.at(0).mData);
mLoraModuleSerialPort.write(GetLoraFrame(4,4,Test));
//Harakiri and Reboot commands should not stay in the queue...
if(mPendingNetworkMsgList.at(0).mMessageID == CHALET_DO_HARAKIRI_REQUEST ||
mPendingNetworkMsgList.at(0).mMessageID == CHALET_REBOOT_CPU_REQUEST)
{
mPendingNetworkMsgList.clear();
ScheduleChaletStatusRequest();
}
mChaletStatusTimer->start(5000); //we should get an answer within 5 seconds.
// SendChaletCommand(CHALET_GENERAL_STATUS_REQUEST,0,QByteArray());
}
int CChaletLoraDevice::SendWiFiModuleSetState(bool State)
{
QByteArray Data;
Data.resize(1);
if(State)
{
Data[0] = 1;
}
else
{
Data[0] = 0;
}
ScheduleChaletCommand(CHALET_WIFI_SET_STATE_REQUEST,1,Data);
return RET_OK;
}
int CChaletLoraDevice::SendInverterPowerRelayState(bool State)
{
QByteArray Data;
Data.resize(1);
if(State)
{
Data[0] = 1;
}
else
{
Data[0] = 0;
}
ScheduleChaletCommand(CHALET_AC_POWER_SET_STATE_REQUEST,Data);
// SendChaletCommand(CHALET_AC_POWER_SET_STATE_REQUEST,1,Data);
return RET_OK;
}
int CChaletLoraDevice::SendDOHarakiri()
{
QByteArray Data; //Magic word...
Data.clear();
Data.append(0xBA);
Data.append(0xAD);
Data.append(0xBE);
Data.append(0xEF);
ScheduleChaletCommand(CHALET_DO_HARAKIRI_REQUEST,Data);
}
int CChaletLoraDevice::SendRebootCmd()
{
QByteArray Data; //Magic word...
Data.clear();
Data.append(0xBA);
Data.append(0xAD);
Data.append(0xCA);
Data.append(0xFE);
ScheduleChaletCommand(CHALET_REBOOT_CPU_REQUEST,Data);
}
int CChaletLoraDevice::SendChaletCommand(int CmdID, int DataSize, QByteArray Data)
{
mNetworkInterfacePtr->SendNetworkMessage(ID_CHALET_DEVICE,mDeviceAddress,CmdID,DataSize,Data);
return RET_OK;
}
int CChaletLoraDevice::CmdResponseReceived(int CmdID)
{
Q_UNUSED(CmdID)
qDebug("Chalet response received from cmd: 0x%x",CmdID);
if(mPendingNetworkMsgList.size() == 0)
{
qDebug("Cmd ack received but list is empty!!!");
}
else
{
CChaletNetworkMessage Msg = mPendingNetworkMsgList.takeFirst();
if(Msg.mMessageID != CmdID)
{
qDebug("Inconsistency between active cmd and ack received [received 0x%x] != [cur 0x%x]!!!", Msg.mMessageID,CmdID);
}
}
if(mPendingNetworkMsgList.size() == 0) //If no message is left pending... schedule status request
{
ScheduleChaletStatusRequest();
mChaletStatusTimer->start(1000);//Next status request will be sent in 1000ms
}
else
{
mChaletStatusTimer->start(500); //wait a little and send the next cmd.
}
return RET_OK;
}
void CChaletLoraDevice::LoraStatusRefreshTimerExpired()
int CChaletLoraDevice::ScheduleChaletStatusRequest()
{
QByteArray Test;
Test.resize(4);
Test[0] = 0xBA;
Test[1] = 0xAD;
Test[2] = 0xCA;
Test[3] = 0xFE;
// Test[4] = '\r';
GetLoraFrame(4,4,Test);
mLoraModuleSerialPort.write(GetLoraFrame(4,4,Test));
return;
ScheduleChaletCommand(CHALET_GENERAL_STATUS_REQUEST,0,QByteArray());
}
int CChaletLoraDevice::ScheduleChaletCommand(int CmdID, int DataSize, QByteArray Data)
{
Q_UNUSED(DataSize)
CChaletNetworkMessage Command(CmdID,Data);
mPendingNetworkMsgList.append(Command);
return RET_OK;
}
int CChaletLoraDevice::ScheduleChaletCommand(int CmdID, QByteArray Data)
{
CChaletNetworkMessage Command(CmdID,Data);
mPendingNetworkMsgList.append(Command);
return RET_OK;
}
Sources/Chalet/ChaletLoraDevice.h
+33 -10
View File
@@ -1,27 +1,50 @@
#ifndef CCHALETLORADEVICE_H
#define CCHALETLORADEVICE_H
#include "GlobalDefine.h"
#include "LoraDevice.h"
#include <QByteArray>
#include <QObject>
#include <QSerialPort>
#include "LoraNetworkCommIF.h"
#include "NetworkDevice.h"
#include <QTimer>
#include "ChaletData.h"
#include "ChaletNetworkMessage.h"
#include <QList>
#define LORA_MAGIC_WORD 0xBAADCAFE
class CChaletLoraDevice : public QObject, public CLoraDevice
class CChaletLoraDevice : public QObject, public CNetworkDevice
{
Q_OBJECT
public:
CChaletLoraDevice();
CChaletLoraDevice(int Address,CAbstractNetworkCommIF *NetworkInterface);
~CChaletLoraDevice();
int Init();
QTimer *mLoraStatusRefreshTimer;
virtual int NewDeviceFrameReceived(int DeviceID, int DeviceAddress, int MessageID, int DataSize, QByteArray Data);
private:
QSerialPort mLoraModuleSerialPort;
QTimer *mChaletStatusTimer;
int Start();
CChaletMainStatus GetChaletMainStatus() {return mChaletMainStatus;}
CChaletMainStatus mChaletMainStatus;
QList<CChaletNetworkMessage> mPendingNetworkMsgList;
int SendWiFiModuleSetState(bool State);
int SendInverterPowerRelayState(bool State);
int SendDOHarakiri();
int SendRebootCmd();
int SendChaletCommand(int CmdID,int DataSize, QByteArray Data);
int CmdResponseReceived(int CmdID);
int ScheduleChaletStatusRequest();
int ScheduleChaletCommand(int CmdID, int DataSize, QByteArray Data);
int ScheduleChaletCommand(int CmdID,QByteArray Data);
public slots:
void LoraStatusRefreshTimerExpired();
void CommTimerExpired();
};
#endif // CCHALETLORADEVICE_H
Sources/Chalet/ChaletNetworkMessage.cpp
+10
View File
@@ -0,0 +1,10 @@
#include "ChaletNetworkMessage.h"
CChaletNetworkMessage::CChaletNetworkMessage(int MessageID, QByteArray Data)
{
mMessageID = MessageID;
mData = Data;
PendingResponse = false;
ResendCounter = 0;
}
Sources/Chalet/ChaletNetworkMessage.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef HALETNETWORKMESSAGE_H
#define HALETNETWORKMESSAGE_H
#include <QByteArray>
class CChaletNetworkMessage
{
public:
CChaletNetworkMessage(int MessageID, QByteArray Data);
int mMessageID;
QByteArray mData;
bool PendingResponse;
int ResendCounter;
};
#endif // HALETNETWORKMESSAGE_H
Sources/Chalet/LoraDevice.cpp
-25
View File
@@ -1,25 +0,0 @@
#include "LoraDevice.h"
CLoraDevice::CLoraDevice()
{
}
QByteArray CLoraDevice::GetLoraFrame(unsigned short DestAddress, unsigned char DestChannel, QByteArray Payload)
{
QByteArray OutputFrame;
OutputFrame.clear();
//E32 modules frame is [Address_MSB][Address_LSB][Channel][Payload]
char AddressByte = (char)((DestAddress >> 8) & 0x00FF);
OutputFrame.append(AddressByte);
AddressByte = (char)(DestAddress & 0x00FF);
OutputFrame.append(AddressByte);
OutputFrame.append(DestChannel);
OutputFrame.append(Payload);
return OutputFrame;
}
Sources/Chalet/LoraDevice.h
-16
View File
@@ -1,16 +0,0 @@
#ifndef CLORADEVICE_H
#define CLORADEVICE_H
#include <QByteArray>
class CLoraDevice
{
public:
CLoraDevice();
unsigned short mMyLoraAddress;
unsigned char mMyLoraChannel;
QByteArray GetLoraFrame(unsigned short DestAddress,unsigned char DestChannel,QByteArray Payload);
};
#endif // CLORADEVICE_H