Microgrid_zh/meter/appl.c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#include <sys/ioctl.h>
#include <linux/if.h>
#include <linux/serial.h>
#include <syslog.h>
#include <unistd.h>
#include "mongoose.h"
#include "can_frame.h"
#include "appl.h"
#include "modbus.h"
#include "MQTTClient.h"
#include "MQTTClientPersistence.h"

#define EXPORT_PATH "/sys/class/gpio/export" // GPIO设备导出设备
#define DIR_OUT "out"
#define DIR_IN "in"

char *VERSION = "3.1.4";

struct appl_t APPL;
struct mg_mgr mgr_mqtt1; // thingsboard
struct mg_mgr mgr_mqtt2; // cloud
struct mg_mgr mgr_mqtt3; // gate and trans meter

pthread_t hthrd_485_1;
pthread_t hthrd_485_2;
pthread_t hthrd_485_3;
pthread_t hthrd_485_4;
pthread_t hthrd_can_1;
pthread_t hthrd_can_2;
pthread_t hthrd_dido;
pthread_t hthrd_ctl;
pthread_t hthrd_mqtt1;
pthread_t hthrd_mqtt2;
pthread_t hthrd_mqtt3;
pthread_t hthrd_mqtt4;
pthread_t hthrd_snap;

static void *thrd_485_1(void *param);
static void *thrd_485_2(void *param);
static void *thrd_485_3(void *param);
static void *thrd_485_4(void *param);

const struct Chan485Config_t chan485_config_t[] = {
	{0,	"NULL",			9600,	'N',	&hthrd_485_1,	thrd_485_1,	"not used"},//reseve
	{1,	"/dev/ttyAMA1",	9600,	'N',	&hthrd_485_1,	thrd_485_1,	"光伏表/变压器表/233柜表"},
	{0,	"/dev/ttyAMA2",	9600,	'N',	&hthrd_485_2,	thrd_485_2,	"未使用"},
	{0,	"/dev/ttyAMA3",	9600,	'N',	&hthrd_485_3,	thrd_485_3,	"未使用"},
	{0,	"/dev/ttyAMA4",	9600,	'N',	&hthrd_485_4,	thrd_485_4,	"未使用"}
};

// const struct MeterConfig_t meter_config_t[] = {
// 	{0,	0,  "NULL",             "未使用"},
// 	{1,	2,	"SolarMeter",        "光伏表"},
// 	//{1,	2,	"CtnMeter2"},
// 	//{2,	1,	"TransMeter1"},
// };

const struct MeterConfig_t meter_config_t[] = {
	{0,	0,  "NULL",             "未使用"},
	{1,	2,	"SolarMeter",       "光伏表"},
	{1,	1,	"TransMeter",       "变压器表"},
	{1,	4,	"CtnMeter",         "233柜表"},
};

#define CHAN485CONFIG_NBR   (sizeof(chan485_config_t) / sizeof(struct Chan485Config_t))
#define METERCONFIG_NBR     (sizeof(meter_config_t) / sizeof(struct MeterConfig_t))


int appl_cfg_save(void)
{
    long long chksum = 0;
    FILE *fp = NULL;
    int rc, i;
    fp = fopen("./cfg.bin", "wb");
    if (fp == NULL)
    {
        syslog(LOG_INFO, "%s, fopen ./cfg.bin Fail", __func__);
        return -1;
    }
    else
    {
        for (i = 0; i < sizeof(APPL.Set.buf - 8); i++)
        {
            chksum += APPL.Set.buf[8 + i];
        }
        APPL.Set.s.chksum = chksum;
        rc = fwrite(APPL.Set.buf, sizeof(char), sizeof(APPL.Set.buf), fp);
        if (rc != sizeof(APPL.Set.buf))
        {
            syslog(LOG_INFO, "%s, fwrite ./cfg.bin Fail, rc:%d", __func__, rc);
            return -1;
        }
        else
        {
            return 0;
        }
    }
}

int appl_cfg_read(void)
{
    long long chksum = 0;
    FILE *fp = NULL;
    int rc, i;
    fp = fopen("./cfg.bin", "rb");
    if (fp == NULL)
    {
        syslog(LOG_INFO, "%s, fopen ./cfg.bin Fail", __func__);
        return -1;
    }
    else
    {
        rc = fread(APPL.Set.buf, sizeof(char), sizeof(APPL.Set.buf), fp);
        if (rc != sizeof(APPL.Set.buf))
        {
            syslog(LOG_INFO, "%s, fread ./cfg.bin Fail, rc:%d", __func__, rc);
            return -1;
        }
        else
        {
            for (i = 0; i < sizeof(APPL.Set.buf - 8); i++)
            {
                chksum += APPL.Set.buf[8 + i];
            }
            if (chksum == APPL.Set.s.chksum)
            {
                return 0;
            }
            else
            {
                syslog(LOG_INFO, "%s, Chksum Fail, rc:%d", __func__, rc);
                return -1;
            }
        }
    }
}

void appl_cfg_set_err(void)
{
    APPL.Set.s.bErr = 1;
    strcpy(APPL.Set.s.szState, "故障");
}

void appl_cfg_reset_err(void)
{
    APPL.Set.s.bErr = 0;
    strcpy(APPL.Set.s.szState, "正常");
}

static char *appl_get_datetime_long(void)
{
    time_t timep;
    struct tm *tsp;
    static char buf[128];

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

    sprintf(buf, "%04d-%02d-%02d %02d:%02d:%02d", tsp->tm_year + 1900,
            tsp->tm_mon + 1,
            tsp->tm_mday,
            tsp->tm_hour,
            tsp->tm_min,
            (short)tsp->tm_sec);
    return buf;
}

static char *appl_get_datetime_short(void)
{
    static char buf[128];
    time_t timep;
    struct tm *tsp;

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

    sprintf(buf, "%02d:%02d:%02d",
            tsp->tm_hour,
            tsp->tm_min,
            (short)tsp->tm_sec);
    return buf;
}

static void appl_get_datetime_num(int *y, int *m, int *d, int *h, int *min, int *s)
{
    time_t timep;
    struct tm *tsp;

    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;
}

char *appl_get_dtstr(void)
{
    time_t timep;
    struct tm *tsp;
    static char buf[200];

    time(&timep);
    tsp = localtime(&timep);
    sprintf(buf, "%04d-%02d-%02d %02d:%02d:%02d", tsp->tm_year + 1900,
            tsp->tm_mon + 1,
            tsp->tm_mday,
            tsp->tm_hour,
            tsp->tm_min,
            (short)tsp->tm_sec);
    return buf;
}

static void *thrd_485_1(void *param)
{
    char buf[128];
    modbus_t *ctx = NULL;
    struct timeval t;
    int rc;
    unsigned short data[256];
    unsigned short start;
    unsigned short nbr;
    int chidx = 1;
    int i;
    struct chan485_t *ch = &APPL.chan485[chidx];
    struct Dtsd1352_t *m = NULL;
    int64_t startts;

    syslog(LOG_INFO, "%s ENTER", __func__);

    appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
    while (1)
    {
        startts = mg_millis();
        switch (ch->state)
        {
        case ST_485_INIT:
            ctx = modbus_new_rtu(ch->szdev, ch->baud, 'N', 8, 1);
            if (ctx == NULL)
            {
                MG_INFO(("%s, modbus rtu new fail", __func__));
                appl_485_set_state(chidx, ST_485_ERR, ERR_485_INIT_FAIL);
            }
            else if (modbus_connect(ctx) == -1)
            {
                MG_INFO(("%s, modbus rtu connect fail", __func__));
                modbus_free(ctx);
                ctx = NULL;
                appl_485_set_state(chidx, ST_485_ERR, ERR_485_INIT_FAIL);
            }
            else
            {
                // t.tv_sec = 0;
                // t.tv_usec = 500000;  // 500ms
                // //modbus_set_response_timeout(ctx, &t);
                // modbus_set_response_timeout(ctx, 0, 500000);
                ch->reqcnt = 0;
                ch->failcnt = 0;
                appl_485_set_state(chidx, ST_485_RUN, ERR_485_NONE);
            }
            break;

        case ST_485_RUN:
            // Process Cmd
            if (ch->Cmd == CMD_485_RESET)
            {
                ch->Cmd = CMD_485_DONE;
                if (ctx != NULL)
                {
                    modbus_close(ctx);
                    modbus_free(ctx);
                    ctx = NULL;
                }
                appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
                break;
            }

            for(i = 1;i < METERCONFIG_NBR;i ++){
                if(meter_config_t[i].ch_idx != 1)
                    continue;
                m = &APPL.Dtsd1352[i];
                if (mg_millis() - m->LastUpdate > 5000)
                {
                    m->CommState = ST_COMM_ERR;
                    strcpy(m->szCommState, "故障");
                }
                else
                {
                    m->CommState = ST_COMM_NORM;
                    strcpy(m->szCommState, "正常");
                }
                // Comm with DTSD1352
                // PART 1
                appl_chan485_lock(chidx);
                usleep(100000);
                modbus_set_slave(ctx, m->Adr);
                m->ctx = ctx;
                start = 0x0000;
                nbr = 32;
                rc = modbus_read_registers(ctx, start, nbr, data);
                appl_chan485_unlock(chidx);
                ch->reqcnt += 1;
                if (rc != nbr)
                {
                    ch->failcnt += 1;
                    m->CommFailTotalCnt += 1;
                    modbus_flush(ctx);
                }
                else
                {
                    m->com_active_e = ((uint32_t)(data[0x0000 - start] << 16 | data[0x0001 - start])) * m->PT * m->CT * 0.01;
                    m->pos_active_e = ((uint32_t)(data[0x000A - start] << 16 | data[0x000B - start])) * m->PT * m->CT * 0.01;
                    m->neg_active_e = ((uint32_t)(data[0x0014 - start] << 16 | data[0x0015 - start])) * m->PT * m->CT * 0.01;

                    // PART 2
                    appl_chan485_lock(chidx);
                    usleep(100000);
                    start = 0x0061;
                    nbr = 23;
                    rc = modbus_read_registers(ctx, start, nbr, data);
                    appl_chan485_unlock(chidx);
                    ch->reqcnt += 1;
                    if (rc != nbr)
                    {
                        ch->failcnt += 1;
                        m->CommFailTotalCnt += 1;
                        modbus_flush(ctx);
                    }
                    else
                    {
                        m->ua = data[0x0061 - start] * m->PT * 0.1;
                        m->ub = data[0x0062 - start] * m->PT * 0.1;
                        m->uc = data[0x0063 - start] * m->PT * 0.1;
                        m->ia = data[0x0064 - start] * m->CT * 0.01;
                        m->ib = data[0x0065 - start] * m->CT * 0.01;
                        m->ic = data[0x0066 - start] * m->CT * 0.01;
                        m->freq = data[0x0077 - start] * 0.01;

                        // PART 3
                        appl_chan485_lock(chidx);
                        usleep(100000);
                        start = 0x0078;
                        nbr = 32;
                        rc = modbus_read_registers(ctx, start, nbr, data);
                        appl_chan485_unlock(chidx);
                        ch->reqcnt += 1;
                        if (rc != nbr)
                        {
                            ch->failcnt += 1;
                            m->CommFailTotalCnt += 1;
                            modbus_flush(ctx);
                        }
                        else
                        {
                            m->PT = data[0x008D - start];
                            m->CT = data[0x008E - start];

                            // PART 4
                            appl_chan485_lock(chidx);
                            usleep(100000);
                            start = 0x016A;
                            nbr = 60;
                            rc = modbus_read_registers(ctx, start, nbr, data);
                            appl_chan485_unlock(chidx);
                            ch->reqcnt += 1;
                            if (rc != nbr)
                            {
                                ch->failcnt += 1;
                                m->CommFailTotalCnt += 1;
                                modbus_flush(ctx);
                            }
                            else
                            {
                                m->com_active_p = ((int32_t)(data[0x016A - start] << 16 | data[0x016B - start])) * m->PT * m->CT * 0.001;
                                m->com_ractive_p = ((int32_t)(data[0x0172 - start] << 16 | data[0x0173 - start])) * m->PT * m->CT * 0.001;
                                m->pwr_factor = (short)data[0x017F - start] * 0.001;
                                m->pos_active_dem = data[0x0198 - start];
                                m->neg_active_dem = data[0x0199 - start];

                                m->LastUpdate = mg_millis();
                                strcpy(m->szLastUpdate, appl_get_dtstr());
                            }
                        }
                    }
                }
            }
            break;

        case ST_485_ERR:
            if (ch->Cmd == CMD_485_RESET)
            {
                ch->Cmd = CMD_485_DONE;
                if (ctx != NULL)
                {
                    modbus_close(ctx);
                    modbus_free(ctx);
                    ctx = NULL;
                }
                appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
            }
            else
            {
                usleep(300000);
            }
            break;

        default:
            // never reach here
            break;
        }
        usleep(100000);
        ch->loopcnt += 1;
        ch->looptime = mg_millis() - startts;
    }

    syslog(LOG_INFO, "%s EXIT", __func__);
}

