MDL_cxx/mbs.c

#include <pthread.h>
#include <stdbool.h>

#include "mbs.h"
#include "freemodbus/modbus/include/mb.h"
#include "freemodbus/modbus/include/mbctx.h"
#include "freemodbus/port/port.h"

enum mbs_idx_t
{
    MBSIDX_CESS2000 = 0,
    MBSIDX_EMA = 1,
};
// 0:cess2000 modbus tcp slave
fmodbus_t *MB[8];
/* ----------------------- Defines ------------------------------------------*/
/* ctn modbus tcp slave*/
#define REG_HOLDING_START_CESS2000 0x0000
#define REG_HOLDING_NREGS_CESS2000 0x5400
// static USHORT   usRegHoldingStart_CTN[CTN_NBR_MAX + 1];
static USHORT usRegHoldingBuf_CESS2000[REG_HOLDING_NREGS_CESS2000] = {0};

#define REG_HOLDING_START_EMA 0x0000
#define REG_HOLDING_NREGS_EMA 0x5400
// static USHORT   usRegHoldingStart_CTN[CTN_NBR_MAX + 1];
static USHORT usRegHoldingBuf_EMA[REG_HOLDING_NREGS_EMA] = {0};

static enum ThreadState {
    STOPPED,
    RUNNING,
    SHUTDOWN
} ePollThreadState;

static pthread_mutex_t xLock = PTHREAD_MUTEX_INITIALIZER;
// static BOOL     bDoExit;

void *pvPollingThread(void *pvParameter)
{
    fmodbus_t *ctx = (fmodbus_t *)pvParameter;
    // struct chan_t* chan = &sta.chan[ctx->chanidx];

    printf("%s, ++, mbsidx:%d", __func__, ctx->mbsidx);

    if (eMBEnable(ctx) == MB_ENOERR)
    {
        do
        {
            if (eMBPoll(ctx) != MB_ENOERR)
                break;
        } while (true);
    }
    (void)eMBDisable(ctx);

    printf("%s, --, mbsidx:%d", __func__, ctx->mbsidx);
    pthread_exit(0);

    return NULL;
}

// process 03
static void prepareRegHoldingBuf_CESS2000(fmodbus_t *ctx)
{
    // struct chan_t* chan = &sta.chan[ctx->chanidx];
    // int mbsidx = chan->mbsidx;
    // int mbsdevidx = chan->mbsdevidx;
    // struct cess2000_t *dev = &cess2000[1];
    // short temp = 0;
    // // struct bcu_t* bcu = &sta.catl280a[1].bcu[1];
    // // int bmuidx, moduleidx, cellidx, tempidx;

    // // if( chan->dbg > 0 ){
    // //     printf("%s, chanidx:%d, mbsidx:%d, mbsdevm:%d, mbsdevidx:%d",
    // //             __func__, ctx->chanidx, chan->mbsidx, chan->mbsdevm, chan->mbsdevidx);
    // // }

    usRegHoldingBuf_CESS2000[0 - REG_HOLDING_START_CESS2000] = 1;
    usRegHoldingBuf_CESS2000[1 - REG_HOLDING_START_CESS2000] = 2;
    usRegHoldingBuf_CESS2000[2 - REG_HOLDING_START_CESS2000] = 3;
    usRegHoldingBuf_CESS2000[3 - REG_HOLDING_START_CESS2000] = 4;
    usRegHoldingBuf_CESS2000[4 - REG_HOLDING_START_CESS2000] = 4;
    usRegHoldingBuf_CESS2000[5 - REG_HOLDING_START_CESS2000] = 5;   // reserved
    usRegHoldingBuf_CESS2000[6 - REG_HOLDING_START_CESS2000] = 5;   // reserved
    usRegHoldingBuf_CESS2000[7 - REG_HOLDING_START_CESS2000] = 6;
    usRegHoldingBuf_CESS2000[8 - REG_HOLDING_START_CESS2000] = 7; // 本级心跳，先不管
    usRegHoldingBuf_CESS2000[9 - REG_HOLDING_START_CESS2000] = 7; // reserved

    usRegHoldingBuf_CESS2000[10 - REG_HOLDING_START_CESS2000] = 1;
    usRegHoldingBuf_CESS2000[11 - REG_HOLDING_START_CESS2000] = 2;
    usRegHoldingBuf_CESS2000[12 - REG_HOLDING_START_CESS2000] = 1;  // 当前有功功率
    usRegHoldingBuf_CESS2000[13 - REG_HOLDING_START_CESS2000] = 1; // 有功功率设定值

    usRegHoldingBuf_CESS2000[14 - REG_HOLDING_START_CESS2000] = 1;  // 预留
    usRegHoldingBuf_CESS2000[15 - REG_HOLDING_START_CESS2000] = 2; // 预留

    usRegHoldingBuf_CESS2000[16 - REG_HOLDING_START_CESS2000] = 3;  // soc
    usRegHoldingBuf_CESS2000[17 - REG_HOLDING_START_CESS2000] = 4; // soh

    usRegHoldingBuf_CESS2000[125 - REG_HOLDING_START_CESS2000] = 4; // 额定容量
    usRegHoldingBuf_CESS2000[126 - REG_HOLDING_START_CESS2000] = 5; // 额定功率

    usRegHoldingBuf_CESS2000[138 - REG_HOLDING_START_CESS2000] = 6; // 硬件版本号
    usRegHoldingBuf_CESS2000[139 - REG_HOLDING_START_CESS2000] = 6; // 软件版本号
}

