IoT_SCV_CH584M/bsp/src/bsp_ml307r.c

#include "bsp_ml307r.h"
#include "at_chat.h"
#include "at_port.h"
#include "bsp_uart.h"
#include "log.h"
#include "stdio.h"
#include "CONFIG.h"
#include "SLEEP.h"
#include "bsp_iwdg.h"
#include "bsp_bmp390.h"
#include "bsp_tim.h"
#include "time.h"
#include <stdlib.h>
#undef  LOG_ENABLE
#define LOG_ENABLE  1

IotFlagStruct  IotFlag_t;

#define ML307_PERIODIC_EVT (0x0001 << 0)


MultiTimer Multi_Power_ON_t;  //<2F><><EFBFBD><EFBFBD>
MultiTimer Multi_Power_OFF_t; //<2F>ػ<EFBFBD>
MultiTimer Multi_Restart_t;   //<2F><><EFBFBD><EFBFBD>
MultiTimer Multi_Cpin_t;      //cpin
MultiTimer Multi_Connect_t;   //Connect
MultiTimer Multi_Send_t;      //Send
MultiTimer Multi_StopTask_t;  //StopTask
MultiTimer Multi_Loop_t;      //Loop

// <20><>Դ״̬
typedef enum {
    POWER_STATE_INIT,
    POWER_STATE_ON_START,
    POWER_STATE_ON_COMPLETE,
    POWER_STATE_OFF_START,
    POWER_STATE_OFF_COMPLETE
} ml307_power_state_t;

static ml307_power_state_t ml307_power_state = POWER_STATE_INIT;
static tmosTaskID ml307_task_id = INVALID_TASK_ID;

at_obj_t *ml307r_obj;
uint8_t databuf[5] = {0x01,0xaa,0x12,0xde,0x39};


int Ml307r_Gpio_Init(void)
{
    GPIOB_SetBits(ENABLE_3_8_V);
    GPIOB_ModeCfg(ENABLE_3_8_V, GPIO_ModeOut_PP_5mA);

    GPIOB_ResetBits(ML307_RST_PIN);
    GPIOB_ModeCfg(ML307_RST_PIN, GPIO_ModeOut_PP_5mA);

    GPIOB_ModeCfg(USIM_DECT_PIN, GPIO_ModeIN_Floating);

    GPIOB_ModeCfg(ML307_PWR_PIN, GPIO_ModeOut_PP_5mA);


    return 0;
}

void At_Debug(const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    vprintf(fmt, args);
    va_end(args);
}

void Ml307_Delay_Ms(uint16_t ms)
{
    DelayMs(ms);
}

void Ml307_Delay_us(uint16_t us)
{
    DelayUs(us);
}

static const at_adapter_t at_adapter =
{
    .write  = BSP_Uart1_Send_Data,
    .read   = BSP_Uart1_Receive_Data,
    .debug  = At_Debug,
    .recv_bufsize   = 256,
    .urc_bufsize    = 512
};

static uint8_t state = 0;
/*
 * ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<EFBFBD><EFBFBD>λ:ms,Ĭ<EFBFBD><EFBFBD>:10s
 */
#define   POWERON_RETRY_INTERVAL_TIME           (10*1000UL)
#define   RESTART_RETRY_INTERVAL_TIME           (40*1000UL)
#define   CPIN_RETRY_INTERVAL_TIME              (20*1000UL)
#define   CONNECT_RETRY_INTERVAL_TIME           (20*1000UL)
#define   SEND_RETRY_INTERVAL_TIME              (30*1000UL)
#define   STOP_TASK_INTERVAL_TIME               (25*1000UL)
#define   LOOP_INTERVAL_TIME                    (30*1000UL)

//<2F><><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>
void Power_ON_t_CallBack(MultiTimer* timer, void* userData)
{
    IotFlag_t.PowerOn_error_flag = 1;
}

//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD>ص<EFBFBD>
void Restart_CallBack(MultiTimer* timer, void* userData)
{
    IotFlag_t.restart_error_flag = 1;
}

