#include "mb.h"
#include "mbport.h"
#include "port.h"
#include "elog.h"

extern void Modbus_Port( );
extern void Modbus_Task(void * argument);
osThreadId_t modbus_taskHandle;
const osThreadAttr_t modbus_task_attributes = {
    .name = "modbus_task",
    .stack_size = 512,
    .priority = (osPriority_t) osPriorityLow,
};

void Modbus_Port( )
{
    modbus_taskHandle = osThreadNew( Modbus_Task, NULL, &modbus_task_attributes );
}

/* ----------------------- Defines ------------------------------------------*/
// 输入寄存器
#define REG_INPUT_START 0
#define REG_INPUT_NREGS 6

// 保持寄存器
#define REG_HOLD_START   0
#define REG_HOLD_NREGS   10

// 线圈
#define REG_COILS_START  0
#define REG_COILS_NREGS  4

// 开关寄存器
#define REG_DISCRETE_START 0
#define REG_DISCRETE_NREGS 4

/* ----------------------- Static variables ---------------------------------*/
static USHORT   usRegInputStart = REG_INPUT_START;
static USHORT   usRegHoldStart = REG_HOLD_START;
static USHORT   usRegCoilsStart = REG_COILS_START;
static USHORT   usRegDiscreteStart = REG_DISCRETE_START;

//static 
uint16_t   usRegInputBuf[REG_INPUT_NREGS];
uint16_t    InputBuff[5];  // 这个buf 传递给usRegInputBuf

uint16_t   usRegHoldBuf[REG_HOLD_NREGS];
uint16_t    HoldBuff[10];

static uint8_t  usRegCoilsBuf[REG_COILS_NREGS];

static uint8_t  usRegDiscreteBuf[REG_DISCRETE_NREGS];

void Modbus_Set_HoldingBuff(uint8_t* buf, uint16_t size, uint16_t begin)
{
    /* 设置 Holding 寄存器， usRegHoldBuf , 16 位寄存器 */
    /*  判断是否超长 */
    if (size > 2*(REG_HOLD_NREGS - begin)) 
    {
        return;
    }

    ENTER_CRITICAL_SECTION();
    memcpy( (uint8_t*) (usRegHoldBuf+begin) , buf, size);
    EXIT_CRITICAL_SECTION();
    
}

void Modbus_Task(void * argument)
{
    /* ABCDEF */
		InputBuff[0] = 0x11;
		InputBuff[1] = 0x22;
		InputBuff[2] = 0x33;
		InputBuff[3] = 0x44;
		InputBuff[4] = 0x55;
		InputBuff[5] = 0x66; 


    usRegHoldBuf[0] = 0x99;
    usRegHoldBuf[1] = 0x22;
    usRegHoldBuf[2] = 0x33;
    usRegHoldBuf[3] = 0x44;
    usRegHoldBuf[4] = 0x55;
    usRegHoldBuf[5] = 0x66;
    usRegHoldBuf[6] = 0x77;
    usRegHoldBuf[7] = 0x88;  
    usRegHoldBuf[8] = 0x99;  
    usRegHoldBuf[9] = 0xBB;

    usRegCoilsBuf[0]  = 0;
    usRegCoilsBuf[1]  = 1;
    usRegCoilsBuf[2]  = 1;
    usRegCoilsBuf[3]  =1;

    usRegDiscreteBuf[0]  = 1;
    usRegDiscreteBuf[1]  = 0;
    usRegDiscreteBuf[2]  = 0;
    usRegDiscreteBuf[3]  =1;
 

    eMBInit(MB_RTU, 0x01, 0x00, 9600, MB_PAR_NONE);
    eMBEnable();   
    
    for(;;)
    {
         eMBPoll();
         osDelay(2);
    }
    
}


