/*
 * L505.c
 *
 *  Created on: Apr 1, 2021
 *      Author: wushufeng
 */

#include "drv_ec800k.h"
#include <stdint.h>
#include "VK_Com.h"
#include "VK_Log.h"
#include "rtdef.h"
#include "rtthread.h"
#include "rttypes.h"

#define DBG_TAG "DTU_LOG"
#define DBG_LVL DBG_INFO
#include "rtdbg.h"


Cclient_t client1 = {
    .mode = "TCP",
    /*教培IP和PORT*/
    .ip = "uavedu.jiagutech.com",
    .port = "19763",
    .connect_ID = 0,
    .connect_sta = false,
    .error_cnt = 0,
};

CLte_dev_t lte_dev = {
    .client1 = (Cclient_t *)&client1,
    .config_sta = false,
    .reset_flag = DTU_CF_NEED_RESET,
    .dev_init_flag = true,
    .data_tx_paused = false,
};

lte_diag_t lte_diag = {0};
static bool lte_log_clock_query_done = false;
static rt_uint8_t pdpdeact_match_position = 0;

typedef struct {
  rt_uint16_t remaining;
  rt_uint16_t checksum;
  rt_uint16_t received_checksum;
  rt_uint8_t magic;
  rt_uint8_t phase;
  rt_uint8_t position;
  rt_uint8_t payload_length;
  rt_uint8_t incompat_flags;
  bool heartbeat;
} mavlink_diag_parser_t;

static mavlink_diag_parser_t fmu_mavlink_parser;
static mavlink_diag_parser_t server_mavlink_parser;

static int parse_decimal(const char **text) {
  int value = 0;
  bool found = false;
  const char *p = *text;

  while (*p == ' ') p++;
  while (*p >= '0' && *p <= '9') {
    found = true;
    value = value * 10 + (*p++ - '0');
  }
  *text = p;
  return found ? value : -1;
}

static void copy_csv_token(const char **text, char *output, rt_size_t capacity) {
  const char *p = *text;
  rt_size_t used = 0;
  char terminator = ',';

  if (capacity == 0) return;
  while (*p == ' ' || *p == ',') p++;
  if (*p == '"') {
    terminator = '"';
    p++;
  }
  while (*p != '\0' && *p != '\r' && *p != '\n' && *p != terminator) {
    if (used + 1 < capacity) output[used++] = *p;
    p++;
  }
  while (used > 0 && output[used - 1] == ' ') used--;
  output[used] = '\0';
  if (*p == terminator) p++;
  *text = p;
}

static void mavlink_crc_accumulate(uint8_t data, rt_uint16_t *checksum) {
  uint8_t tmp = data ^ (uint8_t)(*checksum & 0xff);
  tmp ^= tmp << 4;
  *checksum = (*checksum >> 8) ^ ((rt_uint16_t)tmp << 8) ^
              ((rt_uint16_t)tmp << 3) ^ ((rt_uint16_t)tmp >> 4);
}

static void mavlink_diag_start(mavlink_diag_parser_t *parser, uint8_t magic) {
  parser->magic = magic;
  parser->phase = 1;
  parser->position = 0;
  parser->remaining = 0;
  parser->checksum = 0xffff;
  parser->received_checksum = 0;
  parser->payload_length = 0;
  parser->incompat_flags = 0;
  parser->heartbeat = false;
}