//Cpin<69><6E>ʱ<EFBFBD>ص<EFBFBD>
void Cpin_CallBack(MultiTimer* timer, void* userData)
{
    IotFlag_t.sim_error_flag = 1;
}

//Connect<63><74>ʱ<EFBFBD>ص<EFBFBD>
void Connect_CallBack(MultiTimer* timer, void* userData)
{
    IotFlag_t.Connect_error_flag = 1; 
}

//Send<6E><64>ʱ<EFBFBD>ص<EFBFBD>
void Send_CallBack(MultiTimer* timer, void* userData)
{
    IotFlag_t.send_error_flag = 1; 
}

//Loop<6F>ص<EFBFBD>
void Loop_CallBack(MultiTimer* timer, void* userData)
{
    state = 0;
    IotFlag_t.Loop_count_flag++;
    IotFlag_t.module_init_flag = 1;
    IotFlag_t.Iot_Retry_flag = 0;
}

//StopTask<73><6B>ʱ<EFBFBD>ص<EFBFBD>
void StopTask_CallBack(MultiTimer* timer, void* userData)
{
    logDebug("BSP_Ml307_Power_Off\r\n");
    IotFlag_t.Loop_count_flag = 0;
    if(IotFlag_t.PowerOn_error_flag == 1)
    {
        IotFlag_t.PowerOn_error_flag = 0;
        tmos_stop_task(ml307_task_id, ML307_PERIODIC_EVT); 
        BSP_RequestSleep();
    }else{
        BSP_Ml307_Power_Off();          //<2F>ػ<EFBFBD>
        tmos_stop_task(ml307_task_id, ML307_PERIODIC_EVT); 
        BSP_RequestSleep();
    }
}

//ģ<><C4A3>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
static int URC_Module_Ready_Cb(at_urc_info_t *info)
{
    logDebug("module CPIN READY ! \r\n");

    return 0;
}


/**
 * @brief urc<EFBFBD><EFBFBD><EFBFBD>ı<EFBFBD>
 */
static const urc_item_t urc_table[] =
{
    {.prefix = "+CPIN: READY",       .endmark = '\n',  .handler = URC_Module_Ready_Cb},//ģ<><C4A3>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
};


uint64_t imei_dec = 0;//ʮ<><CAAE><EFBFBD>Ƶ<EFBFBD>IMEI,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD>
TsModule_Info_t Module_Info_t = {0};
//Convert strings to hexadecimal strings and store them in hex_arry
void Module_String2Hex(char *hex_arry, char *str)
{
    for (int i = 0; i < strlen(str); i++)
    {
        sprintf(hex_arry + (i * 2), "%02X", str[i]);
    }
}

static void Module_Get_Imei_Cb(at_response_t *r)
{
    char imei[16] = {0};
    if (r->code == AT_RESP_OK)
    {
        if (sscanf(r->prefix, "+GSN:%s\r\n", imei) == 1)
        {
            logDebug("imei: %s\r\n", imei);
            imei_dec = strtoll(imei, NULL, 10);
            Module_String2Hex(Module_Info_t.imei, imei);
            sprintf(Module_Info_t.imei_len, "%04X", strlen(Module_Info_t.imei)/2);
            logDebug("Module_Info_t.imei: %s\r\n", Module_Info_t.imei);
        }
    }
    else
    {
        logDebug("'CGSN' command response failed!\r\n");
    }
}

/*
 * @brief <EFBFBD><EFBFBD>ȡIMEI<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 * @return
 */
static void Module_Get_Imei(void)
{
    at_attr_t attr;
    at_attr_deinit(&attr);
    attr.prefix = "+GSN:";
    attr.cb = Module_Get_Imei_Cb;
    at_send_singlline(ml307r_obj, &attr, "AT+GSN=1");
}

static void Module_Get_Imsi_Cb(at_response_t *r)
{
    char imsi[60] = {0};
    if (r->code == AT_RESP_OK)
    {
        if (sscanf(r->prefix, "%s\r\n", imsi) == 1)
        {
            logDebug("imsi:%s\r\n",imsi);
            Module_String2Hex(Module_Info_t.imsi, imsi);
            sprintf( Module_Info_t.imsi_len, "%04X", strlen(Module_Info_t.imsi)/2);
            logDebug("Module_Info_t.imsi: %s\r\n", Module_Info_t.imsi);
        }
    }
    else
    {
        logDebug("'AT+CIMI' command response failed!\r\n");
    }
}