static void *thrd_485_2(void *param)
{
    char buf[128];
    modbus_t *ctx = NULL;
    struct timeval t;
    int rc;
    unsigned short data[256];
    unsigned short start;
    unsigned short nbr;
    int chidx = 2;
    struct chan485_t *ch = &APPL.chan485[chidx];
    struct Dtsd1352_t *m = NULL;
    int step = 1;
    int i;
    int64_t startts;

    syslog(LOG_INFO, "%s ENTER", __func__);

    appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
    while (1)
    {
        startts = mg_millis();
        switch (ch->state)
        {
        case ST_485_INIT:
            ctx = modbus_new_rtu(ch->szdev, ch->baud, 'N', 8, 1);
            if (ctx == NULL)
            {
                MG_INFO(("%s, modbus rtu new fail", __func__));
                appl_485_set_state(chidx, ST_485_ERR, ERR_485_INIT_FAIL);
            }
            else if (modbus_connect(ctx) == -1)
            {
                MG_INFO(("%s, modbus rtu connect fail", __func__));
                modbus_free(ctx);
                ctx = NULL;
                appl_485_set_state(chidx, ST_485_ERR, ERR_485_INIT_FAIL);
            }
            else
            {
                t.tv_sec = 0;
                t.tv_usec = 500000;
                // modbus_set_response_timeout(ctx, &t);
                modbus_set_response_timeout(ctx, 0, 500000);
                ch->reqcnt = 0;
                ch->failcnt = 0;
                appl_485_set_state(chidx, ST_485_RUN, ERR_485_NONE);
            }
            break;

        case ST_485_RUN:
            // Process Cmd
            if (ch->Cmd == CMD_485_RESET)
            {
                ch->Cmd = CMD_485_DONE;
                if (ctx != NULL)
                {
                    modbus_close(ctx);
                    modbus_free(ctx);
                    ctx = NULL;
                }
                appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
                break;
            }
            for(i = 1;i < METERCONFIG_NBR;i ++){
                if(meter_config_t[i].ch_idx != 2)
                    continue;
                m = &APPL.Dtsd1352[i];
                if (mg_millis() - m->LastUpdate > 5000)
                {
                    m->CommState = ST_COMM_ERR;
                    strcpy(m->szCommState, "故障");
                }
                else
                {
                    m->CommState = ST_COMM_NORM;
                    strcpy(m->szCommState, "正常");
                }
                // Comm with DTSD1352
                // PART 1
                appl_chan485_lock(chidx);
                usleep(50000);
                modbus_set_slave(ctx, m->Adr);
                m->ctx = ctx;
                start = 0x0000;
                nbr = 32;
                rc = modbus_read_registers(ctx, start, nbr, data);
                appl_chan485_unlock(chidx);
                ch->reqcnt += 1;
                if (rc != nbr)
                {
                    ch->failcnt += 1;
                    m->CommFailTotalCnt += 1;
                    modbus_flush(ctx);
                }
                else
                {
                    m->com_active_e = ((int32_t)(data[0x0000 - start] << 16 | data[0x0001 - start])) * m->PT * m->CT * 0.01;
                    m->pos_active_e = ((int32_t)(data[0x000A - start] << 16 | data[0x000B - start])) * m->PT * m->CT * 0.01;
                    m->neg_active_e = ((int32_t)(data[0x0014 - start] << 16 | data[0x0015 - start])) * m->PT * m->CT * 0.01;

                    // PART 2
                    appl_chan485_lock(chidx);
                    usleep(50000);
                    start = 0x0061;
                    nbr = 23;
                    rc = modbus_read_registers(ctx, start, nbr, data);
                    appl_chan485_unlock(chidx);
                    ch->reqcnt += 1;
                    if (rc != nbr)
                    {
                        ch->failcnt += 1;
                        m->CommFailTotalCnt += 1;
                        modbus_flush(ctx);
                    }
                    else
                    {
                        m->ua = data[0x0061 - start] * m->PT * 0.1;
                        m->ub = data[0x0062 - start] * m->PT * 0.1;
                        m->uc = data[0x0063 - start] * m->PT * 0.1;
                        m->ia = data[0x0064 - start] * m->CT * 0.01;
                        m->ib = data[0x0065 - start] * m->CT * 0.01;
                        m->ic = data[0x0066 - start] * m->CT * 0.01;
                        m->freq = data[0x0077 - start] * 0.01;

                        // PART 3
                        appl_chan485_lock(chidx);
                        usleep(50000);
                        start = 0x0078;
                        nbr = 32;
                        rc = modbus_read_registers(ctx, start, nbr, data);
                        appl_chan485_unlock(chidx);
                        ch->reqcnt += 1;
                        if (rc != nbr)
                        {
                            ch->failcnt += 1;
                            m->CommFailTotalCnt += 1;
                            modbus_flush(ctx);
                        }
                        else
                        {
                            m->PT = data[0x008D - start];
                            m->CT = data[0x008E - start];

                            // PART 4
                            appl_chan485_lock(chidx);
                            usleep(50000);
                            start = 0x016A;
                            nbr = 60;
                            rc = modbus_read_registers(ctx, start, nbr, data);
                            appl_chan485_unlock(chidx);
                            ch->reqcnt += 1;
                            if (rc != nbr)
                            {
                                ch->failcnt += 1;
                                m->CommFailTotalCnt += 1;
                                modbus_flush(ctx);
                            }
                            else
                            {
                                m->com_active_p = ((int32_t)(data[0x016A - start] << 16 | data[0x016B - start])) * m->PT * m->CT * 0.001;
                                m->com_ractive_p = ((int32_t)(data[0x0172 - start] << 16 | data[0x0173 - start])) * m->PT * m->CT * 0.001;
                                m->pwr_factor = (short)data[0x017F - start] * 0.001;
                                m->pos_active_dem = data[0x0198 - start];
                                m->neg_active_dem = data[0x0199 - start];

                                m->LastUpdate = mg_millis();
                                strcpy(m->szLastUpdate, appl_get_dtstr());
                            }
                        }
                    }
                }
            }

            break;

        case ST_485_ERR:
            if (ch->Cmd == CMD_485_RESET)
            {
                ch->Cmd = CMD_485_DONE;
                if (ctx != NULL)
                {
                    modbus_close(ctx);
                    modbus_free(ctx);
                    ctx = NULL;
                }
                appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
            }
            else
            {
                usleep(300000);
            }
            break;

        default:
            // never reach here
            break;
        }
        usleep(100000);
        ch->loopcnt += 1;
        ch->looptime = mg_millis() - startts;
    }
    syslog(LOG_INFO, "%s EXIT", __func__);
}

static void *thrd_485_3(void *param)
{
    char buf[128];
    modbus_t *ctx = NULL;
    struct timeval t;
    int rc;
    unsigned short data[256];
    unsigned short start;
    unsigned short nbr;
    int chidx = 3;
    int i;
    struct chan485_t *ch = &APPL.chan485[chidx];
    int64_t startts;
    struct Dtsd1352_t *m = NULL;

    syslog(LOG_INFO, "%s ENTER", __func__);

    appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
    while (1)
    {
        startts = mg_millis();
        switch (ch->state)
        {
        case ST_485_INIT:
            ctx = modbus_new_rtu(ch->szdev, ch->baud, 'N', 8, 1);
            if (ctx == NULL)
            {
                MG_INFO(("%s, modbus rtu new fail", __func__));
                appl_485_set_state(chidx, ST_485_ERR, ERR_485_INIT_FAIL);
            }
            else if (modbus_connect(ctx) == -1)
            {
                MG_INFO(("%s, modbus rtu connect fail", __func__));
                modbus_free(ctx);
                ctx = NULL;
                appl_485_set_state(chidx, ST_485_ERR, ERR_485_INIT_FAIL);
            }
            else
            {
                t.tv_sec = 0;
                t.tv_usec = 500000;
                // modbus_set_response_timeout(ctx, &t);
                modbus_set_response_timeout(ctx, 0, 500000);
                ch->reqcnt = 0;
                ch->failcnt = 0;
                appl_485_set_state(chidx, ST_485_RUN, ERR_485_NONE);
            }
            break;

        case ST_485_RUN:
            // Process Cmd
            if (ch->Cmd == CMD_485_RESET)
            {
                ch->Cmd = CMD_485_DONE;
                if (ctx != NULL)
                {
                    modbus_close(ctx);
                    modbus_free(ctx);
                    ctx = NULL;
                }
                appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
                break;
            }
            for(i = 1;i < METERCONFIG_NBR;i ++){
                if(meter_config_t[i].ch_idx != 3)
                    continue;
                m = &APPL.Dtsd1352[i];
                if (mg_millis() - m->LastUpdate > 5000)
                {
                    m->CommState = ST_COMM_ERR;
                    strcpy(m->szCommState, "故障");
                }
                else
                {
                    m->CommState = ST_COMM_NORM;
                    strcpy(m->szCommState, "正常");
                }
                // Comm with DTSD1352
                // PART 1
                appl_chan485_lock(chidx);
                usleep(50000);
                modbus_set_slave(ctx, m->Adr);
                m->ctx = ctx;
                start = 0x0000;
                nbr = 32;
                rc = modbus_read_registers(ctx, start, nbr, data);
                appl_chan485_unlock(chidx);
                ch->reqcnt += 1;
                if (rc != nbr)
                {
                    ch->failcnt += 1;
                    m->CommFailTotalCnt += 1;
                    modbus_flush(ctx);
                }
                else
                {
                    m->com_active_e = ((int32_t)(data[0x0000 - start] << 16 | data[0x0001 - start])) * m->PT * m->CT * 0.01;
                    m->pos_active_e = ((int32_t)(data[0x000A - start] << 16 | data[0x000B - start])) * m->PT * m->CT * 0.01;
                    m->neg_active_e = ((int32_t)(data[0x0014 - start] << 16 | data[0x0015 - start])) * m->PT * m->CT * 0.01;

                    // PART 2
                    appl_chan485_lock(chidx);
                    usleep(50000);
                    start = 0x0061;
                    nbr = 23;
                    rc = modbus_read_registers(ctx, start, nbr, data);
                    appl_chan485_unlock(chidx);
                    ch->reqcnt += 1;
                    if (rc != nbr)
                    {
                        ch->failcnt += 1;
                        m->CommFailTotalCnt += 1;
                        modbus_flush(ctx);
                    }
                    else
                    {
                        m->ua = data[0x0061 - start] * m->PT * 0.1;
                        m->ub = data[0x0062 - start] * m->PT * 0.1;
                        m->uc = data[0x0063 - start] * m->PT * 0.1;
                        m->ia = data[0x0064 - start] * m->CT * 0.01;
                        m->ib = data[0x0065 - start] * m->CT * 0.01;
                        m->ic = data[0x0066 - start] * m->CT * 0.01;
                        m->freq = data[0x0077 - start] * 0.01;

                        // PART 3
                        appl_chan485_lock(chidx);
                        usleep(50000);
                        start = 0x0078;
                        nbr = 32;
                        rc = modbus_read_registers(ctx, start, nbr, data);
                        appl_chan485_unlock(chidx);
                        ch->reqcnt += 1;
                        if (rc != nbr)
                        {
                            ch->failcnt += 1;
                            m->CommFailTotalCnt += 1;
                            modbus_flush(ctx);
                        }
                        else
                        {
                            m->PT = data[0x008D - start];
                            m->CT = data[0x008E - start];

                            // PART 4
                            appl_chan485_lock(chidx);
                            usleep(50000);
                            start = 0x016A;
                            nbr = 60;
                            rc = modbus_read_registers(ctx, start, nbr, data);
                            appl_chan485_unlock(chidx);
                            ch->reqcnt += 1;
                            if (rc != nbr)
                            {
                                ch->failcnt += 1;
                                m->CommFailTotalCnt += 1;
                                modbus_flush(ctx);
                            }
                            else
                            {
                                m->com_active_p = ((int32_t)(data[0x016A - start] << 16 | data[0x016B - start])) * m->PT * m->CT * 0.001;
                                m->com_ractive_p = ((int32_t)(data[0x0172 - start] << 16 | data[0x0173 - start])) * m->PT * m->CT * 0.001;
                                m->pwr_factor = (short)data[0x017F - start] * 0.001;
                                m->pos_active_dem = data[0x0198 - start];
                                m->neg_active_dem = data[0x0199 - start];

                                m->LastUpdate = mg_millis();
                                strcpy(m->szLastUpdate, appl_get_dtstr());
                            }
                        }
                    }
                }
            }
            break;

        case ST_485_ERR:
            if (ch->Cmd == CMD_485_RESET)
            {
                ch->Cmd = CMD_485_DONE;
                if (ctx != NULL)
                {
                    modbus_close(ctx);
                    modbus_free(ctx);
                    ctx = NULL;
                }
                appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
            }
            else
            {
                usleep(300000);
            }
            break;

        default:
            // never reach here
            break;
        }

        usleep(100000);
        ch->loopcnt += 1;
        ch->looptime = mg_millis() - startts;
    }
    syslog(LOG_INFO, "%s EXIT", __func__);
}


