ctnd/appl/ems/ems_sm.c

#include "ems.h"
#include "plt.h"
static struct state_t ems_states[] = {
    {SMST_LAUNCH, "launch"},
    {SMST_IDLE, "idle"},
    {SMST_RUN, "run"},
    {SMST_ERR, "err"},
};

static struct err_t ems_errs[] = {
    {EMSERR_NONE, "none"},

    // launch
    {EMSERR_LAUNCH_INIT_PLT_FAIL, "launch, init plt fail"},
    {EMSERR_LAUNCH_INIT_CHAN_FAIL, "launch, init chan fail"},
    {EMSERR_LAUNCH_INIT_MAC_FAIL, "launch, init mac fail"},
    {EMSERR_LAUNCH_INIT_SHM_FAIL, "launch, init shm fail"},
    {EMSERR_LAUNCH_INIT_LOG_FAIL, "launch, init log fail"},
    {EMSERR_LAUNCH_INIT_BKD_FAIL, "launch, init bkd fail"},
    {EMSERR_LAUNCH_INIT_CFGDB_FAIL, "launch, init cfgdb fail"},
    {EMSERR_LAUNCH_INIT_PROJDB_FAIL, "launch, init proj db fail"},
    {EMSERR_LAUNCH_INIT_ESS_FAIL, "launch, init ess fail"},
    {EMSERR_LAUNCH_INIT_SNAP_FAIL, "launch, init snap fail"},
    {EMSERR_LAUNCH_INIT_EVENT_FAIL, "launch, init event fail"},
    {EMSERR_LAUNCH_INIT_CLOUD_FAIL, "launch, init cloud fail"},
    {EMSERR_LAUNCH_INIT_TB_FAIL, "launch, init tb fail"},
    {EMSERR_LAUNCH_START_AUX_FAIL, "launch, init aux fail"},
    {EMSERR_LAUNCH_LOAD_PARAMS_FAIL, "launch, load params fail"},
    {EMSERR_LAUNCH_SET_TIMESEG_FAIL, "launch, set timeseg fail"},
    {EMSERR_LAUNCH_INIT_ESTATS_FAIL, "launch, init estats fail"},
    {EMSERR_LAUNCH_INIT_CTN_CAL_FAIL, "launch, init cal fail"},
};

static void ems_sm_launch()
{
  struct ems_t *dev = &ems;
  struct statemachine_t *sm = &dev->sm;

  if (sm_get_step(sm) == 0)
  { // entry
    syslog(LOG_INFO, "%s, state:%s, step:%d, entry", __func__,
           sm_get_szstate(sm), sm_get_step(sm));
    sm_set_step(sm, 5);
  }
  else if (sm_get_step(sm) == 5)
  { // do init
    if (plt_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_PLT_FAIL);
    }
    else if (shm_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_SHM_FAIL);
    }
    else if (log_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_LOG_FAIL);
    } /*else if( bkds_init()!= 0 ){
         sm_set_state(sm,SMST_ERR, EMSERR_LAUNCH_INIT_BKD_FAIL);
     }*/
    else if (plt_init_cfgdb() != 0)
    { //
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_CFGDB_FAIL);
    }
    else if (plt_init_projdb() != 0)
    { //
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_PROJDB_FAIL);
    }
    else if (chan_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_CHAN_FAIL);
    }
    else if (mac_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_MAC_FAIL);
    }
    else if (cloud_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_CLOUD_FAIL);
    }
    else if (tb_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_TB_FAIL);
    }
    else if (ess_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_ESS_FAIL);
    }
    else if (/*snap_init()!= */ 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_SNAP_FAIL);
    }
    else if (ev_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_EVENT_FAIL);
    }
    else if (ems_start_aux() != 0)
    { // ems_start_aux()!= 0
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_START_AUX_FAIL);
    }
    else if (ems_set_timeseg(1) != 0)
    { //
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_SET_TIMESEG_FAIL);
    }
    else if (estats_init() != 0)
    { //
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_ESTATS_FAIL);
    }
    else if (ems_load_params() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_LOAD_PARAMS_FAIL);
    }
    else if (ctn_cal_init() != 0)
    {
      sm_set_state(sm, SMST_ERR, EMSERR_LAUNCH_INIT_CTN_CAL_FAIL);
    }
    else
    {
      sm_set_state(sm, SMST_IDLE, EMSERR_NONE);
    }
  }
}

