ctnd/platform/device/meter/adl200.c

#include "adl200.h"
#include "plt.h"

int adl200_nbr;
struct adl200_t adl200[adl200_NBR_MAX + 1];

static int adl200_dbcb_0(void *para, int ncolumn, char **columnvalue,
                         char *columnname[])
{
  int i;
  struct dbcbparam_t *pcbparam = (struct dbcbparam_t *)para;
  struct adl200_t *dev = NULL;

  pcbparam->nrow++;
  log_dbg("%s, ++,row:%d, col:%d", __func__, pcbparam->nrow, ncolumn);

  dev = &adl200[pcbparam->nrow];
  for (i = 0; i < ncolumn; i++)
  {
    if (strcmp("chan_idx", columnname[i]) == 0)
    {
      dev->comm.chanidx = atoi(columnvalue[i]);
    }
    else if (strcmp("info", columnname[i]) == 0)
    {
      strcpy(dev->szinfo, columnvalue[i]);
    }
    else if (strcmp("adr", columnname[i]) == 0)
    {
      dev->comm.adr = atoi(columnvalue[i]);
    }
    else if (strcmp("idx", columnname[i]) == 0)
    {
      dev->idx = atoi(columnvalue[i]);
    }
    else if (strcmp("devid", columnname[i]) == 0)
    {
      if (columnvalue[i] != NULL && strcmp(columnvalue[i], "") != 0)
      {
        strcpy(dev->szdev_id, columnvalue[i]);
      }
      else
      {
        log_dbg("%s, devid is null", __func__);
      }
    }
  }

  pcbparam->ret = 0;
  log_dbg("%s, --,ret:%d", __func__, pcbparam->ret);
  return 0;
}

static void aux(int idx)
{
  static int cnt = 0;
  if (cnt < adl200_nbr && mqtt_get_state() == SMST_READY)
  {
    cnt++;
    if (idx == adl200_nbr)
    {
      cloud.meter_init = 0;
    }
    char buf[4096];
    adl200_get_init_data(ctn_get_idx_in_ess(), idx, buf);
    cloud_send_init(buf);
  }
}

void *adl200_thrd_main(void *param)
{
  struct adl200_t *dev = NULL;
  int idx;

  log_dbg("%s, ++", __func__);

  for (idx = 1; idx <= adl200_nbr; idx++)
  {
    dev = &adl200[idx];
    adl200_sm_init(idx);
    adl200_comm_init(idx);
  }

  while (1)
  {
    for (idx = 1; idx <= adl200_nbr; idx++)
    {
      adl200_comm_dac(idx);
      adl200_sm(idx);
      aux(idx);
      // usleep(100000); // 100ms
      sleep(2);
    }
  }

  log_dbg("%s, --, idx:%d", __func__, idx);
  return NULL;
}

int adl200_get_cmd(int idx) { return adl200[idx].cmd; }

void adl200_reset_cmd(int idx) { adl200[idx].cmd = CMD_SM_DONE; }

int adl200_init()
{
  pthread_t thrd;
  int result = 0;
  int ret = 0;
  int idx = 0;
  struct adl200_t *dev = NULL;
  char *errmsg = NULL;
  char sql[1024];
  struct dbcbparam_t cbparam;
  sqlite3 *db = NULL;

  log_dbg("%s, ++", __func__);

  plt_lock_ctndb();
  db = plt_get_ctndb();
  sprintf(sql, "select * from adl200");
  cbparam.nrow = 0;
  result = sqlite3_exec(db, sql, adl200_dbcb_0, (void *)&cbparam, &errmsg);
  plt_unlock_ctndb();
  if (result != SQLITE_OK)
  {
    log_dbg("%s, result != SQLITE_OK, result:%d", __func__, result);
    ret = -1;
  }
  else if (cbparam.ret != 0)
  {
    log_dbg("%s, cbparam.ret != 0, cbparam.ret:%d", __func__, cbparam.ret);
    ret = -2;
  }
  else
  {
    adl200_nbr = cbparam.nrow;
    cbparam.nrow = 0;
    db = plt_get_devdb();
    plt_lock_devdb();
    sprintf(sql, "select * from adl200");
    result = sqlite3_exec(db, sql, adl200_dbcb_0, (void *)&cbparam, &errmsg);
    plt_unlock_devdb();

    for (int i = 1; i <= adl200_nbr; ++i)
    {
      if (strcmp(adl200[i].szdev_id, "") == 0)
      {
        if (get_snow_id(adl200[i].szdev_id) != 0)
        {
          ret = -4;
        }
        else
        {
          char sql[1024];
          char *errmsg = NULL;
          sprintf(sql, "update adl200 set devid=\"%s\" where idx=%d", adl200[i].szdev_id, adl200[i].idx);
          plt_lock_devdb();
          int rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
          plt_unlock_devdb();
          if (rc != SQLITE_OK)
          {
            log_dbg("%s, failed to update level device id:%s", __func__, errmsg);
            ret = -4;
            goto leave;
          }
          else
          {
            log_dbg("%s, update device id:%s", __func__, adl200[i].szdev_id);
          }
        }
      }
    }

    if (pthread_create(&thrd, NULL, adl200_thrd_main, NULL) != 0)
    {
      log_dbg("%s, create adl200 thrd main fail", __func__);
      ret = -1;
    }
  }

leave:
  log_dbg("%s--, ret:%d", __func__, ret);
  return ret;
}