static void *thrd_485_4(void *param)
{
    char buf[128];
    modbus_t *ctx = NULL;
    struct timeval t;
    int rc;
    unsigned short data[256];
    unsigned short start;
    unsigned short nbr;
    int chidx = 4;
    int i;
    struct chan485_t *ch = &APPL.chan485[chidx];
    int64_t startts;
    struct Dtsd1352_t *m = NULL;

    syslog(LOG_INFO, "%s ENTER", __func__);

    appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
    while (1)
    {
        startts = mg_millis();
        switch (ch->state)
        {
        case ST_485_INIT:
            ctx = modbus_new_rtu(ch->szdev, ch->baud, 'N', 8, 1);
            if (ctx == NULL)
            {
                MG_INFO(("%s, modbus rtu new fail", __func__));
                appl_485_set_state(chidx, ST_485_ERR, ERR_485_INIT_FAIL);
            }
            else if (modbus_connect(ctx) == -1)
            {
                MG_INFO(("%s, modbus rtu connect fail", __func__));
                modbus_free(ctx);
                ctx = NULL;
                appl_485_set_state(chidx, ST_485_ERR, ERR_485_INIT_FAIL);
            }
            else
            {
                t.tv_sec = 0;
                t.tv_usec = 500000;
                // modbus_set_response_timeout(ctx, &t);
                modbus_set_response_timeout(ctx, 0, 500000);
                ch->reqcnt = 0;
                ch->failcnt = 0;
                appl_485_set_state(chidx, ST_485_RUN, ERR_485_NONE);
            }
            break;

        case ST_485_RUN:
            // Process Cmd
            if (ch->Cmd == CMD_485_RESET)
            {
                ch->Cmd = CMD_485_DONE;
                if (ctx != NULL)
                {
                    modbus_close(ctx);
                    modbus_free(ctx);
                    ctx = NULL;
                }
                appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
                break;
            }
            for(i = 1;i < METERCONFIG_NBR;i ++){
                if(meter_config_t[i].ch_idx != 4)
                    continue;
                m = &APPL.Dtsd1352[i];
                if (mg_millis() - m->LastUpdate > 5000)
                {
                    m->CommState = ST_COMM_ERR;
                    strcpy(m->szCommState, "故障");
                }
                else
                {
                    m->CommState = ST_COMM_NORM;
                    strcpy(m->szCommState, "正常");
                }
                // Comm with DTSD1352
                // PART 1
                appl_chan485_lock(chidx);
                usleep(50000);
                modbus_set_slave(ctx, m->Adr);
                m->ctx = ctx;
                start = 0x0000;
                nbr = 32;
                rc = modbus_read_registers(ctx, start, nbr, data);
                appl_chan485_unlock(chidx);
                ch->reqcnt += 1;
                if (rc != nbr)
                {
                    ch->failcnt += 1;
                    m->CommFailTotalCnt += 1;
                    modbus_flush(ctx);
                }
                else
                {
                    m->com_active_e = ((int32_t)(data[0x0000 - start] << 16 | data[0x0001 - start])) * m->PT * m->CT * 0.01;
                    m->pos_active_e = ((int32_t)(data[0x000A - start] << 16 | data[0x000B - start])) * m->PT * m->CT * 0.01;
                    m->neg_active_e = ((int32_t)(data[0x0014 - start] << 16 | data[0x0015 - start])) * m->PT * m->CT * 0.01;

                    // PART 2
                    appl_chan485_lock(chidx);
                    usleep(50000);
                    start = 0x0061;
                    nbr = 23;
                    rc = modbus_read_registers(ctx, start, nbr, data);
                    appl_chan485_unlock(chidx);
                    ch->reqcnt += 1;
                    if (rc != nbr)
                    {
                        ch->failcnt += 1;
                        m->CommFailTotalCnt += 1;
                        modbus_flush(ctx);
                    }
                    else
                    {
                        m->ua = data[0x0061 - start] * m->PT * 0.1;
                        m->ub = data[0x0062 - start] * m->PT * 0.1;
                        m->uc = data[0x0063 - start] * m->PT * 0.1;
                        m->ia = data[0x0064 - start] * m->CT * 0.01;
                        m->ib = data[0x0065 - start] * m->CT * 0.01;
                        m->ic = data[0x0066 - start] * m->CT * 0.01;
                        m->freq = data[0x0077 - start] * 0.01;

                        // PART 3
                        appl_chan485_lock(chidx);
                        usleep(50000);
                        start = 0x0078;
                        nbr = 32;
                        rc = modbus_read_registers(ctx, start, nbr, data);
                        appl_chan485_unlock(chidx);
                        ch->reqcnt += 1;
                        if (rc != nbr)
                        {
                            ch->failcnt += 1;
                            m->CommFailTotalCnt += 1;
                            modbus_flush(ctx);
                        }
                        else
                        {
                            m->PT = data[0x008D - start];
                            m->CT = data[0x008E - start];

                            // PART 4
                            appl_chan485_lock(chidx);
                            usleep(50000);
                            start = 0x016A;
                            nbr = 60;
                            rc = modbus_read_registers(ctx, start, nbr, data);
                            appl_chan485_unlock(chidx);
                            ch->reqcnt += 1;
                            if (rc != nbr)
                            {
                                ch->failcnt += 1;
                                m->CommFailTotalCnt += 1;
                                modbus_flush(ctx);
                            }
                            else
                            {
                                m->com_active_p = ((int32_t)(data[0x016A - start] << 16 | data[0x016B - start])) * m->PT * m->CT * 0.001;
                                m->com_ractive_p = ((int32_t)(data[0x0172 - start] << 16 | data[0x0173 - start])) * m->PT * m->CT * 0.001;
                                m->pwr_factor = (short)data[0x017F - start] * 0.001;
                                m->pos_active_dem = data[0x0198 - start];
                                m->neg_active_dem = data[0x0199 - start];

                                m->LastUpdate = mg_millis();
                                strcpy(m->szLastUpdate, appl_get_dtstr());
                            }
                        }
                    }
                }
            }
            break;

        case ST_485_ERR:
            if (ch->Cmd == CMD_485_RESET)
            {
                ch->Cmd = CMD_485_DONE;
                if (ctx != NULL)
                {
                    modbus_close(ctx);
                    modbus_free(ctx);
                    ctx = NULL;
                }
                appl_485_set_state(chidx, ST_485_INIT, ERR_485_NONE);
            }
            else
            {
                usleep(300000);
            }
            break;

        default:
            // never reach here
            break;
        }

        usleep(100000);
        ch->loopcnt += 1;
        ch->looptime = mg_millis() - startts;
    }
    syslog(LOG_INFO, "%s EXIT", __func__);
}

void appl_chan485_lock(int idx)
{
    // pthread_mutex_lock(&APPL.chan485[idx].mutex);
}

void appl_chan485_unlock(int idx)
{
    // pthread_mutex_unlock(&APPL.chan485[idx].mutex);
}

void appl_485_set_state(int idx, int s, int e)
{
    struct chan485_t *c = &APPL.chan485[idx];
    c->state = s;
    switch (c->state)
    {
    case ST_485_INIT:
        strcpy(c->szstate, "初始化");
        break;

    case ST_485_RUN:
        strcpy(c->szstate, "运行");
        break;

    case ST_485_ERR:
        strcpy(c->szstate, "故障");
        break;

    default:
        strcpy(c->szstate, "未知");
        break;
    }

    c->err = e;
    switch (e)
    {
    case ERR_485_NONE:
        strcpy(c->szerr, "无");
        break;
    case ERR_485_INIT_FAIL:
        strcpy(c->szerr, "初始化失败");
        break;

    default:
        strcpy(c->szerr, "未知");
        break;
    }
}

int appl_chan485_get_state(int idx)
{
    return APPL.chan485[idx].state;
}

void appl_can_set_state(int idx, int s, int e)
{
    struct chancan_t *c = &APPL.chancan[idx];
    c->State = s;
    switch (c->State)
    {
    case ST_CAN_INIT:
        strcpy(c->szState, "初始化");
        break;

    case ST_CHANCAN_RUN:
        strcpy(c->szState, "运行");
        break;

    case ST_CHANCAN_ERR:
        strcpy(c->szState, "故障");
        break;

    default:
        strcpy(c->szState, "未知");
        break;
    }

    c->Err = e;
    switch (e)
    {
    case ERR_CAN_NONE:
        strcpy(c->szErr, "无");
        break;

    case ERR_CAN_INIT_FAIL:
        strcpy(c->szErr, "初始化失败");
        break;

    default:
        break;
    }
}