// 06
static void procRegHoldingBuf_CESS2000(fmodbus_t *ctx)
{
    // printf("%s, ++ register write", __func__);
    // if (usRegHoldingBuf_CESS2000[0 - REG_HOLDING_START_CESS2000] != 0)
    // {
    //     log_info("%s,get cmd(%d) form host", __func__, usRegHoldingBuf_CESS2000[0 - REG_HOLDING_START_CESS2000]);
    //     ctn_set_cmd(usRegHoldingBuf_CESS2000[0 - REG_HOLDING_START_CESS2000]);
    //     usRegHoldingBuf_CESS2000[0 - REG_HOLDING_START_CESS2000] = 0;
    // }

    // if ((short)usRegHoldingBuf_CESS2000[13 - REG_HOLDING_START_CESS2000] != ctn_get_aps())
    // {
    //     log_info("%s,get new aps(%d) form host", __func__,(short)usRegHoldingBuf_CESS2000[13 - REG_HOLDING_START_CESS2000]);
    //     ctn_set_aps((short)usRegHoldingBuf_CESS2000[13 - REG_HOLDING_START_CESS2000]);
    // }
    // else
    // {
    //     printf("cyx : %s, aps not change, set value : %d, ctn value : %d", __func__, (ushort)usRegHoldingBuf_CESS2000[13 - REG_HOLDING_START_CESS2000], ctn_get_aps());
    // }

    // ctn_set_bsytikchk_from_host(usRegHoldingBuf_CESS2000[10002 - REG_HOLDING_START_CESS2000]);
    // printf("%s, --", __func__);
}

