ChaletLora/ChaletLora.X/Source/SIM7080GInterface.c

#include "SIM7080GInterface.h"
#include "BoardCfg.h"
#include "timer.h"
#include "Uart.h"
#include "Syslog.h"
#include "WiFiCtrl.h"

int mLTEModuleSMState;
int mNbCmdCharsReceived;
char mATCmd[LTE_MODULE_MAX_CMD_LENGTH];
bool mIsPassthroughEnabled;
bool mModuleSerialDebugEnabled;
bool mPICSerialDebugEnabled;

void InitLTEModule()
{
    mLTEModuleSMState = LTE_MODULE_SM_INIT_STATE;
    mNbCmdCharsReceived = 0;
    mIsPassthroughEnabled = false;
    mModuleSerialDebugEnabled = false;
    mPICSerialDebugEnabled = false;
}

void LTEModuleSM(int SMEvent)
{
    switch(mLTEModuleSMState)
    {
        case LTE_MODULE_SM_INIT_STATE:
        {
            LTE_MODULE_PWR_PIN = 0;
            TimerStart(LTE_MODULE_TIMER,LTE_MODULE_POWERUP_TIMEOUT);
            mLTEModuleSMState = LTE_MODULE_SM_POWERUP_STATE;
            break;
        }
        case LTE_MODULE_SM_POWERUP_STATE:
        {
            if(IsTimerExpired(LTE_MODULE_TIMER) == true)
            {
                LTE_MODULE_PWR_PIN = 1;
                TimerStart(LTE_MODULE_TIMER,LTE_MODULE_WAIT_INIT_TIMEOUT);
                mLTEModuleSMState = LTE_MODULE_SM_WAIT_RDY_STATE;
            }
            break;
        }
        case LTE_MODULE_SM_WAIT_RDY_STATE:
        {
            if(SMEvent == LTE_MODULE_RX_RDY_EVENT)
            {
                mLTEModuleSMState = LTE_MODULE_SM_SETECHOOFF_STATE;
            }
            else if(SMEvent == LTE_MODULE_SM_TICK_EVENT)
            {
                //TODO: it module takes too much time... reset..
                //            if(IsTimerExpired(LTE_MODULE_TIMER) == true)
                //            {
                //                mLTEModuleSMState = LTE_MODULE_SM_SETAPN_STATE;
                //            }
            }
            break;
        }
        case LTE_MODULE_SM_SETECHOOFF_STATE:
        {
            char Cmd[5] = {'A','T','E','0','\r'};
            //UartTransmitData(LTE_IF_UART_PORT,Cmd,5);
            SendDataToLteModule(Cmd,5);
            mLTEModuleSMState = LTE_MODULE_SM_RUN_STATE;
            break;
        }
        case LTE_MODULE_SM_SETAPN_STATE:
        {
            char Cmd[10] = {'A','T','+','C','G','N','A','P','N','\r'};
            //UartTransmitData(LTE_IF_UART_PORT,Cmd,10);
            SendDataToLteModule(Cmd,10);
            mLTEModuleSMState = LTE_MODULE_SM_RUN_STATE;
            break;
        }
        case LTE_MODULE_SM_RUN_STATE:
        {
            if(SMEvent == LTE_MODULE_ENTER_PASSTHROUGH_EVENT)
            {
                mLTEModuleSMState = LTE_MODULE_SM_PASSTHROUGH_STATE;
                SyslogNewString("LTE Module entering passthrough mode...");
            }
            
            break;
        }
        case LTE_MODULE_SM_PASSTHROUGH_STATE:
        {
            if(SMEvent == LTE_MODULE_EXIT_PASSTHROUGH_EVENT)
            {
                SyslogNewString("LTE Module exiting passthrough mode...");
                mLTEModuleSMState = LTE_MODULE_SM_RUN_STATE;  
            }
            break;
        }
    }
}

void TickLTEModule()
{
    LTEModuleSM(LTE_MODULE_SM_TICK_EVENT);
}


void LTEModuleNewData(unsigned char Data)
{
    if(mIsPassthroughEnabled == true)
    {
        SyslogNewByte(Data);
        //        SendSyslogByte(Data);
        return;
    }
    
    if(mModuleSerialDebugEnabled == true)
    {
        SyslogNewByte(Data);
    }
    
    if(Data == '\n')    //ignore line feeds
        return;
    
    if(Data != '\r')
    {
        if(mNbCmdCharsReceived < LTE_MODULE_MAX_CMD_LENGTH)
        {
            mATCmd[mNbCmdCharsReceived] = Data;
            mNbCmdCharsReceived++;
        }
        else
        {
            //error...
            mNbCmdCharsReceived = 0;
        }
    }
    else
    {
        if(mNbCmdCharsReceived != 0)    //New Command received
        {
            
            if(mLTEModuleSMState == LTE_MODULE_SM_WAIT_RDY_STATE)
            {
                if(mATCmd[0] == 'R' && mATCmd[1] == 'D' && mATCmd[2] == 'Y')
                {
                    LTEModuleSM(LTE_MODULE_RX_RDY_EVENT);
                }
            }
            else if(mLTEModuleSMState == LTE_MODULE_SM_RUN_STATE)
            {
                //Fwd cmd to interpreter...
                mNbCmdCharsReceived = mNbCmdCharsReceived;
            }
            
            mNbCmdCharsReceived = 0;
        }
        
    }
}

void LTEEnterSerialPassthrough()
{
    LTEModuleSM(LTE_MODULE_ENTER_PASSTHROUGH_EVENT);
    mIsPassthroughEnabled = true;
    SyslogSetLTEPassthrough(true);
    mPICSerialDebugEnabled = false;
    mModuleSerialDebugEnabled = false;
}
void LTEExitSerialPassthrough()
{
    LTEModuleSM(LTE_MODULE_EXIT_PASSTHROUGH_EVENT);
    mIsPassthroughEnabled = false;
    SyslogSetLTEPassthrough(false);
}

void LTEFwdPassthroughData(char Data)
{
    if(mIsPassthroughEnabled == true)
    {
        UartTransmitData(LTE_IF_UART_PORT,&Data,1);
    }
    
}

int LTEEnableSerialDebug(bool EnModule, bool EnPic)
{
    if(EnModule == true)
    {
        if(mIsPassthroughEnabled == true)
        {
            return RET_ERROR;
        }
        mModuleSerialDebugEnabled = true;
    }
    else
    {
        mModuleSerialDebugEnabled = false;
    }
    
    if(EnPic == true)
    {
        if(mIsPassthroughEnabled == true)
        {
            return RET_ERROR;
        }
        
        mPICSerialDebugEnabled = true;
    }
    else
    {
        mPICSerialDebugEnabled = false;
    }
        
    return RET_OK;
}

void SendDataToLteModule(char *Data, int Size)
{
    if(mPICSerialDebugEnabled)
    {
        int i;
        for(i = 0; i < Size; i++)
        {
            SyslogNewByte(*Data++);
        }
    }
    UartTransmitData(LTE_IF_UART_PORT,Data,Size);
}