本篇主要介绍main函数以及mb.c文件，通过这两部分，我们能够从整体上分析FreeModbus。
打开FreeModbus文件夹中的demo文件夹，该文件夹下是各个平台下的demo，这里我们选择AVR平台来分析。 打开AVR文件夹下的demo.c文件，main函数代码如下：
int main( void ) { const UCHAR ucSlaveID[] = { 0xAA, 0xBB, 0xCC }; eMBErrorCode eStatus; eStatus = eMBInit( MB_RTU, 0x0A, 0, 38400, MB_PAR_EVEN ); eStatus = eMBSetSlaveID( 0x34, TRUE, ucSlaveID, 3 ); sei( ); /* Enable the Modbus Protocol Stack. */ eStatus = eMBEnable( ); for( ;; ) { ( void )eMBPoll( ); /* Here we simply count the number of poll cycles. */ usRegInputBuf[0]++; } }要想使用FreeModbus，这里只要调用三个函数即可，即eMBInit()、eMBEnable()、eMBPoll()三个函数，这三个函数的功能如下：
名称功能eMBInit()完成MODBUS的初始化配置eMBEnable()使能Modbus协议栈eMBPoll()轮询Modbus的数据接收，并进行数据的处理，这个函数需要循环调用在主函数中调用上面三个函数，即可完成Modbus的使用。是不是很简单。在系统上电后先初始化协议栈，然后使能协议栈，最后在一个循环中循环调用eMBPoll()函数即可。其他的函数我们暂时不讨论，等到最后移植的时候再来看，我们现在只关注主干部分。关于这三个函数具体怎么实现的，我们来看一下mb.c文件。
打开mb.c文件，代码如下：
/* * FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU. * Copyright (c) 2006-2018 Christian Walter <cwalter@embedded-solutions.at> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ /* ----------------------- System includes ----------------------------------*/ #include "stdlib.h" #include "string.h" /* ----------------------- Platform includes --------------------------------*/ #include "port.h" /* ----------------------- Modbus includes ----------------------------------*/ #include "mb.h" #include "mbconfig.h" #include "mbframe.h" #include "mbproto.h" #include "mbfunc.h" #include "mbport.h" #if MB_RTU_ENABLED == 1 #include "mbrtu.h" #endif #if MB_ASCII_ENABLED == 1 #include "mbascii.h" #endif #if MB_TCP_ENABLED == 1 #include "mbtcp.h" #endif #ifndef MB_PORT_HAS_CLOSE #define MB_PORT_HAS_CLOSE 0 #endif /* ----------------------- Static variables ---------------------------------*/ static UCHAR ucMBAddress; static eMBMode eMBCurrentMode; static enum { STATE_ENABLED, STATE_DISABLED, STATE_NOT_INITIALIZED } eMBState = STATE_NOT_INITIALIZED; /* Functions pointer which are initialized in eMBInit( ). Depending on the * mode (RTU or ASCII) the are set to the correct implementations. */ static peMBFrameSend peMBFrameSendCur; static pvMBFrameStart pvMBFrameStartCur; static pvMBFrameStop pvMBFrameStopCur; static peMBFrameReceive peMBFrameReceiveCur; static pvMBFrameClose pvMBFrameCloseCur; /* Callback functions required by the porting layer. They are called when * an external event has happend which includes a timeout or the reception * or transmission of a character. */ BOOL( *pxMBFrameCBByteReceived ) ( void ); BOOL( *pxMBFrameCBTransmitterEmpty ) ( void ); BOOL( *pxMBPortCBTimerExpired ) ( void ); BOOL( *pxMBFrameCBReceiveFSMCur ) ( void ); BOOL( *pxMBFrameCBTransmitFSMCur ) ( void ); /* An array of Modbus functions handlers which associates Modbus function * codes with implementing functions. */ static xMBFunctionHandler xFuncHandlers[MB_FUNC_HANDLERS_MAX] = { #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED > 0 {MB_FUNC_OTHER_REPORT_SLAVEID, eMBFuncReportSlaveID}, #endif #if MB_FUNC_READ_INPUT_ENABLED > 0 {MB_FUNC_READ_INPUT_REGISTER, eMBFuncReadInputRegister}, #endif #if MB_FUNC_READ_HOLDING_ENABLED > 0 {MB_FUNC_READ_HOLDING_REGISTER, eMBFuncReadHoldingRegister}, #endif #if MB_FUNC_WRITE_MULTIPLE_HOLDING_ENABLED > 0 {MB_FUNC_WRITE_MULTIPLE_REGISTERS, eMBFuncWriteMultipleHoldingRegister}, #endif #if MB_FUNC_WRITE_HOLDING_ENABLED > 0 {MB_FUNC_WRITE_REGISTER, eMBFuncWriteHoldingRegister}, #endif #if MB_FUNC_READWRITE_HOLDING_ENABLED > 0 {MB_FUNC_READWRITE_MULTIPLE_REGISTERS, eMBFuncReadWriteMultipleHoldingRegister}, #endif #if MB_FUNC_READ_COILS_ENABLED > 0 {MB_FUNC_READ_COILS, eMBFuncReadCoils}, #endif #if MB_FUNC_WRITE_COIL_ENABLED > 0 {MB_FUNC_WRITE_SINGLE_COIL, eMBFuncWriteCoil}, #endif #if MB_FUNC_WRITE_MULTIPLE_COILS_ENABLED > 0 {MB_FUNC_WRITE_MULTIPLE_COILS, eMBFuncWriteMultipleCoils}, #endif #if MB_FUNC_READ_DISCRETE_INPUTS_ENABLED > 0 {MB_FUNC_READ_DISCRETE_INPUTS, eMBFuncReadDiscreteInputs}, #endif }; /* ----------------------- Start implementation -----------------------------*/ eMBErrorCode eMBInit( eMBMode eMode, UCHAR ucSlaveAddress, UCHAR ucPort, ULONG ulBaudRate, eMBParity eParity ) { eMBErrorCode eStatus = MB_ENOERR; /* check preconditions */ if( ( ucSlaveAddress == MB_ADDRESS_BROADCAST ) || ( ucSlaveAddress < MB_ADDRESS_MIN ) || ( ucSlaveAddress > MB_ADDRESS_MAX ) ) { eStatus = MB_EINVAL; } else { ucMBAddress = ucSlaveAddress; switch ( eMode ) { #if MB_RTU_ENABLED > 0 case MB_RTU: pvMBFrameStartCur = eMBRTUStart; pvMBFrameStopCur = eMBRTUStop; peMBFrameSendCur = eMBRTUSend; peMBFrameReceiveCur = eMBRTUReceive; pvMBFrameCloseCur = MB_PORT_HAS_CLOSE ? vMBPortClose : NULL; pxMBFrameCBByteReceived = xMBRTUReceiveFSM; pxMBFrameCBTransmitterEmpty = xMBRTUTransmitFSM; pxMBPortCBTimerExpired = xMBRTUTimerT35Expired; eStatus = eMBRTUInit( ucMBAddress, ucPort, ulBaudRate, eParity ); break; #endif #if MB_ASCII_ENABLED > 0 case MB_ASCII: pvMBFrameStartCur = eMBASCIIStart; pvMBFrameStopCur = eMBASCIIStop; peMBFrameSendCur = eMBASCIISend; peMBFrameReceiveCur = eMBASCIIReceive; pvMBFrameCloseCur = MB_PORT_HAS_CLOSE ? vMBPortClose : NULL; pxMBFrameCBByteReceived = xMBASCIIReceiveFSM; pxMBFrameCBTransmitterEmpty = xMBASCIITransmitFSM; pxMBPortCBTimerExpired = xMBASCIITimerT1SExpired; eStatus = eMBASCIIInit( ucMBAddress, ucPort, ulBaudRate, eParity ); break; #endif default: eStatus = MB_EINVAL; } if( eStatus == MB_ENOERR ) { if( !xMBPortEventInit( ) ) { /* port dependent event module initalization failed. */ eStatus = MB_EPORTERR; } else { eMBCurrentMode = eMode; eMBState = STATE_DISABLED; } } } return eStatus; } #if MB_TCP_ENABLED > 0 eMBErrorCode eMBTCPInit( USHORT ucTCPPort ) { eMBErrorCode eStatus = MB_ENOERR; if( ( eStatus = eMBTCPDoInit( ucTCPPort ) ) != MB_ENOERR ) { eMBState = STATE_DISABLED; } else if( !xMBPortEventInit( ) ) { /* Port dependent event module initalization failed. */ eStatus = MB_EPORTERR; } else { pvMBFrameStartCur = eMBTCPStart; pvMBFrameStopCur = eMBTCPStop; peMBFrameReceiveCur = eMBTCPReceive; peMBFrameSendCur = eMBTCPSend; pvMBFrameCloseCur = MB_PORT_HAS_CLOSE ? vMBTCPPortClose : NULL; ucMBAddress = MB_TCP_PSEUDO_ADDRESS; eMBCurrentMode = MB_TCP; eMBState = STATE_DISABLED; } return eStatus; } #endif eMBErrorCode eMBRegisterCB( UCHAR ucFunctionCode, pxMBFunctionHandler pxHandler ) { int i; eMBErrorCode eStatus; if( ( 0 < ucFunctionCode ) && ( ucFunctionCode <= 127 ) ) { ENTER_CRITICAL_SECTION( ); if( pxHandler != NULL ) { for( i = 0; i < MB_FUNC_HANDLERS_MAX; i++ ) { if( ( xFuncHandlers[i].pxHandler == NULL ) || ( xFuncHandlers[i].pxHandler == pxHandler ) ) { xFuncHandlers[i].ucFunctionCode = ucFunctionCode; xFuncHandlers[i].pxHandler = pxHandler; break; } } eStatus = ( i != MB_FUNC_HANDLERS_MAX ) ? MB_ENOERR : MB_ENORES; } else { for( i = 0; i < MB_FUNC_HANDLERS_MAX; i++ ) { if( xFuncHandlers[i].ucFunctionCode == ucFunctionCode ) { xFuncHandlers[i].ucFunctionCode = 0; xFuncHandlers[i].pxHandler = NULL; break; } } /* Remove can't fail. */ eStatus = MB_ENOERR; } EXIT_CRITICAL_SECTION( ); } else { eStatus = MB_EINVAL; } return eStatus; } eMBErrorCode eMBClose( void ) { eMBErrorCode eStatus = MB_ENOERR; if( eMBState == STATE_DISABLED ) { if( pvMBFrameCloseCur != NULL ) { pvMBFrameCloseCur( ); } } else { eStatus = MB_EILLSTATE; } return eStatus; } eMBErrorCode eMBEnable( void ) { eMBErrorCode eStatus = MB_ENOERR; if( eMBState == STATE_DISABLED ) { /* Activate the protocol stack. */ pvMBFrameStartCur( ); eMBState = STATE_ENABLED; } else { eStatus = MB_EILLSTATE; } return eStatus; } eMBErrorCode eMBDisable( void ) { eMBErrorCode eStatus; if( eMBState == STATE_ENABLED ) { pvMBFrameStopCur( ); eMBState = STATE_DISABLED; eStatus = MB_ENOERR; } else if( eMBState == STATE_DISABLED ) { eStatus = MB_ENOERR; } else { eStatus = MB_EILLSTATE; } return eStatus; } 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; }下面我们详细地分析一下这个文件。
ucMBAddress变量存储了modbus的从机地址，改地址用一个无符号字符型的变量来表示，可以表示的数据范围为0～255；
eMBCurrentMode用来表示当前modbus协议栈的类型，modbus协议栈的类型有三种，由如下枚举类型定义，该定义在mb.h文件中。
typedef enum { MB_RTU, /*!< RTU transmission mode. */ MB_ASCII, /*!< ASCII transmission mode. */ MB_TCP /*!< TCP mode. */ } eMBMode;从上面的定义，我们可以看出，FreeModbus协议共支持三种类型的modbus协议，分别是MODBUS-RTU、MODBUS-ASCII和MODBUS-TCP。
下面看一下static xMBFunctionHandler xFuncHandlers[MB_FUNC_HANDLERS_MAX]，这是一个xMBFunctionHandler类型的数组，这个数组共有MB_FUNC_HANDLERS_MAX个元素。先来看一下数据类型xMBFunctionHandler，它的定义在mbproto.h文件中，定义如下：
typedef eMBException( *pxMBFunctionHandler ) ( UCHAR * pucFrame, USHORT * pusLength ); typedef struct { UCHAR ucFunctionCode; pxMBFunctionHandler pxHandler; } xMBFunctionHandler;先看上面第一行定义的函数指针，这个函数指针的输入参数是一个uchar类型的指针和一个ushort类型的指针。通过名字可以判断出，这两个指针分别指向modbus接收到的数据帧的首地址和接受到的数据长度，由此可以判断这个函数指针指向modbus数据帧的处理函数。 下面的结构体有两个成员，一个是功能码，另一个就是指向这个功能码具体处理函数的指针。 因此可以看出，mb.c中定义的数组存储了一个个功能码和其相应的处理函数。数组的长度由一个宏来定义，这个宏在mbconfig.h文件中，可以由我们来配置，默认值是16。
上面的五个函数指针的定义在mbframe.h中，定义如下：
/* ----------------------- Prototypes 0-------------------------------------*/ typedef void ( *pvMBFrameStart ) ( void ); typedef void ( *pvMBFrameStop ) ( void ); typedef eMBErrorCode( *peMBFrameReceive ) ( UCHAR * pucRcvAddress, UCHAR ** pucFrame, USHORT * pusLength ); typedef eMBErrorCode( *peMBFrameSend ) ( UCHAR slaveAddress, const UCHAR * pucFrame, USHORT usLength ); typedef void( *pvMBFrameClose ) ( void );前面五个函数是在mb.c文件中使用的，这里为什么使用指针而不是直接使用具体的函数的主要原因就是modbus有三种类型的协议，RTU、ASCII和TCP，而mb.c主要是一个框架，包含三种协议，mb.c实现了通用的部分，而把每个协议具体的实现细节交给具体的协议里面的文件去实现，这样就把上层和底层分离开了。
下面几个是回调函数，也是指针，作用和上面相同，这里就不说了。
mb.c主要实现了7个函数，先用表格简单描述一下这几个函数的功能。
函数名功能eMBInit()主要实现modbus协议栈的初始化，这里主要初始化MODBUS-RTU和MODBUS-ASCII，不包括MODBUS-TCPeMBTCPInit()主要完成MODBUS-TCP的初始化eMBRegisterCB()注册新的功能码和相应的处理函数到功能码数组中，便于我们扩展eMBClose()关闭modbus协议栈eMBEnable()使能modbus协议栈eMBDisable()禁止modbus协议栈eMBPoll()modbus轮询函数，主要完成事件的查询和相关处理函数的调用该函数的接收参数为modbus的工作模式、从机地址、端口号、波特率、奇偶校验设置。 函数进来之后首先检查设置的地址合法性，如果设置的地址为广播地址或者不在最小地址和最大地址范围之内，则返回故障。如果地址正确，则将地址设置到Modbus的地址当中。然后根据Modbus的设置模式，将Modbus的处理函数和RTU或者ASCII的函数关联起来。然后初始化串口控制器和事件控制器。这里的串口控制器和事件控制器的具体细节后面再进行讨论，先看Modbus的主框架。
eMBTCPInit()函数和eMBInit()函数类似，一个是初始化RTU和ASCII协议，一个是初始化TCP协议。这里eMBTCPInit()函数初始化TCP协议栈。过程和RTU与ASCII相同，只是传递的参数不同。这里不再重复说明。简单了解一下即可。
这个函数主要是注册或者取消注册Modbus协议的功能码和相应的处理函数的。和上面的xFuncHandlers[]数组息息相关。当传入的函数指针为NULL的时候，注销功能码和它的处理函数，当传入的函数指针非NULL的时候，将功能码和处理函数注册如xFuncHandlers数组。
该函数主要是关闭串口传输，当不再使用协议的时候，可以关闭。
该函数主要是使能UART的接收中断和开启定时器。接收中断用来接收主栈发送过来的数据，定时器用来进行超时检测。
该函数和eMBEnable()函数功能相反，用来关闭UART接收中断和发送中断，关闭定时器。
这是modbus协议的最主要的函数，该函数对事件进行轮询，当接收到数据的时候进行处理。看一下这个函数。 函数首先判断Modbus协议是否使能，如果没有使能，则返回故障。接下来查询Modbus的事件。当系统识别到接收完成事件的时候，进行数据的接收。接受完数据之后，判断是否需要处理（地址是自己的地址或者是广播地址），如果需要处理，则发送一个执行事件，否则就不做处理。系统获取到处理事件的时候，进入数据处理过程。首先从接收到的数据中获取到功能码，然后查找功能码表（上面说到的xFuncHandlers数组），然后嗲用相应功能码的处理函数进行数据处理。数据处理完之后，判断是否需要发送返回帧，如果不是广播地址就需要返回，如果错误，返回的功能码最高位置1，没有错误，则调用发送函数，将返回帧发送出去。
本篇主要简单介绍了main函数和mb.c文件，介绍的并不是很详细，本人也是刚接触FreeModbus，有错误之处请见谅。