// /****************************************************************************
// * 名    称：eMBRegInputCB  输入寄存器，如模拟量输入
// * 功    能：读取输入寄存器，对应功能码是 04 eMBFuncReadInputRegister
// * 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
// *            usAddress: 寄存器地址
// *            usNRegs: 要读取的寄存器个数
// * 出口参数：
// * 注    意：上位机发来的 帧格式是: SlaveAddr(1 Byte)+FuncCode(1 Byte)
// *                +StartAddrHiByte(1 Byte)+StartAddrLoByte(1 Byte)
// *                +LenAddrHiByte(1 Byte)+LenAddrLoByte(1 Byte)+
// *                +CRCAddrHiByte(1 Byte)+CRCAddrLoByte(1 Byte)
// 功  能  码：04
// ****************************************************************************/
eMBErrorCode
eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    int             iRegIndex;
	int             i;

        // 动态改变 Input
		// InputBuff[0] = 0x11;
		// InputBuff[1] = 0x22;
		// InputBuff[2] = 0x33;
		// InputBuff[3] = 0x44;
		// InputBuff[4] = 0x55;
		// InputBuff[5] = 0x66;
	
    if( ( usAddress >= REG_INPUT_START )
        && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
    {
        iRegIndex = ( int )( usAddress - usRegInputStart );
				for(i=0;i<usNRegs;i++)
				{
					*pucRegBuffer=InputBuff[i+usAddress-1]>>8;
					pucRegBuffer++;
					*pucRegBuffer=InputBuff[i+usAddress-1]&0xff;
					pucRegBuffer++;
				}
    }
    else
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}

/****************************************************************************
* 名    称：eMBRegHoldingCB  保持寄存器，可读可写
* 功    能：对应功能码有：06 写保持寄存器 eMBFuncWriteHoldingRegister
*                          16 写多个保持寄存器 eMBFuncWriteMultipleHoldingRegister
*                          03 读保持寄存器 eMBFuncReadHoldingRegister
*                          23 读写多个保持寄存器 eMBFuncReadWriteMultipleHoldingRegister
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
*            usAddress: 寄存器地址
*            usNRegs: 要读写的寄存器个数
*            eMode: 功能码
* 出口参数：
* 功  能  码：03  06 16
****************************************************************************/
eMBErrorCode
eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    int             iRegIndex;
    usAddress = usAddress - 1;

    // log_i("eMBRegHoldingCB  eMode %d  usNRegs  %d  usAddress :%d",eMode, usNRegs,usAddress);

    // usRegHoldBuf[0] = 0x99;
    // usRegHoldBuf[1] = 0x22;
    // usRegHoldBuf[2] = 0x33;
    // usRegHoldBuf[3] = 0x44;
    // usRegHoldBuf[4] = 0x55;
    // usRegHoldBuf[5] = 0x66;
    // usRegHoldBuf[6] = 0x77;
    // usRegHoldBuf[7] = 0x88;  
    // usRegHoldBuf[8] = 0x99;  
    // usRegHoldBuf[9] = 0xBB;  

    if((usAddress >= REG_HOLD_START) && ((usAddress+usNRegs) <= (REG_HOLD_START + REG_HOLD_NREGS)))
    {
        iRegIndex = (int)(usAddress - usRegHoldStart);
        switch(eMode)
        {
        case MB_REG_READ://读寄存器
            while(usNRegs > 0)
            {
                *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] >> 8);
                *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] & 0xFF);
                iRegIndex++;
                usNRegs--;
            }
            break;
        case MB_REG_WRITE://写寄存器
            ENTER_CRITICAL_SECTION();
            while(usNRegs > 0)
            {
                // log_i("eMBRegHoldingCB iRegIndex  %d    %02X  %02X ",iRegIndex,(uint8_t)(*pucRegBuffer),(uint8_t)(*(pucRegBuffer+1)));
                // log_i("eMBRegHoldingCB iRegIndex  %d    %02X  %02X ",iRegIndex,(uint8_t)(*pucRegBuffer++ << 8),(uint8_t)(*pucRegBuffer++));
                usRegHoldBuf[iRegIndex] = *pucRegBuffer++ << 8;
                usRegHoldBuf[iRegIndex] |= *pucRegBuffer++;
 
                // log_i("eMBRegHoldingCB   %02X  %02X",(uint8_t)(usRegHoldBuf[iRegIndex] >> 8), (uint8_t)(usRegHoldBuf[iRegIndex] & 0xFF ));
                iRegIndex++;
                usNRegs--;
            }
            EXIT_CRITICAL_SECTION();
 
        }
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    // for (size_t i = 0; i < 10; i++)
    // {
    //     log_i("  i :  %d    val : %04X", i, usRegHoldBuf[i]);
    // }
    
    return eStatus;
}

