[MM32生态] MM32F3270通讯板之通过RS485接口实现Modbus协议传输

int eMBDemoInit(void)

{

    eMBErrorCode eStatus;



    eStatus = eMBInit(MB_RTU, 0x0A, 0, 115200, MB_PAR_NONE);



    /* Enable the Modbus Protocol Stack. */

    if(eStatus == MB_ENOERR)

    {

        eStatus = eMBEnable();

    }



    return eStatus;

}

void vMBPortSerialEnable(BOOL xRxEnable, BOOL xTxEnable)

{

    if(xRxEnable) UART_ITConfig(UART4, UART_IT_RXIEN, ENABLE);

    else          UART_ITConfig(UART4, UART_IT_RXIEN, DISABLE);



    if(xTxEnable) UART_ITConfig(UART4, UART_IT_TXIEN, ENABLE);

    else          UART_ITConfig(UART4, UART_IT_TXIEN, DISABLE);

}



BOOL xMBPortSerialInit(UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity)

{

    GPIO_InitTypeDef GPIO_InitStructure;

    NVIC_InitTypeDef NVIC_InitStructure;

    UART_InitTypeDef UART_InitStructure;



    RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOC,   ENABLE);

    RCC_APB1PeriphClockCmd(RCC_APB1ENR_UART4, ENABLE);



    NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);



    UART_StructInit(&UART_InitStructure);

    UART_InitStructure.UART_BaudRate = ulBaudRate;



    switch(ucDataBits)

    {

        case 5 : UART_InitStructure.UART_WordLength = UART_WordLength_5b; break;

        case 6 : UART_InitStructure.UART_WordLength = UART_WordLength_6b; break;

        case 7 : UART_InitStructure.UART_WordLength = UART_WordLength_7b; break;

        case 8 : UART_InitStructure.UART_WordLength = UART_WordLength_8b; break;

        default: UART_InitStructure.UART_WordLength = UART_WordLength_8b; break;

    }



    UART_InitStructure.UART_StopBits = UART_StopBits_1;



    switch(eParity)

    {

        case MB_PAR_NONE: UART_InitStructure.UART_Parity = UART_Parity_No;   break;

        case MB_PAR_ODD : UART_InitStructure.UART_Parity = UART_Parity_Odd;  break;

        case MB_PAR_EVEN: UART_InitStructure.UART_Parity = UART_Parity_Even; break;

        default         : UART_InitStructure.UART_Parity = UART_Parity_No;   break;

    }



    UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_None;

    UART_InitStructure.UART_Mode = UART_Mode_Rx | UART_Mode_Tx;

    UART_Init(UART4, &UART_InitStructure);



    UART_Cmd(UART4, ENABLE);



    GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_8);

    GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_8);



    GPIO_StructInit(&GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOC, &GPIO_InitStructure);



    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_11;

    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOC, &GPIO_InitStructure);



    return TRUE;

}



BOOL xMBPortSerialPutByte(CHAR ucByte)

{

    UART_SendData(UART4, ucByte);



    return TRUE;

}



BOOL xMBPortSerialGetByte(CHAR * pucByte)

{

    *pucByte = UART_ReceiveData(UART4);



    return TRUE;

}



static void prvvUARTTxReadyISR(void)

{

    pxMBFrameCBTransmitterEmpty();

}



static void prvvUARTRxISR(void)

{

    pxMBFrameCBByteReceived();

}



void UART4_IRQHandler(void)

{

    if(UART_GetITStatus(UART4, UART_IT_RXIEN) != RESET)

    {

        prvvUARTRxISR();



        UART_ClearITPendingBit(UART4, UART_IT_RXIEN);

    }



    if(UART_GetITStatus(UART4, UART_IT_TXIEN) != RESET)

    {

        prvvUARTTxReadyISR();



        UART_ClearITPendingBit(UART4, UART_IT_TXIEN);

    }

}

BOOL xMBPortTimersInit(USHORT usTim1Timerout50us)

{

    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;

    NVIC_InitTypeDef        NVIC_InitStructure;



    RCC_ClocksTypeDef  RCC_Clocks;

    RCC_GetClocksFreq(&RCC_Clocks);



    RCC_APB1PeriphClockCmd(RCC_APB1ENR_TIM2, ENABLE);



    TIM_TimeBaseStructInit(&TIM_TimeBaseInitStructure);

    TIM_TimeBaseInitStructure.TIM_Prescaler = (RCC_Clocks.PCLK1_Frequency / 1000000 - 1);

    TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;

    TIM_TimeBaseInitStructure.TIM_Period = 500 - 1;

    TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;

    TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;

    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);



    NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);



    TIM_ClearFlag(TIM2, TIM_FLAG_Update);

    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);



    return TRUE;

}



inline void vMBPortTimersEnable(void)

{

    TIM_SetCounter(TIM2, 0);

    TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

    TIM_Cmd(TIM2, ENABLE);

}



inline void vMBPortTimersDisable(void)

{

    TIM_Cmd(TIM2, DISABLE);

    TIM_SetCounter(TIM2, 0);

    TIM_ClearITPendingBit(TIM2, TIM_IT_Update);



}



static void prvvTIMERExpiredISR(void)

{

    (void)pxMBPortCBTimerExpired();

}



void TIM2_IRQHandler(void)

{

    prvvTIMERExpiredISR();

    TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

}

void eMBPollHandler(void)

{

    (void)eMBPoll();

}



eMBErrorCode eMBPoll( void )

