ctnd/appl/ems/estats.c

#include "plt.h"

sqlite3 *s_es_db = NULL;
static pthread_mutex_t s_es_db_mut;
// ms
static double estats_get_timeofday()
{
    struct timeval tv;
    struct timezone tz;

    gettimeofday(&tv, &tz);
    return (double)tv.tv_sec * 1000 + (double)tv.tv_usec / 1000;
}

static void es_lock_db()
{
    pthread_mutex_lock(&s_es_db_mut);
}

static void es_unlock_db()
{
    pthread_mutex_unlock(&s_es_db_mut);
}

static int estats_get_datetime(int *y, int *m, int *d, int *h, int *min, int *s)
{
    time_t timep;
    struct tm *tsp;
    int ret = 0;

    time(&timep);
    // tsp = gmtime(&timep);
    tsp = localtime(&timep);

    *y = 1900 + tsp->tm_year;
    *m = 1 + tsp->tm_mon;
    *d = tsp->tm_mday;
    *h = tsp->tm_hour;
    *min = tsp->tm_min;
    *s = tsp->tm_sec;

    return ret;
}

static int estats_dbcb_0(void *para, int ncolumn, char **columnvalue, char *columnname[])
{
    int i;
    struct dbcbparam_t *pcbparam = (struct dbcbparam_t *)para;
    struct ems_t *e = &ems;
    struct estats_t *dev = &e->estats;

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

    for (i = 0; i < ncolumn; i++)
    {
        if (strcmp("sharp_pos_ae", columnname[i]) == 0)
        {
            dev->day_sharp_pos_ae = atof(columnvalue[i]);
        }
        else if (strcmp("sharp_neg_ae", columnname[i]) == 0)
        {
            dev->day_sharp_neg_ae = atof(columnvalue[i]);
        }
        else if (strcmp("peak_pos_ae", columnname[i]) == 0)
        {
            dev->day_peak_pos_ae = atof(columnvalue[i]);
        }
        else if (strcmp("peak_neg_ae", columnname[i]) == 0)
        {
            dev->day_peak_neg_ae = atof(columnvalue[i]);
        }
        else if (strcmp("flat_pos_ae", columnname[i]) == 0)
        {
            dev->day_flat_pos_ae = atof(columnvalue[i]);
        }
        else if (strcmp("flat_neg_ae", columnname[i]) == 0)
        {
            dev->day_flat_neg_ae = atof(columnvalue[i]);
        }
        else if (strcmp("valley_pos_ae", columnname[i]) == 0)
        {
            dev->day_valley_pos_ae = atof(columnvalue[i]);
        }
        else if (strcmp("valley_neg_ae", columnname[i]) == 0)
        {
            dev->day_valley_neg_ae = atof(columnvalue[i]);
        }
    }

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

static int estats_save_day_sum()
{
    int ret = 0;
    int i, rc;
    char *errmsg = NULL;
    sqlite3 *db = s_es_db;
    struct timeseg_t *ts = NULL;
    int hh;
    int nn;
    char sql[1024];
    struct estats_t *es = &ems.estats;

    if (es->cur_timeseg_type == TIMESEGTYPE_SHARP)
    {
        sprintf(sql, "update year%d set sharp_pos_ae=%.1f where month=%d and day=%d", es->yy, es->day_sharp_pos_ae, es->mm, es->last_dd);
        es_lock_db();
        rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        es_unlock_db();
        if (rc != SQLITE_OK)
        {
            log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        }
        sprintf(sql, "update year%d set sharp_neg_ae=%.1f where month=%d and day=%d", es->yy, es->day_sharp_neg_ae, es->mm, es->last_dd);
        es_lock_db();
        rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        es_unlock_db();
        if (rc != SQLITE_OK)
        {
            log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        }
    }
    else if (es->cur_timeseg_type == TIMESEGTYPE_PEAK)
    {
        sprintf(sql, "update year%d set peak_pos_ae=%.1f where month=%d and day=%d", es->yy, es->day_peak_pos_ae, es->mm, es->last_dd);
        es_lock_db();
        rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        es_unlock_db();
        if (rc != SQLITE_OK)
        {
            log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        }
        sprintf(sql, "update year%d set peak_neg_ae=%.1f where month=%d and day=%d", es->yy, es->day_peak_neg_ae, es->mm, es->last_dd);
        es_lock_db();
        rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        es_unlock_db();
        if (rc != SQLITE_OK)
        {
            log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        }
    }
    else if (es->cur_timeseg_type == TIMESEGTYPE_FLAT)
    {
        sprintf(sql, "update year%d set flat_pos_ae=%.1f where month=%d and day=%d", es->yy, es->day_flat_pos_ae, es->mm, es->last_dd);
        es_lock_db();
        rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        es_unlock_db();
        if (rc != SQLITE_OK)
        {
            log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        }
        sprintf(sql, "update year%d set flat_neg_ae=%.1f where month=%d and day=%d", es->yy, es->day_flat_neg_ae, es->mm, es->last_dd);
        es_lock_db();
        rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        es_unlock_db();
        if (rc != SQLITE_OK)
        {
            log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        }
    }
    else if (es->cur_timeseg_type == TIMESEGTYPE_VALLEY)
    {
        sprintf(sql, "update year%d set valley_pos_ae=%.1f where month=%d and day=%d", es->yy, es->day_valley_pos_ae, es->mm, es->last_dd);
        es_lock_db();
        rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        es_unlock_db();
        if (rc != SQLITE_OK)
        {
            log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        }
        sprintf(sql, "update year%d set valley_neg_ae=%.1f where month=%d and day=%d", es->yy, es->day_valley_neg_ae, es->mm, es->last_dd);
        es_lock_db();
        rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        es_unlock_db();
        if (rc != SQLITE_OK)
        {
            log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        }
    }
    else
    {
        ret = -1;
        goto leave;
    }

leave:
    if (ret != 0)
    {
        log_dbg("%s, --, ret:%d", __func__, ret);
    }

    return ret;
}

// period = 1s
void estats_exe()
{
    struct estats_t *es = &ems.estats;
    static double ts_last = 0;
    static int st = 0;
    int state = 0;
    static double seg_start_pos_ae = 0.0;
    static double seg_start_neg_ae = 0.0;
    static double start_day_sharp_pos_ae;
    static double start_day_sharp_neg_ae;
    static double start_day_peak_pos_ae;
    static double start_day_peak_neg_ae;
    static double start_day_flat_pos_ae;
    static double start_day_flat_neg_ae;
    static double start_day_valley_pos_ae;
    static double start_day_valley_neg_ae;

    double ts = estats_get_timeofday();

    double pos_ae = 0.0;
    double neg_ae = 0.0;

    meter_get_ctn_pos_ae(&pos_ae);
    meter_get_ctn_neg_ae(&neg_ae);

    estats_get_datetime(&es->yy, &es->mm, &es->dd, &es->hh, &es->nn, &es->ss);
    es->cur_timeseg_type = ems_get_cur_timeseg_type();
    // log_dbg("%s, meter state:%d\n", __func__, meter_get_state(DEVM_DTSD1352, 1));
    switch (es->step)
    {
    case 0: // restart
        meter_get_ctn_meter_state(&state);
        if (state == SMST_READY)
        {
            seg_start_pos_ae = pos_ae;
            seg_start_neg_ae = neg_ae;
            es->last_timeseg_type = es->cur_timeseg_type;
            es->last_dd = es->dd;
            ts_last = ts;
            es->step = 1;
            start_day_sharp_pos_ae = es->day_sharp_pos_ae;
            start_day_sharp_neg_ae = es->day_sharp_neg_ae;
            start_day_peak_pos_ae = es->day_peak_pos_ae;
            start_day_peak_neg_ae = es->day_peak_neg_ae;
            start_day_flat_pos_ae = es->day_flat_pos_ae;
            start_day_flat_neg_ae = es->day_flat_neg_ae;
            start_day_valley_pos_ae = es->day_valley_pos_ae;
            start_day_valley_neg_ae = es->day_valley_neg_ae;
        }
        break;

    case 1: // recording
        meter_get_ctn_meter_state(&state);
        if (state != SMST_READY)
        {
            estats_save_day_sum();
            es->step = 0;
        }
        else if (es->cur_timeseg_type != es->last_timeseg_type)
        {
            seg_start_pos_ae = pos_ae;
            seg_start_neg_ae = neg_ae;
            es->last_timeseg_type = es->cur_timeseg_type;
            start_day_sharp_pos_ae = es->day_sharp_pos_ae;
            start_day_sharp_neg_ae = es->day_sharp_neg_ae;
            start_day_peak_pos_ae = es->day_peak_pos_ae;
            start_day_peak_neg_ae = es->day_peak_neg_ae;
            start_day_flat_pos_ae = es->day_flat_pos_ae;
            start_day_flat_neg_ae = es->day_flat_neg_ae;
            start_day_valley_pos_ae = es->day_valley_pos_ae;
            start_day_valley_neg_ae = es->day_valley_neg_ae;
        }
        else if (es->last_dd != es->dd)
        {
            estats_save_day_sum();
            es->last_dd = es->dd;
            seg_start_pos_ae = pos_ae;
            seg_start_neg_ae = neg_ae;
            es->day_sharp_pos_ae = 0.0;
            es->day_sharp_neg_ae = 0.0;
            es->day_peak_pos_ae = 0.0;
            es->day_peak_neg_ae = 0.0;
            es->day_flat_pos_ae = 0.0;
            es->day_flat_neg_ae = 0.0;
            es->day_valley_pos_ae = 0.0;
            es->day_valley_neg_ae = 0.0;
            start_day_sharp_pos_ae = es->day_sharp_pos_ae;
            start_day_sharp_neg_ae = es->day_sharp_neg_ae;
            start_day_peak_pos_ae = es->day_peak_pos_ae;
            start_day_peak_neg_ae = es->day_peak_neg_ae;
            start_day_flat_pos_ae = es->day_flat_pos_ae;
            start_day_flat_neg_ae = es->day_flat_neg_ae;
            start_day_valley_pos_ae = es->day_valley_pos_ae;
            start_day_valley_neg_ae = es->day_valley_neg_ae;
        }
        else if (ts - ts_last > 60000)
        {
            ts_last = ts;
            estats_save_day_sum();
        }
        else
        {
            if (es->cur_timeseg_type == TIMESEGTYPE_SHARP)
            {
                if (pos_ae > seg_start_pos_ae)
                {
                    es->day_sharp_pos_ae = pos_ae - seg_start_pos_ae + start_day_sharp_pos_ae;
                }
                if (neg_ae > seg_start_neg_ae)
                {
                    es->day_sharp_neg_ae = neg_ae - seg_start_neg_ae + start_day_sharp_neg_ae;
                }
            }
            else if (es->cur_timeseg_type == TIMESEGTYPE_PEAK)
            {
                if (pos_ae > seg_start_pos_ae)
                {
                    es->day_peak_pos_ae = pos_ae - seg_start_pos_ae + start_day_peak_pos_ae;
                }
                if (neg_ae > seg_start_neg_ae)
                {
                    es->day_peak_neg_ae = neg_ae - seg_start_neg_ae + start_day_peak_neg_ae;
                }
            }
            else if (es->cur_timeseg_type == TIMESEGTYPE_FLAT)
            {
                if (pos_ae > seg_start_pos_ae)
                {
                    es->day_flat_pos_ae = pos_ae - seg_start_pos_ae + start_day_flat_pos_ae;
                }
                if (neg_ae > seg_start_neg_ae)
                {
                    es->day_flat_neg_ae = neg_ae - seg_start_neg_ae + start_day_flat_neg_ae;
                }
            }
            else if (es->cur_timeseg_type == TIMESEGTYPE_VALLEY)
            {
                if (pos_ae > seg_start_pos_ae)
                {
                    es->day_valley_pos_ae = pos_ae - seg_start_pos_ae + start_day_valley_pos_ae;
                }
                if (neg_ae > seg_start_neg_ae)
                {
                    es->day_valley_neg_ae = neg_ae - seg_start_neg_ae + start_day_valley_neg_ae;
                }
            }
        }
        break;

    default:
        break;
    }
}

int estats_load_day_sum()
{
    int ret = 0;
    int result = 0;
    int yy, mm, dd, hh, nn, ss;
    char *errmsg = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    sqlite3 *db = s_es_db;

    estats_get_datetime(&yy, &mm, &dd, &hh, &nn, &ss);
    sprintf(sql, "select * from year%d where month=%d and day=%d", yy, mm, dd);
    log_dbg("estats, sql : %s", sql);
    cbparam.ret = 0;
    cbparam.nrow = 0;
    es_lock_db();
    result = sqlite3_exec(db, sql, estats_dbcb_0, (void *)&cbparam, &errmsg);
    es_unlock_db();
    if (result != SQLITE_OK)
    {
        log_dbg("%s, result != SQLITE_OK : %d", __func__, result);
        ret = -1;
    }
    else if (cbparam.ret != 0)
    {
        log_dbg("%s, cbparam.ret != 0 : %d", __func__, cbparam.ret);
        ret = -2;
    }
    else
    {
    }

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

int estats_init()
{
    int ret = 0;
    char buf[128];
    int rc;
    struct ems_t *e = &ems;
    struct estats_t *es = &ems.estats;

    sprintf(buf, "../data/estats.db");

    if (access(buf, 0) < 0)
    {
        log_dbg("%s, access estats db fail, path:%s", __func__, buf);
        ret = -1;
    }
    else
    {
        rc = sqlite3_open(buf, &s_es_db);
        if (rc == SQLITE_OK)
        {
            pthread_mutex_init(&s_es_db_mut, NULL);
            ret = estats_load_day_sum();
        }
        else
        {
            ret = -2;
        }
    }

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

int estats_reset_year(int year)
{
    int rc;
    char *errmsg = NULL;
    sqlite3 *db = s_es_db;
    char sql[1024];
    int mm, dd;
    int ret = 0;

    /* delete */
    sprintf(sql, "delete from year%d", year);
    es_lock_db();
    rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
    es_unlock_db();
    if (rc != SQLITE_OK)
    {
        log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
        ret = -1;
        goto leave;
    }

    /* insert */
    mm = 1;
    dd = 1;
    while (mm <= 12)
    {
        while (dd <= 31)
        {
            sprintf(sql, "insert into year%d VALUES(%d,%d,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)", year, mm, dd);
            es_lock_db();
            rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
            es_unlock_db();
            if (rc != SQLITE_OK)
            {
                log_dbg("%s, sqlite3_exec fail:%d, when %s", __func__, rc, sql);
                ret = -2;
                goto leave;
            }
            dd++;
        }
        dd = 1;
        mm++;
    }

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