static void prepareRegHoldingBuf_EMA(fmodbus_t *ctx)
{
    // float temp_f = 0;
    // unsigned short temp_u16 = 0;
    // signed short temp_s16 = 0;
    // signed int temp_s32 = 0;
    // unsigned short *ptemp = NULL;

    // // log_info("%s,running!!!!!",__func__);

    // if (ems_get_mode() == EMSMOD_NONE)
    // {
    //     usRegHoldingBuf_EMA[1000 - REG_HOLDING_START_EMA] = 0;
    //     usRegHoldingBuf_EMA[1001 - REG_HOLDING_START_EMA] = 0;
    // }
    // else if (ems_get_mode() == EMSMOD_PCURV)
    // {
    //     usRegHoldingBuf_EMA[1000 - REG_HOLDING_START_EMA] = 0;
    //     usRegHoldingBuf_EMA[1001 - REG_HOLDING_START_EMA] = 1;
    // }

    // temp_f = 600.0;

    // usRegHoldingBuf_EMA[1002 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f)) >> 16;
    // usRegHoldingBuf_EMA[1003 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f));

    // usRegHoldingBuf_EMA[1004 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f)) >> 16;
    // usRegHoldingBuf_EMA[1005 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f));

    // temp_f = ctn_get_soc();
    // usRegHoldingBuf_EMA[1006 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f)) >> 16;
    // usRegHoldingBuf_EMA[1007 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f));

    // // cell fault state-------reserve

    // temp_f = 2000.0;
    // usRegHoldingBuf_EMA[1010 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f)) >> 16;
    // usRegHoldingBuf_EMA[1011 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f));
    // temp_f = 1800;
    // usRegHoldingBuf_EMA[1012 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f)) >> 16;
    // usRegHoldingBuf_EMA[1013 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f));

    // temp_f = pcs_get_chg_e_total();
    // usRegHoldingBuf_EMA[1014 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f)) >> 16;
    // usRegHoldingBuf_EMA[1015 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f));

    // temp_f = pcs_get_dhg_e_total();
    // usRegHoldingBuf_EMA[1016 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f)) >> 16;
    // usRegHoldingBuf_EMA[1017 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f));

    // usRegHoldingBuf_EMA[1018 - REG_HOLDING_START_EMA] = 0;
    // usRegHoldingBuf_EMA[1019 - REG_HOLDING_START_EMA] = ctn_get_tick();

    // temp_s32 = ctn_cal_get_cycle();
    // usRegHoldingBuf_EMA[1020 - REG_HOLDING_START_EMA] = *(unsigned int *)&temp_s32 >> 16;
    // usRegHoldingBuf_EMA[1021 - REG_HOLDING_START_EMA] = *(unsigned int *)&temp_s32;

    // usRegHoldingBuf_EMA[1022 - REG_HOLDING_START_EMA] = 0;
    // usRegHoldingBuf_EMA[1023 - REG_HOLDING_START_EMA] = ctn_get_state();

    // temp_s32 = ctn_get_ap();
    // usRegHoldingBuf_EMA[1024 - REG_HOLDING_START_EMA] = *(unsigned int *)&temp_s32 >> 16;
    // usRegHoldingBuf_EMA[1025 - REG_HOLDING_START_EMA] = *(unsigned int *)&temp_s32;

    // temp_f = pcs_get_grid_freq();
    // usRegHoldingBuf_EMA[1026 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f)) >> 16;
    // usRegHoldingBuf_EMA[1027 - REG_HOLDING_START_EMA] = *((unsigned int *)(&temp_f));

    // usRegHoldingBuf_EMA[1028 - REG_HOLDING_START_EMA] = 0;
    // usRegHoldingBuf_EMA[1029 - REG_HOLDING_START_EMA] = ctn_get_err();
}

static void procRegHoldingBuf_EMA(fmodbus_t *ctx)
{
    // unsigned int temp = 0;
    // int aps = 0;

    // temp = usRegHoldingBuf_EMA[2000 - REG_HOLDING_START_EMA];
    // // log_info("%s,temp(%d)",__func__,temp);
    // temp = (temp << 16) + usRegHoldingBuf_EMA[2001 - REG_HOLDING_START_EMA];
    // // log_info("%s,temp(%d)",__func__,temp);
    // aps = *((float *)(&temp));
    // // if(aps != 0){
    // log_info("%s,get aps(%d),tepm(%d),2000(%d),2001(%d)form host", __func__, aps, temp, usRegHoldingBuf_EMA[2000 - REG_HOLDING_START_EMA], usRegHoldingBuf_EMA[2001 - REG_HOLDING_START_EMA]);
    // if (ems_get_mode() == EMSMOD_NONE)
    //     ctn_set_aps(aps);
    //}
}

