FreeModbus移植到STM32F107(以太网传输方式)

1.创建工程

FreeModbus移植到STM32F107(以太网传输方式)_第1张图片

FreeModbus移植到STM32F107(以太网传输方式)_第2张图片

FreeModbus移植到STM32F107(以太网传输方式)_第3张图片

 

FreeModbus移植到STM32F107(以太网传输方式)_第4张图片

FreeModbus移植到STM32F107(以太网传输方式)_第5张图片

FreeModbus移植到STM32F107(以太网传输方式)_第6张图片

FreeModbus移植到STM32F107(以太网传输方式)_第7张图片

FreeModbus移植到STM32F107(以太网传输方式)_第8张图片

配置好之后生成工程

FreeModbus移植到STM32F107(以太网传输方式)_第9张图片

 

2.将FreeModbus源码,拷贝到工程目录

FreeModbus移植到STM32F107(以太网传输方式)_第10张图片

FreeModbus移植到STM32F107(以太网传输方式)_第11张图片

 

3.将FreeModbus文件添加进工程

FreeModbus移植到STM32F107(以太网传输方式)_第12张图片

FreeModbus移植到STM32F107(以太网传输方式)_第13张图片

打开mbtcp.c文件发现,受MB_TCP_ENABLED宏定义的影响,所有代码都是灰的

FreeModbus移植到STM32F107(以太网传输方式)_第14张图片

因此跳转到宏定义的地方。打开TCP模式,并将RTU和ASCII模式关闭

FreeModbus移植到STM32F107(以太网传输方式)_第15张图片

打开mbrtu.c和mbascii.c文件检查,发现mbrtu.c源码有问题,不受宏定义影响

FreeModbus移植到STM32F107(以太网传输方式)_第16张图片

FreeModbus移植到STM32F107(以太网传输方式)_第17张图片

因此修改mbrtu.c源码

FreeModbus移植到STM32F107(以太网传输方式)_第18张图片

FreeModbus移植到STM32F107(以太网传输方式)_第19张图片

修改好之后,编译出现错误

FreeModbus移植到STM32F107(以太网传输方式)_第20张图片

 

4.移植底层接口

先看第一个错误,缺少port.h

FreeModbus移植到STM32F107(以太网传输方式)_第21张图片

借鉴demo里面STR71XTCP的程序。将STR71XTCP中的port文件夹,拷贝到工程中。

FreeModbus移植到STM32F107(以太网传输方式)_第22张图片

FreeModbus移植到STM32F107(以太网传输方式)_第23张图片

删除重复文件mbconfig.h

FreeModbus移植到STM32F107(以太网传输方式)_第24张图片

FreeModbus移植到STM32F107(以太网传输方式)_第25张图片

将文件加入工程

FreeModbus移植到STM32F107(以太网传输方式)_第26张图片

FreeModbus移植到STM32F107(以太网传输方式)_第27张图片

添加好之后,重新编译,出现错误,port.h中包含了STR71X相关代码

FreeModbus移植到STM32F107(以太网传输方式)_第28张图片

将这些代码修改

FreeModbus移植到STM32F107(以太网传输方式)_第29张图片

FreeModbus移植到STM32F107(以太网传输方式)_第30张图片

重新编译,出现错误,发现demo中STR71XTCP程序原来是带操作系统的。portevent.c文件不适用于裸机。

FreeModbus移植到STM32F107(以太网传输方式)_第31张图片

借鉴demo里面AVR的程序。将AVR中的portevent.c文件,拷贝过来并覆盖源文件。

FreeModbus移植到STM32F107(以太网传输方式)_第32张图片

FreeModbus移植到STM32F107(以太网传输方式)_第33张图片

重新编译,有部分宏没有定义。

FreeModbus移植到STM32F107(以太网传输方式)_第34张图片

打开port.h,重新定义。

FreeModbus移植到STM32F107(以太网传输方式)_第35张图片

重新编译,出现错误,NETCONN_COPY没有定义。这是因为lwip没有配置LWIP_NETCONN或者LWIP_SOCKET。