/****************************************************************************
* 名    称：eMBRegCoilsCB
* 功    能：对应功能码有：01 读线圈 eMBFuncReadCoils
*                          05 写线圈 eMBFuncWriteCoil
*                          15 写多个线圈 eMBFuncWriteMultipleCoils
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
*            usAddress: 线圈地址
*            usNCoils: 要读写的线圈个数
*            eMode: 功能码
* 出口参数：
* 功  能  码：01
*           
****************************************************************************/
 
eMBErrorCode
eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex;
    USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    UCHAR  ucStatus     = 0;
    UCHAR  ucBits       = 0;
    UCHAR  ucDisp       = 0;
    usAddress = usAddress - 1;

    log_i("eMBRegCoilsCB  eMode %d  usNCoils  %d  usAddress :%d",eMode, usNCoils,usAddress);


    if((usAddress >= REG_COILS_START) &&  ((usAddress + usNCoils) <= (REG_COILS_START + REG_COILS_NREGS)))
    {
        iRegIndex = (int)(usAddress - usRegCoilsStart);
        switch(eMode)
        {
        case MB_REG_READ://读线圈
            while(usCoilGroups--)
            {
                ucDisp = 0;
                ucBits = 8;
                while((usNCoils--) != 0 && (ucBits--) != 0)
                {
                    ucStatus |= (usRegCoilsBuf[iRegIndex++] << (ucDisp++));
                }
                *pucRegBuffer++ = ucStatus;
            }
            break;
        case MB_REG_WRITE://写线圈
            // ENTER_CRITICAL_SECTION();
            while(usCoilGroups--)
            {
                ucStatus = *pucRegBuffer++;
                ucBits   = 8;
                while((usNCoils--) != 0 && (ucBits--) != 0)
                {
                    usRegCoilsBuf[iRegIndex++] = ucStatus & 0X01;
                    ucStatus >>= 1;
                }
            }
            // EXIT_CRITICAL_SECTION();
        }
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}
/****************************************************************************
* 名    称：eMBRegDiscreteCB 
* 功    能：读取离散寄存器，对应功能码有：02 读离散寄存器 eMBFuncReadDiscreteInputs
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机   
*            usAddress: 寄存器地址
*            usNDiscrete: 要读取的寄存器个数
* 出口参数：
* 功  能  码：02
****************************************************************************/
eMBErrorCode
eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex;
    USHORT usDiscreteGroups = ((usNDiscrete - 1) / 8 + 1);
    UCHAR  ucStatus     = 0;
    UCHAR  ucBits       = 0;
    UCHAR  ucDisp       = 0;
    usAddress = usAddress - 1;

    log_i("eMBRegDiscreteCB    usAddress :%d  usNDiscrete : %d",  usAddress, usNDiscrete);


    if((usAddress >= REG_DISCRETE_START) &&  ((usAddress + usNDiscrete) <= (REG_DISCRETE_START + REG_DISCRETE_NREGS)))
    {
        iRegIndex = (int)(usAddress - usRegDiscreteStart);
        log_i("eMBRegDiscreteCB    iRegIndex :%d  usNDiscrete : %d",  iRegIndex, usNDiscrete);

        while(usDiscreteGroups--)
        {
            ucDisp = 0;
            ucBits = 8;
            while((usNDiscrete--) != 0 && (ucBits--) != 0)
            {
                log_i("val     :%d   %d ",  iRegIndex, usRegDiscreteBuf[iRegIndex]);
                if(usRegDiscreteBuf[iRegIndex])
                {
                    ucStatus |= (1 << ucDisp);
                }
                iRegIndex++;
                ucDisp++;
            }
            *pucRegBuffer++ = ucStatus;
        }
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}
 

 // ----------------------------------------------------
 

// #include "mb.h"
// #include "mbport.h"
// #include "main.h"