/*
 * @brief <EFBFBD><EFBFBD>ȡIMSI<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 * @return
 */
static void Module_Get_Imsi(void)
{
    at_attr_t attr;
    at_attr_deinit(&attr);
    attr.prefix = "46";
    attr.suffix = "\r\n";
    attr.cb = Module_Get_Imsi_Cb; 
    at_send_singlline(ml307r_obj, &attr, "AT+CIMI");
}


static void Module_Get_Iccid_Cb(at_response_t *r)
{
    char iccid[30] = {0};

    if (r->code == AT_RESP_OK)
    {
        //+QCCID: 898604D3102280304162
        if (sscanf(r->prefix, "+MCCID: %s", iccid) == 1)
        {
            logDebug("iccid: %s\r\n", iccid);
            Module_String2Hex(Module_Info_t.iccid, iccid);
            sprintf( Module_Info_t.iccid_len, "%04X", strlen(Module_Info_t.iccid)/2);
            logDebug("Module_Info_t.iccid: %s\r\n", Module_Info_t.iccid);
        }
    }
    else
    {
        logDebug("'AT+QCCID' command response failed!\r\n");
    }
}

/*
 * @brief <EFBFBD><EFBFBD>ȡICCID<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 * @return
 */
static void Module_Get_Iccid(void)
{
    at_attr_t attr;
    at_attr_deinit(&attr);
    attr.prefix = "+MCCID:";
    attr.cb = Module_Get_Iccid_Cb;
    at_send_singlline(ml307r_obj, &attr, "AT+MCCID");
}


//<2F><><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD>ض<EFBFBD><D8B6><EFBFBD>ʽ<EFBFBD><CABD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2>
void find_and_extract(char* string_buf, char* result)
{
    const char *start = "+CCLK: \"";
    const char *end = "+32\"";

    char *s = strstr(string_buf, start);
    if(s)
    {
        s += strlen(start);
        char *e = strstr(s, end);
        if(e)
        {
            *e = '\0';
            strncpy(result, s, e-s+1);
        }
    }
}

/*
 * ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ã<EFBFBD>Ĭ<EFBFBD>϶<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 */
#define TIMER_ZONE                              (8U)

// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>ת<EFBFBD><D7AA>Ϊ<EFBFBD><CEAA>Ӧʱ<D3A6><CAB1>ʱ<EFBFBD><CAB1>
static void Time_Zone_Conversion(struct tm* timeInfo)
{
    // <20><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>Ϊ8Сʱ<D0A1><CAB1>û<EFBFBD>з<EFBFBD><D0B7>Ӳ<EFBFBD><D3B2>졣
    timeInfo -> tm_hour += TIMER_ZONE; //Сʱ<D0A1><CAB1><EFBFBD>ּ<EFBFBD>8Сʱ
    if (timeInfo -> tm_hour >= 24)
    {                                  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>24Сʱ<D0A1><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1<EFBFBD><31>Сʱ<D0A1><CAB1><EFBFBD><EFBFBD>24<32><34>
        timeInfo -> tm_mday++;
        timeInfo -> tm_hour -= 24;
        if (timeInfo -> tm_mday >365)
        {
            timeInfo -> tm_year += 1;
        }
    }
}


struct tm Network_Time_t;//<2F><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>