static void mavlink_diag_feed(mavlink_diag_parser_t *parser,
                              const uint8_t *data, rt_size_t size,
                              rt_uint32_t *heartbeat_count) {
  rt_size_t i;

  for (i = 0; i < size; i++) {
    uint8_t ch = data[i];

    if (parser->phase == 0) {
      if (ch == 0xFE || ch == 0xFD) mavlink_diag_start(parser, ch);
      continue;
    }
    if (parser->phase == 5) {
      parser->remaining--;
      if (parser->remaining == 0) parser->phase = 0;
      continue;
    }
    if (parser->phase == 2) {
      mavlink_crc_accumulate(ch, &parser->checksum);
      parser->remaining--;
      if (parser->remaining == 0) parser->phase = 3;
      continue;
    }
    if (parser->phase == 3) {
      parser->received_checksum = ch;
      parser->phase = 4;
      continue;
    }
    if (parser->phase == 4) {
      parser->received_checksum |= (rt_uint16_t)ch << 8;
      mavlink_crc_accumulate(50, &parser->checksum);
      if (parser->heartbeat &&
          parser->checksum == parser->received_checksum) {
        (*heartbeat_count)++;
      }
      if (parser->magic == 0xFD &&
          (parser->incompat_flags & 0x01) != 0) {
        parser->phase = 5;
        parser->remaining = 13;
      } else {
        parser->phase = 0;
      }
      continue;
    }

    mavlink_crc_accumulate(ch, &parser->checksum);
    if (parser->position == 0) parser->payload_length = ch;
    if (parser->magic == 0xFE && parser->position == 4) {
      parser->heartbeat = parser->payload_length == 9 && ch == 0;
      parser->remaining = parser->payload_length;
      parser->phase = parser->remaining > 0 ? 2 : 3;
    } else if (parser->magic == 0xFD) {
      if (parser->position == 1) parser->incompat_flags = ch;
      if (parser->position == 6) parser->heartbeat = ch == 0;
      if (parser->position == 7)
        parser->heartbeat = parser->heartbeat && ch == 0;
      if (parser->position == 8) {
        parser->heartbeat = parser->payload_length == 9 &&
                            parser->heartbeat && ch == 0;
        parser->remaining = parser->payload_length;
        parser->phase = parser->remaining > 0 ? 2 : 3;
      }
    }
    parser->position++;
  }
}

void lte_diag_at_begin(const char *cmd) {
  rt_size_t i;

  lte_diag.at_commands++;
  lte_diag.last_at_elapsed = rt_tick_get();
  lte_diag.last_at_result = -2;
  for (i = 0; i < sizeof(lte_diag.last_at_cmd) - 1 && cmd[i] != '\0'; i++) {
    lte_diag.last_at_cmd[i] = (cmd[i] == '\r' || cmd[i] == '\n') ? '_' : cmd[i];
  }
  lte_diag.last_at_cmd[i] = '\0';
}

void lte_diag_at_end(rt_int32_t result) {
  rt_tick_t now = rt_tick_get();
  lte_diag.last_at_elapsed = now - lte_diag.last_at_elapsed;
  lte_diag.last_at_result = result;
  if (result == -1) {
    lte_diag.at_timeouts++;
  } else if (result != 0) {
    lte_diag.at_errors++;
  }
}

void lte_diag_uart2_rx(rt_size_t size) {
  lte_diag.uart2_rx_bytes += size;
  lte_diag.last_uart2_rx_tick = rt_tick_get();
}

void lte_diag_uart2_tx(rt_size_t size) {
  lte_diag.uart2_tx_bytes += size;
  lte_diag.last_uart2_tx_tick = rt_tick_get();
}

void lte_diag_uart_error(const char *name, rt_uint32_t error_code) {
  lte_diag.last_uart_error_code = error_code;
  if (name != RT_NULL && rt_strcmp(name, "uart2") == 0) {
    lte_diag.uart2_error_count++;
  } else if (name != RT_NULL && rt_strcmp(name, "uart3") == 0) {
    lte_diag.uart3_error_count++;
  }
}

void lte_diag_fmu_rx(rt_size_t size) {
  lte_diag.fmu_rx_bytes += size;
  lte_diag.last_fmu_rx_tick = rt_tick_get();
}

void lte_diag_fmu_data(const uint8_t *data, rt_size_t size) {
  if (data == RT_NULL || size == 0) return;
  lte_diag_fmu_rx(size);
  mavlink_diag_feed(&fmu_mavlink_parser, data, size, &lte_diag.fmu_heartbeats);
}

void lte_diag_server_data(const uint8_t *data, rt_size_t size) {
  if (data == RT_NULL || size == 0) return;
  lte_diag.server_rx_bytes += size;
  lte_diag.server_rx_read_events++;
  lte_diag.last_server_rx_tick = rt_tick_get();
  mavlink_diag_feed(&server_mavlink_parser, data, size,
                    &lte_diag.server_heartbeats);
}

void lte_diag_modem_text(const uint8_t *data, rt_size_t size) {
  static const char pattern[] = "pdpdeact";
  rt_size_t i;

  if (data == RT_NULL) return;
  for (i = 0; i < size; i++) {
    char ch = (char)data[i];
    if (ch >= 'A' && ch <= 'Z') ch = (char)(ch - 'A' + 'a');
    if (ch == pattern[pdpdeact_match_position]) {
      pdpdeact_match_position++;
      if (pdpdeact_match_position == sizeof(pattern) - 1) {
        if (!lte_dev.socket_pdpdeact_pending) lte_diag.pdpdeact_count++;
        lte_dev.socket_pdpdeact_pending = true;
        pdpdeact_match_position = 0;
      }
    } else {
      pdpdeact_match_position = ch == pattern[0] ? 1 : 0;
    }
  }
}