int adl200_get_state(int idx) { return adl200[idx].sm.state; }

char *adl200_get_state_string(int idx) { return adl200[idx].sm.szState; }

int adl200_get_com_ap(int idx) { return adl200[idx].com_ap; }

double adl200_get_com_ae(int idx) { return adl200[idx].com_ae; }

double adl200_get_pos_ae(int idx) { return adl200[idx].pos_active_e; }

double adl200_get_neg_ae(int idx) { return adl200[idx].neg_active_e; }

double adl200_get_pf(int idx) { return adl200[idx].pwr_factor; }

double adl200_get_gf(int idx) { return adl200[idx].freq; }

char *adl200_get_info_str(int idx) { return adl200[idx].szinfo; }

int adl200_chk_state_all(int stat)
{
  int idx;
  for (idx = 1; idx <= adl200_nbr; idx++)
  {
    if (adl200_get_state(idx) != stat)
    {
      return -1;
    }
  }
  return 0;
}

int adl200_send_sm_cmd(int idx, int val)
{
  int ret = 0;
  struct adl200_t *dev = &adl200[idx];

  dev->cmd = val;

leave:
  log_dbg("%s, idx:%d, cmd:%d, ret:%d", __func__, idx, val, ret);
  return ret;
}

int adl200_send_sm_cmd_all(int cmd)
{
  int ret = 0;
  int idx;
  for (idx = 1; idx <= adl200_nbr; idx++)
  {
    adl200_send_sm_cmd(idx, cmd);
  }

  log_dbg("%s, idx:%d, cmd:%d, ret:%d", __func__, idx, cmd, ret);
  return ret;
}

int adl200_get_comm_st(int idx)
{
  struct adl200_t *dev = &adl200[idx];
  struct comm_t *comm = &dev->comm;
  return comm_get_state(comm);
}

void adl200_set_dac_param_en(int idx, int val)
{
  struct adl200_t *dev = &adl200[idx];
  struct comm_t *comm = &dev->comm;

  comm_set_dac_param_en(comm, val);
}

int adl200_get_sm_step(int idx)
{
  struct statemachine_t *sm = &adl200[idx].sm;
  return sm_get_step(sm);
}

char *adl200_get_sm_err_str(int idx) { return adl200[idx].sm.szerr; }

int adl200_get_chan_idx(int idx)
{
  struct comm_t *comm = &adl200[idx].comm;
  return comm_get_chan_idx(comm);
}

int adl200_get_adr(int idx)
{
  struct comm_t *comm = &adl200[idx].comm;
  return comm_get_adr(comm);
}

int adl200_get_tick(int idx) { return adl200[idx].sm.tick; }

char *adl200_get_comm_state_str(int idx)
{
  struct comm_t *comm = &adl200[idx].comm;
  return comm_get_state_str(comm);
}

int adl200_get_nbr() { return adl200_nbr; }

