#include "sub_modbus_rtu.h"

/*!
 * Constants which defines the format of a modbus frame. The example is
 * shown for a Modbus RTU/ASCII frame. Note that the Modbus PDU is not
 * dependent on the underlying transport.
 *
 * <code>
 * <------------------------ MODBUS SERIAL LINE PDU (1) ------------------->
 *              <----------- MODBUS PDU (1') ---------------->
 *  +-----------+---------------+----------------------------+-------------+
 *  | Address   | Function Code | Data                       | CRC/LRC     |
 *  +-----------+---------------+----------------------------+-------------+
 *  |           |               |                                   |
 * (2)        (3/2')           (3')                                (4)
 *
 * (1)  ... MB_SER_PDU_SIZE_MAX = 256
 * (2)  ... MB_SER_PDU_ADDR_OFF = 0
 * (3)  ... MB_SER_PDU_PDU_OFF  = 1
 * (4)  ... MB_SER_PDU_SIZE_CRC = 2
 *
 * (1') ... MB_PDU_SIZE_MAX     = 253
 * (2') ... MB_PDU_FUNC_OFF     = 0
 * (3') ... MB_PDU_DATA_OFF     = 1
 * </code>
 */


CSubModbusRtuProcessItem::CSubModbusRtuProcessItem()
{
    m_YCRegCount = 0;
    m_YMRegCount = 0;
    m_YXRegCount = 0;

    m_pYCRegTab = NULL;
    m_pYMRegTab = NULL;
    m_pYXRegTab = NULL;
}

CSubModbusRtuProcessItem::~CSubModbusRtuProcessItem()
{
    if (m_pYCRegTab)
    {
        delete[] m_pYCRegTab;
        m_pYCRegTab = NULL;
    }
    
    if (m_pYMRegTab)
    {
        delete[] m_pYMRegTab;
        m_pYMRegTab = NULL;
    }
    
    if (m_pYXRegTab)
    {
        delete[] m_pYXRegTab;
        m_pYXRegTab = NULL;
    }
}

void CSubModbusRtuProcessItem::Attach(int uid, int physicsAddress /* = 0 */, int commonAddress /* = 0 */, int originatorAddress /* = 0 */)
{
    CPortProcessItem::Attach(uid, physicsAddress); 
}

void CSubModbusRtuProcessItem::Release(void)
{      
    CPortProcessItem::Release();
}

CSubModbusRtuProcess::CSubModbusRtuProcess()
{
}

CSubModbusRtuProcess::~CSubModbusRtuProcess()
{
}

CPortProcessItem *CSubModbusRtuProcess::CreateItem(int ord)
{
    return dynamic_cast<CPortProcessItem *>(new CSubModbusRtuProcessItem);
}

void CSubModbusRtuProcess::DestroyItem(int ord, BOOLEAN bDeleted /* = FALSE */)
{
    CSubModbusRtuProcessItem *pItem = (CSubModbusRtuProcessItem *)GetItem(ord);
    if (pItem != NULL && !bDeleted)
    {
        delete pItem;
        return CPortProcess::DestroyItem(ord, TRUE);
    }
    
    return CPortProcess::DestroyItem(ord, bDeleted);
}

BOOLEAN CSubModbusRtuProcess::OnPreCreate(int id)
{
    int i;
    int uid;
    int port;
    BYTE addr;
    DWORD ulBaudRate;
    
    CSubModbusRtuProcessItem *pItem;
    if (!CPortProcess::OnPreCreate(id)) return FALSE;
    
    port = config.processes[id].order;
    if (port < 0 || port >= HARDWARE_PORTS_NUM) return FALSE;
    ulBaudRate = config.hardware.ports[port].baud;
    if (ulBaudRate > 19200)
    {
        usTimerT35_50us = 1750;       /* 1800us. */
    }
    else
    {
        /* The timer reload value for a character is given by:
         * 
         * ChTimeValue = Ticks_per_1s / ( Baudrate / 11 )
         * = 11 * Ticks_per_1s / Baudrate
         * = 220000 / Baudrate
         * The reload for t3.5 is 1.5 times this value and similary
         * for t3.5.
         */
        usTimerT35_50us = 38500000L / ulBaudRate;
    }
    for (i = 0; i < PROCESS_UNIT_NUM; i++)
    {
        pItem = (CSubModbusRtuProcessItem *)GetItem(i);
        if (NULL == pItem) continue;
        uid = GetUnitID(i);

        if (uid < 0 || uid >= UNIT_NUM) continue;
        if (GetUnitAddr(uid, &addr, 1))
        {   //获取单元地址成功，则该段原地址采用配置地址，否则该单元为无效地址。
            pItem->Attach(uid, addr);
            //pItem->m_addr = addr;                //配置地址
        }
        pItem->m_YCRegCount = GetUnitYCCount(uid);
        if (m_YC_Type == M_ME_NC)
        {
            pItem->m_YCRegCount = (GetUnitYCCount(uid) << 1);   //采用浮点数上传
        }
        pItem->m_YMRegCount = (GetUnitYMCount(uid) << 1);   //遥脉采用4字节传输
        pItem->m_YXRegCount = GetUnitYXCount(uid);
        if (pItem->m_YCRegCount)
        {
            pItem->m_pYCRegTab = new WORD[pItem->m_YCRegCount];
            if (pItem->m_pYCRegTab == NULL) return FALSE;
        }
        if (pItem->m_YMRegCount)
        {
            pItem->m_pYMRegTab = new WORD[pItem->m_YMRegCount];
            if (pItem->m_pYMRegTab == NULL) return FALSE;
        }
        if (pItem->m_YXRegCount)
        {
            pItem->m_pYXRegTab = new BYTE[pItem->m_YXRegCount];
            if (pItem->m_pYXRegTab == NULL) return FALSE;
        }
    }
    return TRUE;
}