void lte_diag_fmu_tx(rt_size_t size) {
  lte_diag.fmu_tx_bytes += size;
  lte_diag.last_fmu_tx_tick = rt_tick_get();
}

void lte_diag_connect_attempt(void) {
  lte_diag.connect_attempts++;
  if (lte_diag.connect_attempts > 1) {
    lte_diag.reconnect_count++;
  }
}

void lte_diag_connect_success(void) {
  lte_diag.connect_tick = rt_tick_get();
  lte_diag.last_server_rx_tick = lte_diag.connect_tick;
  lte_diag.conn_fmu_rx_base = lte_diag.fmu_rx_bytes;
  lte_diag.conn_fmu_tx_base = lte_diag.fmu_tx_bytes;
  lte_diag.conn_server_rx_base = lte_diag.server_rx_bytes;
  lte_diag.conn_server_events_base = lte_diag.server_rx_read_events;
  lte_diag.conn_fmu_heartbeat_base = lte_diag.fmu_heartbeats;
  lte_diag.conn_server_heartbeat_base = lte_diag.server_heartbeats;
  lte_dev.socket_pdpdeact_pending = false;
  pdpdeact_match_position = 0;
  rt_memset(&fmu_mavlink_parser, 0, sizeof(fmu_mavlink_parser));
  rt_memset(&server_mavlink_parser, 0, sizeof(server_mavlink_parser));
}

void lte_diag_module_reset(void) {
  lte_diag.reset_count++;
}

void BSP_LTE_SendData(uint8_t *pdata, uint32_t length) {
  if (lte_dev.com_dev != RT_NULL) {
    if (lte_dev.data_tx_mutex != RT_NULL) {
      rt_mutex_take(lte_dev.data_tx_mutex, RT_WAITING_FOREVER);
    }
    rt_ssize_t written = rt_device_write(lte_dev.com_dev, 0, pdata, length);
    if (written > 0) {
      lte_diag_uart2_tx((rt_size_t)written);
    }
    if (written != (rt_ssize_t)length) {
      lte_diag.uart2_write_failures++;
    }
    if (lte_dev.data_tx_mutex != RT_NULL) {
      rt_mutex_release(lte_dev.data_tx_mutex);
    }
  }
}

void BSP_LTE_SetDataTxPaused(bool paused) {
  if (lte_dev.data_tx_mutex != RT_NULL) {
    rt_mutex_take(lte_dev.data_tx_mutex, RT_WAITING_FOREVER);
  }
  lte_dev.data_tx_paused = paused;
  if (lte_dev.data_tx_mutex != RT_NULL) {
    rt_mutex_release(lte_dev.data_tx_mutex);
  }
}

void BSP_LTE_InitLogClock(void) {
  if (lte_log_clock_query_done) {
    return;
  }

  lte_log_clock_query_done = true;
  if (BSP_LTE_SendCmd(AT_QLTS, DEFAULT_EXPECT, DEFAULT_ERROR,
                      LTE_CMD_WAIT_NORMAL) == 0) {
    if (dev_log_time_set_from_at((const char *)lte_dev.at_buf) != 0) {
      LOG_W("EC800K clock is not synchronized; using untimestamped logs\n");
    }
  } else {
    LOG_W("EC800K clock query failed; using untimestamped logs\n");
  }
}

static void parse_cereg_snapshot(const char *response) {
  const char *p = rt_strstr(response, "+CEREG:");
  int value;

  if (p == RT_NULL) return;
  p += rt_strlen("+CEREG:");
  value = parse_decimal(&p);
  if (value < 0 || *p != ',') return;
  p++;
  value = parse_decimal(&p);
  if (value < 0) return;
  lte_diag.network.cereg = (int8_t)value;
  if (*p == ',') {
    copy_csv_token(&p, lte_diag.network.tac,
                   sizeof(lte_diag.network.tac));
    copy_csv_token(&p, lte_diag.network.cell,
                   sizeof(lte_diag.network.cell));
  }
}

static void parse_cgatt_snapshot(const char *response) {
  const char *p = rt_strstr(response, "+CGATT:");
  int value;

  if (p == RT_NULL) return;
  p += rt_strlen("+CGATT:");
  value = parse_decimal(&p);
  if (value >= 0) lte_diag.network.cgatt = (int8_t)value;
}