{

    static UCHAR   *ucMBFrame;

    static UCHAR    ucRcvAddress;

    static UCHAR    ucFunctionCode;

    static USHORT   usLength;

    static eMBException eException;



    int             i;

    eMBErrorCode    eStatus = MB_ENOERR;

    eMBEventType    eEvent;



    /* Check if the protocol stack is ready. */

    if( eMBState != STATE_ENABLED )

    {

        return MB_EILLSTATE;

    }



    /* Check if there is a event available. If not return control to caller.

     * Otherwise we will handle the event. */

    if( xMBPortEventGet( &eEvent ) == TRUE )

    {

        switch ( eEvent )

        {

        case EV_READY:

            break;



        case EV_FRAME_RECEIVED:

            eStatus = peMBFrameReceiveCur( &ucRcvAddress, &ucMBFrame, &usLength );

            if( eStatus == MB_ENOERR )

            {

                /* Check if the frame is for us. If not ignore the frame. */

                if( ( ucRcvAddress == ucMBAddress ) || ( ucRcvAddress == MB_ADDRESS_BROADCAST ) )

                {

                    ( void )xMBPortEventPost( EV_EXECUTE );

                }

            }

            break;



        case EV_EXECUTE:

            ucFunctionCode = ucMBFrame[MB_PDU_FUNC_OFF];

            eException = MB_EX_ILLEGAL_FUNCTION;

            for( i = 0; i < MB_FUNC_HANDLERS_MAX; i++ )

            {

                /* No more function handlers registered. Abort. */

                if( xFuncHandlers[i].ucFunctionCode == 0 )

                {

                    break;

                }

                else if( xFuncHandlers[i].ucFunctionCode == ucFunctionCode )

                {

                    eException = xFuncHandlers[i].pxHandler( ucMBFrame, &usLength );

                    break;

                }

            }



            /* If the request was not sent to the broadcast address we

             * return a reply. */

            if( ucRcvAddress != MB_ADDRESS_BROADCAST )

            {

                if( eException != MB_EX_NONE )

                {

                    /* An exception occured. Build an error frame. */

                    usLength = 0;

                    ucMBFrame[usLength++] = ( UCHAR )( ucFunctionCode | MB_FUNC_ERROR );

                    ucMBFrame[usLength++] = eException;

                }

                if( ( eMBCurrentMode == MB_ASCII ) && MB_ASCII_TIMEOUT_WAIT_BEFORE_SEND_MS )

                {

                    vMBPortTimersDelay( MB_ASCII_TIMEOUT_WAIT_BEFORE_SEND_MS );

                }                

                eStatus = peMBFrameSendCur( ucMBAddress, ucMBFrame, usLength );

            }

            break;



        case EV_FRAME_SENT:

            break;

        }

    }

    return MB_ENOERR;

}

#define REG_INPUT_START     10001

#define REG_INPUT_NREGS     4



static USHORT usRegInputBuffer[REG_INPUT_NREGS] =

{

    0x0123, 0x4567, 0x89AB, 0xCDEF,

};



#define REG_HOLDING_START   40001

#define REG_HOLDING_NREGS   16



static USHORT usRegHoldingBuffer[REG_HOLDING_NREGS] =

{

    0x0000, 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777,

    0x8888, 0x9999, 0xAAAA, 0xBBBB, 0xCCCC, 0xDDDD, 0xEEEE, 0xFFFF,

};



eMBErrorCode eMBRegInputCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs)

{

    eMBErrorCode eStatus = MB_ENOERR;

    int iRegIndex;



    usAddress -= 1;



    if((usAddress           >= REG_INPUT_START) &&

       (usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS))

    {

        iRegIndex = (int)(usAddress - REG_INPUT_START);



        while(usNRegs-- > 0)

        {

            *pucRegBuffer++ = (unsigned char)(usRegInputBuffer[iRegIndex] >> 0x08);

            *pucRegBuffer++ = (unsigned char)(usRegInputBuffer[iRegIndex]  & 0xFF);

            iRegIndex++;

        }

    }

    else

    {

        eStatus = MB_ENOREG;

    }



    return eStatus;

}





eMBErrorCode eMBRegHoldingCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode)

{

    eMBErrorCode eStatus = MB_ENOERR;

    USHORT usData;

    int iRegIndex;



    usAddress -= 1;



    if((usAddress           >= REG_HOLDING_START) &&

       (usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS))

    {

        iRegIndex = (int)(usAddress - REG_HOLDING_START);



        switch(eMode)

        {

            case MB_REG_READ:

                while(usNRegs-- > 0)

                {

                    *pucRegBuffer++ = (unsigned char)(usRegHoldingBuffer[iRegIndex] >> 0x08);

                    *pucRegBuffer++ = (unsigned char)(usRegHoldingBuffer[iRegIndex]  & 0xFF);

                    iRegIndex++;

                }

                break;



            case MB_REG_WRITE:

                while(usNRegs-- > 0)

                {

                    usData   = *pucRegBuffer++;

                    usData <<= 0x08;

                    usData  |= *pucRegBuffer++;



                    usRegHoldingBuffer[iRegIndex++] = usData;

                }

                break;



            default:

                break;

        }

    }

    else

    {

        eStatus = MB_ENOREG;

    }



    return eStatus;

}





eMBErrorCode eMBRegCoilsCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode)

{

    eMBErrorCode eStatus = MB_ENOERR;



    return eStatus;

}





eMBErrorCode eMBRegDiscreteCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNDiscrete)

{

    eMBErrorCode eStatus = MB_ENOERR;



    return eStatus;

}