int adl200_get_tool_data(int idx, char *buf)
{
  struct adl200_t *dev = &adl200[idx];
  struct statemachine_t *sm = &dev->sm;
  struct comm_t *comm = &dev->comm;
  char temp_buf[1024 * 8];

  if (idx < 1 || idx > adl200_nbr || buf == NULL)
    return -1;

  sm_get_summary(sm, temp_buf, sizeof(temp_buf));
  sprintf(buf, " [%d] %s  ", idx, temp_buf);

  comm_get_summary(comm, temp_buf, sizeof(temp_buf));
  strcat(buf, temp_buf);

  sprintf(temp_buf,
          "dev id :%s com_ap:" L_GREEN "%.1f" NONE " com_ae:%.1f pos_ae:%.1f neg_ae:%.1f ap:%.1f ip:%.1f app:%.1f freq:%.2f pwr_fct:%.2f, v:%.2f, i:%.2f \n",
          dev->szdev_id,
          dev->com_ap, dev->com_ae, dev->pos_active_e, dev->neg_active_e, dev->ap, dev->inactive_p,
          dev->apparent_p, dev->freq, dev->pwr_factor, dev->u, dev->i);
  strcat(buf, temp_buf);
  return 0;
}

int adl200_get_tbmqtt_data(int idx, char *buf)
{
  struct adl200_t *dev = &adl200[idx];
  struct statemachine_t *sm = &dev->sm;
  struct comm_t *comm = &dev->comm;
  char temp_buf[1024 * 8];

  sprintf(buf, "'adl200_pos_ae':%.1f,'adl200_neg_ae':%.1f,'adl200_ap':%.1f, 'adl200_ip':%.1f, 'adl200_gf':%.1f,'adl200_pf':%.1f,'adl200_state':'%s'",
          adl200_get_pos_ae(idx),
          adl200_get_neg_ae(idx),
          dev->ap,
          dev->inactive_p,
          adl200_get_gf(idx),
          adl200_get_pf(idx),
          adl200_get_state_string(idx));
}

int adl200_get_cloud_data(int ctn_idx, int idx, char *buf)
{
  struct adl200_t *dev = &adl200[idx];
  sprintf(buf, "{\"device_id\":\"%s\",\"type\":10,\"pos_ae\":%.2f,\"neg_ae\":%.2f,\
  \"com_ap\":%.2f,\"rap\":%.2f,\"gf\":%.2f,\"pf\":%.2f,\"state\":\"%d\"}",
          dev->szdev_id,
          adl200_get_pos_ae(idx),
          adl200_get_neg_ae(idx),
          dev->ap, dev->inactive_p,
          adl200_get_gf(idx),
          adl200_get_pf(idx),
          adl200_get_state(idx));
}

int adl200_get_init_data(int ctn_idx, int idx, char *buf)
{
  sprintf(buf, "{\"device_id\":\"%s\", \"type\":10, \"idx\":%d, \"pid\":\"%s\", \"config\":{ \
    \"chan_idx\":%d, \"adr\":%d}}",
          adl200[idx].szdev_id,
          idx,
          ctn_get_dev_id(),
          adl200[idx].comm.chanidx,
          adl200[idx].comm.adr);
  return 0;
}

int adl200_get_modbus_data(int idx,unsigned short* data)
{
  struct adl200_t *dev = &adl200[idx];
  data[0] = (unsigned short)DEVM_ADL200;
  data[1] = (unsigned short)1;
  data[2] = (unsigned short)dev->sm.state;
  data[3] = (unsigned short)dev->sm.step;
  data[4] = (unsigned short)dev->sm.err;
  data[5] = (unsigned short)dev->comm.adr;
  data[6] = (unsigned short)dev->comm.state;
  data[7] = (unsigned short)dev->com_ae;
  data[8] = (unsigned short)dev->u*10;
  data[9] = (unsigned short)dev->i*100;
  data[10] = (unsigned short)dev->ap*1000;
  data[11] = (unsigned short)dev->inactive_p*1000;
  data[12] = (unsigned short)dev->apparent_p*1000;
  data[13] = (unsigned short)dev->pwr_factor*1000;
  data[14] = (unsigned short)dev->freq*100;
  data[15] = (unsigned short)dev->pos_active_e;
  data[16] = (unsigned short)dev->neg_active_e;
  return 0;
}