static void Module_Timer_Cb(at_response_t *r)
{
    int year, mounth, days, hous, min, sec;

    char urc_buf[32] = {0};

    if (r->code == AT_RESP_OK)
    {
        // +CCLK: "24/02/01,05:11:35+32"
        find_and_extract(r->recvbuf, urc_buf);
        if(sscanf(urc_buf, "%d/%d/%d,%d:%d:%d", &year, &mounth, &days, &hous, &min, &sec) == 6)
        {
            logDebug("urc_buf:%s\r\n", urc_buf);
            Network_Time_t.tm_year = (2000 + year);
            Network_Time_t.tm_mon  = mounth;
            Network_Time_t.tm_mday = days;
            Network_Time_t.tm_hour = hous;//<2F><>ʱΪ<CAB1><CEAA><EFBFBD><EFBFBD>ʱ<EFBFBD>䣬<EFBFBD><E4A3AC>Ҫת<D2AA><D7AA>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            Network_Time_t.tm_min  = min;
            Network_Time_t.tm_sec  = sec;
            Time_Zone_Conversion(&Network_Time_t);//ʱ<><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

            // RTC_InitTime(Network_Time_t.tm_year, Network_Time_t.tm_mon, Network_Time_t.tm_mday,
            //                               Network_Time_t.tm_hour, Network_Time_t.tm_min, Network_Time_t.tm_sec); //<2F><><EFBFBD>µ<EFBFBD>ǰʱ<C7B0><CAB1>
            // IotFlag_t.update_time_flag = 1;
            logDebug("NET Timer :%04d-%02d-%02d, %02d:%02d:%02d\r\n", Network_Time_t.tm_year, Network_Time_t.tm_mon, Network_Time_t.tm_mday,
                    Network_Time_t.tm_hour, Network_Time_t.tm_min, Network_Time_t.tm_sec);
        }
        else
        {
               logDebug("Network time resolution failed\r\n");//<2F><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>
        }
    }
    else
    {
        logDebug("Network time acquisition failed\r\n");//<2F><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>ȡʧ<C8A1><CAA7>
    }
}

static void Module_Timer(void)
{
    at_attr_t attr;

    at_attr_deinit(&attr);
    attr.cb = Module_Timer_Cb;
    at_send_singlline(ml307r_obj, &attr, "AT+CCLK?");
}


Ts_Network_Service_Info_t Service_Info_t = {0};

static void Module_NetWork_Info_Cb(at_response_t *r)
{
    if (r->code == AT_RESP_OK)
    {
        //"radio",<rat>,<rsrp>,<rssi>,<tx_power>,<tx_time>,<rx_time>,<last_cellid>,<last_ecl>,<last_sinr>,<last_earfcn>,<last_pci>,<rsrq>
        //+MUESTATS: "radio",4,-660,-400,-32768,0,0,0FB5E606,255,280,38950,22,-60<36><30>
        char *token = strtok(r->prefix, ",");
        int i = 0;
        while (token != NULL)
        {
            if (i == 0)
            {
                i++;
                token = strtok(NULL, ",");
                continue;
            }
            char hex_str[20] = {0};
            if ((i == 2)||(i == 3)||(i == 4)||(i == 12))
            {
                long int num = strtol((token+1), NULL, 10);
                sprintf(hex_str, "%08X", num);
            }
            else
            {
                if (i != 7)
                {
                    long int num = strtol(token, NULL, 10);
                    if ((i == 2)||(i == 9))
                    {
                        // num = num*10;
                        sprintf(hex_str, "%08X", num);
                    }
                    else
                    {
                        sprintf(hex_str, "%08X", num);
                    }
                }
            }
            switch (i)
            {
                case 1:
                    strcpy(Service_Info_t.rat, hex_str);
                    break;
                case 2:
                    strcpy(Service_Info_t.rsrp, hex_str);
                    break;
                case 3:
                    strcpy(Service_Info_t.rssi, hex_str);
                    break;
                case 4:
                    sprintf(Service_Info_t.tx_power,"%08s", hex_str);

                    break;
                case 5:
                    strcpy(Service_Info_t.tx_time, hex_str);
                    break;
                case 6:
                    strcpy(Service_Info_t.rx_time, hex_str);//rsrpʵ<70><CAB5>ֵx10<31><30>
                    break;
                case 7:
                    strncpy(hex_str, token+1, 8);
                    sprintf(Service_Info_t.last_cellid,"%08s", hex_str);
                    break;
                case 8:
                    strcpy(Service_Info_t.last_ecl, hex_str);//sinrʵ<72><CAB5>ֵx10<31>ϱ<EFBFBD>
                    break;
                case 9:
                    strcpy(Service_Info_t.last_sinr, hex_str);
                    break;
                case 10:
                    strcpy(Service_Info_t.last_earfcn, hex_str);
                    break;
                case 11:
                    strcpy(Service_Info_t.last_pci, hex_str);
                    break;
                case 12:
                    strcpy(Service_Info_t.rsrq, hex_str);
                    break;
                default:
                    break;
            }
            i++;
            token = strtok(NULL, ",");
        }
        //    logDebug("Service_Info_t = %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s\r\n", Service_Info_t.rat,
        //            Service_Info_t.rsrp,Service_Info_t.rssi,Service_Info_t.tx_power,Service_Info_t.tx_time,
        //            Service_Info_t.rx_time,Service_Info_t.last_cellid,Service_Info_t.last_ecl,Service_Info_t.last_sinr,
        //            Service_Info_t.last_earfcn,Service_Info_t.last_pci,Service_Info_t.rsrq);
    }
    else
    {
        logDebug("AT+MUESTATS=radio command response failed!\r\n");
    }
}

