update

components/cmdscheduler/cmd_scheduler.cpp

@@ -0,0 +1,112 @@
+
+#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::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];
+  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);
+    m_rxsize      = len;
+    m_dataisready = true;
+    // on data ,in irq context
+  });
+}
+
+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 (size_t 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::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);
+
+  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);
+  }
+#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 (size_t 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;
+    }
+  }
+}

components/cmdscheduler/cmd_scheduler.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include <map>
+#include <string>
+
+#include "sdk/os/zos.hpp"
+namespace iflytop {
+using namespace std;
+
+class CmdScheduler {
+ public:
+  class CmdProcessContext {
+   public:
+    bool breakflag = false;
+  };
+
+  typedef function<void(int, char**, CmdProcessContext*)> call_cmd_t;
+
+ private:
+  map<string, call_cmd_t> m_cmdMap;
+
+  ZUART*  m_uart;
+  char*   rxbuf;
+  int32_t m_rxsize = 0;
+
+  uint32_t m_rxbufsize;
+
+  bool m_dataisready = false;
+
+  char cmdcache[100];
+
+ public:
+  void initialize(UART_HandleTypeDef* huart, uint32_t rxbufsize);
+  void registerCmd(std::string cmd, call_cmd_t call_cmd);
+
+  void schedule();
+
+ private:
+  void callcmd(const char* cmd, CmdProcessContext& context);
+  void prase_cmd(char* input, int inputlen, int& argc, char* argv[]);
+};
+
+}  // namespace iflytop