// #if !defined(LOG_TAG)
//     #define LOG_TAG                    "Modbus"
// #endif
// #undef LOG_LVL
// #if defined(XX_LOG_LVL)
//     #define LOG_LVL                    XX_LOG_LVL
// #endif
// #include "elog.h"


// //输入寄存器
// #define REG_INPUT_START  3000
// #define REG_INPUT_NREGS  4

// //保持寄存器
// #define REG_HOLD_START   4000
// #define REG_HOLD_NREGS   10

// //线圈
// #define REG_COILS_START  0
// #define REG_COILS_NREGS  4

// //开关寄存器
// #define REG_DISCRETE_START 1000
// #define REG_DISCRETE_NREGS 4
// /* ----------------------- Static variables ---------------------------------*/
// static USHORT   usRegInputStart = REG_INPUT_START;
// static USHORT   usRegInputBuf[REG_INPUT_NREGS];


// static USHORT   usRegHoldStart = REG_HOLD_START;
// static USHORT   usRegHoldBuf[REG_HOLD_NREGS];

// static USHORT   usRegCoilsStart = REG_COILS_START;
// static uint8_t  usRegCoilsBuf[REG_COILS_NREGS];

// static USHORT   usRegDiscreteStart = REG_DISCRETE_START;
// static uint8_t  usRegDiscreteBuf[REG_DISCRETE_NREGS];

// /** 初始化供调用*/

// void ModbusRTUTask(void const * argument)
// { 
 
//     eMBPoll();           
 
// }


// void ModbusRTUInit(void const * argument)
// { 
//   /* ABCDEF */
//   usRegInputBuf[0] = 11;
//   usRegInputBuf[1] = 22;
//   usRegInputBuf[2] = 33;
//   usRegInputBuf[3] = 44;
//   usRegInputBuf[4] = 55;
//   usRegInputBuf[5] = 66;
//   usRegInputBuf[6] = 77;
//   usRegInputBuf[7] = 88;  
 
// // 初始化modbus为RTU方式，地址0x01, 波特率9600，无校验
//   eMBErrorCode eStatus = eMBInit( MB_RTU, 1, 3, 19200, MB_PAR_NONE );
 
 
// // 使能modbus协议栈
//   eStatus = eMBEnable();
 
// //   log_i("usRegInputBuf 0  8:  %d  %d ", usRegInputBuf[0], usRegInputBuf[7] );
 
// }


// /****************************************************************************
// * 名    称：eMBRegInputCB
// * 功    能：读取输入寄存器，对应功能码是 04 eMBFuncReadInputRegister
// * 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
// *            usAddress: 寄存器地址
// *            usNRegs: 要读取的寄存器个数
// * 出口参数：
// * 注    意：上位机发来的 帧格式是: SlaveAddr(1 Byte)+FuncCode(1 Byte)
// *                +StartAddrHiByte(1 Byte)+StartAddrLoByte(1 Byte)
// *                +LenAddrHiByte(1 Byte)+LenAddrLoByte(1 Byte)+
// *                +CRCAddrHiByte(1 Byte)+CRCAddrLoByte(1 Byte)
// *              3 区
// ****************************************************************************/
// eMBErrorCode
// eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
// {
//     eMBErrorCode    eStatus = MB_ENOERR;
//     int             iRegIndex;
//     usAddress = usAddress - 1;
  
//     if( ( usAddress >= REG_INPUT_START ) && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
//     {
//         iRegIndex = ( int )( usAddress - usRegInputStart );
//         while( usNRegs > 0 )
//         {
//             *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
//             *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
//             iRegIndex++;
//             usNRegs--;
//         }
//     }
//     else
//     {
//         eStatus = MB_ENOREG;
//     }

//     return eStatus;
// }
// /****************************************************************************
// * 名    称：eMBRegHoldingCB
// * 功    能：对应功能码有：06 写保持寄存器 eMBFuncWriteHoldingRegister
// *                          16 写多个保持寄存器 eMBFuncWriteMultipleHoldingRegister
// *                          03 读保持寄存器 eMBFuncReadHoldingRegister
// *                          23 读写多个保持寄存器 eMBFuncReadWriteMultipleHoldingRegister
// * 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
// *            usAddress: 寄存器地址
// *            usNRegs: 要读写的寄存器个数
// *            eMode: 功能码
// * 出口参数：
// * 注    意：4 区
// ****************************************************************************/
// eMBErrorCode
// eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
// {
//     eMBErrorCode    eStatus = MB_ENOERR;
//     int             iRegIndex;
//     usAddress = usAddress - 1;