/*
 * @brief <EFBFBD><EFBFBD>ȡ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>IJ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
 * @return
 */
static void Module_NetWork_Info(void)
{
    at_attr_t attr;

    at_attr_deinit(&attr);
    attr.prefix = "+MUESTATS: ";
    attr.cb = Module_NetWork_Info_Cb;
    at_send_singlline(ml307r_obj, &attr, "AT+MUESTATS=\"radio\"");
}


static void BSP_Get_Module_Info(void)
{
    at_send_data(ml307r_obj, NULL, "+++", 3);               // <20>˳<EFBFBD>͸<EFBFBD><CDB8>ģʽ
    Module_Get_Imei();
    Module_Get_Imsi();
    Module_Get_Iccid();
    Module_Timer();
    Module_NetWork_Info();                                  // <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
    at_send_singlline(ml307r_obj, NULL, "AT+MIPMODE=0,1");  // <20><><EFBFBD><EFBFBD>͸<EFBFBD><CDB8>ģʽ
}


/*
 * @brief <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>豸
 * @return 
 */
static int BSP_Module_Connect_CtWing_Handle(at_env_t *e)
{
    switch (e->state)
    {
        case 0:
            logDebug("create device...\r\n");  
            e->println(e, "AT+MIPOPEN=0,\"TCP\",\"112.125.89.8\",45600,,1");  // 8.135.10.183,32994
            e->reset_timer(e);
            e->state++;
            break;
        case 1:
            if (e->contains(e, "CONNECT"))
            {
                IotFlag_t.Connect_success_flag = 1; 
                logDebug("create device complete\r\n");
                e->finish(e, AT_RESP_OK);
            }
            else if (e->is_timeout(e, 5000))
            {
                e->state--;
                if (++e->i > 3)
                {
                    logDebug("create device error\r\n");
                    IotFlag_t.Connect_error_flag = 1; 
                    e->finish(e, AT_RESP_ERROR);
                }
            }
            break;
        default:
            break;
    }
    return 0;
}
//<2F><><EFBFBD>ӷ<EFBFBD><D3B7><EFBFBD><EFBFBD><EFBFBD>
static void BSP_Module_Connect_CtWing(void)
{
    at_do_work(ml307r_obj, NULL, BSP_Module_Connect_CtWing_Handle);//<2F><><EFBFBD><EFBFBD><EFBFBD>豸
}


//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void BSP_Module_Send_Data(uint8_t* data, uint8_t len)
{
    at_attr_t attr;
    at_send_data(ml307r_obj, &attr, data, len);
}

void BSP_ML307_SendMessage(void)
{
    BSP_Get_Module_Info();         //<2F><>ȡsim<69><6D>Ϣ
    if(fault_state){
    char json_buffer[300];
    snprintf(json_buffer, sizeof(json_buffer), 
            "{"
            "\"device\":{"
                "\"id\":\"SCV001\","
                "\"time\":\"2025\""
            "},"
            "\"status\":\"closed\","
            "\"fault\":{"
                "\"lowBattery\":true,"
                "\"code\":1"
            "},"
            "\"monitor\":{"
                "\"pressure\":0.8,"
                "\"lowVoltage\":true"
            "},"
            "\"network\":{"
                "\"sinr\":15.2,"
                "\"signal\":4"
            "},"
            "\"standards\":{"
                "\"iotId\":\"IoT-SCV-12345\""
            "}"
            "}");

    // BSP_Module_Send_Data((uint8_t*)json_buffer, strlen(json_buffer));
    // logDebug("fault_state: %d\n", fault_state);
    IotFlag_t.send_complete_flag = 1;
    logDebug("BSP_ML307_SendMessage: %s\n", json_buffer);
    }
}