int appl_can_get_state(int idx)
{
    return APPL.chancan[idx].State;
}

void appl_485_set_485mode(void)
{
    int fd;
    struct serial_rs485 rs485conf = {0};
    int ret;

    // 1# 485
    fd = open("/dev/ttymxc1", O_RDWR | O_NOCTTY);
    if (fd <= 0)
    {
        syslog(LOG_INFO, "%s, Open ttymxc1 Fail", __func__);
    }
    else
    {
        /* get configure from device */
        ret = ioctl(fd, TIOCGRS485, &rs485conf);
        if (ret < 0)
        {
            // failed
            syslog(LOG_INFO, "%s, ioctl ttymxc1 Fail", __func__);
        }
        /* set enable rs485 mode in configure */
        /* Enable RS485 mode: */
        rs485conf.flags |= SER_RS485_ENABLED;
        /* Set logical level for RTS pin equal to 1 when sending: */
        rs485conf.flags |= SER_RS485_RTS_ON_SEND;
        /* Set logical level for RTS pin equal to 0 after sending: */
        rs485conf.flags &= ~SER_RS485_RTS_AFTER_SEND;
        /* Set this flag if you want to receive data even whilst sending data */
        rs485conf.flags &= ~SER_RS485_RX_DURING_TX;
        /* Set rts delay before send, if needed: */
        rs485conf.delay_rts_before_send = 0; // in miliseconds
        /* Set rts delay after send, if needed: */
        rs485conf.delay_rts_after_send = 0; // in miliseconds
        ret = ioctl(fd, TIOCSRS485, &rs485conf);
        if (ret < 0)
        {
            /* Error handling. See errno. */
            syslog(LOG_INFO, "%s, Set ttymxc1 485 Fail", __func__);
        }
        close(fd);
    }

    // 2# 485
    fd = open("/dev/ttymxc2", O_RDWR | O_NOCTTY);
    if (fd <= 0)
    {
        syslog(LOG_INFO, "%s, Open ttymxc2 Fail", __func__);
    }
    else
    {
        /* get configure from device */
        ret = ioctl(fd, TIOCGRS485, &rs485conf);
        if (ret < 0)
        {
            // failed
            syslog(LOG_INFO, "%s, ioctl ttymxc2 Fail", __func__);
        }
        /* set enable rs485 mode in configure */
        /* Enable RS485 mode: */
        rs485conf.flags |= SER_RS485_ENABLED;
        /* Set logical level for RTS pin equal to 1 when sending: */
        rs485conf.flags |= SER_RS485_RTS_ON_SEND;
        /* Set logical level for RTS pin equal to 0 after sending: */
        rs485conf.flags &= ~SER_RS485_RTS_AFTER_SEND;
        /* Set this flag if you want to receive data even whilst sending data */
        rs485conf.flags &= ~SER_RS485_RX_DURING_TX;
        /* Set rts delay before send, if needed: */
        rs485conf.delay_rts_before_send = 0; // in miliseconds
        /* Set rts delay after send, if needed: */
        rs485conf.delay_rts_after_send = 0; // in miliseconds
        ret = ioctl(fd, TIOCSRS485, &rs485conf);
        if (ret < 0)
        {
            /* Error handling. See errno. */
            syslog(LOG_INFO, "%s, Set ttymxc2 485 Fail", __func__);
        }
        close(fd);
    }

    // 3# 485
    fd = open("/dev/ttymxc3", O_RDWR | O_NOCTTY);
    if (fd <= 0)
    {
        syslog(LOG_INFO, "%s, Open ttymxc3 Fail", __func__);
    }
    else
    {
        /* get configure from device */
        ret = ioctl(fd, TIOCGRS485, &rs485conf);
        if (ret < 0)
        {
            // failed
            syslog(LOG_INFO, "%s, ioctl ttymxc3 Fail", __func__);
        }
        /* set enable rs485 mode in configure */
        /* Enable RS485 mode: */
        rs485conf.flags |= SER_RS485_ENABLED;
        /* Set logical level for RTS pin equal to 1 when sending: */
        rs485conf.flags |= SER_RS485_RTS_ON_SEND;
        /* Set logical level for RTS pin equal to 0 after sending: */
        rs485conf.flags &= ~SER_RS485_RTS_AFTER_SEND;
        /* Set this flag if you want to receive data even whilst sending data */
        rs485conf.flags &= ~SER_RS485_RX_DURING_TX;
        /* Set rts delay before send, if needed: */
        rs485conf.delay_rts_before_send = 0; // in miliseconds
        /* Set rts delay after send, if needed: */
        rs485conf.delay_rts_after_send = 0; // in miliseconds
        ret = ioctl(fd, TIOCSRS485, &rs485conf);
        if (ret < 0)
        {
            /* Error handling. See errno. */
            syslog(LOG_INFO, "%s, Set ttymxc3 485 Fail", __func__);
        }
        close(fd);
    }

    // 4# 485
    fd = open("/dev/ttymxc5", O_RDWR | O_NOCTTY);
    if (fd <= 0)
    {
        syslog(LOG_INFO, "%s, Open ttymxc5 Fail", __func__);
    }
    else
    {
        /* get configure from device */
        ret = ioctl(fd, TIOCGRS485, &rs485conf);
        if (ret < 0)
        {
            // failed
            syslog(LOG_INFO, "%s, ioctl ttymxc5 Fail", __func__);
        }
        /* set enable rs485 mode in configure */
        /* Enable RS485 mode: */
        rs485conf.flags |= SER_RS485_ENABLED;
        /* Set logical level for RTS pin equal to 1 when sending: */
        rs485conf.flags |= SER_RS485_RTS_ON_SEND;
        /* Set logical level for RTS pin equal to 0 after sending: */
        rs485conf.flags &= ~SER_RS485_RTS_AFTER_SEND;
        /* Set this flag if you want to receive data even whilst sending data */
        rs485conf.flags &= ~SER_RS485_RX_DURING_TX;
        /* Set rts delay before send, if needed: */
        rs485conf.delay_rts_before_send = 0; // in miliseconds
        /* Set rts delay after send, if needed: */
        rs485conf.delay_rts_after_send = 0; // in miliseconds
        ret = ioctl(fd, TIOCSRS485, &rs485conf);
        if (ret < 0)
        {
            /* Error handling. See errno. */
            syslog(LOG_INFO, "%s, Set ttymxc5 485 Fail", __func__);
        }
        close(fd);
    }
}

static void fn_mqtt1(struct mg_connection *c, int ev, void *ev_data)
{
    //   struct chanmqtt_t* m = &APPL.chanmqtt[1];
    //   if (ev == MG_EV_OPEN) {
    //     MG_INFO(("%lu CREATED", c->id));
    //     // c->is_hexdumping = 1;
    //   } else if (ev == MG_EV_CONNECT) {
    //     if (mg_url_is_ssl(m->szs_url)) {
    //       struct mg_tls_opts opts = {.ca = mg_unpacked("/certs/ca.pem"),
    //                                  .name = mg_url_host(m->szs_url)};
    //       mg_tls_init(c, &opts);
    //     }
    //   } else if (ev == MG_EV_ERROR) {
    //     // On error, log error message
    //     MG_ERROR(("%lu ERROR %s", c->id, (char *) ev_data));
    //   } else if (ev == MG_EV_MQTT_OPEN) {
    //     m->bConnected = 1;
    //     strcpy(m->szState,"正常");
    //     // MQTT connect is successful
    //     struct mg_str subt = mg_str(m->szs_sub_topic);
    //     MG_INFO(("%lu CONNECTED to %s", c->id, m->szs_url));
    //     struct mg_mqtt_opts sub_opts;
    //     memset(&sub_opts, 0, sizeof(sub_opts));
    //     sub_opts.topic = subt;
    //     sub_opts.qos = m->s_qos;
    //     mg_mqtt_sub(c, &sub_opts);
    //     MG_INFO(("%lu SUBSCRIBED to %.*s", c->id, (int) subt.len, subt.ptr));

    //   } else if (ev == MG_EV_MQTT_MSG) {
    //     // When we get echo response, print it
    //     struct mg_mqtt_message *mm = (struct mg_mqtt_message *) ev_data;
    //     MG_INFO(("%lu RECEIVED %.*s <- %.*s", c->id, (int) mm->data.len,
    //              mm->data.ptr, (int) mm->topic.len, mm->topic.ptr));
    //   } else if (ev == MG_EV_CLOSE) {
    //     MG_INFO(("%lu CLOSED", c->id));
    //     m->s_conn = NULL;  // Mark that we're closed
    //     m->bConnected = 0;
    //     strcpy(m->szState,"故障");
    //   }
}

static void fn_mqtt2(struct mg_connection *c, int ev, void *ev_data)
{
    struct chanmqtt_t *m = &APPL.chanmqtt[2];
    if (ev == MG_EV_OPEN)
    {
        syslog(LOG_INFO, "%lu CREATED", c->id);
        // c->is_hexdumping = 1;
    }
    else if (ev == MG_EV_CONNECT)
    {
        if (mg_url_is_ssl(m->szs_url))
        {
            struct mg_tls_opts opts = {.ca = mg_unpacked("/certs/ca.pem"),
                                       .name = mg_url_host(m->szs_url)};
            mg_tls_init(c, &opts);
        }
    }
    else if (ev == MG_EV_ERROR)
    {
        // On error, log error message
        syslog(LOG_INFO, "%lu ERROR %s", c->id, (char *)ev_data);
    }
    else if (ev == MG_EV_MQTT_OPEN)
    {
        m->bConnected = 1;
        strcpy(m->szState, "正常");
        m->TotalReconn++;
        // MQTT connect is successful
        struct mg_str subt = mg_str(m->szs_sub_topic);
        syslog(LOG_INFO, "%lu CONNECTED to %s", c->id, m->szs_url);
        struct mg_mqtt_opts sub_opts;
        memset(&sub_opts, 0, sizeof(sub_opts));
        sub_opts.topic = subt;
        sub_opts.qos = m->s_qos;
        mg_mqtt_sub(c, &sub_opts);
        syslog(LOG_INFO, "%lu SUBSCRIBED to %.*s", c->id, (int)subt.len, subt.ptr);
    }
    else if (ev == MG_EV_MQTT_MSG)
    {
        // When we get echo response, print it
        struct mg_mqtt_message *mm = (struct mg_mqtt_message *)ev_data;
        syslog(LOG_INFO, "%lu RECEIVED %.*s <- %.*s", c->id, (int)mm->data.len,
               mm->data.ptr, (int)mm->topic.len, mm->topic.ptr);
        m->TotalRecv++;
    }
    else if (ev == MG_EV_CLOSE)
    {
        syslog(LOG_INFO, "%lu CLOSED", c->id);
        m->s_conn = NULL; // Mark that we're closed
        m->bConnected = 0;
        strcpy(m->szState, "故障");
    }
}