BOOLEAN CSubModbusRtuProcess::Run(void)
{
    //if (!CPortProcess::Run()) return FALSE;

    if (!CProcess::Run()) return FALSE;
    SerialPortRead(usTimerT35_50us);
    //数据发送
    SerialPortWrite();
    
    int i, j, uid;

    FeedDog();
    for (i = 0; i < PROCESS_UNIT_NUM; i++)
    {
        CSubModbusRtuProcessItem *pItem = (CSubModbusRtuProcessItem *)GetItem(i);
        if (NULL == pItem) continue;
        uid = pItem->GetUnitID();
        if (uid < 0) continue;
        //刷新寄存器
        float   *fvalue = NULL;
        short   *svalue = NULL;
        DWORD   *dvalue = NULL;
        BYTE    *bvalue = NULL;
        if (m_YC_Type == M_ME_NC) fvalue = (float *)pItem->m_pYCRegTab;
        else svalue = (short *)pItem->m_pYCRegTab;
        for (j = 0; j < GetUnitYCCount(uid); j++)
        {
            if (m_YC_Type == M_ME_NC)
            {
                *fvalue = GetUnitYCReal(uid, j); fvalue++;
            }
            else
            {
                *svalue = (short)GetUnitYC(uid, j); svalue++;
            }
        }
        
        dvalue = (DWORD *)pItem->m_pYMRegTab;
        for (j = 0; j < GetUnitYMCount(uid); j++)
        {
            *dvalue = (DWORD)GetUnitYM(uid, j); dvalue++;
        }
        
        bvalue = (BYTE *)pItem->m_pYXRegTab;
        for (j = 0; j < GetUnitYXCount(uid); j++)
        {
            *bvalue = (BYTE)GetUnitYX(uid, j); bvalue++;
        }
        
        
        int order;
        BYTE action, result;
        DWORD value;
        BYTE  by_value;
        if (GetUnitYT(uid, order, value, action, result))
		{
			vLog(LOG_DEBUG, "Unit(%d) set point(%d) %d state is %s result is %s\n", uid, order, value, val_to_str(action, yt_state, "STATE=%d"), val_to_str(result, yt_result, "RESULT=%d"));
			if (YTS_SELED == action && YTR_FAIL ==  result)
			{
				action = YTS_ABRED;
			}
			else if (YTS_SELREQ == action && YTR_OVER == result)
			{
				action = YTS_ABRED;
			}
			else if (YTS_SELING == action && YTR_OVER == result)
			{
				action = YTS_ABRED;
			}

			if (YTS_SELED == action)
			{
				SetUnitYT(uid, order, value, YTS_EXEREQ, YTR_IDLE);
				vLog(LOG_DEBUG, "Unit(%d) set point(%d) %d state is YTS_EXEREQ result is YTR_IDLE.\n", uid, order, value);
			}
			else if (YTS_ABRED == action)
			{
				SetUnitYT(uid, order, value, YTS_ABRREQ, YTR_IDLE);
				vLog(LOG_DEBUG, "Unit(%d) set point(%d) %d state is YTS_ABRREQ result is YTR_IDLE.\n", uid, order, value);
			}
		}
		if (GetUnitYK(uid, order, by_value, action, result))
		{
			vLog(LOG_WARN, "Unit(%d) yk(%d) %s state is %s result is %s\n", uid, order, (by_value ? "CLOSE" : "TRIP"), val_to_str(action, yk_state, "STATE=%d"), val_to_str(result, yk_result, "RESULT=%d"));
			if (YKS_SELED == action && YKR_FAIL ==  result)
			{
				action = YKS_ABRED;
			}
			else if (YKS_SELREQ == action && YKR_OVER == result)
			{
				action = YKS_ABRED;
			}
			else if (YKS_SELING == action && YKR_OVER == result)
			{
				action = YKS_ABRED;
			}
			if (YKS_ABRED == action)
			{
				SetUnitYK(uid, order, by_value, YKS_ABRREQ, YKR_IDLE);
				vLog(LOG_WARN, "Unit(%d) yk(%d) %s state is YKS_ABRREQ result is YKR_IDLE.\n", uid, order, (by_value ? "CLOSE" : "TRIP"));
			}
			else if (YKS_SELED == action)
			{
				SetUnitYK(uid, order, by_value, YKS_EXEREQ, YKR_IDLE);
				vLog(LOG_WARN, "Unit(%d) yk(%d) %s state is YKS_EXEREQ result is YKR_IDLE.\n", uid, order, (by_value ? "CLOSE" : "TRIP"));
			}
		}
	}
	return TRUE;
}

