zcancmder_v2/api/zi_module.hpp

#pragma once
#include <stdint.h>

#include <functional>

#include "errorcode.hpp"
#include "module_type_index.hpp"

namespace iflytop {
using namespace std;

#define REG_SET(reg, ...) _module_set_reg(param_id, &reg, val, ##__VA_ARGS__)
#define REG_GET(reg)      _module_get_reg(param_id, reg, val)

#define REG_SET_FLOAT(reg, precision, ...) _module_set_reg_float(param_id, &reg, val, precision, ##__VA_ARGS__)
#define REG_GET_FLOAT(reg, precision)      _module_get_reg_float(param_id, reg, val, precision)

#define ACTION_NONE 0
#define PROCESS_REG(param_id, readaction, writeacton) \
  case param_id: {                                    \
    if (read) {                                       \
      return readaction;                              \
    } else {                                          \
      return writeacton;                              \
    }                                                 \
  } break;

#define PROCESS_ACTION()                                                                                                      \
  PROCESS_REG(kreg_module_do_action0, /*        */ ACTION_NONE, do_action(val));                                              \
  PROCESS_REG(kreg_module_action_param1, /*     */ REG_GET(m_reg.module_action_param1), REG_SET(m_reg.module_action_param1)); \
  PROCESS_REG(kreg_module_action_param2, /*     */ REG_GET(m_reg.module_action_param2), REG_SET(m_reg.module_action_param2)); \
  PROCESS_REG(kreg_module_action_param3, /*     */ REG_GET(m_reg.module_action_param3), REG_SET(m_reg.module_action_param3)); \
  PROCESS_REG(kreg_module_action_ack1, /*       */ REG_GET(m_reg.module_action_ack1), ACTION_NONE);                           \
  PROCESS_REG(kreg_module_action_ack2, /*       */ REG_GET(m_reg.module_action_ack2), ACTION_NONE);

#define ENABLE_MODULE(name, type, version) module_common_reg_t m_com_reg = {.module_version = version, .module_type = type};

#define MODULE_COMMON_PROCESS_REG_CB()                                                                                                \
  PROCESS_REG(kreg_module_version, /*           */ REG_GET(m_com_reg.module_version), ACTION_NONE);                                   \
  PROCESS_REG(kreg_module_type, /*              */ REG_GET(m_com_reg.module_type), ACTION_NONE);                                      \
  PROCESS_REG(kreg_module_status, /*            */ module_get_status(&val), ACTION_NONE);                                             \
  PROCESS_REG(kreg_module_errorcode, /*         */ REG_GET(m_com_reg.module_errorcode), ACTION_NONE);                                 \
  PROCESS_REG(kreg_module_initflag, /*          */ REG_GET(m_com_reg.module_initflag), REG_SET(m_com_reg.module_initflag));           \
  PROCESS_REG(kreg_module_errorbitflag0, /*     */ REG_GET(m_com_reg.module_errorbitflag0), ACTION_NONE);                             \
  PROCESS_REG(kreg_module_enableflag, /*        */ REG_GET(m_com_reg.module_enable), ACTION_NONE);                                    \
  PROCESS_REG(kreg_module_do_action0, /*        */ ACTION_NONE, do_action(val));                                                      \
  PROCESS_REG(kreg_module_action_param1, /*     */ REG_GET(m_com_reg.module_action_param1), REG_SET(m_com_reg.module_action_param1)); \
  PROCESS_REG(kreg_module_action_param2, /*     */ REG_GET(m_com_reg.module_action_param2), REG_SET(m_com_reg.module_action_param2)); \
  PROCESS_REG(kreg_module_action_param3, /*     */ REG_GET(m_com_reg.module_action_param3), REG_SET(m_com_reg.module_action_param3)); \
  PROCESS_REG(kreg_module_action_ack1, /*       */ REG_GET(m_com_reg.module_action_ack1), ACTION_NONE);                               \
  PROCESS_REG(kreg_module_action_ack2, /*       */ REG_GET(m_com_reg.module_action_ack2), ACTION_NONE);                               \
  PROCESS_REG(kreg_module_last_cmd_exec_status, /*       */ REG_GET(m_com_reg.module_last_cmd_exec_status), ACTION_NONE);             \
  PROCESS_REG(kreg_module_last_cmd_exec_val0, /*       */ REG_GET(m_com_reg.module_last_cmd_exec_val0), ACTION_NONE);                 \
  PROCESS_REG(kreg_module_last_cmd_exec_val1, /*       */ REG_GET(m_com_reg.module_last_cmd_exec_val1), ACTION_NONE);                 \
  PROCESS_REG(kreg_module_last_cmd_exec_val2, /*       */ REG_GET(m_com_reg.module_last_cmd_exec_val2), ACTION_NONE);                 \
  PROCESS_REG(kreg_module_last_cmd_exec_val3, /*       */ REG_GET(m_com_reg.module_last_cmd_exec_val3), ACTION_NONE);                 \
  PROCESS_REG(kreg_module_last_cmd_exec_val4, /*       */ REG_GET(m_com_reg.module_last_cmd_exec_val4), ACTION_NONE);

typedef struct {
  int32_t module_version;
  int32_t module_type;
  int32_t module_errorcode;
  int32_t module_initflag;
  int32_t module_errorbitflag0;
  int32_t module_enable;

  int32_t module_last_cmd_exec_status;
  int32_t module_last_cmd_exec_val0;
  int32_t module_last_cmd_exec_val1;
  int32_t module_last_cmd_exec_val2;
  int32_t module_last_cmd_exec_val3;
  int32_t module_last_cmd_exec_val4;

  int32_t module_do_action0;
  int32_t module_action_param1;
  int32_t module_action_param2;
  int32_t module_action_param3;
  int32_t module_action_ack1;
  int32_t module_action_ack2;

} module_common_reg_t;

class ModuleCMDExecStatus {
 public:
  int32_t exec_status = 0;
  int32_t exec_val[6] = {0};