//     if((usAddress >= REG_HOLD_START) && ((usAddress+usNRegs) <= (REG_HOLD_START + REG_HOLD_NREGS)))
//     {
//         iRegIndex = (int)(usAddress - usRegHoldStart);
//         switch(eMode)
//         {
//         case MB_REG_READ://读寄存器
//             while(usNRegs > 0)
//             {
//                 *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] >> 8);
//                 *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] & 0xFF);
//                 iRegIndex++;
//                 usNRegs--;
//             }
//             break;
//         case MB_REG_WRITE://写寄存器
//             while(usNRegs > 0)
//             {
//                 usRegHoldBuf[iRegIndex] = *pucRegBuffer++ << 8;
//                 usRegHoldBuf[iRegIndex] |= *pucRegBuffer++;
//                 iRegIndex++;
//                 usNRegs--;
//             }
//         }
//     }
//     else//错误
//     {
//         eStatus = MB_ENOREG;
//     }

//     return eStatus;
// }

// /****************************************************************************
// * 名    称：eMBRegCoilsCB
// * 功    能：对应功能码有：01 读线圈 eMBFuncReadCoils
// *                          05 写线圈 eMBFuncWriteCoil
// *                          15 写多个线圈 eMBFuncWriteMultipleCoils
// * 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
// *            usAddress: 线圈地址
// *            usNCoils: 要读写的线圈个数
// *            eMode: 功能码
// * 出口参数：
// * 注    意：如继电器
// *            0 区
// ****************************************************************************/
// eMBErrorCode
// eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
// {
//     eMBErrorCode    eStatus = MB_ENOERR;
//     USHORT          iRegIndex;
//     USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
//     UCHAR  ucStatus     = 0;
//     UCHAR  ucBits       = 0;
//     UCHAR  ucDisp       = 0;
//     usAddress = usAddress - 1;
  
//     if((usAddress >= REG_COILS_START) &&  ((usAddress + usNCoils) <= (REG_COILS_START + REG_COILS_NREGS)))
//     {
//         iRegIndex = (int)(usAddress - usRegCoilsStart);
//         switch(eMode)
//         {
//         case MB_REG_READ://读线圈
//             while(usCoilGroups--)
//             {
//                 ucDisp = 0;
//                 ucBits = 8;
//                 while((usNCoils--) != 0 && (ucBits--) != 0)
//                 {
//                     ucStatus |= (usRegCoilsBuf[iRegIndex++] << (ucDisp++));
//                 }
//                 *pucRegBuffer++ = ucStatus;
//             }
//             break;
//         case MB_REG_WRITE://写线圈
//             while(usCoilGroups--)
//             {
//                 ucStatus = *pucRegBuffer++;
//                 ucBits   = 8;
//                 while((usNCoils--) != 0 && (ucBits--) != 0)
//                 {
//                     usRegCoilsBuf[iRegIndex++] = ucStatus & 0X01;
//                     ucStatus >>= 1;
//                 }
//             }
//         }
//     }
//     else//错误
//     {
//         eStatus = MB_ENOREG;
//     }

//     return eStatus;
// }
// /****************************************************************************
// * 名    称：eMBRegDiscreteCB 
// * 功    能：读取离散寄存器，对应功能码有：02 读离散寄存器 eMBFuncReadDiscreteInputs
// * 入口参数：pucRegBuffer: 数据缓存区，用于响应主机   
// *            usAddress: 寄存器地址
// *            usNDiscrete: 要读取的寄存器个数
// * 出口参数：
// * 注    意：1 区
// ****************************************************************************/
// eMBErrorCode
// eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
// {
//     eMBErrorCode    eStatus = MB_ENOERR;
//     USHORT          iRegIndex;
//     USHORT usDiscreteGroups = ((usNDiscrete - 1) / 8 + 1);
//     UCHAR  ucStatus     = 0;
//     UCHAR  ucBits       = 0;
//     UCHAR  ucDisp       = 0;
//     usAddress = usAddress - 1;
  