BOOLEAN CSubModbusRtuProcess::OnTimer(void)
{
    if (!CPortProcess::OnTimer()) return FALSE;

    return TRUE;
}

BOOLEAN CSubModbusRtuProcess::OnReceiveData(BYTE* pData, int count)
{
    return TRUE;
}

BOOLEAN CSubModbusRtuProcess::SerialPortTimeout(void)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    
    BYTE ucRcvAddress;
    BYTE *pucFrame;
    WORD usLength;
    WORD usRcvBufferPos = GetDataCount();
    if (!GetData(ucRTUBuf, usRcvBufferPos))
    {
        vLog(LOG_ERROR, "%s GetData() ERROR!\n", __FILE__);
        return FALSE;
    }
    /* Length and CRC check */
    if ((usRcvBufferPos >= MB_SER_PDU_SIZE_MIN) && (GetCRC16((BYTE *)ucRTUBuf, usRcvBufferPos) == 0))
    {
        /* Save the address field. All frames are passed to the upper layed
         * and the decision if a frame is used is done there.
         */
        ucRcvAddress = ucRTUBuf[MB_SER_PDU_ADDR_OFF];

        /* Total length of Modbus-PDU is Modbus-Serial-Line-PDU minus
         * size of address field and CRC checksum.
         */
        usLength = (WORD)(usRcvBufferPos - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_CRC);
        /* Return the start of the Modbus PDU to the caller. */
        pucFrame = (BYTE *)&ucRTUBuf[MB_SER_PDU_PDU_OFF];
        
        DropData(usRcvBufferPos);
        int uid, order;
        CSubModbusRtuProcessItem* pItem;
        
        uid = GetUnitByAddr(&ucRcvAddress, 1);
        if (uid < 0 || uid >= UNIT_NUM) return FALSE;
        order = GetOrderByUnitID(uid);
        if (order < 0 || order >= PROCESS_UNIT_NUM) return FALSE;
        pItem = (CSubModbusRtuProcessItem *)GetItem(order);
        if ((ucRcvAddress != pItem->m_physicsAddress) && (ucRcvAddress != MB_ADDRESS_BROADCAST))
        {
            return TRUE;
        }
        BYTE ucFunctionCode = pucFrame[MB_PDU_FUNC_OFF];
        eMBException eException;
        
        DisplayRxData(ucRTUBuf, usRcvBufferPos, TRUE, uid);
        UnitFeedDog(uid);
        eException = MB_EX_ILLEGAL_FUNCTION;
        switch (ucFunctionCode)
        {
            case MB_FUNC_READ_INPUT_REGISTER:
                eException = eMBFuncReadInputRegister(pItem, pucFrame, &usLength);
                break;
            case MB_FUNC_READ_HOLDING_REGISTER:
                eException = eMBFuncReadHoldingRegister(pItem, pucFrame, &usLength);
                break;
            case MB_FUNC_WRITE_MULTIPLE_REGISTERS:
                eException = eMBFuncWriteMultipleHoldingRegister(pItem, pucFrame, &usLength);
                break;
            case MB_FUNC_WRITE_REGISTER:
                eException = eMBFuncWriteHoldingRegister(pItem, pucFrame, &usLength);
                break;
            case MB_FUNC_READ_COILS:
                eException = eMBFuncReadCoils(pItem, pucFrame, &usLength);
                break;
            case MB_FUNC_WRITE_SINGLE_COIL:
                eException = eMBFuncWriteCoil(pItem, pucFrame, &usLength);
                break;
            case MB_FUNC_WRITE_MULTIPLE_COILS:
                eException = eMBFuncWriteMultipleCoils(pItem, pucFrame, &usLength);
                break;
            case MB_FUNC_READ_DISCRETE_INPUTS:
                eException = eMBFuncReadDiscreteInputs(pItem, pucFrame, &usLength);
                break;
            default:
                break;
        }
        if (ucRcvAddress != MB_ADDRESS_BROADCAST)
        {
            if (eException != MB_EX_NONE)
            {
                /* An exception occured. Build an error frame. */
                usLength = 0;
                pucFrame[usLength++] = (BYTE)(ucFunctionCode | MB_FUNC_ERROR);
                pucFrame[usLength++] = eException;
            }
            eStatus = eMBRTUSend(ucRcvAddress, pucFrame, usLength);
        }
    }
    else
    {
        DropData(usRcvBufferPos);
        eStatus = MB_EIO;
    }
    if (eStatus != MB_ENOERR) 
    {
        vLog(LOG_ERROR, "modbus have error(%d)!\n", eStatus);
        return FALSE;
    }
    return TRUE;
}

