/*******************************************************************************
 * File Name         : rola.c
 * Description       :
 * Created on        : 2022Äê4ÔÂ30ÈÕ
 * Author            : hidi.ltd
 *******************************************************************************/

/*******************************************************************************
 *                              Include Files                                  *
 *******************************************************************************/
#include "lora.h"
#include "uart.h"
#include "HIDO_Timer.h"
#include "gpio.h"
#include "HIDO_Util.h"
#include "stdarg.h"
#include "string.h"
#include "stdio.h"
#include "HIDO_Debug.h"
#include "global_param.h"
/*******************************************************************************
 *                                  Macro                                      *
 *******************************************************************************/

#define LORA_UART_RX_BUF_SIZE   (1024)
#define LORA_UART_TX_BUF_SIZE   (128)
uint8_t lora_rxbuf[256]={0,};
uint8_t lora_rxbufnum=0;
extern uint8_t lora_sendfinalbag_flag;
extern uint32_t dev_id;
/*******************************************************************************
 *                             Type Definition                                 *
 *******************************************************************************/
typedef enum
{
    RECV_STATE_HEAD,
    RECV_STATE_BODY,
} E_RecvState;

typedef enum
{
    LORA_CMD_GOTO_AT_MODE,
    LORA_CMD_CONFIG_WAN_MODE,
    LORA_CMD_JOIN_OTAA,
    LORA_CMD_CONFIG_CLASS,
    LORA_CMD_SET_DEVEUI,
    LORA_CMD_SET_APPEUI,
    LORA_CMD_SET_APPKEY,
    LORA_CMD_SET_DR,
    LORA_CMD_SET_CH,
    LORA_CMD_SET_ADR,
    LORA_CMD_SET_SLEEP,
    LORA_CMD_REBOOT,

    LORA_CMD_MAX,
} E_LoraCmd;

typedef enum
{
	LORA_EVENT_START,
	LORA_EVENT_CMD_OK,
    LORA_EVENT_CMD_ERROR,
	LORA_EVENT_CMD_TIMEOUT,
} E_LoraEvent;

/*******************************************************************************
 *                             Local Variable                                  *
 *******************************************************************************/
static E_RecvState l_eRecvState = RECV_STATE_HEAD;
static ST_GPIO l_astLoraPin[LORA_PIN_MAX];
static HIDO_UINT8 l_au8LoraUartRxBuf[LORA_UART_RX_BUF_SIZE];
static HIDO_UINT8 l_au8LoraUartTxBuf[LORA_UART_TX_BUF_SIZE];

static HIDO_UINT32 l_u32LoraTimerID;
static HIDO_UINT8 l_au8LoraRecvBuff[128];
static HIDO_UINT32 l_u32LoraRecvLen;
static E_LoraCmd l_eLoraCmd = LORA_CMD_MAX;
uint8_t lora_recv_num=0;
static HIDO_CHAR *l_apcLoraCmd[LORA_CMD_MAX] =
{
        "+++\r",
        "at+mode=mac\r",
        "at+join=otaa,10\r",
        "at+class=a\r",
        "at+deveui=4736549f0031%04x\r",
        "at+appeui=526973696e674846\r",
        "at+appkey=2b7e151628aed2a6abf7158809cf4f3c\r",
        "at+dr=5\r",
        "at+ch=cn470,3\r",
        "at+adr=off\r",
        "at+sleep=light,0,level,low\r",
        "at+reboot\r",
};

/*******************************************************************************
 *                        Local Function Declaration                           *
 *******************************************************************************/
HIDO_VOID Lora_Fsm(E_LoraEvent _eEvent);

/*******************************************************************************
 *                             Local Function                                  *
 *******************************************************************************/