FreeModbus移植到STM32F107(以太网传输方式)_第36张图片

 

对于这个我们直接搜寻整个工程,发现NETCONN_COPY的值为1。将NETCONN_COPY的值直接替换掉。

FreeModbus移植到STM32F107(以太网传输方式)_第37张图片

 

FreeModbus移植到STM32F107(以太网传输方式)_第38张图片

重新编译,报告eMBRegCoilsCB、eMBRegDiscreteCB、eMBRegHoldingCB和eMBRegInputCB没有定义。

FreeModbus移植到STM32F107(以太网传输方式)_第39张图片

这四个接口是协议栈预留给用户自己去实现的,分别创建user_mb_app.h和user_mb_app.c两个文件

FreeModbus移植到STM32F107(以太网传输方式)_第40张图片

#ifndef _USER_MB_APP_H_
#define _USER_MB_APP_H_
 
/* ----------------------- Modbus includes ----------------------------------*/
#include "mb.h"
#include "mbconfig.h"
#include "mbframe.h"
#include "mbutils.h"
 
/* -----------------------Slave Defines -------------------------------------*/
#define S_DISCRETE_INPUT_START        0
#define S_DISCRETE_INPUT_NDISCRETES   16
#define S_COIL_START                  0
#define S_COIL_NCOILS                 64
#define S_REG_INPUT_START             0
#define S_REG_INPUT_NREGS             100
#define S_REG_HOLDING_START           0
#define S_REG_HOLDING_NREGS           100
/* salve mode: holding register's all address */
#define          S_HD_RESERVE                     0
#define          S_HD_CPU_USAGE_MAJOR             1
#define          S_HD_CPU_USAGE_MINOR             2
/* salve mode: input register's all address */
#define          S_IN_RESERVE                     0
/* salve mode: coil's all address */
#define          S_CO_RESERVE                     0
/* salve mode: discrete's all address */
#define          S_DI_RESERVE                     0
 
/* -----------------------Master Defines -------------------------------------*/
#define M_DISCRETE_INPUT_START        0
#define M_DISCRETE_INPUT_NDISCRETES   16
#define M_COIL_START                  0
#define M_COIL_NCOILS                 64
#define M_REG_INPUT_START             0
#define M_REG_INPUT_NREGS             100
#define M_REG_HOLDING_START           0
#define M_REG_HOLDING_NREGS           100
/* master mode: holding register's all address */
#define          M_HD_RESERVE                     0
/* master mode: input register's all address */
#define          M_IN_RESERVE                     0
/* master mode: coil's all address */
#define          M_CO_RESERVE                     0
/* master mode: discrete's all address */
#define          M_DI_RESERVE                     0
 
#endif
/*
 * FreeModbus Libary: user callback functions and buffer define in slave mode
 * Copyright (C) 2013 Armink 
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * File: $Id: user_mb_app.c,v 1.60 2013/11/23 11:49:05 Armink $
 */
#include "user_mb_app.h"
 
/*------------------------Slave mode use these variables----------------------*/
//Slave mode:DiscreteInputs variables
USHORT   usSDiscInStart                               = S_DISCRETE_INPUT_START;
#if S_DISCRETE_INPUT_NDISCRETES%8
UCHAR    ucSDiscInBuf[S_DISCRETE_INPUT_NDISCRETES/8+1];
#else
UCHAR    ucSDiscInBuf[S_DISCRETE_INPUT_NDISCRETES/8]  ;
#endif
//Slave mode:Coils variables
USHORT   usSCoilStart                                 = S_COIL_START;
#if S_COIL_NCOILS%8
UCHAR    ucSCoilBuf[S_COIL_NCOILS/8+1]                ;
#else
UCHAR    ucSCoilBuf[S_COIL_NCOILS/8]                  ;
#endif
//Slave mode:InputRegister variables
USHORT   usSRegInStart                                = S_REG_INPUT_START;
USHORT   usSRegInBuf[S_REG_INPUT_NREGS]               ;
//Slave mode:HoldingRegister variables
USHORT   usSRegHoldStart                              = S_REG_HOLDING_START;
USHORT   usSRegHoldBuf[S_REG_HOLDING_NREGS]           ;
 