static void parse_qiact_snapshot(const char *response) {
  const char *p = rt_strstr(response, "+QIACT:");
  int context;
  int state;

  if (p == RT_NULL) {
    lte_diag.network.pdp = 0;
    return;
  }
  p += rt_strlen("+QIACT:");
  context = parse_decimal(&p);
  if (context < 0 || *p != ',') return;
  p++;
  state = parse_decimal(&p);
  if (context == 1 && state >= 0) lte_diag.network.pdp = (int8_t)state;
}

static void parse_qnwinfo_snapshot(const char *response) {
  const char *p = rt_strstr(response, "+QNWINFO:");
  char channel[12];

  if (p == RT_NULL) return;
  p += rt_strlen("+QNWINFO:");
  copy_csv_token(&p, lte_diag.network.rat, sizeof(lte_diag.network.rat));
  copy_csv_token(&p, lte_diag.network.oper, sizeof(lte_diag.network.oper));
  copy_csv_token(&p, lte_diag.network.band, sizeof(lte_diag.network.band));
  copy_csv_token(&p, channel, sizeof(channel));
  p = channel;
  {
    int value = parse_decimal(&p);
    if (value >= 0) lte_diag.network.channel = (rt_uint32_t)value;
  }
}

void BSP_LTE_CollectNetworkSnapshot(void) {
  lte_network_snapshot_t *network = &lte_diag.network;

  rt_memset(network, 0, sizeof(*network));
  network->cereg = -1;
  network->cgatt = -1;
  network->pdp = -1;
  network->csq = -1;

  BSP_LTE_SendCmd(AT_CEREG2, DEFAULT_EXPECT, DEFAULT_ERROR,
                  LTE_CMD_WAIT_NORMAL);
  if (BSP_LTE_SendCmd(AT_CEREG, DEFAULT_EXPECT, DEFAULT_ERROR,
                      LTE_CMD_WAIT_NORMAL) == 0) {
    parse_cereg_snapshot((const char *)lte_dev.at_buf);
  }
  BSP_LTE_SendCmd(AT_CEREG0, DEFAULT_EXPECT, DEFAULT_ERROR,
                  LTE_CMD_WAIT_NORMAL);
  if (BSP_LTE_SendCmd(AT_CGATT, DEFAULT_EXPECT, DEFAULT_ERROR,
                      LTE_CMD_WAIT_NORMAL) == 0) {
    parse_cgatt_snapshot((const char *)lte_dev.at_buf);
  }
  if (BSP_LTE_SendCmd(AT_QIACT, DEFAULT_EXPECT, DEFAULT_ERROR,
                      LTE_CMD_WAIT_NORMAL) == 0) {
    parse_qiact_snapshot((const char *)lte_dev.at_buf);
  }
  if (BSP_LTE_SendCmd(AT_QNWINFO, DEFAULT_EXPECT, DEFAULT_ERROR,
                      LTE_CMD_WAIT_NORMAL) == 0) {
    parse_qnwinfo_snapshot((const char *)lte_dev.at_buf);
  }
  network->csq = BSP_LTE_GetCSQ();
  if (network->csq >= 0) lte_dev.csq = network->csq;
}

int16_t BSP_LTE_SendCmd(const char *cmd, const char *expect, const char *error,
                        uint32_t waittime) {
  lte_diag_at_begin(cmd);
  LOG_I("%s\n", cmd);
  BSP_LTE_SendData((uint8_t *)cmd, rt_strlen(cmd));

  rt_err_t ret = rt_sem_take(lte_dev.com_dev_rx_sem, waittime);
  if (ret == RT_EOK) {
    rt_thread_mdelay(500);

    rt_memset(lte_dev.at_buf, 0, sizeof(lte_dev.at_buf));

    rt_ssize_t read_len = rt_device_read(lte_dev.com_dev, 0, lte_dev.at_buf,
                                         sizeof(lte_dev.at_buf));
    if (read_len > 0) {
      lte_diag_uart2_rx((rt_size_t)read_len);
      lte_diag_modem_text(lte_dev.at_buf, (rt_size_t)read_len);
    }

    LOG_I("%s\n", lte_dev.at_buf);
    /* 清空缓存 */
    uint8_t c;
    while (rt_device_read(lte_dev.com_dev, 0, &c, 1) == 1) {
    }

    if (expect != NULL && NULL != rt_strstr((char *)lte_dev.at_buf, expect)) {
      lte_diag_at_end(0);
      return 0;
    } else if (error != NULL && NULL != rt_strstr((char *)lte_dev.at_buf, error)) {
      lte_diag_at_end(1);
      return 1;
    } else {
      lte_diag_at_end(2);
      return 2;
    }
  } else {
    lte_diag_at_end(-1);
    return -1;
  }
}

