dtu_4g/applications/VK_Client.c

#include "VK_Client.h"

#include <stdint.h>

#include "VK_Com.h"
#include "drv_ec800k.h"
#include "rtdef.h"
#include "rtthread.h"
#include "rttypes.h"
#include "VKFly/mavlink.h"
#include "mavlink_helpers.h"


char cmd_cmd[100] = {0};
char cmd_str[100] = {0};

/*关闭TCP连接*/
void client_tcp_close(Cclient_t *client) {
  rt_sprintf(cmd_str, AT_QICLOSE, client->connect_ID);
  BSP_LTE_SendCmd(cmd_str, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_NORMAL);
  // client->connect_sta = false;
  // client->error_cnt = 0;
}

/*将EC800K软件复位*/
int16_t EC800K_Reset(void) {
  int16_t rst = -1;

  lte_dev.config_sta = false;
  lte_dev.reset_flag = DTU_CF_NEED_RESET;
  lte_dev.client1->connect_sta = false;
  //lte_dev.client2->connect_sta = false;

  rt_thread_mdelay(3000);
  BSP_LTE_SendData((uint8_t *)"+++", 3);
  rt_thread_mdelay(2000);
  BSP_LTE_SendData((uint8_t *)"+++", 3);
  rt_thread_mdelay(2000);

  uint8_t try_count = 5;

  do {
    rt_thread_mdelay(1000);

    rst = BSP_LTE_SendCmd(SOFT_RESET, DEFAULT_EXPECT, DEFAULT_ERROR,
                          LTE_CMD_WAIT_LONG);
    if (0 == rst) return 0;

    try_count--;
  } while (try_count > 0);

  return rst;
}

/*将EC800K为透传模式*/
// int16_t Set_Tansparent_Mode(Cclient_t *pClient)
//{
//    int AT_QISWTMD_error_count = 0;
//    /*如果socket成功打开，则将它设置为透传模式*/
//    if(pClient->connect_sta == true)
//    {
//       /*打开透传模式*/
//       memset(cmd_cmd, 0, sizeof(cmd_cmd));
//       sprintf(cmd_cmd, AT_QISWTMD, pClient->connect_ID, 2);
//       while(0 != BSP_LTE_SendCmd( cmd_cmd, CONNECTE_OK, DEFAULT_ERROR,
//       LTE_CMD_WAIT_LONG ))
//       {
//          //rt_thread_mdelay(1000);
//
//          if(AT_QISWTMD_error_count++ > 5)
//          {
//             EC800K_Reset();
//
//             rt_thread_mdelay(3000);
//
//             break;
//          }
//       }
//    }
//
//    return 0;
// }