static void fn_mqtt3(struct mg_connection *c, int ev, void *ev_data)
{
    struct chanmqtt_t *m = &APPL.chanmqtt[3];
    char buf[256];
    if (ev == MG_EV_OPEN)
    {
        syslog(LOG_INFO, "%s, %lu CREATED", __func__, c->id);
        // c->is_hexdumping = 1;
    }
    else if (ev == MG_EV_CONNECT)
    {
        if (mg_url_is_ssl(m->szs_url))
        {
            struct mg_tls_opts opts = {.ca = mg_unpacked("/certs/ca.pem"),
                                       .name = mg_url_host(m->szs_url)};
            mg_tls_init(c, &opts);
        }
    }
    else if (ev == MG_EV_ERROR)
    {
        // On error, log error message
        syslog(LOG_INFO, "%s, %lu ERROR %s", __func__, c->id, (char *)ev_data);
    }
    else if (ev == MG_EV_MQTT_OPEN)
    {
        m->bConnected = 1;
        strcpy(m->szState, "正常");
        // MQTT connect is successful
        syslog(LOG_INFO, "%s, %lu CONNECTED to %s", __func__, c->id, m->szs_url);

        struct mg_str subt = mg_str(m->szs_sub_topic[0]);
        struct mg_mqtt_opts sub_opts;
        memset(&sub_opts, 0, sizeof(sub_opts));
        sub_opts.topic = subt;
        sub_opts.qos = m->s_qos;
        mg_mqtt_sub(c, &sub_opts);
        syslog(LOG_INFO, "%s, %lu SUBSCRIBED to %.*s", __func__, c->id, (int)subt.len, subt.ptr);

        // subt = mg_str(m->szs_sub_topic[1]);
        // memset(&sub_opts, 0, sizeof(sub_opts));
        // sub_opts.topic = subt;
        // sub_opts.qos = m->s_qos;
        // mg_mqtt_sub(c, &sub_opts);
        // syslog(LOG_INFO,"%s, %lu SUBSCRIBED to %.*s", __func__, c->id, (int) subt.len, subt.ptr);
    }
    else if (ev == MG_EV_MQTT_MSG)
    {
        // When we get echo response, print it
        struct mg_mqtt_message *mm = (struct mg_mqtt_message *)ev_data;
        // syslog(LOG_INFO,"%s, %lu RECEIVED %.*s <- %.*s", __func__, c->id, (int) mm->data.len,
        //          mm->data.ptr, (int) mm->topic.len, mm->topic.ptr);
        struct mg_str json = mg_str(mm->data.ptr);
        double dval;
        bool ok;
        if (strcmp(mm->topic.ptr, m->szs_sub_topic[0]) == 0)
        { // gate meter
            syslog(LOG_INFO, "%s, Get Gate Meter Data", __func__);
            ok = mg_json_get_num(json, "$.m1_com_ap", &dval);
            if (ok)
            {
                // gm->com_active_p = dval;
                // gm->LastUpdate = mg_millis();
                // strcpy(gm->szLastUpdate, appl_get_datetime_long());
            }
            ok = mg_json_get_num(json, "$.m2_com_ap", &dval);
            if (ok)
            {
                // tm->com_active_p = dval;
                // tm->LastUpdate = mg_millis();
                // strcpy(tm->szLastUpdate, appl_get_datetime_long());
            }
        }
    }
    else if (ev == MG_EV_CLOSE)
    {
        syslog(LOG_INFO, "%s, %lu CLOSED", __func__, c->id);
        m->s_conn = NULL; // Mark that we're closed
        m->bConnected = 0;
        strcpy(m->szState, "故障");
    }
}

static void *thrd_mqtt_1(void *param)
{
    //     struct chanmqtt_t* m = &APPL.chanmqtt[1];
    //     struct Dtsd1352_t* meter = NULL;
    //     struct mg_mqtt_opts opts = {.user = mg_str(m->szusrname),
    //                                 .clean = true,
    //                                 .qos = m->s_qos,
    //                                 .topic = mg_str(m->szs_pub_topic),
    //                                 .version = 4,
    //                                 .message = mg_str("bye")};
    //     struct mg_mqtt_opts pub_opts;
    //     struct mg_str pubt = mg_str(m->szs_pub_topic);
    //     char msg[2048];
    //     char buf[2048];
    //     int i;

    //     mg_mgr_init(&mgr_mqtt1);

    //     MG_INFO(("%s ENTER, idx:1", __func__));

    //     if (m->s_conn == NULL) m->s_conn = mg_mqtt_connect(&mgr_mqtt1, m->szs_url, &opts, fn_mqtt1, NULL);
    //     while(1){
    //         mg_mgr_poll(&mgr_mqtt1, 50);
    //         if(mg_millis() - m->LastUpload > 5000){
    //             m->LastUpload = mg_millis();
    //             if(m->bConnected){
    //                 for(i = 1; i <= 2; i++){
    //                     meter = &APPL.Dtsd1352[i];
    //                     if( meter->CommState == ST_COMM_NORM ){
    //                         memset(&pub_opts, 0, sizeof(pub_opts));
    //                         pub_opts.topic = pubt;
    //                         sprintf(buf,
    // "\"m%d_pf\":%.3f,\
// \"m%d_com_ap\":%.1f,\"m%d_com_ae\":%.1f,\"m%d_pos_ae\":%.1f,\"m%d_neg_ae\":%.1f, \
// \"m%d_ua\":%.1f,\"m%d_ub\":%.1f,\"m%d_uc\":%.1f, \
// \"m%d_ia\":%.1f,\"m%d_ib\":%.1f,\"m%d_ic\":%.1f",
    // i, meter->pwr_factor,
    // i, meter->com_active_p,i, meter->com_active_e,i, meter->pos_active_e,i, meter->neg_active_e,
    // i, meter->ua,i, meter->ub,i, meter->uc,
    // i, meter->ia,i, meter->ib,i, meter->ic);
    //                         sprintf(msg,"{'ts':%lld,'values':{%s}}", (long long)time(NULL)*1000, buf);
    //                         pub_opts.message = mg_str(msg);
    //                         pub_opts.qos = m->s_qos, pub_opts.retain = false;
    //                         mg_mqtt_pub(m->s_conn, &pub_opts);
    //                     }
    //                 }
    //             }
    //             if (m->s_conn == NULL) m->s_conn = mg_mqtt_connect(&mgr_mqtt1, m->szs_url, &opts, fn_mqtt1, NULL);
    //         }
    //     }

    //     MG_INFO(("%s EXIT, idx:1", __func__));
}

static void *thrd_mqtt_2(void *param)
{
    int i;
    struct Dtsd1352_t *me = NULL;
    struct chanmqtt_t *m = &APPL.chanmqtt[2];
    struct Settings_t *set = &APPL.Set.s;
    struct mg_mqtt_opts opts = {.user = mg_str(m->szusrname),
                                .pass = mg_str(m->szpasswd),
                                .client_id = mg_str(m->szclientid),
                                .clean = true,
                                .qos = m->s_qos,
                                .topic = mg_str(m->szs_pub_topic[0]),
                                .version = 4,
                                .message = mg_str("bye")};
    struct mg_mqtt_opts pub_opts;
    struct mg_str pubt = mg_str(m->szs_pub_topic[0]);
    char msg[2048];
    char buf[2048];

    mg_mgr_init(&mgr_mqtt2);

    syslog(LOG_INFO, "%s ENTER idx:2", __func__);

    if (m->s_conn == NULL)
        m->s_conn = mg_mqtt_connect(&mgr_mqtt2, m->szs_url, &opts, fn_mqtt2, NULL);
    while (1)
    {
        mg_mgr_poll(&mgr_mqtt2, 20);
        // Process Cmd
        if (m->Cmd == CMD_MQTT_REGISTER)
        {
            m->Cmd = CMD_MQTT_DONE;
            // Register GateMeter
            sprintf(msg, "{\"project_id\":\"%s\",\"timestamp\":%lld,\"data\":[{\"device_id\":\"%s\",\"type\":17,\"idx\":1}]}",
                    set->szCloudUserName, (long long)time(NULL) * 1000, "GateMeter");
            pub_opts.message = mg_str(msg);
            pub_opts.qos = m->s_qos, pub_opts.retain = false;
            pub_opts.topic = mg_str("register");
            mg_mqtt_pub(m->s_conn, &pub_opts);
        }

        if (mg_millis() - m->LastFastUpload > set->UploadHighSpeed)
        {
            m->LastFastUpload = mg_millis();
            if (m->bConnected)
            {
                // GateMeter
                me = &APPL.Dtsd1352[1];
                if (me->CommState == ST_COMM_NORM)
                {
                    sprintf(msg, "{\"project_id\":\"%s\",\"timestamp\":%lld,\"data\":[{\"device_id\":\"%s\",\"type\":17,\"idx\":1,\
\"pos_ae\":%.1f,\"neg_ae\":%.1f,\"com_ap\":%.1f,\"com_rap\":%.1f,\
\"ua\":%.1f,\"ub\":%.1f,\"uc\":%.1f,\"ia\":%.1f,\"ib\":%.1f,\"ic\":%.1f,\
\"gf\":%.1f,\"pf\":%.1f,\"pos_adem\":%.1f}]}",
                            set->szCloudUserName, (long long)time(NULL) * 1000, "GateMeter",
                            me->pos_active_e, me->neg_active_e, me->com_active_p, me->com_ractive_p,
                            me->ua, me->ub, me->uc, me->ia, me->ib, me->ic,
                            me->freq, me->pwr_factor, me->pos_active_dem);
                    pub_opts.message = mg_str(msg);
                    pub_opts.qos = m->s_qos, pub_opts.retain = false;
                    pub_opts.topic = mg_str(m->szs_pub_topic[0]);
                    mg_mqtt_pub(m->s_conn, &pub_opts);
                    m->TotalSend++;
                }
            }
        }
        if (m->s_conn == NULL)
            m->s_conn = mg_mqtt_connect(&mgr_mqtt2, m->szs_url, &opts, fn_mqtt2, NULL);
    }

    syslog(LOG_INFO, "%s EXIT, idx:2", __func__);
}

static void fn_mqtt3_connlost(void *context, char *cause)

{

    syslog(LOG_INFO, "%s, mqtt connection lost, cause: %s\n", __func__, cause);
    struct chanmqtt_t *m = &APPL.chanmqtt[3];
    m->bConnected = 0;
    strcpy(m->szState, "故障");
}

static int fn_mqtt3_msgarrvd(void *context, char *topicName, int topicLen, MQTTClient_message *message)
{
    struct chanmqtt_t *m = &APPL.chanmqtt[3];
    int64_t CurrIntv;

    struct mg_str json = mg_str(message->payload);
    double dval;
    bool ok = 0;

    // struct mg_str json_device_id;
    // char buf[512];
    // char devid[128] = {0};
    // int i;
    // int length;
    // int offset = mg_json_get(json, "$.data[0]", &length);
    // double val;
    // struct Settings_t *set = &APPL.Set.s;

    // if (offset > 0)
    //{
        //memset(buf, 0, sizeof(buf));
        //strncpy(buf, json.ptr + offset, length);
        // syslog(LOG_INFO,"%s, Get data[0]:%s", __func__, buf);

    //json_device_id = mg_str(buf);
    ok = mg_json_get_num(json, "$.com_ap",&dval);
    if (ok > 0){
        syslog(LOG_INFO,"%s,get pv meter com_ap:%.1f",__func__,dval);
    }else{
        syslog(LOG_INFO, "%s, Fail to Get com_ap", __func__);
    }

    MQTTClient_freeMessage(&message);
    MQTTClient_free(topicName);
    return 1;
}