int16_t BSP_LTE_SendATE(int16_t retry) {
  do {
    if (0 == BSP_LTE_SendCmd(AT_ATE0, DEFAULT_EXPECT, DEFAULT_ERROR,
                             LTE_CMD_WAIT_NORMAL)) {
      return 0;
    }
    retry--;
  } while (retry);

  return -1;
}

int extract_number(const char *src, char *dest) {
  if(src == RT_NULL || dest == RT_NULL){
    return -1;
  }
  char *start = NULL;
  char *end = NULL;
  if (strchr(src, '\n') != NULL) {
    start = strchr(src, '\n') + 1;
    if (start != NULL) {
      end = strchr(start, '\r');
    }
  }
  if (start != NULL && end != NULL) {
    int length = end - start;
    if(length >= 30){
      return -1;
    }
    strncpy(dest, start, length);
    dest[length] = '\0';
  }
  return 0;
}

int BSP_LTE_GetIMEI(char *pIMEI) {
  int ret = 0;
  // while (0 != BSP_LTE_SendCmd(AT_IMEI, DEFAULT_EXPECT, DEFAULT_ERROR,
  //                             LTE_CMD_WAIT_NORMAL));
  ret = BSP_LTE_SendCmd(AT_IMEI, DEFAULT_EXPECT, DEFAULT_ERROR,
                        LTE_CMD_WAIT_NORMAL);
  if (ret != 0) {
    return -1;
  }
  if (extract_number((const char *)lte_dev.at_buf, pIMEI) == -1) {
    return -1;
  }
  if (strlen(pIMEI) < 10) {
    ret = -1;
  }
  if (pIMEI[15] == '\"')
    pIMEI[15] = 0;
  return ret;
}

int BSP_LTE_GetICCID(char *pICCID) {
  char *start = NULL;
  char *end = NULL;
  int ret = 0;
  // while (0 != BSP_LTE_SendCmd(AT_ICCID, DEFAULT_EXPECT, DEFAULT_ERROR,
  //                             LTE_CMD_WAIT_LONG));
  ret = BSP_LTE_SendCmd(AT_ICCID, DEFAULT_EXPECT, DEFAULT_ERROR,
                        LTE_CMD_WAIT_LONG);
  if(ret != 0){
    return -1;
  }
  if(rt_strstr((const char *)lte_dev.at_buf, "+ICCID:") != NULL){
    start =
      rt_strstr((const char *)lte_dev.at_buf, "+ICCID:") + rt_strlen("+ICCID:") + 1;
  }
  if(start == RT_NULL){
    return -1;
  }
  end = start;
  while (*end != '\0' && *end != '\r' && *end != '\n') end++;
  rt_size_t len = end - start;
  if(len >= 30){
    return -1;
  }
  rt_memcpy(pICCID, start, len);
  pICCID[len] = '\0';

  if (strlen(pICCID) < 10) {
    ret = -1;
  }
  return ret;
}

#define CSQ_CMD_RESP "+CSQ:"
int8_t BSP_LTE_GetCSQ(void) {
  int8_t ret = 0;
  char *start;

  if (0 != BSP_LTE_SendCmd(AT_CSQ, DEFAULT_EXPECT, DEFAULT_ERROR,
                           LTE_CMD_WAIT_LONG)) {
    return -1;
  }

  start = rt_strstr((const char *)lte_dev.at_buf, CSQ_CMD_RESP);
  if (start == RT_NULL) {
    return -1;
  }

  start += rt_strlen(CSQ_CMD_RESP) + 1;

  while (*start >= '0' && *start <= '9') {
    ret = ret * 10 + (*start - '0');
    start++;
  }

  return ret;
}

int16_t BSP_LTE_SendATCPIN(int16_t retry) {
  do {
    if (0 ==
        BSP_LTE_SendCmd(AT_CPIN, "READY", DEFAULT_ERROR, LTE_CMD_WAIT_NORMAL)) {
      return 0;
    } else if (NULL != strstr((char *)lte_dev.at_buf, "ERROR: 10")) {
      // No SimCard
      return 1;
    }

    retry--;
  } while (retry);

  return -1;
}