int16_t client_tcp_connect(Cclient_t *client) {
  int16_t rtn = 0;

  if (lte_dev.config_sta == false)
    return rtn;
  if (client->connect_sta == true)
    return rtn;

  if (lte_dev.reset_flag == DTU_CF_NEED_RESET) {
    /*查询PDP场景*/
    if (0 != BSP_LTE_SendCmd(AT_QIACT, "+QIACT: 1,1,1,", DEFAULT_ERROR,
                             LTE_CMD_WAIT_LLONG)) {
      /*如果查询PDP场景未设置成功，则激活PDP场景模式*/
      if (0 != BSP_LTE_SendCmd(AT_QIACT1, DEFAULT_EXPECT, DEFAULT_ERROR,
                               LTE_CMD_WAIT_LLONG)) {
        BSP_LTE_SendCmd(AT_QIDEACT, NETCLOSE_SUCCESS, NETCLOSE_FAILURE,
                        LTE_CMD_WAIT_LLONG);
        // client->error_cnt++;
        return -1;
      }
    }

    //
    BSP_LTE_SendCmd(AT_CFG_TRANS_SIZE, DEFAULT_EXPECT, DEFAULT_ERROR,
                    LTE_CMD_WAIT_LLONG);
    BSP_LTE_SendCmd(AT_CFG_TRANS_WAITTM, DEFAULT_EXPECT, DEFAULT_ERROR,
                    LTE_CMD_WAIT_LLONG);
    //
  }
  // 1. 检查网络信号
  lte_dev.csq = BSP_LTE_GetCSQ();
  
  // 2, 打开链接
  memset(cmd_cmd, 0, sizeof(cmd_cmd));
  memset(cmd_str, 0, sizeof(cmd_str));
  rt_sprintf(cmd_cmd, AT_QIOPEN_TRANS /*AT_QIOPEN_FORW*/, client->connect_ID,
          client->mode, client->ip, client->port);
  rt_sprintf(cmd_str, "+QIOPEN: %d,0", client->connect_ID);

  /*打开socket, 这个模块他不返回+QIOPEN:字符串*/
  while (0 != BSP_LTE_SendCmd(cmd_cmd, CONNECTE_OK, DEFAULT_ERROR,
                              LTE_CMD_WAIT_LLONG) &&
         0 != BSP_LTE_SendCmd(cmd_cmd, cmd_str, DEFAULT_ERROR,
                              LTE_CMD_WAIT_LLONG)) {
    client_tcp_close(client);
    client->error_cnt++;
    if (client->error_cnt > 5) {
      EC800K_Reset();
      client->error_cnt = 0;
      return 0;
    }
  }
  client->connect_sta = true;
  client->error_cnt = 0;
  lte_dev.reset_flag = DTU_CF_NO_NEED_RESET;

  rt_kprintf("%s\r", lte_dev.at_buf);

#ifdef TRANSPARENT_MODE
// Set_Tansparent_Mode(client);
#endif

#ifdef EDU_TRAINING
  mavlink_message_t msg = {0};
  uint8_t mav_buf[MAVLINK_MAX_PACKET_LEN] = {0};
  uint16_t mav_len = 0;
  mavlink_dtu_status_t _status_t = {0};
  _status_t.csq = lte_dev.csq;
  rt_memcpy(_status_t.sn, lte_dev.iccid, sizeof(_status_t.sn));
  rt_memcpy(_status_t.imei,lte_dev.imei,sizeof(_status_t.imei));
  mavlink_msg_dtu_status_encode(1, MAV_COMP_ID_TELEMETRY_RADIO, &msg,
                                &_status_t);
  mav_len = mavlink_msg_to_send_buffer(mav_buf, &msg);

  for (int i = 0; i < 3; i++) {
    rt_device_write(lte_dev.com_dev, 0, mav_buf, mav_len);
  }
  rt_device_t fmu_com = fmu_com_get();
  if (fmu_com != RT_NULL) {
    rt_device_write(fmu_com, 0, mav_buf, mav_len);
  }
#else
  char buf[128] = {0};
  rt_sprintf(buf, "{\"sn\":\"%s\",\"client_id\":\"%s\",\"csq\":\"%d\"}\r\n",
             lte_dev.iccid, lte_dev.imei, lte_dev.csq);

  rt_device_write(lte_dev.com_dev, 0, buf, sizeof(buf));

  rt_device_write(lte_dev.com_dev, 0, buf, sizeof(buf));

  rt_device_write(lte_dev.com_dev, 0, buf, sizeof(buf));

  hw_printf(buf);
#endif

  return rtn;
}

static rt_tick_t last_rx_tick = 0;
int16_t client_yield(CLte_dev_t *pLte_dev) {
  int16_t rtn = 0;

  while (1) {
    if (pLte_dev->client1->connect_sta == true) {
      rt_err_t ret = rt_sem_take(pLte_dev->com_dev_rx_sem, 1000);
      // if (rt_tick_get() - last_rx_tick > RT_TICK_PER_SECOND * 10) {
      //   rt_kprintf("timeout!!! reconnect.\n");
      //   hw_printf("timeout!!! reconnect.\n");
      //   pLte_dev->client1->connect_sta = false;
      // }
      if (RT_EOK == ret) {
        rt_ssize_t len = 0;
        while (1) {
          rt_memset(pLte_dev->at_buf, 0, sizeof(pLte_dev->at_buf));
          len = rt_device_read(pLte_dev->com_dev, 0, pLte_dev->at_buf,
                               sizeof(pLte_dev->at_buf));
          if (len > 0) {
            /*收到TCP关闭的消息*/
            if (strstr((const char *)pLte_dev->at_buf, CLOSED)) {
              memset(cmd_str, 0, sizeof(cmd_str));
              rt_sprintf(cmd_str, "\"closed\",%d", pLte_dev->client1->connect_ID);
              if (NULL != strstr((char *)lte_dev.at_buf, cmd_str)) {
                EC800K_Reset();
                pLte_dev->client1->connect_sta = false;
                break;
              }
              break;
            } else if (strstr((const char *)lte_dev.at_buf, "NO CARRIER")) {
              rt_kprintf("disconnect!!!\n");
              hw_printf("disconnect!!!\n");
              pLte_dev->client1->connect_sta = false;
              break;
            }

            rt_device_t fmu_com = fmu_com_get();
            if (fmu_com) {
              rt_device_write(fmu_com, 0, pLte_dev->at_buf, len);
            }
          }else{
            break;
          }
          last_rx_tick = rt_tick_get();   
        }
      }

    } else {
      if(pLte_dev->reset_flag == DTU_CF_NEED_RESET){
        BSP_LTE_Config();
      }
      client_tcp_connect(pLte_dev->client1);
      last_rx_tick = rt_tick_get();
    }
  }

  return rtn;
}

void client_task(void) {
  if (lte_dev.config_sta == false) {
  }

  client_yield(&lte_dev);
}

//------------------End of File----------------------------