static void mqtt3_connect(void)
{
    struct Settings_t *set = &APPL.Set.s;

    int rc;

    struct chanmqtt_t *m = &APPL.chanmqtt[3];

    MQTTClient_deliveryToken token;
    MQTTClient_connectOptions conn_opts;
    MQTTClient_connectOptions tmpconn_opts = MQTTClient_connectOptions_initializer5;

    conn_opts = tmpconn_opts;
    MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;

    createOpts.MQTTVersion = MQTTVERSION_5;
    if ((m->s_paho_client) != NULL)
        MQTTClient_destroy(&m->s_paho_client);

    if ((rc = MQTTClient_createWithOptions(&m->s_paho_client, m->szs_url, m->szclientid, MQTTCLIENT_PERSISTENCE_NONE, NULL, &createOpts)) != MQTTCLIENT_SUCCESS)
    {
        syslog(LOG_INFO, "%s, MQTTClient_createWithOptions fail, rc:%d msg:%s  %s    %s", __func__, rc, MQTTClient_strerror(rc));
    }

    conn_opts.keepAliveInterval = 8;
    conn_opts.cleansession = 0;
    conn_opts.username = m->szusrname;
    conn_opts.password = m->szpasswd;

    MQTTProperties props = MQTTProperties_initializer;
    MQTTProperties willProps = MQTTProperties_initializer;
    MQTTResponse response = MQTTResponse_initializer;

    MQTTClient_setCallbacks(m->s_paho_client, NULL, fn_mqtt3_connlost, fn_mqtt3_msgarrvd, NULL);
    response = MQTTClient_connect5(m->s_paho_client, &conn_opts, &props, &willProps);
    if (response.reasonCode != MQTTCLIENT_SUCCESS)
    {
        syslog(LOG_INFO, "%s, MQTTClient_connect fail, rc:%d msg:%s", __func__, response.reasonCode, MQTTClient_strerror(response.reasonCode));
        m->bConnected = 0;
        strcpy(m->szState, "故障");
    }
    else
    {
        syslog(LOG_INFO, "%s, Connect Ok", __func__);
        m->bConnected = 1;
        strcpy(m->szState, "正常");
        // control
        response = MQTTClient_subscribe5(m->s_paho_client, m->szs_sub_topic[0], m->s_qos, NULL, NULL);

        if (response.reasonCode != MQTTCLIENT_SUCCESS && response.reasonCode != m->s_qos)
        {
            syslog(LOG_INFO, "%s, MQTTClient_subscribe fail, rc: %d msg: %s", __func__, response.reasonCode, MQTTClient_strerror(response.reasonCode));
        }
        else
        {
            syslog(LOG_INFO, "SUBSCRIBED to %s", m->szs_sub_topic[0]);
        }
    }
}

static void mqtt3_pub(const char *szTopic, const char *szPayload)
{

    double pub_time;
    int ret = 0;
    int rc;

    struct chanmqtt_t *m = &APPL.chanmqtt[3];
    MQTTResponse response = MQTTResponse_initializer;
    if (m->bConnected == false)
    {
        goto leave;
    }

    MQTTClient_deliveryToken token;
    MQTTClient_message msg = MQTTClient_message_initializer;

    msg.retained = 0;
    msg.qos = m->s_qos;
    msg.payload = (void *)szPayload;
    msg.payloadlen = (int)strlen(szPayload);
    response = MQTTClient_publishMessage5(m->s_paho_client, szTopic, &msg, &token);

    if (response.reasonCode != MQTTCLIENT_SUCCESS)
    {

        syslog(LOG_INFO, "%s, Failed to publish message: error msg : %s\n", __func__, MQTTClient_strerror(response.reasonCode));
        goto leave;
    }

    rc = MQTTClient_waitForCompletion(m->s_paho_client, token, 100000L);

    if (rc != MQTTCLIENT_SUCCESS)
    {
        syslog(LOG_INFO, "%s, MQTTClient_waitForCompletion Failed, error msg : %s\n", __func__, MQTTClient_strerror(rc));
        goto leave;
    }
    else
    {

        // syslog(LOG_INFO, "%s, Published message: topic %s, payload %s\n",

        // __func__,

        //         szTopic, szPayload);
    }
leave:
    MQTTResponse_free(response);
}
// Get data from mosquitto server
static void *thrd_mqtt_3(void *param)
{
    int i, j;
    int ReconnChk = 0;

    char buf[8196];
    char msg[8196];
    char kv[8196];

    struct Settings_t *set = &APPL.Set.s;
    struct chanmqtt_t *m = &APPL.chanmqtt[3];
    struct Dtsd1352_t *me = &APPL.Dtsd1352[1];
    mqtt3_connect();

    while (1)
    {
        if (++ReconnChk > 10)
        {
            ReconnChk = 0;
            if (m->bConnected == 0)
            {
                mqtt3_connect();
            }
        }

        if (m->Cmd == CMD_MQTT_REGISTER)
        {

            m->Cmd = CMD_MQTT_DONE;
            // sprintf(msg,"{\"project_id\":\"%s\",\"timestamp\":%lld,\"data\":[{\"device_""id\":\"%s\",\"type\":1,\"idx\":1}]}",set->szCloudUserName,(long long)time(NULL) * 1000,set->szSN);
            // mqtt3_pub("register",msg);
            m->TotalSend++;
        }
        // ******************************************

        // Upload Fast Data

        // ******************************************

        if (mg_millis() - m->LastFastUpload > set->UploadHighSpeed)
        {

            m->LastFastUpload = mg_millis();
            if (m->bConnected)
            {

                msg[0] = 0;
                //if (me->CommState == ST_COMM_NORM)
                {
                    sprintf(msg, "{\"project_id\":\"%s\",\"timestamp\":%lld,\"device_id\":\"%s\",\"type\":15,\"idx\":1,\"com_ap\":%.1f}",
                            set->szCloudLocalUserName, (long long)time(NULL) * 1000, "pvMeter",
                            appl_meter_com_ap_get_from_file());
                    strcat(kv, buf);
                    mqtt3_pub(m->szs_pub_topic, msg);
                    m->TotalSend++;
                }
            }
        }

        // ******************************************

        // Upload Medium Data

        // ******************************************

        if (mg_millis() - m->LastMediumUpload > set->UploadMediumSpeed)
        {

            m->LastMediumUpload = mg_millis();
            if (m->bConnected)
            {
            }
        }

        // ******************************************

        // Upload SLow Data

        // ******************************************

        if (mg_millis() - m->LastSlowUpload > set->UploadSlowSpeed)

        {

            m->LastSlowUpload = mg_millis();

            if (m->bConnected)

            {
            }
        }

        //   if(mg_millis() - gm->LastUpdate > 15000)

        //   {

        //     gm->CommState = ST_COMM_ERR;

        //     strcpy(gm->szCommState,"故障");

        //   }

        //   else

        //   {

        //     gm->CommState = ST_COMM_NORM;

        //     strcpy(gm->szCommState,"正常");

        //   }

        //   if(mg_millis() - tm->LastUpdate > 15000)

        //   {

        //     tm->CommState = ST_COMM_ERR;

        //     strcpy(tm->szCommState,"故障");

        //   }

        //   else

        //   {

        //     tm->CommState = ST_COMM_NORM;

        //     strcpy(tm->szCommState,"正常");

        //   }

        //   for(i = 0; i < set->CtnMeterNbrOfGateway; i++)

        //   {

        //     cm = &APPL.CtnMeter[i + set->CtnMeterStartOfGateway];

        //     if(mg_millis() - cm->LastUpdate > 15000)

        //     {

        //       cm->CommState = ST_COMM_ERR;

        //       strcpy(cm->szCommState,"故障");

        //     }

        //     else

        //     {

        //       cm->CommState = ST_COMM_NORM;

        //       strcpy(cm->szCommState,"正常");

        //     }

        //   }

        // }
    }
}

static int mqtt4_connlost = 0;
static MQTTClient cli;
static MQTTClient_deliveryToken token;
static void fn_mqtt4_connlost(void *context, char *cause)
{
    syslog(LOG_INFO, "%s, mqtt connection lost, cause: %s\n", __func__, cause);
    struct chanmqtt_t *m = &APPL.chanmqtt[4];
    m->bConnected = 0;
    strcpy(m->szState, "故障");
}

static int fn_mqtt4_msgarrvd(void *context, char *topicName, int topicLen, MQTTClient_message *message)
{
    struct chanmqtt_t *m = &APPL.chanmqtt[4];
    int64_t CurrIntv;

    // syslog(LOG_INFO, "%s, Message arrived, topic:%s topic len:%d payload

    // len:%d",

    //        __func__, topicName, topicLen, message->payloadlen);

    struct mg_str json = mg_str(message->payload);
    double dval;
    bool ok;
    char *str = NULL;
    struct mg_str json_device_id;
    char buf[512];
    char devid[128] = {0};
    int i;
    int length;
    int offset = mg_json_get(json, "$.data[0]", &length);
    double val;
    struct Settings_t *set = &APPL.Set.s;

    if (offset > 0)
    {
        memset(buf, 0, sizeof(buf));
        strncpy(buf, json.ptr + offset, length);
        // syslog(LOG_INFO,"%s, Get data[0]:%s", __func__, buf);

        json_device_id = mg_str(buf);
        str = mg_json_get_str(json_device_id, "$.device_id");
        if (str != NULL)
        {
            free(str);
        }
    }
    else
    {

        syslog(LOG_INFO, "%s, Fail to Get data[0]:%d", __func__, offset);
    }

    MQTTClient_freeMessage(&message);
    MQTTClient_free(topicName);
    return 1;
}

static void mqtt4_pub(const char *szTopic, const char *szPayload)
{
    double pub_time;
    int ret = 0;
    int rc;
    struct chanmqtt_t *m = &APPL.chanmqtt[4];
    MQTTResponse response = MQTTResponse_initializer;

    if (m->bConnected == false)
    {
        goto leave;
    }
    MQTTClient_deliveryToken token;
    MQTTClient_message msg = MQTTClient_message_initializer;

    msg.retained = 0;
    msg.qos = m->s_qos;
    msg.payload = (void *)szPayload;
    msg.payloadlen = (int)strlen(szPayload);
    response = MQTTClient_publishMessage5(m->s_paho_client, szTopic, &msg, &token);

    if (response.reasonCode != MQTTCLIENT_SUCCESS)
    {
        syslog(LOG_INFO, "%s, Failed to publish message: error msg : %s\n", __func__, MQTTClient_strerror(response.reasonCode));
        goto leave;
    }
    rc = MQTTClient_waitForCompletion(m->s_paho_client, token, 100000L);
    if (rc != MQTTCLIENT_SUCCESS)
    {
        syslog(LOG_INFO,
               "%s, MQTTClient_waitForCompletion Failed, error msg : %s\n",
               __func__, MQTTClient_strerror(rc));
        goto leave;
    }
    else
    {
        // syslog(LOG_INFO, "%s, Published message: topic %s, payload %s\n",
        // __func__,
        //         szTopic, szPayload);
    }

leave:
    MQTTResponse_free(response);
}