//     if((usAddress >= REG_DISCRETE_START) &&  ((usAddress + usNDiscrete) <= (REG_DISCRETE_START + REG_DISCRETE_NREGS)))
//     {
//         iRegIndex = (int)(usAddress - usRegDiscreteStart);

//         while(usDiscreteGroups--)
//         {
//             ucDisp = 0;
//             ucBits = 8;
//             while((usNDiscrete--) != 0 && (ucBits--) != 0)
//             {
//                 if(usRegDiscreteBuf[iRegIndex])
//                 {
//                     ucStatus |= (1 << ucDisp);
//                 }
//                 ucDisp++;
//             }
//             *pucRegBuffer++ = ucStatus;
//         }
//     }
//     else//错误
//     {
//         eStatus = MB_ENOREG;
//     }

//     return eStatus;
// }
 

// // extern UART_HandleTypeDef huart2; // 引入串口

// // // 十路输入寄存器
// // #define REG_INPUT_SIZE 10
// // uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];

// // // 十路保持寄存器
// // #define REG_HOLDING_START 0x0000
// // #define REG_HOLD_SIZE 8
// // // uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
// // uint16_t usRegHoldingBuf[REG_HOLD_SIZE] = {0x147b, 0x3f8e, 0x147b, 0x400e, 0x1eb8, 0x4055, 0x147b, 0x408e};

// // // 十路线圈
// // #define REG_COILS_SIZE 10
// // uint8_t REG_COILS_BUF[REG_COILS_SIZE] = {1, 1, 1, 1, 0, 0, 0, 0, 1, 1};

// // // 十路离散量
// // #define REG_DISC_SIZE 10
// // uint8_t REG_DISC_BUF[REG_DISC_SIZE] = {1, 1, 1, 1, 0, 0, 0, 0, 1, 1};

// // /// CMD4命令处理回调函数
// // eMBErrorCode eMBRegInputCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs)
// // {
// //     USHORT usRegIndex = usAddress - 1;

// //     // 非法检测
// //     if ((usRegIndex + usNRegs) > REG_INPUT_SIZE)
// //     {
// //         return MB_ENOREG;
// //     }

// //     // 循环读取
// //     while (usNRegs > 0)
// //     {
// //         *pucRegBuffer++ = (unsigned char)(REG_INPUT_BUF[usRegIndex] >> 8);
// //         *pucRegBuffer++ = (unsigned char)(REG_INPUT_BUF[usRegIndex] & 0xFF);
// //         usRegIndex++;
// //         usNRegs--;
// //     }

// //     // 模拟输入寄存器被改变
// //     for (usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
// //     {
// //         REG_INPUT_BUF[usRegIndex]++;
// //     }

// //     return MB_ENOERR;
// // }

// // /// CMD6、3、16命令处理回调函数
// // eMBErrorCode eMBRegHoldingCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode)
// // {
// //     // 错误状态
// //     eMBErrorCode eStatus = MB_ENOERR;
// //     // 偏移量
// //     int16_t iRegIndex;

// //     // 判断寄存器是不是在范围内
// //     if (((int16_t)usAddress >= REG_HOLDING_START) && (usAddress + usNRegs <= REG_HOLDING_START + REG_HOLD_SIZE))
// //     {
// //         // 计算偏移量
// //         iRegIndex = (int16_t)(usAddress - REG_HOLDING_START);

// //         switch (eMode)
// //         {
// //         // 读处理函数
// //         case MB_REG_READ:
// //             while (usNRegs > 0)
// //             {
// //                 *pucRegBuffer++ = (uint8_t)(usRegHoldingBuf[iRegIndex] >> 8);
// //                 *pucRegBuffer++ = (uint8_t)(usRegHoldingBuf[iRegIndex] & 0xFF);
// //                 iRegIndex++;
// //                 usNRegs--;
// //             }
// //             break;