/*******************************************************************************
 * Function Name     : Lora_CmdTimeout
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
static void Lora_CmdTimeout(void *_pArg)
{
    Lora_Fsm(LORA_EVENT_CMD_TIMEOUT);
}

/*******************************************************************************
 * Function Name     : Lora_RecvResp
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
static void Lora_RecvResp(HIDO_UINT8 *_pu8Resp, HIDO_UINT32 _u32Len)
{
    HIDO_TimerCancel(l_u32LoraTimerID);

    if(HIDO_UtilStrStr(_pu8Resp, _u32Len, "ok") != HIDO_NULL)
    {
        HIDO_Debug("[R] %s\n", (HIDO_CHAR *)_pu8Resp);
    	Lora_Fsm(LORA_EVENT_CMD_OK);
        
    }
    else if(HIDO_UtilStrStr(_pu8Resp, _u32Len, "error") != HIDO_NULL)
    {
        HIDO_Debug("[R] %s\n", (HIDO_CHAR *)_pu8Resp);
    	Lora_Fsm(LORA_EVENT_CMD_ERROR);
    }
}

/*******************************************************************************
 * Function Name     : Lora_RecvByte
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
static HIDO_INT32 Lora_RecvByte(HIDO_UINT8 _pu8Byte)
{
	if(RECV_STATE_BODY == l_eRecvState)
	{
		if(l_u32LoraRecvLen < (sizeof(l_au8LoraRecvBuff) - 1))
		{
			l_au8LoraRecvBuff[l_u32LoraRecvLen++] = _pu8Byte;
		}
	}

	if('\n' == _pu8Byte)
	{
		l_u32LoraRecvLen = 0;
		l_eRecvState = RECV_STATE_BODY;
	}
	else if('\r' == _pu8Byte)
	{
		l_eRecvState = RECV_STATE_HEAD;
		if(l_u32LoraRecvLen != 0)
		{
			l_au8LoraRecvBuff[l_u32LoraRecvLen - 1] = '\0';
			Lora_RecvResp(l_au8LoraRecvBuff, l_u32LoraRecvLen);
		}
	}

	return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Lora_SendCmd
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
static HIDO_INT32 Lora_SendCmd(const HIDO_CHAR *_pcCmd, ...)
{
    va_list ap;
    HIDO_INT32 i32Ret;
    HIDO_CHAR acCmdBuf[64];

    va_start(ap, _pcCmd);
    vsnprintf(acCmdBuf, sizeof(acCmdBuf), _pcCmd, ap);
    va_end(ap);

    i32Ret = Uart_Send(UART_ID_LORA, (HIDO_UINT8 *) acCmdBuf, strlen(acCmdBuf));
    HIDO_TimerStart(l_u32LoraTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), Lora_CmdTimeout, HIDO_NULL);
    HIDO_Debug("[S] %s\n", acCmdBuf);
    return i32Ret;
}

/*******************************************************************************
 * Function Name     : Lora_Fsm
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_VOID Lora_Fsm(E_LoraEvent _eEvent)
{
    if(LORA_EVENT_START == _eEvent)
    {
        Lora_WakeUp();
        HAL_Delay(5);
        l_eLoraCmd = LORA_CMD_GOTO_AT_MODE;
        Lora_SendCmd(l_apcLoraCmd[l_eLoraCmd]);
        return;
    }

    if(LORA_EVENT_CMD_TIMEOUT == _eEvent)
    {
        if(LORA_CMD_GOTO_AT_MODE == l_eLoraCmd)
        {
            Lora_SendCmd(l_apcLoraCmd[l_eLoraCmd]);
            return;
        }
        
        return;
    }

    if(LORA_EVENT_CMD_OK == _eEvent)
    {
        l_eLoraCmd++;
        if(l_eLoraCmd < LORA_CMD_MAX)
        {
            if(LORA_CMD_SET_DEVEUI == l_eLoraCmd)
            {
                Lora_SendCmd(l_apcLoraCmd[l_eLoraCmd], dev_id);
            }
            else
            {
                Lora_SendCmd(l_apcLoraCmd[l_eLoraCmd]);
            }
        }
        else
        {
            Lora_Sleep();
        }

        return;
    }
}

/*******************************************************************************
 *                             Global Function                                 *
 *******************************************************************************/