eMBErrorCode CSubModbusRtuProcess::eMBRTUSend(BYTE ucSlaveAddress, const BYTE *pucFrame, WORD usLength)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    BYTE *pucSndBufferCur;
    WORD usSndBufferCount;
    WORD usCRC16;
    
    pucSndBufferCur = (BYTE *) pucFrame - 1;
    usSndBufferCount = 1;
    
    /* Now copy the Modbus-PDU into the Modbus-Serial-Line-PDU. */
    pucSndBufferCur[MB_SER_PDU_ADDR_OFF] = ucSlaveAddress;
    usSndBufferCount += usLength;
    
    /* Calculate CRC16 checksum for Modbus-Serial-Line-PDU. */
    usCRC16 = GetCRC16((BYTE *) pucSndBufferCur, usSndBufferCount);
    ucRTUBuf[usSndBufferCount++] = (BYTE)(usCRC16 >> 8);
    ucRTUBuf[usSndBufferCount++] = (BYTE)(usCRC16 & 0xFF);
    if (WriteData(ucRTUBuf, usSndBufferCount))
    {
        DisplayTxData(ucRTUBuf, usSndBufferCount, TRUE);
        eStatus = MB_EIO;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::prveMBError2Exception(eMBErrorCode eErrorCode)
{
    eMBException    eStatus;
    
    switch (eErrorCode)
    {
        case MB_ENOERR:
            eStatus = MB_EX_NONE;
            break;
        case MB_ENOREG:
            eStatus = MB_EX_ILLEGAL_DATA_ADDRESS;
            break;
        case MB_ETIMEDOUT:
            eStatus = MB_EX_SLAVE_BUSY;
            break;
        default:
            eStatus = MB_EX_SLAVE_DEVICE_FAILURE;
            break;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::eMBFuncReadInputRegister(CSubModbusRtuProcessItem *pItem, BYTE* pucFrame, WORD* usLen)
{
    WORD          usRegAddress;
    WORD          usRegCount;
    BYTE          *pucFrameCur;

    eMBException    eStatus = MB_EX_NONE;
    eMBErrorCode    eRegStatus;

    if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
    {
        usRegAddress = (WORD)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
        usRegAddress |= (WORD)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
        
        usRegCount = (WORD)(pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF] << 8);
        usRegCount |= (WORD)(pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF + 1]);
        
        /* Check if the number of registers to read is valid. If not
         * return Modbus illegal data value exception. 
         */
        if ((usRegCount >= 1) && (usRegCount < MB_PDU_FUNC_READ_REGCNT_MAX))
        {
            /* Set the current PDU data pointer to the beginning. */
            pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
            *usLen = MB_PDU_FUNC_OFF;
            
            /* First byte contains the function code. */
            *pucFrameCur++ = MB_FUNC_READ_INPUT_REGISTER;
            *usLen += 1;
            
            /* Second byte in the response contain the number of bytes. */
            *pucFrameCur++ = (BYTE)(usRegCount << 1);
            *usLen += 1;
            eRegStatus = eMBRegInputCB(pItem, pucFrameCur, usRegAddress, usRegCount);
            
            /* If an error occured convert it into a Modbus exception. */
            if (eRegStatus != MB_ENOERR)
            {
                eStatus = prveMBError2Exception(eRegStatus);
            }
            else
            {
                *usLen += usRegCount << 1;
            }
        }
        else
        {
            eStatus = MB_EX_ILLEGAL_DATA_VALUE;
        }
    }
    else
    {
        /* Can't be a valid read input register request because the length
         * is incorrect. */
        eStatus = MB_EX_ILLEGAL_DATA_VALUE;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::eMBFuncWriteHoldingRegister(CSubModbusRtuProcessItem *pItem, BYTE* pucFrame, WORD* usLen)
{
    WORD            usRegAddress;
    eMBException    eStatus = MB_EX_NONE;
    eMBErrorCode    eRegStatus;

    if (*usLen == (MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN))
    {
        usRegAddress = (WORD)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF] << 8);
        usRegAddress |= (WORD)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF + 1]);
        
        /* Make callback to update the value. */
        eRegStatus = eMBRegHoldingCB(pItem, &pucFrame[MB_PDU_FUNC_WRITE_VALUE_OFF], usRegAddress, 1, MB_REG_WRITE);
        
        /* If an error occured convert it into a Modbus exception. */
        if (eRegStatus != MB_ENOERR)
        {
            eStatus = prveMBError2Exception(eRegStatus);
        }
    }
    else
    {
        /* Can't be a valid request because the length is incorrect. */
        eStatus = MB_EX_ILLEGAL_DATA_VALUE;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::eMBFuncWriteMultipleHoldingRegister(CSubModbusRtuProcessItem *pItem, BYTE* pucFrame, WORD* usLen)
{
    WORD            usRegAddress;
    WORD            usRegCount;
    BYTE            ucRegByteCount;

    eMBException    eStatus = MB_EX_NONE;
    eMBErrorCode    eRegStatus;
    
    if (*usLen >= (MB_PDU_FUNC_WRITE_MUL_SIZE_MIN + MB_PDU_SIZE_MIN))
    {
        usRegAddress = (WORD)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF] << 8);
        usRegAddress |= (WORD)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF + 1]);
        
        usRegCount = (WORD)(pucFrame[MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF] << 8);
        usRegCount |= (WORD)(pucFrame[MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF + 1]);
        
        ucRegByteCount = pucFrame[MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF];
        
        if ((usRegCount >= 1) && (usRegCount <= MB_PDU_FUNC_WRITE_MUL_REGCNT_MAX) && (ucRegByteCount == (BYTE) (usRegCount << 1)))
        {
            /* Make callback to update the register values. */
            eRegStatus = eMBRegHoldingCB(pItem, &pucFrame[MB_PDU_FUNC_WRITE_MUL_VALUES_OFF], usRegAddress, usRegCount, MB_REG_WRITE);

            /* If an error occured convert it into a Modbus exception. */
            if (eRegStatus != MB_ENOERR)
            {
                eStatus = prveMBError2Exception(eRegStatus);
            }
            else
            {
                /* The response contains the function code, the starting
                 * address and the quantity of registers. We reuse the
                 * old values in the buffer because they are still valid.
                 */
                *usLen = MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF;
            }
        }
        else
        {
            eStatus = MB_EX_ILLEGAL_DATA_VALUE;
        }
    }
    else
    {
        /* Can't be a valid request because the length is incorrect. */
        eStatus = MB_EX_ILLEGAL_DATA_VALUE;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::eMBFuncReadHoldingRegister(CSubModbusRtuProcessItem *pItem, BYTE* pucFrame, WORD* usLen)
{
    WORD          usRegAddress;
    WORD          usRegCount;
    BYTE          *pucFrameCur;

    eMBException    eStatus = MB_EX_NONE;
    eMBErrorCode    eRegStatus;

    if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
    {
        usRegAddress = (WORD)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
        usRegAddress |= (WORD)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
        
        usRegCount = (WORD)(pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF] << 8);
        usRegCount = (WORD)(pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF + 1]);

        /* Check if the number of registers to read is valid. If not
         * return Modbus illegal data value exception. 
         */
        if ((usRegCount >= 1) && (usRegCount <= MB_PDU_FUNC_READ_REGCNT_MAX))
        {
            /* Set the current PDU data pointer to the beginning. */
            pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
            *usLen = MB_PDU_FUNC_OFF;

            /* First byte contains the function code. */
            *pucFrameCur++ = MB_FUNC_READ_HOLDING_REGISTER;
            *usLen += 1;

            /* Second byte in the response contain the number of bytes. */
            *pucFrameCur++ = (BYTE) (usRegCount << 1);
            *usLen += 1;

            /* Make callback to fill the buffer. */
            eRegStatus = eMBRegHoldingCB(pItem, pucFrameCur, usRegAddress, usRegCount, MB_REG_READ);
            /* If an error occured convert it into a Modbus exception. */
            if (eRegStatus != MB_ENOERR)
            {
                eStatus = prveMBError2Exception(eRegStatus);
            }
            else
            {
                *usLen += usRegCount << 1;
            }
        }
        else
        {
            eStatus = MB_EX_ILLEGAL_DATA_VALUE;
        }
    }
    else
    {
        /* Can't be a valid request because the length is incorrect. */
        eStatus = MB_EX_ILLEGAL_DATA_VALUE;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::eMBFuncReadCoils(CSubModbusRtuProcessItem *pItem, BYTE* pucFrame, WORD* usLen)
{
    WORD          usRegAddress;
    WORD          usCoilCount;
    BYTE           ucNBytes;
    BYTE          *pucFrameCur;

    eMBException    eStatus = MB_EX_NONE;
    eMBErrorCode    eRegStatus;

    if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
    {
        usRegAddress = (WORD)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
        usRegAddress |= (WORD)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
        
        usCoilCount = (WORD)(pucFrame[MB_PDU_FUNC_READ_COILCNT_OFF] << 8);
        usCoilCount |= (WORD)(pucFrame[MB_PDU_FUNC_READ_COILCNT_OFF + 1]);

        /* Check if the number of registers to read is valid. If not
         * return Modbus illegal data value exception. 
         */
        if ((usCoilCount >= 1) && (usCoilCount < MB_PDU_FUNC_READ_COILCNT_MAX))
        {
            /* Set the current PDU data pointer to the beginning. */
            pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
            *usLen = MB_PDU_FUNC_OFF;

            /* First byte contains the function code. */
            *pucFrameCur++ = MB_FUNC_READ_COILS;
            *usLen += 1;

            /* Test if the quantity of coils is a multiple of 8. If not last
             * byte is only partially field with unused coils set to zero. */
            if ((usCoilCount & 0x0007) != 0)
            {
                ucNBytes = (BYTE)((usCoilCount >> 3) + 1);
            }
            else
            {
                ucNBytes = (BYTE)(usCoilCount >> 3);
            }
            *pucFrameCur++ = ucNBytes;
            *usLen += 1;

            eRegStatus = eMBRegCoilsCB(pItem, pucFrameCur, usRegAddress, usCoilCount, MB_REG_READ);

            /* If an error occured convert it into a Modbus exception. */
            if (eRegStatus != MB_ENOERR)
            {
                eStatus = prveMBError2Exception(eRegStatus);
            }
            else
            {
                /* The response contains the function code, the starting address
                 * and the quantity of registers. We reuse the old values in the 
                 * buffer because they are still valid. */
                *usLen += ucNBytes;;
            }
        }
        else
        {
            eStatus = MB_EX_ILLEGAL_DATA_VALUE;
        }
    }
    else
    {
        /* Can't be a valid read coil register request because the length
         * is incorrect. */
        eStatus = MB_EX_ILLEGAL_DATA_VALUE;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::eMBFuncWriteCoil(CSubModbusRtuProcessItem *pItem, BYTE* pucFrame, WORD* usLen)
{
    WORD          usRegAddress;
    BYTE           ucBuf[2];

    eMBException    eStatus = MB_EX_NONE;
    eMBErrorCode    eRegStatus;

    if (*usLen == (MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN))
    {
        usRegAddress = (WORD)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF] << 8);
        usRegAddress |= (WORD)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF + 1]);
        
        if ((pucFrame[MB_PDU_FUNC_WRITE_VALUE_OFF + 1] == 0x00) && ((pucFrame[MB_PDU_FUNC_WRITE_VALUE_OFF] == 0xFF) || (pucFrame[MB_PDU_FUNC_WRITE_VALUE_OFF] == 0x00)))
        {
            ucBuf[1] = 0;
            if (pucFrame[MB_PDU_FUNC_WRITE_VALUE_OFF] == 0xFF)
            {
                ucBuf[0] = 1;
            }
            else
            {
                ucBuf[0] = 0;
            }
            eRegStatus = eMBRegCoilsCB(pItem, &ucBuf[0], usRegAddress, 1, MB_REG_WRITE);

            /* If an error occured convert it into a Modbus exception. */
            if (eRegStatus != MB_ENOERR)
            {
                eStatus = prveMBError2Exception(eRegStatus);
            }
        }
        else
        {
            eStatus = MB_EX_ILLEGAL_DATA_VALUE;
        }
    }
    else
    {
        /* Can't be a valid write coil register request because the length
         * is incorrect. */
        eStatus = MB_EX_ILLEGAL_DATA_VALUE;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::eMBFuncWriteMultipleCoils(CSubModbusRtuProcessItem *pItem, BYTE* pucFrame, WORD* usLen)
{
    WORD          usRegAddress;
    WORD          usCoilCnt;
    BYTE           ucByteCount;
    BYTE           ucByteCountVerify;

    eMBException    eStatus = MB_EX_NONE;
    eMBErrorCode    eRegStatus;

    if (*usLen > (MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN))
    {
        usRegAddress = (WORD)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF] << 8);
        usRegAddress |= (WORD)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF + 1]);
        
        usCoilCnt = (WORD)(pucFrame[MB_PDU_FUNC_WRITE_MUL_COILCNT_OFF] << 8);
        usCoilCnt |= (WORD)(pucFrame[MB_PDU_FUNC_WRITE_MUL_COILCNT_OFF + 1]);

        ucByteCount = pucFrame[MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF];

        /* Compute the number of expected bytes in the request. */
        if ((usCoilCnt & 0x0007) != 0)
        {
            ucByteCountVerify = (BYTE)(usCoilCnt / 8 + 1);
        }
        else
        {
            ucByteCountVerify = (BYTE)(usCoilCnt / 8);
        }

        if ((usCoilCnt >= 1) &&
            (usCoilCnt <= MB_PDU_FUNC_WRITE_MUL_COILCNT_MAX) &&
            (ucByteCountVerify == ucByteCount))
        {
            eRegStatus = eMBRegCoilsCB(pItem, &pucFrame[MB_PDU_FUNC_WRITE_MUL_VALUES_OFF], usRegAddress, usCoilCnt, MB_REG_WRITE);

            /* If an error occured convert it into a Modbus exception. */
            if (eRegStatus != MB_ENOERR)
            {
                eStatus = prveMBError2Exception(eRegStatus);
            }
            else
            {
                /* The response contains the function code, the starting address
                 * and the quantity of registers. We reuse the old values in the 
                 * buffer because they are still valid. */
                *usLen = MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF;
            }
        }
        else
        {
            eStatus = MB_EX_ILLEGAL_DATA_VALUE;
        }
    }
    else
    {
        /* Can't be a valid write coil register request because the length
         * is incorrect. */
        eStatus = MB_EX_ILLEGAL_DATA_VALUE;
    }
    return eStatus;
}