static int Ml307_Power_On(at_env_t *e)
{
    switch (e->state)
    {
        case 0:
            logDebug("Ml307_Power_On start!\r\n");
            GPIOB_SetBits(ML307_PWR_PIN);
            e->reset_timer(e);
            e->state++;
            break;
        case 1:
            #define ML307_POWER_ON_TIME 3
            if (e->is_timeout(e, ML307_POWER_ON_TIME *1000))
            {
                logDebug("Ml307_Power_On end!\r\n");
                GPIOB_ResetBits(ML307_PWR_PIN);
                IotFlag_t.PowerOn_success_flag = 1;
                e->finish(e, AT_RESP_OK);
            }
            break;
    }
    return 0;
}

static void BSP_Ml307_Power_On(void)
{
    at_do_work(ml307r_obj, NULL, Ml307_Power_On);
}


static int Ml307_Power_Off(at_env_t *e)
{
    switch (e->state)
    {
        case 0:
            logDebug("Ml307_Power_Off start!\r\n");
            GPIOB_SetBits(ML307_PWR_PIN);
            e->reset_timer(e);
            e->state++;
            break;
        case 1:
            #define M307_POWER_OFF_TIME 4
            if (e->is_timeout(e, M307_POWER_OFF_TIME * 1000))
            {
                GPIOB_ResetBits(ML307_PWR_PIN);
                logDebug("Ml307_Power_Off end!\r\n");
                e->reset_timer(e);
                e->state++;
           }
            break;
        case 2:
            if (e->is_timeout(e, 1000))
            {
                e->finish(e, AT_RESP_OK);
            }
            break;
    }
    return 0;
}

static void BSP_Ml307_Power_Off(void)
{
    at_do_work(ml307r_obj, NULL, Ml307_Power_Off);
}



static int Module_Restart_Work(at_env_t *e)
{
    switch (e->state)
    {
        case 0:
            logDebug("restart module...\r\n");
            e->println(e, "AT+CFUN=1,1");//<2F><><EFBFBD><EFBFBD>ģ<EFBFBD><C4A3>
            e->reset_timer(e);
            e->state++;
            break;
        case 1:
            if (e->contains(e, "OK"))
            {
                 logDebug("restart module complete\r\n");
                 e->reset_timer(e);
                 e->state++;
            }
            if (e->is_timeout(e, 5000))
            {
                e->state--;
                if (++e->i > 3)
                {
                    IotFlag_t.restart_error_flag = 1;
                    logDebug("Module restart error\r\n");
                    e->finish(e, AT_RESP_ERROR);
                }
           }
            break;
        case 2:
            logDebug("Check if the Module is ready\r\n");
            e->println(e, "AT");
            e->reset_timer(e);
            e->state++;
            break;
        case 3:
            if (e->contains(e, "OK"))
            {
                IotFlag_t.restart_success_flag = 1;
                e->recvclr(e);
                e->finish(e, AT_RESP_OK);
                logDebug("Module is ready\r\n");
            }
            if (e->is_timeout(e, 5000))
            {
                e->state--;
                if (++e->i > 3)
                {
                    IotFlag_t.restart_error_flag = 1;
                    logDebug("Module  error\r\n");
                    e->finish(e, AT_RESP_ERROR);
                }
            }
            break;
        }
    return 0;
}
//<2F><><EFBFBD><EFBFBD>ģ<EFBFBD><C4A3>
static void BSP_Restart_Module(void)
{
    at_do_work(ml307r_obj, NULL, Module_Restart_Work);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч
}