eMBErrorCode eMBRegInputCB(fmodbus_t *ctx, UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs)
{
    eMBErrorCode eStatus = MB_ENOERR;
    int iRegIndex;
    // struct chan_t* chan = &sta.chan[ctx->chanidx];

    // if( chan->dbg > 0 ){
    //     printf("%s, chanidx:%d, mbsidx:%d, mbsdevm:%d, mbsdevidx:%d, usAddress:%d, usNRegs:%d",
    //                                         __func__, ctx->chanidx, chan->mbsidx, chan->mbsdevm, chan->mbsdevidx,usAddress, usNRegs);
    // }

    /*********************
    if(chan->mbsidx >= 1 && chan->mbsidx <= PCS_NBR_MAX){ // pcs modbus rtu slave
        if( ( usAddress >= REG_INPUT_START_PCS )
            && ( usAddress + usNRegs <= REG_INPUT_START_PCS + REG_INPUT_NREGS_PCS ) ){
            iRegIndex = ( int )( usAddress - usRegInputStart_PCS[chan->mbsidx] );
            while( usNRegs > 0 ){
                //_prepareInputReg_PCS(ctx);
                *pucRegBuffer++ = ( unsigned char )( usRegInputBuf_PCS[chan->mbsidx][iRegIndex] >> 8 );
                *pucRegBuffer++ = ( unsigned char )( usRegInputBuf_PCS[chan->mbsidx][iRegIndex] & 0xFF );
                iRegIndex++;
                usNRegs--;
            }

        }else{
            eStatus = MB_ENOREG;
        }
        return eStatus;
    }
    *******************/
    return MB_ENOREG;
}

eMBErrorCode eMBRegHoldingCB(fmodbus_t *ctx, UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode)
{
    eMBErrorCode eStatus = MB_ENOERR;
    int iRegIndex;
    int i = 0;
    // struct chan_t* chan = &sta.chan[ctx->chanidx];

    // if( chan->dbg > 0 ){
    //     printf("%s, chanidx:%d, mbsidx:%d, mbsdevm:%d, mbsdevidx:%d, usAddress:%d, usNRegs:%d, eMode:%d",
    //                                                             __func__, ctx->chanidx, chan->mbsidx, chan->mbsdevm, chan->mbsdevidx,
    //                                                             usAddress, usNRegs, eMode);
    // }
    // if( chan->en == 0 ){
    //     return MB_EIO;
    // }
    if (ctx->mbsidx == MBSIDX_CESS2000)
    { // ctn modbus tcp slave
        if ((usAddress >= REG_HOLDING_START_CESS2000) && (usAddress + usNRegs <= REG_HOLDING_START_CESS2000 + REG_HOLDING_NREGS_CESS2000))
        {
            iRegIndex = (int)(usAddress - REG_HOLDING_START_CESS2000);
            switch (eMode)
            {
            /* Pass current register values to the protocol stack. */
            case MB_REG_READ:
                prepareRegHoldingBuf_CESS2000(ctx);
                while (usNRegs > 0)
                {
                    *pucRegBuffer++ = (UCHAR)(usRegHoldingBuf_CESS2000[iRegIndex] >> 8);
                    *pucRegBuffer++ = (UCHAR)(usRegHoldingBuf_CESS2000[iRegIndex] & 0xFF);
                    iRegIndex++;
                    usNRegs--;
                }
                break;

                /* Update current register values with new values from the
                 * protocol stack. */
            case MB_REG_WRITE:
                while (usNRegs > 0)
                {
                    usRegHoldingBuf_CESS2000[iRegIndex] = *pucRegBuffer++ << 8;
                    usRegHoldingBuf_CESS2000[iRegIndex] |= *pucRegBuffer++;
                    iRegIndex++;
                    usNRegs--;
                }
                procRegHoldingBuf_CESS2000(ctx);
                break;
            }
        }
        else
        {
            eStatus = MB_ENOREG;
        }

        return eStatus;
    }
    else if (ctx->mbsidx == MBSIDX_EMA)
    { // ctn modbus tcp slave
        if ((usAddress >= REG_HOLDING_START_EMA) && (usAddress + usNRegs <= REG_HOLDING_START_EMA + REG_HOLDING_NREGS_EMA))
        {
            iRegIndex = (int)(usAddress - REG_HOLDING_START_EMA);
            // log_info("%s,%d",__func__,iRegIndex);
            switch (eMode)
            {
            /* Pass current register values to the protocol stack. */
            case MB_REG_READ:
                prepareRegHoldingBuf_EMA(ctx);
                while (usNRegs > 0)
                {
                    *pucRegBuffer++ = (UCHAR)(usRegHoldingBuf_EMA[iRegIndex] >> 8);
                    *pucRegBuffer++ = (UCHAR)(usRegHoldingBuf_EMA[iRegIndex] & 0xFF);
                    iRegIndex++;
                    usNRegs--;
                }
                break;

                /* Update current register values with new values from the
                 * protocol stack. */
            case MB_REG_WRITE:
                while (usNRegs > 0)
                {
                    usRegHoldingBuf_EMA[iRegIndex] = *pucRegBuffer++ << 8;
                    usRegHoldingBuf_EMA[iRegIndex] |= *pucRegBuffer++;
                    iRegIndex++;
                    usNRegs--;
                }
                procRegHoldingBuf_EMA(ctx);
                break;
            }
        }
        else
        {
            eStatus = MB_ENOREG;
        }

        return eStatus;
    }
    return eStatus;
}