eMBException CSubModbusRtuProcess::eMBFuncReadDiscreteInputs(CSubModbusRtuProcessItem *pItem, BYTE* pucFrame, WORD* usLen)
{
    WORD          usRegAddress;
    WORD          usDiscreteCnt;
    BYTE           ucNBytes;
    BYTE          *pucFrameCur;

    eMBException    eStatus = MB_EX_NONE;
    eMBErrorCode    eRegStatus;

    if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
    {
        usRegAddress = (WORD)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
        usRegAddress |= (WORD)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
        
        usDiscreteCnt = (WORD)(pucFrame[MB_PDU_FUNC_READ_DISCCNT_OFF] << 8);
        usDiscreteCnt |= (WORD)(pucFrame[MB_PDU_FUNC_READ_DISCCNT_OFF + 1]);

        /* Check if the number of registers to read is valid. If not
         * return Modbus illegal data value exception. 
         */
        if ((usDiscreteCnt >= 1) && (usDiscreteCnt < MB_PDU_FUNC_READ_DISCCNT_MAX))
        {
            /* Set the current PDU data pointer to the beginning. */
            pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
            *usLen = MB_PDU_FUNC_OFF;

            /* First byte contains the function code. */
            *pucFrameCur++ = MB_FUNC_READ_DISCRETE_INPUTS;
            *usLen += 1;

            /* Test if the quantity of coils is a multiple of 8. If not last
             * byte is only partially field with unused coils set to zero. */
            if ((usDiscreteCnt & 0x0007) != 0)
            {
                ucNBytes = (BYTE) ((usDiscreteCnt >> 3) + 1);
            }
            else
            {
                ucNBytes = (BYTE) (usDiscreteCnt >> 3);
            }
            *pucFrameCur++ = ucNBytes;
            *usLen += 1;

            eRegStatus = eMBRegDiscreteCB(pItem, pucFrameCur, usRegAddress, usDiscreteCnt);

            /* If an error occured convert it into a Modbus exception. */
            if (eRegStatus != MB_ENOERR)
            {
                eStatus = prveMBError2Exception(eRegStatus);
            }
            else
            {
                /* The response contains the function code, the starting address
                 * and the quantity of registers. We reuse the old values in the 
                 * buffer because they are still valid. */
                *usLen += ucNBytes;;
            }
        }
        else
        {
            eStatus = MB_EX_ILLEGAL_DATA_VALUE;
        }
    }
    else
    {
        /* Can't be a valid read coil register request because the length
         * is incorrect. */
        eStatus = MB_EX_ILLEGAL_DATA_VALUE;
    }
    return eStatus;
}