/**
 * Modbus slave input register callback function.
 *
 * @param pucRegBuffer input register buffer
 * @param usAddress input register address
 * @param usNRegs input register number
 *
 * @return result
 */
eMBErrorCode eMBRegInputCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex;
    USHORT *        pusRegInputBuf;
    USHORT          REG_INPUT_START;
    USHORT          REG_INPUT_NREGS;
    USHORT          usRegInStart;
 
    pusRegInputBuf = usSRegInBuf;
    REG_INPUT_START = S_REG_INPUT_START;
    REG_INPUT_NREGS = S_REG_INPUT_NREGS;
    usRegInStart = usSRegInStart;
 
    /* it already plus one in modbus function method. */
    usAddress--;
 
    if ((usAddress >= REG_INPUT_START)
            && (usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS))
    {
        iRegIndex = usAddress - usRegInStart;
        while (usNRegs > 0)
        {
            *pucRegBuffer++ = (UCHAR) (pusRegInputBuf[iRegIndex] >> 8);
            *pucRegBuffer++ = (UCHAR) (pusRegInputBuf[iRegIndex] & 0xFF);
            iRegIndex++;
            usNRegs--;
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }
 
    return eStatus;
}
 
/**
 * Modbus slave holding register callback function.
 *
 * @param pucRegBuffer holding register buffer
 * @param usAddress holding register address
 * @param usNRegs holding register number
 * @param eMode read or write
 *
 * @return result
 */
eMBErrorCode eMBRegHoldingCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex;
    USHORT *        pusRegHoldingBuf;
    USHORT          REG_HOLDING_START;
    USHORT          REG_HOLDING_NREGS;
    USHORT          usRegHoldStart;
 
    pusRegHoldingBuf = usSRegHoldBuf;
    REG_HOLDING_START = S_REG_HOLDING_START;
    REG_HOLDING_NREGS = S_REG_HOLDING_NREGS;
    usRegHoldStart = usSRegHoldStart;
 
    /* it already plus one in modbus function method. */
    usAddress--;
 
    if ((usAddress >= REG_HOLDING_START)
            && (usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS))
    {
        iRegIndex = usAddress - usRegHoldStart;
        switch (eMode)
        {
        /* read current register values from the protocol stack. */
        case MB_REG_READ:
            while (usNRegs > 0)
            {
                *pucRegBuffer++ = (UCHAR) (pusRegHoldingBuf[iRegIndex] >> 8);
                *pucRegBuffer++ = (UCHAR) (pusRegHoldingBuf[iRegIndex] & 0xFF);
                iRegIndex++;
                usNRegs--;
            }
            break;
 
        /* write current register values with new values from the protocol stack. */
        case MB_REG_WRITE:
            while (usNRegs > 0)
            {
                pusRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
                pusRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
                iRegIndex++;
                usNRegs--;
            }
            break;
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }
    return eStatus;
}
 
/**
 * Modbus slave coils callback function.
 *
 * @param pucRegBuffer coils buffer
 * @param usAddress coils address
 * @param usNCoils coils number
 * @param eMode read or write
 *
 * @return result
 */