eMBErrorCode eMBRegCoilsCB(fmodbus_t *ctx, UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode)
{
    return MB_ENOREG;
}

eMBErrorCode eMBRegDiscreteCB(fmodbus_t *ctx, UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNDiscrete)
{
    return MB_ENOREG;
}

static pthread_t xthrd;

int mbs_start_cess2000(int port)
{
    int ret = 0;
    const UCHAR ucSlaveID[] = {0xAA, 0xBB, 0xCC};

    //if (eMBTCPInit(&MB[MBSIDX_CESS2000], port) != MB_ENOERR)
    if (eMBInit(&MB[MBSIDX_CESS2000], MB_RTU, 1, "/dev/ttymxc1", 115200, MB_PAR_NONE) != MB_ENOERR)
    {
        printf("%s, eMBTCPInit fail", __func__);
        ret = -1;
    }
    // else if (eMBSetSlaveID(MB[MBSIDX_CESS2000], 0x34, TRUE, ucSlaveID, 3) != MB_ENOERR)
    // {
    //     printf("%s, eMBSetSlaveID fail", __func__);
    //     ret = -2;
    // }
    else
    {
        MB[MBSIDX_CESS2000]->mbsidx = MBSIDX_CESS2000;
        if (pthread_create(&xthrd, NULL, pvPollingThread, MB[MBSIDX_CESS2000]) != 0)
        {
            printf("%s, pthread_create fail", __func__);
            ret = -3;
        }
        else
        {
            pthread_detach(xthrd);
            printf("%s, start ok", __func__);
        }
    }

    return ret;
}

int mbs_start_EMA(int port)
{
    int ret = 0;
    const UCHAR ucSlaveID[] = {0xAA, 0xBB, 0xCC};
    pthread_t xthrd;

    if (eMBTCPInit(&MB[MBSIDX_EMA], port) != MB_ENOERR)
    {
        printf("%s, eMBTCPInit fail", __func__);
        ret = -1;
    }
    else if (eMBSetSlaveID(MB[MBSIDX_EMA], 0x34, TRUE, ucSlaveID, 3) != MB_ENOERR)
    {
        printf("%s, eMBSetSlaveID fail", __func__);
        ret = -2;
    }
    else
    {
        MB[MBSIDX_EMA]->mbsidx = MBSIDX_EMA;
        if (pthread_create(&xthrd, NULL, pvPollingThread, MB[MBSIDX_EMA]) != 0)
        {
            printf("%s, pthread_create fail", __func__);
            ret = -3;
        }
        else
        {
            printf("%s, port:%d,start ok", __func__, port);
        }
    }

    return ret;
}