eMBErrorCode CSubModbusRtuProcess::eMBRegInputCB(CSubModbusRtuProcessItem *pItem, BYTE* pucRegBuffer, WORD usAddress, WORD usNRegs)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    int             iRegIndex;
    
    if ((usAddress >= 0) && (usAddress + usNRegs <= 0 + pItem->m_YCRegCount))
    {
        iRegIndex = (int)(usAddress - 0);
        while (usNRegs > 0)
        {
            *pucRegBuffer++ = (BYTE)(pItem->m_pYCRegTab[iRegIndex] >> 8);
            *pucRegBuffer++ = (BYTE)(pItem->m_pYCRegTab[iRegIndex] & 0xFF);
            iRegIndex++;
            usNRegs--;
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}

eMBErrorCode CSubModbusRtuProcess::eMBRegHoldingCB(CSubModbusRtuProcessItem *pItem, BYTE* pucRegBuffer, WORD usAddress, WORD usNRegs, eMBRegisterMode eMode)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    WORD            usRegHoldingValue;
    int             iRegIndex;
    int             uid;
    
    uid = pItem->GetUnitID();

    if ((usAddress >= 0) && (usAddress + usNRegs <= 0 + pItem->m_YMRegCount))
    {
        iRegIndex = (int)(usAddress - 0);
        switch (eMode)
        {   /* Pass current register values to the protocol stack. */
            case MB_REG_READ:
                while (usNRegs > 0)
                {
                    *pucRegBuffer++ = (BYTE)(pItem->m_pYMRegTab[iRegIndex] >> 8);
                    *pucRegBuffer++ = (BYTE)(pItem->m_pYMRegTab[iRegIndex] & 0xFF);
                    iRegIndex++;
                    usNRegs--;
                }
                break;
                /* Update current register values with new values from the
                 * protocol stack. */
            case MB_REG_WRITE:
                while (usNRegs > 0)
                {
                    usRegHoldingValue = *pucRegBuffer++ << 8;
                    usRegHoldingValue |= *pucRegBuffer++;
                    //写寄存器
                    SetUnitYT(uid, iRegIndex, usRegHoldingValue, YTS_EXEREQ, YTR_IDLE);
                    vLog(LOG_DEBUG, "Unit(%d) set point(%d) %d state is YTS_EXEREQ result is YTR_IDLE.\n", uid, iRegIndex, usRegHoldingValue);
                    iRegIndex++;
                    usNRegs--;
                }
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }
    return eStatus;
}


eMBErrorCode CSubModbusRtuProcess::eMBRegCoilsCB(CSubModbusRtuProcessItem *pItem, BYTE* pucRegBuffer, WORD usAddress, WORD usNCoils, eMBRegisterMode eMode)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    WORD            usCoilGroups    = ((usNCoils - 1) / 8 + 1);
    BYTE            ucStatus        = 0;
    BYTE            usRegCoilsValue;
    BYTE            ucBits          = 0;
    BYTE            ucDisp          = 0;
    int             iRegIndex       = usAddress - 0;
    int             uid;

    uid = pItem->GetUnitID();
    if ((usAddress >= 0) && (usAddress + usNCoils <= 0 + pItem->m_YXRegCount))
    {
        iRegIndex = (int)(usAddress - 0);
        switch (eMode)
        {   /* Pass current register values to the protocol stack. */
            case MB_REG_READ:
               while (usCoilGroups--)
               {
                   ucDisp = 0;
                   ucBits = 8;
                   ucStatus = 0;
                   while((usNCoils--) != 0 && (ucBits--) != 0)
                   {
                       ucStatus |= (pItem->m_pYXRegTab[iRegIndex++] << (ucDisp++));
                   }
                   *pucRegBuffer++ = ucStatus;
               }
               break;
               /* Update current register values with new values from the
                * protocol stack. */
            case MB_REG_WRITE:
                while (usCoilGroups--)
                {
                    ucStatus = *pucRegBuffer++;
                    ucBits   = 8;
                    while ((usNCoils--) != 0 && (ucBits--) != 0)
                    {
                        usRegCoilsValue = ucStatus & 0X01;
                        //写线圈
                        SetUnitYK(uid, iRegIndex, usRegCoilsValue, YKS_SELREQ, YKR_IDLE);
                        vLog(LOG_WARN, "Unit(%d) yk(%d) %s state is YKS_EXEREQ result is YKR_IDLE.\n", uid, iRegIndex, (usRegCoilsValue ? "CLOSE" : "TRIP"));
                        iRegIndex++;
                        ucStatus >>= 1;
                    }
                }
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }
    return eStatus;
}

eMBErrorCode CSubModbusRtuProcess::eMBRegDiscreteCB(CSubModbusRtuProcessItem *pItem, BYTE* pucRegBuffer, WORD usAddress, WORD usNDiscrete)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    WORD            usDiscreteGroups    = ((usNDiscrete - 1) / 8 + 1);
    BYTE            ucStatus        = 0;
    BYTE            ucBits          = 0;
    BYTE            ucDisp          = 0;
    int             iRegIndex       = usAddress - 0;
    
    if ((usAddress >= 0) && (usAddress + usNDiscrete <= 0 + pItem->m_YXRegCount))
    {
        iRegIndex = (int)(usAddress - 0);
        while (usDiscreteGroups--)
        {
            ucDisp = 0;
            ucBits = 8;
            ucStatus = 0;
            while((usNDiscrete--) != 0 && (ucBits--) != 0)
            {
                ucStatus |= (pItem->m_pYXRegTab[iRegIndex++] << (ucDisp++));
            }
            *pucRegBuffer++ = ucStatus;
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }
    return eStatus;
}