Masterctrl/Sources/LoraModuleInterface/LoraModuleInterface.cpp

#include "LoraModuleInterface.h"

CLoraModuleInterface::CLoraModuleInterface()
{
    connect(&mLoraModuleIFSerialPort,SIGNAL(readyRead()),this,SLOT(NewLoraModuleIFDataReady()));

    mLoraModuleIFStatusTimer = new QTimer();
    mLoraModuleIFStatusTimer->setSingleShot(false);
    mLoraModuleIFStatusTimer->setInterval(1000);
    mLoraModuleIFStatusTimer->start();

    connect(mLoraModuleIFStatusTimer,SIGNAL(timeout()),this,SLOT(LoraModuleStatusTimerExpired()));
}

CLoraModuleInterface::~CLoraModuleInterface()
{
    delete mLoraModuleIFStatusTimer;
}


//This the handling of the Microcontroller (LoraModuleInterface)
int CLoraModuleInterface::NewFrameReceived(int DeviceID, int DeviceAddress, int MessageID, int DataSize, QByteArray Data)
{
    switch(MessageID)
    {
        case LORA_IF_GET_STATUS_RESPONSE:
        {
            unsigned char model = Data.at(0);
            qDebug("LoraModuleInterface status received : %d",model);
            break;
        }
        case LORA_IF_SEND_FRAME_RESPONSE:
        {
            qDebug("LoraModuleInterface sent frame to end Lora device");
            break;
        }
        case LORA_IF_NEW_FRAME_RESPONSE:    //LoraInterface received a message from the Lora end point (chalet for example).  Let's decode it and send it to the destination device
        {
            CNetworkProtocol *mTempProtocol = new CNetworkProtocol;   //Let's instanciate a temp protocol class to avoid messing with our own derived class...
            int FwdDeviceID;
            int FwdDeviceAddress;
            int FwdMessageID;
            int FwdDataSize;
            QByteArray FwdData;
            if(mTempProtocol->ProtocolAnalyseBufferStatically(Data,FwdDeviceID,FwdDeviceAddress,FwdMessageID,FwdDataSize,FwdData) == PROTOCOL_RET_OK_PACKET_COMPLETE)
            {
                mDevicePtr->NewDeviceFrameReceived(FwdDeviceID,FwdDeviceAddress,FwdMessageID,FwdDataSize,FwdData);
            }
            else
            {
                qDebug("LoraModuleInterface received an invalid packet from end Lora device in NewFrameReceived");
            }

            delete mTempProtocol;
            break;
        }
        case LORA_IF_GET_MODULE_CONFIG_RESPONSE:
        {
            break;
        }
        case LORA_IF_GET_RSSI_RESPONSE:
        {
            break;
        }
        case LORA_IF_SET_MODULE_CONFIG_RESPONSE:
        {
            break;
        }
        case LORA_IF_GET_STATUS_REQUEST:
        case LORA_IF_SEND_FRAME_REQUEST:
        case LORA_IF_GET_MODULE_CONFIG_REQUEST:
        case LORA_IF_GET_RSSI_REQUEST:
        case LORA_IF_SET_MODULE_CONFIG_REQUEST:
        default:
        {
            qDebug("CLoraModuleInterface: Received invalid response from LoraModule: %d",MessageID);
            break;
        }

    }

    return RET_OK;
}

//This is the CAbstractNetworkCommIF class implementation (to answer to CChaletDevice requests).
int CLoraModuleInterface::SendNetworkMessage(int DeviceID, int DeviceAddress, int MessageID, int DataSize, QByteArray *Data)
{
    qDebug("LoraInterfce: New frame received from MasterCtrl class");
    return RET_OK;
}



void CLoraModuleInterface::LoraModuleStatusTimerExpired()
{
    QByteArray Packet = GetTxPacket(LORA_IF_GET_STATUS_REQUEST,0,0,0,1,ID_LORA_INTERFACE);
    mLoraModuleIFSerialPort.write(Packet);
    mLoraModuleIFSerialPort.waitForBytesWritten(500);
}

int CLoraModuleInterface::SetLoraModuleInterfaceParameters(QString ComPort, qint32 BaudRate)
{
    mLoraModuleIFComPortName = ComPort;
    mLoraModuleIFComPortBaudRate = BaudRate;


    if(mLoraModuleIFSerialPort.isOpen())
    {
        mLoraModuleIFSerialPort.close();
    }

    mLoraModuleIFSerialPort.setPortName(mLoraModuleIFComPortName);
    if(mLoraModuleIFSerialPort.setBaudRate(mLoraModuleIFComPortBaudRate) == false)
    {
        qDebug("Invalid Lora Device serial port baud rate...");
    }

    //The other serial port parameters (parity, stop bits, data bits) are all set to mentally sane default values so no need to set them.
    if(mLoraModuleIFSerialPort.open(QIODevice::ReadWrite) == false)
    {
        qDebug("Could not open Lora device port");
        return RET_ERROR;
    }

    qDebug("LoraModuleInterface serial port opened");
    return RET_OK;



    return RET_OK;
}

void CLoraModuleInterface::NewLoraModuleIFDataReady()
{
    QByteArray NewData = mLoraModuleIFSerialPort.readAll();

    AnalyzeRxBuffer(NewData);
}