p_graphite_digester_sdk/components/cmdscheduler/cmd_scheduler.cpp

#include "cmd_scheduler.hpp"

#include <stdlib.h>
#include <string.h>
using namespace iflytop;

#define TAG "CmdScheduler"

void CmdScheduler::registerCmd(std::string cmd, call_cmd_t call_cmd) { m_cmdMap[cmd] = call_cmd; }
void CmdScheduler::regbasiccmd() {
  this->registerCmd("help", [this](int argc, char** argv, CmdScheduler::CmdProcessContext* context) {
    ZLOGI(TAG, "help");
    ZLOGI(TAG, "cmdlist:");
    for (auto it = m_cmdMap.begin(); it != m_cmdMap.end(); it++) {
      ZLOGI(TAG, "  %s", it->first.c_str());
    }
  });
}

void CmdScheduler::initialize(UART_HandleTypeDef* huart, uint32_t rxbufsize) {
  m_rxbufsize = rxbufsize;

  m_uart = new ZUART();
  ZASSERT(m_uart != NULL);

  ZUART::cfg_t cfg;
  cfg.huart         = huart;
  cfg.rxbuffersize  = rxbufsize;
  cfg.rxovertime_ms = 3;
  cfg.name          = "CmdSchedulerUart";

  rxbuf = new char[rxbufsize + 1];
  ZASSERT(rxbuf != NULL);

  m_uart->initialize(&cfg);
  ZASSERT(m_uart->startRxIt());
  m_uart->setrxcb([this](uint8_t* data, size_t len) {
    if (m_dataisready) {
      return;
    }
    memcpy(rxbuf, data, len);
    rxbuf[len]    = '\0';
    m_rxsize      = len;
    m_dataisready = true;
    // on data ,in irq context
  });
  regbasiccmd();
}

void CmdScheduler::schedule() {
  if (!m_dataisready) {
    return;
  }
  for (size_t i = 0; i < m_rxsize; i++) {
    if (rxbuf[i] == '\r' || rxbuf[i] == '\n') {
      rxbuf[i] = '\0';
    }
  }
  // ZLOGI(TAG, "cmdstr2: %s %d %d", cmdstr, strlen(cmdstr),m_rxsize);
  for (int i = 0; i < m_rxsize; i++) {
    if (rxbuf[i] != '\0') {
      ZLOGI(TAG, "docmd: %s", &rxbuf[i]);
      int               inext = strlen(&rxbuf[i]) + i;
      CmdProcessContext context;
      callcmd(&rxbuf[i], context);
      i = inext;
      if (context.breakflag) {
        ZLOGE(TAG, "do break");
        break;
      }
    }
  }
  ZLOGI(TAG, "process_rx_cmd:end");
  m_dataisready = false;
}

void CmdScheduler::tx(const char* data, int len) { m_uart->tx((uint8_t*)data, len); }

void CmdScheduler::callcmd(const char* cmd, CmdProcessContext& context) {
  int   argc     = 0;
  char* argv[10] = {0};
  memset(cmdcache, 0, sizeof(cmdcache));
  argc = 0;
  memset(argv, 0, sizeof(argv));
  strcpy(cmdcache, cmd);
  prase_cmd(cmdcache, strlen(cmdcache), argc, argv);
  if (argc == 0) {
    return;
  }
  // printf("argc:%d\n", argc);
  // for (size_t i = 0; i < argc; i++) {
  //   printf("argv[%d]:%s\n", i, argv[i]);
  // }
#if 1
  /**
   * @brief �����ﴦ��ָ��
   */
  if (m_cmdMap.find(string(argv[0])) != m_cmdMap.end()) {
    context.breakflag = false;
    m_cmdMap.find(string(argv[0]))->second(argc, argv, &context);
  } else {
    ZLOGE(TAG, "cmd not found");
  }
#endif
}

void CmdScheduler::prase_cmd(char* input, int inputlen, int& argc, char* argv[]) {
  for (size_t i = 0; input[i] == 0 || i < inputlen; i++) {
    if (input[i] == ' ' || input[i] == '\r' || input[i] == '\n') {
      input[i] = 0;
    }
  }

  int j = 0;
  for (int i = 0; input[i] == 0 || i < inputlen; i++) {
    if (input[i] != 0 && j == 0) {
      argv[argc++] = &input[i];
      j            = 1;
      continue;
    }

    if (input[i] == 0 && j == 1) {
      j = 0;
      continue;
    }
  }
}