  void set_exec_status(int32_t status, int32_t val0 = 0, int32_t val1 = 0, int32_t val2 = 0, int32_t val3 = 0, int32_t val4 = 0, int32_t val5 = 0) {
    exec_status = status;
    exec_val[0] = val0;
    exec_val[1] = val1;
    exec_val[2] = val2;
    exec_val[3] = val3;
    exec_val[4] = val4;
    exec_val[5] = val5;
  }
};

class ZIModule {
  int32_t m_inited_flag = 0;

 public:
  virtual ~ZIModule() {}

  virtual int32_t getid(int32_t *id) = 0;
  virtual int32_t getid() {
    int32_t id = 0;
    getid(&id);
    return id;
  };

  virtual int32_t module_ping() = 0;

  virtual int32_t module_stop() { return err::koperation_not_support; }
  virtual int32_t module_break() { return err::koperation_not_support; }
  virtual int32_t module_start() { return err::koperation_not_support; }

  virtual int32_t module_get_last_exec_status(int32_t *status) { return err::koperation_not_support; }
  virtual int32_t module_get_status(int32_t *status) { return err::koperation_not_support; }
  virtual int32_t module_get_error(int32_t *iserror) { return err::koperation_not_support; }
  virtual int32_t module_clear_error() { return err::koperation_not_support; }

  virtual int32_t module_enable(int32_t enable) { return err::koperation_not_support; }

  virtual int32_t module_xxx_reg(int32_t param_id, bool read, int32_t &val) { return err::koperation_not_support; }

  virtual int32_t module_set_reg(int32_t param_id, int32_t param_value) { return module_xxx_reg(param_id, false, param_value); }
  virtual int32_t module_get_reg(int32_t param_id, int32_t *param_value) { return module_xxx_reg(param_id, true, *param_value); }

  virtual int32_t module_readio(int32_t *io) { return err::koperation_not_support; }
  virtual int32_t module_writeio(int32_t idindex, int32_t io) { return err::koperation_not_support; }

  virtual int32_t module_read_adc(int32_t adcindex, int32_t *adc) { return err::koperation_not_support; }

  virtual int32_t module_read_raw(int32_t index, uint8_t *data, int32_t *len) { return err::koperation_not_support; }

  virtual int32_t module_set_inited_flag(int32_t flag) {
    m_inited_flag = flag;
    return 0;
  }
  virtual int32_t module_get_inited_flag(int32_t *flag) {
    *flag = m_inited_flag;
    return 0;
  }

  virtual int32_t module_get_inited_flag() { return m_inited_flag; }
  // kmodule_factory_reset        = CMDID(1, 14),  // para:{}, ack:{}
  // kmodule_flush_cfg            = CMDID(1, 15),  // para:{}, ack:{}
  // kmodule_active_cfg           = CMDID(1, 16),  // para:{}, ack:{}

  virtual int32_t module_factory_reset() { return err::koperation_not_support; }
  virtual int32_t module_flush_cfg() { return err::koperation_not_support; }
  virtual int32_t module_active_cfg() { return err::koperation_not_support; }

  virtual int32_t _module_set_reg(int32_t regoff, int32_t *regval, int32_t val, int32_t min = INT32_MIN, int32_t max = INT32_MAX) {
    if (val < min || val > max) {
      return err::kparam_out_of_range;
    }
    *regval = val;
    return 0;
  }
  virtual int32_t _module_get_reg(int32_t regoff, int32_t regval, int32_t &val) {
    val = regval;
    return 0;
  }

  virtual int32_t _module_set_reg_float(int32_t regoff, float *regval, int32_t val, float precision, int32_t min = INT32_MIN, int32_t max = INT32_MAX) {
    if (val < min || val > max) {
      return err::kparam_out_of_range;
    }
    *regval = val * precision;
    return 0;
  }
  virtual int32_t _module_get_reg_float(int32_t regoff, float regval, int32_t &val, float precision) {
    val = regval / precision;
    return 0;
  }

 public:
  virtual int32_t do_action(int32_t actioncode) { return err::kmodule_not_support_action; };
};
}  // namespace iflytop