static int simcom_init(at_env_t *e)
{
    switch (e->state)
    {
        case 0:
            logDebug("simcom_cpin!\r\n");
            e->println(e, "AT+CPIN?");
            e->reset_timer(e);
            e->state++;
            break;
        case 1:
            if (e->contains(e, "+CPIN: READY"))
            {
                IotFlag_t.sim_success_flag = 1;
                logDebug("simcom CPIN READY!\r\n");
                e->finish(e, AT_RESP_OK);
            }
            if (e->is_timeout(e, 5000))
            {
                e->state--;
                if (++e->i > 3)
                {
                    IotFlag_t.sim_error_flag = 1;
                    logDebug("simcom CPIN NO READY!\r\n");
                    e->finish(e, AT_RESP_ERROR);
                }
            }
            break;
    }
    return 0;
}
//CPIN
static void BSP_simcom_init(void)
{
    at_do_work(ml307r_obj, NULL, simcom_init);
}


static void BSP_Iot_Loop(void)
{
    switch (state)
    {
        case 0:                                  //<2F><><EFBFBD><EFBFBD>
            if(IotFlag_t.module_init_flag)       //<2F><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            {
                logDebug("IotFlag_t.module_init_flag %d\r\n",IotFlag_t.module_init_flag);
                IotFlag_t.module_init_flag = 0;
                MultiTimerStart(&Multi_Power_ON_t,POWERON_RETRY_INTERVAL_TIME, Power_ON_t_CallBack, NULL);
                logDebug("BSP_Ml307_Power_On\r\n");
                BSP_Ml307_Power_On();          
            }
            if (IotFlag_t.PowerOn_success_flag)   //<2F><><EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD>
            {
                logDebug("BSP_Ml307_Power_On!\r\n");
                MultiTimerStop(&Multi_Power_ON_t);
                state++;
            }
            if (IotFlag_t.PowerOn_error_flag)     
            {
                logDebug("PowerOn_error_flag!\r\n");
                state = 5;
            }
            break;
        case 1:                                   //<2F><><EFBFBD><EFBFBD>
            if(IotFlag_t.PowerOn_success_flag)    //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            {
                IotFlag_t.PowerOn_success_flag = 0;
                MultiTimerStart(&Multi_Restart_t, RESTART_RETRY_INTERVAL_TIME, Restart_CallBack, NULL);
                BSP_Restart_Module();             
            }
            if (IotFlag_t.restart_success_flag)   //<2F><><EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD>
            {
                logDebug("restart_success_flag!\r\n");
                MultiTimerStop(&Multi_Restart_t);
                state++;
            }
            if(IotFlag_t.restart_error_flag == 1)  
            {
                MultiTimerStop(&Multi_Restart_t);
                IotFlag_t.restart_error_flag = 0;
                state = 5;
            }
            break;
        case 2:                                  //sim״̬
            if(IotFlag_t.restart_success_flag)   //<2F><><EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD>
            {
                IotFlag_t.restart_success_flag = 0;
                MultiTimerStart(&Multi_Cpin_t, CPIN_RETRY_INTERVAL_TIME, Cpin_CallBack, NULL);
                BSP_simcom_init();               
            }
            if (IotFlag_t.sim_success_flag)       //sim<69>ɹ<EFBFBD>
            {
                logDebug("BSP_Get_Module_Info!!!\r\n");
                MultiTimerStop(&Multi_Cpin_t);
                state++;
            }
            if(IotFlag_t.sim_error_flag == 1)  
            {
                logDebug("BSP_simcom_init Error !\r\n");
                MultiTimerStop(&Multi_Cpin_t);
                IotFlag_t.sim_error_flag = 0;
                state = 5;
            }
            break;
        case 3:                                  //<2F><><EFBFBD><EFBFBD>
            if(IotFlag_t.sim_success_flag)       //sim<69><6D><EFBFBD><EFBFBD>
            {
                IotFlag_t.sim_success_flag = 0;
                MultiTimerStart(&Multi_Connect_t, CONNECT_RETRY_INTERVAL_TIME, Connect_CallBack, NULL);
                BSP_Module_Connect_CtWing();     
            }
            if (IotFlag_t.Connect_success_flag)   //<2F><><EFBFBD>ӳɹ<D3B3>
            {
                logDebug("Connect_success_flag!\r\n");
                MultiTimerStop(&Multi_Connect_t);
                state++;
            }
            if(IotFlag_t.Connect_error_flag == 1)  
            {
                logDebug("Connect_error_flag!\r\n");
                IotFlag_t.Connect_error_flag = 0;
                MultiTimerStop(&Multi_Connect_t);
                state = 5;
            }
            break;
        case 4:                                  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            if(IotFlag_t.Connect_success_flag)   //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            {
                IotFlag_t.Connect_success_flag = 0;
                MultiTimerStart(&Multi_Send_t, SEND_RETRY_INTERVAL_TIME, Send_CallBack, NULL);
                BSP_ML307_SendMessage();           
            }
            if (IotFlag_t.send_complete_flag)      //<2F><><EFBFBD>ͳɹ<CDB3>
            {
                logDebug("send_complete_flag!\r\n");
                MultiTimerStop(&Multi_Send_t);
                state++;
            }
            if(IotFlag_t.send_error_flag == 1)  
            {
                logDebug("send_error_flag!\r\n");
                MultiTimerStop(&Multi_Send_t);
                IotFlag_t.send_error_flag = 0;
                state = 5;
            }
            break;
        case 5:                                  //<2F><><EFBFBD><EFBFBD>
            if(IotFlag_t.send_complete_flag == 1)
            {
                logDebug("send_complete_into_stop\r\n");
                IotFlag_t.send_complete_flag = 0;
                state = 0;   
                MultiTimerStart(&Multi_StopTask_t, STOP_TASK_INTERVAL_TIME, StopTask_CallBack, NULL);  //<2F>ر<EFBFBD>
            }else
            {
                if (IotFlag_t.Loop_count_flag > 2)
                {
                    logDebug("Loop_count_flag_end %d\r\n",IotFlag_t.Loop_count_flag);
                    state = 0;
                    IotFlag_t.Iot_Retry_flag = 0;
                    IotFlag_t.module_init_flag = 0;
                    MultiTimerStart(&Multi_StopTask_t, STOP_TASK_INTERVAL_TIME, StopTask_CallBack, NULL);
                }
                if((IotFlag_t.Iot_Retry_flag == 0)&&(IotFlag_t.Loop_count_flag < 3))
                {
                    logDebug("error_into_loop\r\n");
                    logDebug("Loop_count_flag %d\r\n",IotFlag_t.Loop_count_flag);
                    BSP_Ml307_Power_Off();          //<2F>ػ<EFBFBD>
                    MultiTimerStart(&Multi_Loop_t, LOOP_INTERVAL_TIME, Loop_CallBack, NULL);
                    IotFlag_t.Iot_Retry_flag = 1;
                }
            }
            break;
    }
}

void Ml307r_Loop(void)
{
    FEED_IWDG();
    at_obj_process(ml307r_obj);
    BSP_Iot_Loop();
}

__HIGH_CODE
__attribute__((noinline))
uint16_t Ml307r_Handle(uint8_t task_id, uint16_t events)
{
    if (events & ML307_PERIODIC_EVT)
    {
        Ml307r_Loop();
        tmos_start_task(ml307_task_id, ML307_PERIODIC_EVT, MS1_TO_SYSTEM_TIME(5));  //5
        return (events ^ ML307_PERIODIC_EVT);
    }
    return 0;
}

void BSP_Ml307r_Init(void)
{
    Ml307r_Gpio_Init();
    BSP_UART1_Init();
    ml307r_obj = at_obj_create(&at_adapter);//Create AT communication object
    if(ml307r_obj != NULL) 
    {
        at_obj_set_urc(ml307r_obj, urc_table, sizeof(urc_table) / sizeof(urc_table[0]));
        IotFlag_t.module_init_flag = 1;
        BSP_BlockSleep();
    }
    ml307_task_id = TMOS_ProcessEventRegister(Ml307r_Handle);
    tmos_set_event(ml307_task_id, ML307_PERIODIC_EVT);
}