/*******************************************************************************
 * Function Name     : Lora_Poll
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
extern void delay_ms(uint32_t nTimer)  ;
extern uint8_t lora_sendfinal_rx_bag_flag;
uint8_t flag_lorainit=1;
uint8_t fengming_time,fengming_flag;
extern uint32_t lora_sendfinal_rx_time;
void Lora_Poll(void)
{
    HIDO_UINT8 u8Byte = 0;
    uint16_t lora_recv_devid=0;
    uint16_t lora_recv_gpstime=0;
    while(Uart_GetChar(UART_ID_LORA, &u8Byte) == HIDO_OK)
	{
    	Lora_RecvByte(u8Byte);
        lora_rxbuf[lora_rxbufnum++]=u8Byte;
        if(lora_rxbuf[0]==0x55&&lora_rxbuf[1]==0xAA&&lora_rxbuf[9]==0x55&&lora_rxbuf[10]==0xAA)
        {
          memcpy(&lora_recv_devid,&lora_rxbuf[4],2);
            if(lora_recv_devid==dev_id)
            {
            if(lora_rxbuf[6]==0x01&&lora_rxbuf[7]==0x01&&lora_rxbuf[8]==0x00)//½ÓÊÕGPS»Ø¸´µÄOK
            {   
                lora_sendfinal_rx_time=0;   
                lora_sendfinalbag_flag=0;
                lora_sendfinal_rx_bag_flag=0;
                HIDO_Debug("ÊÕµ½GPSµÄOK\r\n");
                memset(&lora_rxbuf,0,sizeof(lora_rxbuf));
                lora_rxbufnum=0;
            }
            if(lora_rxbuf[6]==0x02)//½ÓÊÕÏ·¢ÐÞ¸ÄGPS¿ª¹Øʱ¼ä²ÎÊý
            {  
                memcpy(&lora_recv_gpstime,&lora_rxbuf[7],2);
                if(lora_recv_gpstime<=60)
                    lora_recv_gpstime=60;
                g_com_map[GPS_ONTIME]=lora_recv_gpstime;
                save_com_map_to_flash();
                HIDO_Debug("ÊÕµ½ÐÞ¸ÄGPS¿ª¹Øʱ¼ä:%d\r\n",lora_recv_gpstime);
                delay_ms(100);
                NVIC_SystemReset();
            }
            if(lora_rxbuf[6]==0x03)//½ÓÊÕÏ·¢Ð޸ľ²Ö¹ÐÝÃßʱ¼ä²ÎÊý
            {  
                memcpy(&lora_recv_gpstime,&lora_rxbuf[7],2);
                    if(lora_recv_gpstime<=10)
                    lora_recv_gpstime=10;
                g_com_map[NOMOVESLEEP_TIME]=lora_recv_gpstime;
                save_com_map_to_flash();
                HIDO_Debug("ÊÕµ½Ð޸ľ²Ö¹ÐÝÃßʱ¼ä:%d\r\n",lora_recv_gpstime);
                delay_ms(100);
                NVIC_SystemReset();
            }
            if(lora_rxbuf[6]==0x04)//½ÓÊÕÏ·¢·äÃù
            {  
                memcpy(&lora_recv_gpstime,&lora_rxbuf[7],2);
                    if(lora_recv_gpstime<=10)
                    {lora_recv_gpstime=10;}
                    if(lora_recv_gpstime>100)
                    {lora_recv_gpstime=100;}
                    fengming_time=lora_recv_gpstime;
                    fengming_flag=1       ;
                    lora_sendfinalbag_flag=0;
                    lora_sendfinal_rx_bag_flag=0;
                    lora_sendfinal_rx_time=0;
                    memset(&lora_rxbuf,0,sizeof(lora_rxbuf));
                    lora_rxbufnum=0;
            }
            }
        
        } 

	}
    if(Lora_IsIdle() == HIDO_TRUE&&flag_lorainit)
    {
      memset(&lora_rxbuf,0,sizeof(lora_rxbuf));
        flag_lorainit=0;
        lora_rxbufnum=0;
    }
}

/*******************************************************************************
 * Function Name     : Lora_ResetH
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
void Lora_ResetH(void)
{
    GPIO_SET(&l_astLoraPin[LORA_PIN_RESET]);
}

/*******************************************************************************
 * Function Name     : Lora_ResetL
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
void Lora_ResetL(void)
{
    GPIO_RESET(&l_astLoraPin[LORA_PIN_RESET]);
}

/*******************************************************************************
 * Function Name     : Lora_ResetH
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
void Lora_Sleep(void)
{
    GPIO_RESET(&l_astLoraPin[LORA_PIN_SLEEP]);
}

/*******************************************************************************
 * Function Name     : Lora_WakeUp
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
void Lora_WakeUp(void)
{
    GPIO_SET(&l_astLoraPin[LORA_PIN_SLEEP]);
}

/*******************************************************************************
 * Function Name     : Lora_ResetL
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_BOOL Lora_IsRun(void)
{
    if(GPIO_IS_SET(&l_astLoraPin[LORA_PIN_RESET]))
    {
        return HIDO_TRUE;
    }
    else
    {
        return HIDO_FALSE;
    }
}

/*******************************************************************************
 * Function Name     : Lora_ResetL
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_VOID Lora_Run(void)
{
    Lora_Fsm(LORA_EVENT_START);
}

/*******************************************************************************
 * Function Name     : Lora_PinRegister
 * Description       : Lora¹Ü½Å×¢²á
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_INT32 Lora_PinRegister(E_LoraPin _ePin, void *_pGPIO, HIDO_UINT16 _u16Pin)
{
    if(_ePin >= LORA_PIN_MAX)
    {
        return HIDO_ERR;
    }
    
    l_astLoraPin[_ePin].m_pstGPIOx = (GPIO_TypeDef *)_pGPIO;
    l_astLoraPin[_ePin].m_u16GPIOPin = _u16Pin;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Lora_IsIdle
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_BOOL Lora_IsIdle(void)
{
    if(LORA_CMD_MAX == l_eLoraCmd)
    {
        return HIDO_TRUE;
    }
    
    return HIDO_FALSE;
}

/*******************************************************************************
 * Function Name     : Lora_SendData
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_INT32 Lora_SendData(HIDO_UINT8 *_pu8Data, HIDO_UINT32 _u32Len)
{
    if(LORA_CMD_MAX != l_eLoraCmd)
    {
        return HIDO_ERR;
    }
    
    Lora_WakeUp();
    HAL_Delay(5);
    Uart_Send(UART_ID_LORA, _pu8Data, _u32Len);
    HAL_Delay(5);
    Lora_Sleep();
    
    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Lora_Init
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_INT32 Lora_Init(void)
{
    ST_UartInit stInit;

    stInit.m_eRxMode = UART_RX_MODE_INT;
    stInit.m_eTxMode = UART_TX_MODE_POLL;
    stInit.m_pu8RxBuf = l_au8LoraUartRxBuf;
    stInit.m_u32RxBufSize = LORA_UART_RX_BUF_SIZE;
    stInit.m_pu8TxBuf = l_au8LoraUartTxBuf;
    stInit.m_u32TxBufSize = LORA_UART_TX_BUF_SIZE;
    stInit.m_u32TxQueueMemberCnt = 2;
    Uart_Init(UART_ID_LORA, &stInit);

    HIDO_TimerCreate(&l_u32LoraTimerID);

    Lora_WakeUp();
    Lora_ResetH();
    
    HAL_Delay(100);
    Lora_Run();

    return HIDO_OK;
}