static void ems_sm_err()
{
  struct ems_t *dev = &ems;
  struct statemachine_t *sm = &dev->sm;

  if (sm_get_step(sm) == 0)
  { // entry
    log_dbg("%s, state:%s, step:%d, entry", __func__, sm_get_szstate(sm),
            sm_get_step(sm));
    sm_set_step(sm, 5);
  }
  else if (sm_get_step(sm) == 5)
  {
    ;
  }
}

static void ems_reset_reg()
{
  struct ems_t *dev = &ems;
  dev->pow_reg.timer = dev->pow_reg.intv;
}

static void ems_sm_idle()
{
  struct ems_t *dev = &ems;
  struct statemachine_t *sm = &dev->sm;

  if (sm_get_step(sm) == 0)
  { // entry
    log_dbg("%s, state:%s, step:%d, entry", __func__, sm_get_szstate(sm),
            sm_get_step(sm));
    sm_set_step(sm, 10);
  }
  else if (sm_get_step(sm) == 10)
  {
    if (ems_get_cmd() == CMD_SM_RUN)
    {
      ems_reset_cmd();
      if (ems_get_mode() != EMSMOD_NONE)
      {
        log_dbg("%s, state:%s, step:%d, get run cmd, mode:%s, goto run",
                __func__, sm_get_szstate(sm), sm_get_step(sm),
                ems_get_modestr());
        ems_reset_reg();
        sm_set_state(sm, SMST_RUN, EMSERR_NONE);
      }
      else
      {
        log_dbg("%s, state:%s, step:%d, get run cmd, mode:%s, stay idle",
                __func__, sm_get_szstate(sm), sm_get_step(sm),
                ems_get_modestr());
      }
    }
  }
}

static void ems_sm_run()
{
  struct ems_t *dev = &ems;
  struct statemachine_t *sm = &dev->sm;

  if (sm_get_step(sm) == 0)
  { // entry
    log_dbg("%s, state:%s, step:%d, entry", __func__, sm_get_szstate(sm),
            sm_get_step(sm));
    sm_set_step(sm, 10);
  }
  else if (sm_get_step(sm) == 10)
  {
    if (ems_get_cmd() == CMD_SM_IDLE)
    { // idle cmd
      log_dbg("%s, state:%s, step:%d, get idle cmd, goto idle", __func__,
              sm_get_szstate(sm), sm_get_step(sm));
      sm_set_state(sm, SMST_IDLE, EMSERR_NONE);
    }
    else
    {
      if (ems_get_mode() == EMSMOD_PCURV)
      {
        ems_exe_pcurv();
      }
      else if (ems_get_mode() == EMSMOD_PDEM)
      {
        ems_exe_pdem();
      }
    }
  }
}

void ems_sm()
{
  struct ems_t *dev = &ems;
  struct statemachine_t *sm = &dev->sm;

  sm_cal_timing(sm);

  switch (sm_get_state(sm))
  {
  case SMST_LAUNCH:
    ems_sm_launch();
    break;

  case SMST_IDLE:
    ems_sm_idle();
    break;

  case SMST_RUN:
    ems_sm_run();
    break;

  case SMST_ERR:
    ems_sm_err();
    break;

  default:
    break;
  }
}

int ems_sm_init()
{
  struct statemachine_t *sm = &ems.sm;

  sm_reset_timing(sm, 100, 100);
  sm->states = ems_states;
  sm->state_nbr = sizeof(ems_states) / sizeof(struct state_t);
  sm->errs = ems_errs;
  sm->err_nbr = sizeof(ems_errs) / sizeof(struct err_t);
  sm_set_state(sm, SMST_LAUNCH, EMSERR_NONE);
  return 0;
}