// //         // 写处理函数
// //         case MB_REG_WRITE:
// //             while (usNRegs > 0)
// //             {
// //                 usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
// //                 usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
// //                 iRegIndex++;
// //                 usNRegs--;
// //             }
// //             break;
// //         }
// //     }
// //     else
// //     {
// //         // 返回错误状态
// //         eStatus = MB_ENOREG;
// //     }

// //     return eStatus;
// //     // USHORT usRegIndex = usAddress - 1;

// //     // // 非法检测
// //     // if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
// //     // {
// //     //     return MB_ENOREG;
// //     // }

// //     // // 写寄存器
// //     // if(eMode == MB_REG_WRITE)
// //     // {
// //     //     while( usNRegs > 0 )
// //     //     {
// //     //         usRegHoldingBuf[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
// //     //         pucRegBuffer += 2;
// //     //         usRegIndex++;
// //     //         usNRegs--;
// //     //     }
// //     // }

// //     // // 读寄存器
// //     // else
// //     // {
// //     //     while( usNRegs > 0 )
// //     //     {
// //     //         *pucRegBuffer++ = ( unsigned char )( usRegHoldingBuf[usRegIndex] >> 8 );
// //     //         *pucRegBuffer++ = ( unsigned char )( usRegHoldingBuf[usRegIndex] & 0xFF );
// //     //         usRegIndex++;
// //     //         usNRegs--;
// //     //     }
// //     // }

// //     // return MB_ENOERR;
// // }

// // /// CMD1、5、15命令处理回调函数
// // eMBErrorCode eMBRegCoilsCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode)
// // {
// //     USHORT usRegIndex = usAddress - 1;
// //     UCHAR ucBits = 0;
// //     UCHAR ucState = 0;
// //     UCHAR ucLoops = 0;

// //     // 非法检测
// //     if ((usRegIndex + usNCoils) > REG_COILS_SIZE)
// //     {
// //         return MB_ENOREG;
// //     }

// //     if (eMode == MB_REG_WRITE)
// //     {
// //         ucLoops = (usNCoils - 1) / 8 + 1;
// //         while (ucLoops != 0)
// //         {
// //             ucState = *pucRegBuffer++;
// //             ucBits = 0;
// //             while (usNCoils != 0 && ucBits < 8)
// //             {
// //                 REG_COILS_BUF[usRegIndex++] = (ucState >> ucBits) & 0X01;
// //                 usNCoils--;
// //                 ucBits++;
// //             }
// //             ucLoops--;
// //         }
// //     }
// //     else
// //     {
// //         ucLoops = (usNCoils - 1) / 8 + 1;
// //         while (ucLoops != 0)
// //         {
// //             ucState = 0;
// //             ucBits = 0;
// //             while (usNCoils != 0 && ucBits < 8)
// //             {
// //                 if (REG_COILS_BUF[usRegIndex])
// //                 {
// //                     ucState |= (1 << ucBits);
// //                 }
// //                 usNCoils--;
// //                 usRegIndex++;
// //                 ucBits++;
// //             }
// //             *pucRegBuffer++ = ucState;
// //             ucLoops--;
// //         }
// //     }

// //     return MB_ENOERR;
// // }

// // /// CMD2命令处理回调函数
// // eMBErrorCode eMBRegDiscreteCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNDiscrete)
// // {
// //     USHORT usRegIndex = usAddress - 1;
// //     UCHAR ucBits = 0;
// //     UCHAR ucState = 0;
// //     UCHAR ucLoops = 0;

// //     // 非法检测
// //     if ((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
// //     {
// //         return MB_ENOREG;
// //     }

// //     ucLoops = (usNDiscrete - 1) / 8 + 1;
// //     while (ucLoops != 0)
// //     {
// //         ucState = 0;
// //         ucBits = 0;
// //         while (usNDiscrete != 0 && ucBits < 8)
// //         {
// //             if (REG_DISC_BUF[usRegIndex])
// //             {
// //                 ucState |= (1 << ucBits);
// //             }
// //             usNDiscrete--;
// //             usRegIndex++;
// //             ucBits++;
// //         }
// //         *pucRegBuffer++ = ucState;
// //         ucLoops--;
// //     }

// //     // 模拟离散量输入被改变
// //     for (usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
// //     {
// //         REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
// //     }

// //     return MB_ENOERR;
// // }