static void mqtt4_connect(void)
{
    struct Settings_t *set = &APPL.Set.s;

    int rc;
    struct chanmqtt_t *m = &APPL.chanmqtt[4];
    MQTTClient_deliveryToken token;
    MQTTClient_connectOptions conn_opts;

    MQTTClient_connectOptions tmpconn_opts =
        MQTTClient_connectOptions_initializer5;
    conn_opts = tmpconn_opts;
    MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
    createOpts.MQTTVersion = MQTTVERSION_5;

    if ((m->s_paho_client) != NULL)
        MQTTClient_destroy(&m->s_paho_client);

    if ((rc = MQTTClient_createWithOptions(&m->s_paho_client, m->szs_url, set->szClientId,
                                           MQTTCLIENT_PERSISTENCE_NONE, NULL,
                                           &createOpts)) != MQTTCLIENT_SUCCESS)
    {
        syslog(LOG_INFO,
               "%s, MQTTClient_createWithOptions fail, rc:%d msg:%s  %s    %s",
               __func__, rc, MQTTClient_strerror(rc));
    }
    conn_opts.keepAliveInterval = 8;
    conn_opts.cleansession = 0;
    conn_opts.username = m->szusrname;
    conn_opts.password = m->szpasswd;

    MQTTProperties props = MQTTProperties_initializer;
    MQTTProperties willProps = MQTTProperties_initializer;
    MQTTResponse response = MQTTResponse_initializer;
    MQTTClient_setCallbacks(m->s_paho_client, NULL, fn_mqtt4_connlost, fn_mqtt4_msgarrvd,
                            NULL);
    response = MQTTClient_connect5(m->s_paho_client, &conn_opts, &props, &willProps);
    if (response.reasonCode != MQTTCLIENT_SUCCESS)
    {
        syslog(LOG_INFO, "%s, MQTTClient_connect fail, rc:%d msg:%s", __func__,
               response.reasonCode, MQTTClient_strerror(response.reasonCode));
        m->bConnected = 0;
        strcpy(m->szState, "故障");
    }
    else
    {
        syslog(LOG_INFO, "%s, Connect Ok", __func__);
        m->bConnected = 1;
        strcpy(m->szState, "正常");

        // control
        // response = MQTTClient_subscribe5(m->s_paho_client,m->szs_sub_topic[0],m->s_qos,NULL,NULL);
        // if(response.reasonCode != MQTTCLIENT_SUCCESS &&
        //   response.reasonCode != m->s_qos)
        // {
        //   syslog(LOG_INFO,"%s, MQTTClient_subscribe fail, rc: %d msg: %s",
        //     __func__,response.reasonCode,
        //     MQTTClient_strerror(response.reasonCode));
        // }
        // else
        // {
        //   syslog(LOG_INFO,"SUBSCRIBED to %s",m->szs_sub_topic[0]);
        // }

        // GateMeter
        // response =
        //   MQTTClient_subscribe5(m->s_paho_client,m->szs_sub_topic[1],m->s_qos,NULL,NULL);
        // if(response.reasonCode != MQTTCLIENT_SUCCESS &&
        //   response.reasonCode != m->s_qos)
        // {
        //   syslog(LOG_INFO,"%s, MQTTClient_subscribe fail, rc: %d msg: %s",
        //     __func__,response.reasonCode,
        //     MQTTClient_strerror(response.reasonCode));
        // }
        // else
        // {
        //   syslog(LOG_INFO,"SUBSCRIBED to %s",m->szs_sub_topic[1]);
        // }

        // TransMeter
        // response =
        //   MQTTClient_subscribe5(m->s_paho_client,m->szs_sub_topic[2],m->s_qos,NULL,NULL);
        // if(response.reasonCode != MQTTCLIENT_SUCCESS &&
        //   response.reasonCode != m->s_qos)
        // {
        //   syslog(LOG_INFO,"%s, MQTTClient_subscribe fail, rc: %d msg: %s",
        //     __func__,response.reasonCode,
        //     MQTTClient_strerror(response.reasonCode));
        // }
        // else
        // {
        //   syslog(LOG_INFO,"SUBSCRIBED to %s",m->szs_sub_topic[2]);
        // }
        // CtnMeter1
        // for(int i = 0; (i + 1) < (set->CtnMeterStartOfGateway + set->CtnMeterNbrOfGateway); i++)
        // {
        //   response = MQTTClient_subscribe5(m->s_paho_client,m->szs_sub_topic[3 + i],m->s_qos,
        //     NULL,NULL);
        //   if(response.reasonCode != MQTTCLIENT_SUCCESS &&
        //     response.reasonCode != m->s_qos)
        //   {
        //     syslog(LOG_INFO,"%s, MQTTClient_subscribe fail, rc: %d msg: %s",
        //       __func__,response.reasonCode,
        //       MQTTClient_strerror(response.reasonCode));
        //   }
        //   else
        //   {
        //     syslog(LOG_INFO,"SUBSCRIBED to %s",m->szs_sub_topic[3 + i]);
        //   }
        // }
    }
}

static void *thrd_mqtt4(void *param)
{
    struct chanmqtt_t *m = &APPL.chanmqtt[4];
    struct Settings_t *set = &APPL.Set.s;
    int64_t LastConnChk = 0;
    int64_t LastUpload = 0;
    char payload[2048];
    int ReconnChk = 0;

    syslog(LOG_INFO, "%s, ++", __func__);
    mqtt4_connect();
    while (1)
    {
        if (++ReconnChk > 10)
        {
            ReconnChk = 0;
            if (m->bConnected == 0)
            {
                mqtt4_connect();
            }
        }

        if (mg_millis() - LastUpload > set->UploadHighSpeed)
        {
            LastUpload = mg_millis();
            if (mqtt4_connlost != 1)
            {
                // GateMeter
                struct Dtsd1352_t *me = &APPL.Dtsd1352[1];
                if (me->CommState == ST_COMM_NORM)
                {
                    sprintf(payload, "{\"project_id\":\"%s\",\"timestamp\":%lld,\"data\":[{\"device_id\":\"%s\",\"type\":17,\"idx\":1,\
\"pos_ae\":%.1f,\"neg_ae\":%.1f,\"com_ap\":%.1f,\"com_rap\":%.1f,\
\"ua\":%.1f,\"ub\":%.1f,\"uc\":%.1f,\"ia\":%.1f,\"ib\":%.1f,\"ic\":%.1f,\
\"gf\":%.1f,\"pf\":%.1f,\"pos_adem\":%.1f}]}",
                            set->szCloudUserName, (long long)time(NULL) * 1000, "GateMeter",
                            me->pos_active_e, me->neg_active_e, me->com_active_p, me->com_ractive_p,
                            me->ua, me->ub, me->uc, me->ia, me->ib, me->ic,
                            me->freq, me->pwr_factor, me->pos_active_dem);

                    mqtt4_pub(m->szs_pub_topic, payload);
                    m->TotalSend++;
                }
            }
        }

        usleep(100000);
    }
    syslog(LOG_INFO, "%s, --", __func__);
}

void appl_snap_set_err(void)
{
    APPL.Snap.bErr = 1;
    strcpy(APPL.Snap.szState, "故障");
}

void appl_snap_reset_err(void)
{
    APPL.Snap.bErr = 0;
    strcpy(APPL.Snap.szState, "正常");
}

static int appl_snap_day_diff(int year_start, int month_start, int day_start, int year_end, int month_end, int day_end)
{
    int y2, m2, d2;
    int y1, m1, d1;

    m1 = (month_start + 9) % 12;
    y1 = year_start - m1 / 10;
    d1 = 365 * y1 + y1 / 4 - y1 / 100 + y1 / 400 + (m1 * 306 + 5) / 10 + (day_start - 1);

    m2 = (month_end + 9) % 12;
    y2 = year_end - m2 / 10;
    d2 = 365 * y2 + y2 / 4 - y2 / 100 + y2 / 400 + (m2 * 306 + 5) / 10 + (day_end - 1);

    return (d2 - d1);
}

int appl_snap_rmdir(const char *path)
{
    DIR *d = opendir(path);
    size_t path_len = strlen(path);
    int r = -1;

    if (d)
    {
        struct dirent *p;

        r = 0;
        while (!r && (p = readdir(d)))
        {
            int r2 = -1;
            char *buf;
            size_t len;

            /* Skip the names "." and ".." as we don't want to recurse on them. */
            if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, ".."))
                continue;

            len = path_len + strlen(p->d_name) + 2;
            buf = malloc(len);

            if (buf)
            {
                struct stat statbuf;

                snprintf(buf, len, "%s/%s", path, p->d_name);
                if (!stat(buf, &statbuf))
                {
                    if (S_ISDIR(statbuf.st_mode))
                        r2 = appl_snap_rmdir(buf);
                    else
                        r2 = unlink(buf);
                }
                free(buf);
            }
            r = r2;
        }
        closedir(d);
    }

    if (!r)
        r = rmdir(path);

    return r;
}

static void *thrd_snap(void *param)
{
    struct Snap_t *s = &APPL.Snap;
    struct Dtsd1352_t *me = NULL;
    char buf[128];
    char szfn[128];
    int y, m, d, h, min, ss; // current
    int yy, mm, dd;          // dir
    int diff_day;
    int rc;
    DIR *dir;
    struct dirent *ptr;
    char szyy[8];
    char szmm[8];
    char szdd[8];
    int i;

    sleep(5);
    syslog(LOG_INFO, "%s, ++", __func__);

    while (1)
    {
        usleep(300000);
        if (s->bErr)
        {
            continue;
        }
        if (s->bStart == 0)
        {
            appl_get_datetime_num(&y, &m, &d, &h, &min, &ss);
            sprintf(s->szcurrDatePath, "./snap/%04d-%02d-%02d", y, m, d);
            if (access(s->szcurrDatePath, NULL) != 0)
            { // directory does not exists
                // syslog(LOG_INFO,"%s, DatePath:%s does not exist",__func__, s->szcurrDatePath);
                if (mkdir(s->szcurrDatePath, 0755) < 0)
                {
                    s->bErr = 1;
                    // syslog(LOG_INFO,"%s, mkdir fail",__func__);
                    continue;
                }
            }

            // Meter Snap Start
            for (i = 1; i <= 1; i++)
            {
                sprintf(szfn, "%s/M%d_%04d-%02d-%02d %02d-%02d-%02d.csv", s->szcurrDatePath, i, y, m, d, h, min, ss);
                s->f[i] = fopen(szfn, "w+");
                if (s->f[i] == NULL)
                {
                    s->bErr = 1;
                    continue;
                }
                else
                {
                    rc = fprintf(s->f[i], "ts,com_ap,pos_adem,neg_adem,com_ae,pos_ae,neg_ae,pf,pt,ct,ua,ub,uc,ia,ib,ic,freq,CommState\n");
                    if (rc < 0)
                    {
                        s->bErr = 1;
                        continue;
                    }
                }
            }

            s->LastSnap = 0;
            s->bStart = 1;
        }
        else
        {
            if (mg_millis() - s->LastSnap > 5000)
            { /* snap every 5 seconds */
                s->LastSnap = mg_millis();
                appl_get_datetime_num(&y, &m, &d, &h, &min, &ss);
                sprintf(buf, "./snap/%04d-%02d-%02d", y, m, d);
                if (strcmp(buf, s->szcurrDatePath) != 0)
                { /* new date */
                    // syslog(LOG_INFO,"%s, New Date Detected : %s", __func__, buf);
                    if (s->fpcs != NULL)
                    {
                        fclose(s->fpcs);
                        s->fpcs = NULL;
                    }
                    // del outofdate dir
                    if ((dir = opendir("./snap")) == NULL)
                    {
                        s->bErr = 1;
                        continue;
                    }
                    else
                    {
                        while ((ptr = readdir(dir)) != NULL)
                        {
                            if (strcmp(ptr->d_name, ".") == 0 || strcmp(ptr->d_name, "..") == 0)
                            { /// current dir OR parrent dir
                                continue;
                            }
                            else if (ptr->d_type == 8)
                            { /// file
                            }
                            else if (ptr->d_type == 10)
                            { /// link file
                              // printf("d_name:%s/%s\n",basePath,ptr->d_name);
                            }
                            else if (ptr->d_type == 4)
                            { /// dir
                                if (strlen(ptr->d_name) == 10 && ptr->d_name[4] == '-' && ptr->d_name[7] == '-')
                                { // target dir
                                    // syslog(LOG_INFO,"%s, Target Dir:%s Detedted", __func__, ptr->d_name);
                                    strncpy(szyy, ptr->d_name, 4);
                                    strncpy(szmm, ptr->d_name + 5, 2);
                                    strncpy(szdd, ptr->d_name + 8, 2);
                                    yy = atoi(szyy);
                                    mm = atoi(szmm);
                                    dd = atoi(szdd);
                                    diff_day = appl_snap_day_diff(yy, mm, dd, y, m, d);
                                    if (diff_day > s->KeepDay)
                                    {
                                        sprintf(buf, "./snap/%s", ptr->d_name);
                                        rc = appl_snap_rmdir(buf);
                                        if (rc < 0)
                                        {
                                            syslog(LOG_INFO, "%s, Target Dir:%s Del Fail", __func__, ptr->d_name);
                                            s->bErr = 1;
                                            continue;
                                        }
                                        else
                                        {
                                            syslog(LOG_INFO, "%s, Target Dir:%s Del Ok", __func__, ptr->d_name);
                                        }
                                    }
                                }
                            }
                        }
                        closedir(dir);
                    }
                    s->bStart = 0; /* start again at next loop */
                    continue;
                }
                else
                {
                    s->LastSnap = mg_millis();
                    strcpy(buf, appl_get_datetime_short());

                    // Meter Snap
                    for (i = 1; i <= 6; i++)
                    {
                        me = &APPL.Dtsd1352[i];
                        if (s->f[i] != NULL && me->CommState == ST_COMM_NORM)
                        {
                            fprintf(s->f[i], "\
%s,%.1f,%.1f,%.1f,\
%.1f,%.1f,%.1f,\
%.3f,%d,%d,\
%.1f,%.1f,%.1f,\
%.1f,%.1f,%.1f,\
%.1f,%.d\n",
                                    /*1*/ buf, me->com_active_p, me->pos_active_dem, me->neg_active_dem,
                                    /*2*/ me->com_active_e, me->pos_active_e, me->neg_active_e,
                                    /*3*/ me->pwr_factor, me->PT, me->CT,
                                    /*4*/ me->ua, me->ub, me->uc,
                                    /*5*/ me->ia, me->ib, me->ic,
                                    /*6*/ me->freq, me->CommState);
                            fflush(s->f[i]);
                        }
                    }
                }
            }
        }
    }
    syslog(LOG_INFO, "%s, --", __func__);
}