int16_t BSP_LTE_GetCEREG(int16_t retry) {
  do {
    if (0 ==
        BSP_LTE_SendCmd(AT_CEREG, CEREG_OK, DEFAULT_ERROR, LTE_CMD_WAIT_LONG)) {
      return 0;
    } else if (0 == BSP_LTE_SendCmd(AT_CEREG, "+CEREG: 0,5\r\n\r\nOK",
                                    DEFAULT_ERROR, LTE_CMD_WAIT_LONG)) {
      return 0;
    } else if (0 == BSP_LTE_SendCmd(AT_CEREG, CEREG_OK_2, DEFAULT_ERROR,
                                    LTE_CMD_WAIT_LONG)) {
      return 0;
    } else if (0 == BSP_LTE_SendCmd(AT_CEREG, DEFAULT_EXPECT, DEFAULT_ERROR,
                                    LTE_CMD_WAIT_LONG)) {
      return 0;
    }
    retry--;
  } while (retry);
  return -1;
}

static rt_err_t lte_com_rx_cb(rt_device_t dev, rt_size_t size) {
  lte_diag.uart2_rx_events++;
  if (lte_dev.com_dev_rx_sem != RT_NULL) {
    rt_sem_release(lte_dev.com_dev_rx_sem);
  }
  return RT_EOK;
}

void BSP_LET_Register_Com(rt_device_t com_dev) {
  if (lte_dev.com_dev_rx_sem == RT_NULL) {
    lte_dev.com_dev_rx_sem = rt_sem_create("lteRx", 0, RT_IPC_FLAG_PRIO);
  }

  lte_dev.com_dev = com_dev;
  if (lte_dev.data_tx_mutex == RT_NULL) {
    lte_dev.data_tx_mutex = rt_mutex_create("lteTx", RT_IPC_FLAG_PRIO);
  }
  BSP_LTE_SetDataTxPaused(false);
}

/*
函数功能：配置EC800K
*/
void BSP_LTE_Config(void) {
  int res = 0;

  rt_device_set_rx_indicate(lte_dev.com_dev, lte_com_rx_cb);

  uint8_t c = 0;

  //rt_thread_mdelay(3000);
  BSP_LTE_SendData((uint8_t *)"+++", 3);
  rt_thread_mdelay(2000);
  BSP_LTE_SendData((uint8_t *)"+++", 3);
  rt_thread_mdelay(2000);
  while (rt_device_read(lte_dev.com_dev, 0, &c, 1) == 1);

  while (0 != BSP_LTE_SendATE(3)) {
    rt_thread_mdelay(500);
    LOG_I("BSP_LTE_SendATE error\n");
  }

  /* Allow the network to update the module clock after registration. */
  BSP_LTE_SendCmd(AT_CTZU, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_NORMAL);

  /*查询模块信息*/
  if (lte_dev.dev_init_flag == true) {
    BSP_LTE_SendCmd(AT_ATI, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_NORMAL);
  }
  /*查询SIM卡是否存在*/
  res = BSP_LTE_SendATCPIN(3);
  if (res == 1) {
    return;
  }

  /*请求移动设备的识别码*/
  if (lte_dev.dev_init_flag == true) {
    if (BSP_LTE_GetIMEI(lte_dev.imei) == -1) {
      return;
    }

    /*请求sim卡号码*/
    if (BSP_LTE_GetICCID(lte_dev.iccid) == -1) {
      return;
    }
  }
  /*查询信号强度*/
  res = BSP_LTE_GetCSQ();
  if (res != -1) lte_dev.csq = res;

  /*查询网络注册状态*/
  res = BSP_LTE_GetCEREG(3);
  if(res == -1){
    return;
  }
  /*配置应用场景*/
  BSP_LTE_SendCmd(AT_QICSGP, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_LONG);
  //BSP_LTE_SendCmd(AT_QICSGP_CTIOT, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_LONG);
  //BSP_LTE_SendCmd(AT_QICSGP_CMTDS, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_LONG);
  /*定义 PDP 上下文*/
  BSP_LTE_SendCmd("AT+CGDCONT?\r\n", DEFAULT_EXPECT, DEFAULT_ERROR,
                  LTE_CMD_WAIT_NORMAL);
  //+CGDCONT: 1,"IP","cmiot","0.0.0.0",0,0,0,0,0,0....OK

  lte_dev.config_sta = true;
  lte_dev.dev_init_flag = false;
}
//------------------End of File----------------------------