eMBErrorCode eMBRegCoilsCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex , iRegBitIndex , iNReg;
    UCHAR *         pucCoilBuf;
    USHORT          COIL_START;
    USHORT          COIL_NCOILS;
    USHORT          usCoilStart;
    iNReg =  usNCoils / 8 + 1;
 
    pucCoilBuf = ucSCoilBuf;
    COIL_START = S_COIL_START;
    COIL_NCOILS = S_COIL_NCOILS;
    usCoilStart = usSCoilStart;
 
    /* it already plus one in modbus function method. */
    usAddress--;
 
    if( ( usAddress >= COIL_START ) &&
        ( usAddress + usNCoils <= COIL_START + COIL_NCOILS ) )
    {
        iRegIndex = (USHORT) (usAddress - usCoilStart) / 8;
        iRegBitIndex = (USHORT) (usAddress - usCoilStart) % 8;
        switch ( eMode )
        {
        /* read current coil values from the protocol stack. */
        case MB_REG_READ:
            while (iNReg > 0)
            {
                *pucRegBuffer++ = xMBUtilGetBits(&pucCoilBuf[iRegIndex++],
                        iRegBitIndex, 8);
                iNReg--;
            }
            pucRegBuffer--;
            /* last coils */
            usNCoils = usNCoils % 8;
            /* filling zero to high bit */
            *pucRegBuffer = *pucRegBuffer << (8 - usNCoils);
            *pucRegBuffer = *pucRegBuffer >> (8 - usNCoils);
            break;
 
            /* write current coil values with new values from the protocol stack. */
        case MB_REG_WRITE:
            while (iNReg > 1)
            {
                xMBUtilSetBits(&pucCoilBuf[iRegIndex++], iRegBitIndex, 8,
                        *pucRegBuffer++);
                iNReg--;
            }
            /* last coils */
            usNCoils = usNCoils % 8;
            /* xMBUtilSetBits has bug when ucNBits is zero */
            if (usNCoils != 0)
            {
                xMBUtilSetBits(&pucCoilBuf[iRegIndex++], iRegBitIndex, usNCoils,
                        *pucRegBuffer++);
            }
            break;
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }
    return eStatus;
}
 
/**
 * Modbus slave discrete callback function.
 *
 * @param pucRegBuffer discrete buffer
 * @param usAddress discrete address
 * @param usNDiscrete discrete number
 *
 * @return result
 */
eMBErrorCode eMBRegDiscreteCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNDiscrete)
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex , iRegBitIndex , iNReg;
    UCHAR *         pucDiscreteInputBuf;
    USHORT          DISCRETE_INPUT_START;
    USHORT          DISCRETE_INPUT_NDISCRETES;
    USHORT          usDiscreteInputStart;
    iNReg =  usNDiscrete / 8 + 1;
 
    pucDiscreteInputBuf = ucSDiscInBuf;
    DISCRETE_INPUT_START = S_DISCRETE_INPUT_START;
    DISCRETE_INPUT_NDISCRETES = S_DISCRETE_INPUT_NDISCRETES;
    usDiscreteInputStart = usSDiscInStart;
 
    /* it already plus one in modbus function method. */
    usAddress--;
 
    if ((usAddress >= DISCRETE_INPUT_START)
            && (usAddress + usNDiscrete    <= DISCRETE_INPUT_START + DISCRETE_INPUT_NDISCRETES))
    {
        iRegIndex = (USHORT) (usAddress - usDiscreteInputStart) / 8;
        iRegBitIndex = (USHORT) (usAddress - usDiscreteInputStart) % 8;
 
        while (iNReg > 0)
        {
            *pucRegBuffer++ = xMBUtilGetBits(&pucDiscreteInputBuf[iRegIndex++],
                    iRegBitIndex, 8);
            iNReg--;
        }
        pucRegBuffer--;
        /* last discrete */
        usNDiscrete = usNDiscrete % 8;
        /* filling zero to high bit */
        *pucRegBuffer = *pucRegBuffer << (8 - usNDiscrete);
        *pucRegBuffer = *pucRegBuffer >> (8 - usNDiscrete);
    }
    else
    {
        eStatus = MB_ENOREG;
    }
 
    return eStatus;
}

重新编译,提示vMBPortEventClose未定义。由于我们是裸机程序,并未创建系统对象,也就不需要释放。直接将vMBPortEventClose注释即可。

FreeModbus移植到STM32F107(以太网传输方式)_第41张图片

重新编译,无错误

FreeModbus移植到STM32F107(以太网传输方式)_第42张图片

8.协议栈移植工作完成。

FreeModbus移植到STM32F107(以太网传输方式)_第43张图片

烧录之后,发现程序死在了vMBPortLog函数中。这是由于我们没有打印口,我们直接将这段代码注释即可。

FreeModbus移植到STM32F107(以太网传输方式)_第44张图片

你可能感兴趣的:(STM32,Modbus)