void appl_start(void)
{
    struct Settings_t *set = &APPL.Set.s;
    struct chan485_t *ch = NULL;
    struct chanmqtt_t *m = NULL;
    struct Snap_t *snap = &APPL.Snap;
    char buf[128];
    char buf2[128];
    int len;
    int i;
    
    appl_485_set_485mode();

    // Set
    if (appl_cfg_read() != 0)
    {
        appl_cfg_set_err();
        syslog(LOG_INFO, "%s, appl_cfg_read fail", __func__);

        // Load Default
        set->DataKeepDay = 700;

        strcpy(set->szCloudUserName, "3d7d1de58c7c42c7bd4d99e32c8d5b84");
        strcpy(set->szCloudPasswd, "zhPbPPWEBES2YhtF");
        strcpy(set->szCloudUrl, "119.45.116.112:18883");
        strcpy(set->szClientId, "gcw_gatemeter");

        strcpy(set->szCloudLocalUserName, "hetian");
        strcpy(set->szCloudLocalPasswd, "123456");
        strcpy(set->szCloudLocalUrl, "192.168.3.136:1883");
        strcpy(set->szLocalClientId, "gcw_pv_meter");


        set->UploadHighSpeed = 1500;
        set->UploadMediumSpeed = 60000;
        set->UploadSlowSpeed = 180000;
    }
    else
    {
        appl_cfg_reset_err();

        snap->KeepDay = set->DataKeepDay;

        // //1# MQTT thingsboard
        // m = &APPL.chanmqtt[1];
        // m->s_conn = NULL;
        // strcpy(m->szs_url,"124.222.45.156:1883");
        // strcpy(m->szs_pub_topic,"v1/devices/me/telemetry");
        // strcpy(m->szs_sub_topic,"v1/devices/me/ctl");
        // m->s_qos = 1;
        // //测试设备
        // //strcpy(m->szusrname,"gFCNk8oSxC6VlYXkhs3a");
        // strcpy(m->szusrname,"DZHbY2HAGeATfRCfhlW7");
        // m->bConnected = 0;

        // //2# MQTT Cloud
        // m = &APPL.chanmqtt[2];
        // m->s_conn = NULL;
        // strncpy(m->szs_url, set->szCloudUrl, sizeof(m->szs_url)-1);
        // strncpy(m->szusrname,set->szCloudUserName, sizeof(m->szusrname) - 1);
        // strncpy(m->szpasswd,set->szCloudPasswd, sizeof(m->szpasswd) - 1);
        // strncpy(m->szclientid,set->szClientId, sizeof(m->szclientid) - 1);

        // sprintf(m->szs_pub_topic[0],"sequential/%s/GateMeter",m->szusrname);
        // strcpy(m->szs_sub_topic,"control");
        // m->s_qos = 1;
        // m->bConnected = 0;
        // pthread_create(&hthrd_mqtt2, NULL, thrd_mqtt_2, NULL);

        //3#mqtt
        // m = &APPL.chanmqtt[3];
        // m->s_conn = NULL;
        // strncpy(m->szs_url, set->szCloudLocalUrl, sizeof(m->szs_url) - 1);
        // strncpy(m->szusrname, set->szCloudLocalUserName, sizeof(m->szusrname) - 1);
        // strncpy(m->szpasswd, set->szCloudLocalPasswd, sizeof(m->szpasswd) - 1);
        // strncpy(m->szclientid, set->szLocalClientId, sizeof(m->szclientid) - 1);

        // sprintf(m->szs_pub_topic[0], "timeData/pvMeter1");
        // strcpy(m->szs_sub_topic, "timeData/pvMeter1");
        // m->s_qos = 1;
        // m->bConnected = 0;
        // pthread_create(&hthrd_mqtt3, NULL, thrd_mqtt_3, NULL);

        // 4# MQTT Cloud
        m = &APPL.chanmqtt[4];
        m->s_conn = NULL;
        strncpy(m->szs_url, set->szCloudUrl, sizeof(m->szs_url) - 1);
        strncpy(m->szusrname, set->szCloudUserName, sizeof(m->szusrname) - 1);
        strncpy(m->szpasswd, set->szCloudPasswd, sizeof(m->szpasswd) - 1);
        strncpy(m->szclientid, set->szClientId, sizeof(m->szclientid) - 1);

        
        for(i = 1;i < METERCONFIG_NBR;i ++)
            sprintf(m->szs_pub_topic[i - 1], "sequential/%s/%s", m->szusrname,meter_config_t[i].szTopic);
        //sprintf(m->szs_pub_topic[0], "sequential/%s/pvMeter", m->szusrname);
        strcpy(m->szs_sub_topic, "control");
        m->s_qos = 1;
        m->bConnected = 0;
        pthread_create(&hthrd_mqtt4, NULL, thrd_mqtt4, NULL);
    }


    for(i = 1;i < METERCONFIG_NBR;i ++){
        APPL.Dtsd1352[i].Adr = meter_config_t[i].adr; // 关口电表
        sprintf(APPL.Dtsd1352[i].szinfo,meter_config_t[i].szinfo);
    }


    for(i = 1;i < CHAN485CONFIG_NBR;i ++){
        ch = &APPL.chan485[i];
        strcpy(ch->szdev, chan485_config_t[i].szDev);
        ch->baud = chan485_config_t[i].baud;
        ch->parity = chan485_config_t[i].parity;  
        strcpy(ch->szinfo, chan485_config_t[i].szInfo);
        if(chan485_config_t[i].used == 1 && chan485_config_t[i].thread != NULL)
        pthread_create(chan485_config_t[i].hthrd, NULL, chan485_config_t[i].thread, NULL);
    }

    // CHAN 485 1
    // ch = &APPL.chan485[1];
    // strcpy(ch->szdev, "/dev/ttymxc1");
    // ch->baud = 9600;
    // ch->parity = 'N';
    // strcpy(ch->szinfo, "关口电表");

    // // CHAN 485 2
    // ch = &APPL.chan485[2];
    // strcpy(ch->szdev, "/dev/ttymxc2");
    // ch->baud = 9600;
    // ch->parity = 'N';
    // strcpy(ch->szinfo, "未使用");

    // // CHAN 485 3
    // ch = &APPL.chan485[3];
    // strcpy(ch->szdev, "/dev/ttymxc3");
    // ch->baud = 9600;
    // ch->parity = 'N';
    // strcpy(ch->szinfo, "未使用");

    // // CHAN 485 4
    // ch = &APPL.chan485[4];
    // strcpy(ch->szdev, "/dev/ttymxc5");
    // ch->baud = 9600;
    // ch->parity = 'N';
    // strcpy(ch->szinfo, "未使用");

    // pthread_create(&hthrd_485_1, NULL, thrd_485_1, NULL);

    // Snap
    appl_snap_reset_err();
    snap->bStart = 0;
    snap->KeepDay = set->DataKeepDay;
    pthread_create(&hthrd_snap, NULL, thrd_snap, NULL);

    // appl_load_meter_data_from_file();
}


int appl_load_meter_data_from_file(void)
{
    struct Settings_t *set = &APPL.Set.s;
    FILE *file = NULL;
    char file_path[256];
    char line[1024];
    const char delim[2] = ",";
    char* p = NULL;
    int i = 0;

    sprintf(set->meterDataLoadFileName,"%s","pvMeter.csv");

    if(set->meterDataLoadFileName[0] == 0){
        syslog(LOG_INFO,"%s,set->meterDataLoadFileName is NULL",__func__);
        return -1;
    }
    sprintf(file_path,"./data/%s",set->meterDataLoadFileName);

    if(access(file_path,F_OK|R_OK) == -1){
        syslog(LOG_INFO,"%s,%s is not exit or can not read",__func__,file_path);
        return -1;
    }

    file = fopen(file_path,"r");
    if(file == NULL){
        syslog(LOG_INFO,"%s,%s can not read",__func__,file_path);
        return -1;
    }

    while(fgets(line,1024,file)){

        p = strtok(line,delim);
        if(p != NULL)
            APPL.MeterDayData.com_active_p[i] = atof(p);

        //next
        //p = strok(NULL,delim)
        i++;
        if(i > 24*60*60/5){
            syslog(LOG_INFO,"%s,%s is too long to read",__func__,file_path);
            fclose(file);
            return -1;
        }
        
    }

    fclose(file);
    syslog(LOG_INFO,"%s,%s read succuss (line:%d)",__func__,file_path,i);
    return 0;

}

double appl_meter_com_ap_get_from_file(void)
{

    time_t timep;
    struct tm *tsp;
    uint32_t day_ts = 0;
    uint32_t idx = 0;

    time(&timep);
    // tsp = gmtime(&timep);
    tsp = localtime(&timep);
    day_ts = tsp->tm_hour * 60 * 60 +  tsp->tm_min * 60 + tsp->tm_sec;

    idx = day_ts / 5;
    if(idx > 24 * 60 * 60 / 5){
        return 0.0;
    }else{
        return APPL.MeterDayData.com_active_p[idx];
    }
}


uint32_t appl_get_meter_config_nbr(void)
{

    return METERCONFIG_NBR;
}