sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

apps/modbus: That completes a complete pass; all of the modbus files a little closer to NuttX coding style. Still not compliant with naming conventions

Browse Source
This commit is contained in:
Gregory Nutt 2015-04-07 16:48:09 -06:00
parent 00a091a840
commit 44d966b0a1
22 changed files with 695 additions and 563 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/modbus/mb.h
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/include/modbus/mb.h
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
include/modbus/mbframe.h
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/include/modbus/mbframe.h
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
include/modbus/mbfunc.h
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/include/modbus/mbfunc.h
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
include/modbus/mbport.h
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/include/modbus/mbport.h
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
include/modbus/mbutils.h
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/include/modbus/mbutils.h
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
modbus/ascii/mbascii.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/ascii/mbascii.c
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

319
modbus/functions/mbfunccoils.c
View File

@ -1,5 +1,7 @@
/*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
/****************************************************************************
* apps/functions/mbfunccoils.c
*
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*
@ -25,246 +27,273 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* File: $Id: mbfunccoils.c,v 1.8 2007/02/18 23:47:16 wolti Exp $
*/
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
/* ----------------------- System includes ----------------------------------*/
#include <nuttx/config.h>
#include <stdlib.h>
#include <string.h>
/* ----------------------- Platform includes --------------------------------*/
#include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h>
#include <apps/modbus/mbframe.h>
#include <apps/modbus/mbproto.h>
/* ----------------------- Defines ------------------------------------------*/
#define MB_PDU_FUNC_READ_ADDR_OFF ( MB_PDU_DATA_OFF )
#define MB_PDU_FUNC_READ_COILCNT_OFF ( MB_PDU_DATA_OFF + 2 )
#define MB_PDU_FUNC_READ_SIZE ( 4 )
#define MB_PDU_FUNC_READ_COILCNT_MAX ( 0x07D0 )
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define MB_PDU_FUNC_WRITE_ADDR_OFF ( MB_PDU_DATA_OFF )
#define MB_PDU_FUNC_WRITE_VALUE_OFF ( MB_PDU_DATA_OFF + 2 )
#define MB_PDU_FUNC_WRITE_SIZE ( 4 )
#define MB_PDU_FUNC_READ_ADDR_OFF (MB_PDU_DATA_OFF)
#define MB_PDU_FUNC_READ_COILCNT_OFF (MB_PDU_DATA_OFF + 2)
#define MB_PDU_FUNC_READ_SIZE (4)
#define MB_PDU_FUNC_READ_COILCNT_MAX (0x07D0)
#define MB_PDU_FUNC_WRITE_MUL_ADDR_OFF ( MB_PDU_DATA_OFF )
#define MB_PDU_FUNC_WRITE_MUL_COILCNT_OFF ( MB_PDU_DATA_OFF + 2 )
#define MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF ( MB_PDU_DATA_OFF + 4 )
#define MB_PDU_FUNC_WRITE_MUL_VALUES_OFF ( MB_PDU_DATA_OFF + 5 )
#define MB_PDU_FUNC_WRITE_MUL_SIZE_MIN ( 5 )
#define MB_PDU_FUNC_WRITE_MUL_COILCNT_MAX ( 0x07B0 )
#define MB_PDU_FUNC_WRITE_ADDR_OFF (MB_PDU_DATA_OFF)
#define MB_PDU_FUNC_WRITE_VALUE_OFF (MB_PDU_DATA_OFF + 2)
#define MB_PDU_FUNC_WRITE_SIZE (4)
/* ----------------------- Static functions ---------------------------------*/
eMBException prveMBError2Exception( eMBErrorCode eErrorCode );
#define MB_PDU_FUNC_WRITE_MUL_ADDR_OFF (MB_PDU_DATA_OFF)
#define MB_PDU_FUNC_WRITE_MUL_COILCNT_OFF (MB_PDU_DATA_OFF + 2)
#define MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF (MB_PDU_DATA_OFF + 4)
#define MB_PDU_FUNC_WRITE_MUL_VALUES_OFF (MB_PDU_DATA_OFF + 5)
#define MB_PDU_FUNC_WRITE_MUL_SIZE_MIN (5)
#define MB_PDU_FUNC_WRITE_MUL_COILCNT_MAX (0x07B0)
/* ----------------------- Start implementation -----------------------------*/
/****************************************************************************
* External Function Prototypes
****************************************************************************/
eMBException prveMBError2Exception(eMBErrorCode eErrorCode);
/****************************************************************************
* Public Functions
****************************************************************************/
#ifdef CONFIG_MB_FUNC_READ_COILS_ENABLED
eMBException
eMBFuncReadCoils( uint8_t * pucFrame, uint16_t * usLen )
eMBException eMBFuncReadCoils(uint8_t *pucFrame, uint16_t *usLen)
{
uint16_t usRegAddress;
uint16_t usCoilCount;
uint8_t ucNBytes;
uint8_t *pucFrameCur;
uint16_t usRegAddress;
uint16_t usCoilCount;
uint8_t ucNBytes;
uint8_t *pucFrameCur;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if( *usLen == ( MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN ) )
if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
{
usRegAddress = ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8 );
usRegAddress |= ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1] );
usRegAddress++;
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
usRegAddress++;
usCoilCount = ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_COILCNT_OFF] << 8 );
usCoilCount |= ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_COILCNT_OFF + 1] );
usCoilCount = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_COILCNT_OFF] << 8);
usCoilCount |= (uint16_t)(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 ) )
/* 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;
/* Set the current PDU data pointer to the beginning. */
/* First byte contains the function code. */
*pucFrameCur++ = MB_FUNC_READ_COILS;
*usLen += 1;
pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
*usLen = MB_PDU_FUNC_OFF;
/* 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 )
/* 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 = ( uint8_t )( usCoilCount / 8 + 1 );
ucNBytes = (uint8_t)(usCoilCount / 8 + 1);
}
else
else
{
ucNBytes = ( uint8_t )( usCoilCount / 8 );
ucNBytes = (uint8_t)(usCoilCount / 8);
}
*pucFrameCur++ = ucNBytes;
*usLen += 1;
eRegStatus =
eMBRegCoilsCB( pucFrameCur, usRegAddress, usCoilCount,
MB_REG_READ );
*pucFrameCur++ = ucNBytes;
*usLen += 1;
/* If an error occured convert it into a Modbus exception. */
if( eRegStatus != MB_ENOERR )
eRegStatus = eMBRegCoilsCB(pucFrameCur, usRegAddress, usCoilCount,
MB_REG_READ);
/* If an error occured convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
{
eStatus = prveMBError2Exception( eRegStatus );
eStatus = prveMBError2Exception(eRegStatus);
}
else
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;;
/* 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
else
{
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
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;
/* Can't be a valid read coil register request because the length
* is incorrect.
*/
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
return eStatus;
return eStatus;
}
#ifdef CONFIG_MB_FUNC_WRITE_COIL_ENABLED
eMBException
eMBFuncWriteCoil( uint8_t * pucFrame, uint16_t * usLen )
eMBException eMBFuncWriteCoil(uint8_t *pucFrame, uint16_t *usLen)
{
uint16_t usRegAddress;
uint8_t ucBuf[2];
uint16_t usRegAddress;
uint8_t ucBuf[2];
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if( *usLen == ( MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN ) )
if (*usLen == (MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN))
{
usRegAddress = ( uint16_t )( pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF] << 8 );
usRegAddress |= ( uint16_t )( pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF + 1] );
usRegAddress++;
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF + 1]);
usRegAddress++;
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 ) ) )
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[1] = 0;
if (pucFrame[MB_PDU_FUNC_WRITE_VALUE_OFF] == 0xFF)
{
ucBuf[0] = 1;
ucBuf[0] = 1;
}
else
else
{
ucBuf[0] = 0;
ucBuf[0] = 0;
}
eRegStatus =
eMBRegCoilsCB( &ucBuf[0], usRegAddress, 1, MB_REG_WRITE );
/* If an error occured convert it into a Modbus exception. */
if( eRegStatus != MB_ENOERR )
eRegStatus = eMBRegCoilsCB(&ucBuf[0], usRegAddress, 1,
MB_REG_WRITE);
/* If an error occured convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
{
eStatus = prveMBError2Exception( eRegStatus );
eStatus = prveMBError2Exception(eRegStatus);
}
}
else
else
{
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
}
else
else
{
/* Can't be a valid write coil register request because the length
* is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
/* Can't be a valid write coil register request because the length
* is incorrect.
*/
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
return eStatus;
return eStatus;
}
#endif
#ifdef CONFIG_MB_FUNC_WRITE_MULTIPLE_COILS_ENABLED
eMBException
eMBFuncWriteMultipleCoils( uint8_t * pucFrame, uint16_t * usLen )
eMBException eMBFuncWriteMultipleCoils(uint8_t *pucFrame, uint16_t *usLen)
{
uint16_t usRegAddress;
uint16_t usCoilCnt;
uint8_t ucByteCount;
uint8_t ucByteCountVerify;
uint16_t usRegAddress;
uint16_t usCoilCnt;
uint8_t ucByteCount;
uint8_t ucByteCountVerify;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if( *usLen > ( MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN ) )
if (*usLen > (MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN))
{
usRegAddress = ( uint16_t )( pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF] << 8 );
usRegAddress |= ( uint16_t )( pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF + 1] );
usRegAddress++;
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF + 1]);
usRegAddress++;
usCoilCnt = ( uint16_t )( pucFrame[MB_PDU_FUNC_WRITE_MUL_COILCNT_OFF] << 8 );
usCoilCnt |= ( uint16_t )( pucFrame[MB_PDU_FUNC_WRITE_MUL_COILCNT_OFF + 1] );
usCoilCnt = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_COILCNT_OFF] << 8);
usCoilCnt |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_COILCNT_OFF + 1]);
ucByteCount = pucFrame[MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF];
ucByteCount = pucFrame[MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF];
/* Compute the number of expected bytes in the request. */
if( ( usCoilCnt & 0x0007 ) != 0 )
/* Compute the number of expected bytes in the request. */
if ((usCoilCnt & 0x0007) != 0)
{
ucByteCountVerify = ( uint8_t )( usCoilCnt / 8 + 1 );
ucByteCountVerify = (uint8_t)(usCoilCnt / 8 + 1);
}
else
else
{
ucByteCountVerify = ( uint8_t )( usCoilCnt / 8 );
ucByteCountVerify = (uint8_t)(usCoilCnt / 8);
}
if( ( usCoilCnt >= 1 ) &&
( usCoilCnt <= MB_PDU_FUNC_WRITE_MUL_COILCNT_MAX ) &&
( ucByteCountVerify == ucByteCount ) )
if ((usCoilCnt >= 1) &&
(usCoilCnt <= MB_PDU_FUNC_WRITE_MUL_COILCNT_MAX) &&
(ucByteCountVerify == ucByteCount))
{
eRegStatus =
eMBRegCoilsCB( &pucFrame[MB_PDU_FUNC_WRITE_MUL_VALUES_OFF],
usRegAddress, usCoilCnt, MB_REG_WRITE );
eRegStatus =
eMBRegCoilsCB(&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 )
/* If an error occured convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
{
eStatus = prveMBError2Exception( eRegStatus );
eStatus = prveMBError2Exception(eRegStatus);
}
else
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;
/* 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
else
{
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
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;
/* Can't be a valid write coil register request because the length
* is incorrect.
*/
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
return eStatus;
return eStatus;
}
#endif
#endif

9
modbus/functions/mbfuncdiag.c
View File

@ -1,5 +1,7 @@
/*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
/****************************************************************************
* apps/functions/mbfuncdiag.c
*
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*
@ -25,5 +27,4 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* File: $Id: mbfuncdiag.c,v 1.3 2006/12/07 22:10:34 wolti Exp $
*/
****************************************************************************/

191
modbus/functions/mbfuncdisc.c
View File

@ -1,123 +1,154 @@
/*
* FreeRTOS Modbus Libary: A Modbus serial implementation for FreeRTOS
* Copyright (C) 2006 Christian Walter <wolti@sil.at>
*
* 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
*/
/****************************************************************************
* apps/functions/mbfuncdisc.c
*
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
/* ----------------------- System includes ----------------------------------*/
#include <nuttx/config.h>
#include <stdlib.h>
#include <string.h>
/* ----------------------- Platform includes --------------------------------*/
#include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h>
#include <apps/modbus/mbframe.h>
#include <apps/modbus/mbproto.h>
/* ----------------------- Defines ------------------------------------------*/
#define MB_PDU_FUNC_READ_ADDR_OFF ( MB_PDU_DATA_OFF )
#define MB_PDU_FUNC_READ_DISCCNT_OFF ( MB_PDU_DATA_OFF + 2 )
#define MB_PDU_FUNC_READ_SIZE ( 4 )
#define MB_PDU_FUNC_READ_DISCCNT_MAX ( 0x07D0 )
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* ----------------------- Static functions ---------------------------------*/
eMBException prveMBError2Exception( eMBErrorCode eErrorCode );
#define MB_PDU_FUNC_READ_ADDR_OFF (MB_PDU_DATA_OFF)
#define MB_PDU_FUNC_READ_DISCCNT_OFF (MB_PDU_DATA_OFF + 2)
#define MB_PDU_FUNC_READ_SIZE (4)
#define MB_PDU_FUNC_READ_DISCCNT_MAX (0x07D0)
/* ----------------------- Start implementation -----------------------------*/
/****************************************************************************
* External Function Prototypes
****************************************************************************/
eMBException prveMBError2Exception(eMBErrorCode eErrorCode);
/****************************************************************************
* Public Functions
****************************************************************************/
#ifdef CONFIG_MB_FUNC_READ_COILS_ENABLED
eMBException
eMBFuncReadDiscreteInputs( uint8_t * pucFrame, uint16_t * usLen )
eMBException eMBFuncReadDiscreteInputs(uint8_t *pucFrame, uint16_t *usLen)
{
uint16_t usRegAddress;
uint16_t usDiscreteCnt;
uint8_t ucNBytes;
uint8_t *pucFrameCur;
uint16_t usRegAddress;
uint16_t usDiscreteCnt;
uint8_t ucNBytes;
uint8_t *pucFrameCur;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if( *usLen == ( MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN ) )
if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
{
usRegAddress = ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8 );
usRegAddress |= ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1] );
usRegAddress++;
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
usRegAddress++;
usDiscreteCnt = ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_DISCCNT_OFF] << 8 );
usDiscreteCnt |= ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_DISCCNT_OFF + 1] );
usDiscreteCnt = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_DISCCNT_OFF] << 8);
usDiscreteCnt |= (uint16_t)(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 ) )
/* 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;
/* Set the current PDU data pointer to the beginning. */
/* First byte contains the function code. */
*pucFrameCur++ = MB_FUNC_READ_DISCRETE_INPUTS;
*usLen += 1;
pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
*usLen = MB_PDU_FUNC_OFF;
/* 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 )
/* 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 = ( uint8_t ) ( usDiscreteCnt / 8 + 1 );
ucNBytes = (uint8_t) (usDiscreteCnt / 8 + 1);
}
else
else
{
ucNBytes = ( uint8_t ) ( usDiscreteCnt / 8 );
ucNBytes = (uint8_t) (usDiscreteCnt / 8);
}
*pucFrameCur++ = ucNBytes;
*usLen += 1;
eRegStatus =
eMBRegDiscreteCB( pucFrameCur, usRegAddress, usDiscreteCnt );
*pucFrameCur++ = ucNBytes;
*usLen += 1;
/* If an error occured convert it into a Modbus exception. */
if( eRegStatus != MB_ENOERR )
eRegStatus = eMBRegDiscreteCB(pucFrameCur, usRegAddress,
usDiscreteCnt);
/* If an error occurred convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
{
eStatus = prveMBError2Exception( eRegStatus );
eStatus = prveMBError2Exception(eRegStatus);
}
else
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;;
/* 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
else
{
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
}
else
else
{
/* Can't be a valid read coil register request because the length
* is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
/* Can't be a valid read coil register request because the length
* is incorrect.
*/
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
return eStatus;
return eStatus;
}
#endif

337
modbus/functions/mbfuncholding.c
View File

@ -1,5 +1,7 @@
/*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
/****************************************************************************
* apps/functions/mbfuncholding.c
*
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*
@ -25,23 +27,26 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* File: $Id: mbfuncholding.c,v 1.12 2007/02/18 23:48:22 wolti Exp $
*/
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
/* ----------------------- System includes ----------------------------------*/
#include <nuttx/config.h>
#include <stdlib.h>
#include <string.h>
/* ----------------------- Platform includes --------------------------------*/
#include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h>
#include <apps/modbus/mbframe.h>
#include <apps/modbus/mbproto.h>
/* ----------------------- Defines ------------------------------------------*/
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define MB_PDU_FUNC_READ_ADDR_OFF (MB_PDU_DATA_OFF + 0)
#define MB_PDU_FUNC_READ_REGCNT_OFF (MB_PDU_DATA_OFF + 2)
#define MB_PDU_FUNC_READ_SIZE (4)
@ -66,246 +71,266 @@
#define MB_PDU_FUNC_READWRITE_WRITE_VALUES_OFF (MB_PDU_DATA_OFF + 9)
#define MB_PDU_FUNC_READWRITE_SIZE_MIN (9)
/* ----------------------- Static functions ---------------------------------*/
eMBException prveMBError2Exception(eMBErrorCode eErrorCode);
/****************************************************************************
* External Function Prototypes
****************************************************************************/
/* ----------------------- Start implementation -----------------------------*/
eMBException prveMBError2Exception(eMBErrorCode eErrorCode);
/****************************************************************************
* Public Functions
****************************************************************************/
#ifdef CONFIG_MB_FUNC_WRITE_HOLDING_ENABLED
eMBException
eMBFuncWriteHoldingRegister(uint8_t * pucFrame, uint16_t * usLen)
eMBException eMBFuncWriteHoldingRegister(uint8_t *pucFrame, uint16_t *usLen)
{
uint16_t usRegAddress;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
uint16_t usRegAddress;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if (*usLen == (MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN))
if (*usLen == (MB_PDU_FUNC_WRITE_SIZE + MB_PDU_SIZE_MIN))
{
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF + 1]);
usRegAddress++;
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF + 1]);
usRegAddress++;
/* Make callback to update the value. */
eRegStatus = eMBRegHoldingCB(&pucFrame[MB_PDU_FUNC_WRITE_VALUE_OFF],
usRegAddress, 1, MB_REG_WRITE);
/* Make callback to update the value. */
/* If an error occured convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
eRegStatus = eMBRegHoldingCB(&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);
eStatus = prveMBError2Exception(eRegStatus);
}
}
else
else
{
/* Can't be a valid request because the length is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
/* Can't be a valid request because the length is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
return eStatus;
return eStatus;
}
#endif
#ifdef CONFIG_MB_FUNC_WRITE_MULTIPLE_HOLDING_ENABLED
eMBException
eMBFuncWriteMultipleHoldingRegister(uint8_t * pucFrame, uint16_t * usLen)
eMBException eMBFuncWriteMultipleHoldingRegister(uint8_t *pucFrame, uint16_t *usLen)
{
uint16_t usRegAddress;
uint16_t usRegCount;
uint8_t ucRegByteCount;
uint16_t usRegAddress;
uint16_t usRegCount;
uint8_t ucRegByteCount;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if (*usLen >= (MB_PDU_FUNC_WRITE_MUL_SIZE_MIN + MB_PDU_SIZE_MIN))
if (*usLen >= (MB_PDU_FUNC_WRITE_MUL_SIZE_MIN + MB_PDU_SIZE_MIN))
{
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF + 1]);
usRegAddress++;
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF + 1]);
usRegAddress++;
usRegCount = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF] << 8);
usRegCount |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF + 1]);
usRegCount = (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF] << 8);
usRegCount |= (uint16_t)(pucFrame[MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF + 1]);
ucRegByteCount = pucFrame[MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF];
ucRegByteCount = pucFrame[MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF];
if ((usRegCount >= 1) &&
(usRegCount <= MB_PDU_FUNC_WRITE_MUL_REGCNT_MAX) &&
(ucRegByteCount == (uint8_t) (2 * usRegCount)))
if ((usRegCount >= 1) &&
(usRegCount <= MB_PDU_FUNC_WRITE_MUL_REGCNT_MAX) &&
(ucRegByteCount == (uint8_t) (2 * usRegCount)))
{
/* Make callback to update the register values. */
eRegStatus =
eMBRegHoldingCB(&pucFrame[MB_PDU_FUNC_WRITE_MUL_VALUES_OFF],
usRegAddress, usRegCount, MB_REG_WRITE);
/* Make callback to update the register values. */
/* If an error occurred convert it into a Modbus exception. */
eRegStatus =
eMBRegHoldingCB(&pucFrame[MB_PDU_FUNC_WRITE_MUL_VALUES_OFF],
usRegAddress, usRegCount, MB_REG_WRITE);
if (eRegStatus != MB_ENOERR)
/* If an error occurred convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
{
eStatus = prveMBError2Exception(eRegStatus);
eStatus = prveMBError2Exception(eRegStatus);
}
else
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.
*/
/* 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;
*usLen = MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF;
}
}
else
else
{
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
}
else
else
{
/* Can't be a valid request because the length is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
/* Can't be a valid request because the length is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
return eStatus;
return eStatus;
}
#endif
#ifdef CONFIG_MB_FUNC_READ_HOLDING_ENABLED
eMBException
eMBFuncReadHoldingRegister(uint8_t * pucFrame, uint16_t * usLen)
eMBException eMBFuncReadHoldingRegister(uint8_t * pucFrame, uint16_t * usLen)
{
uint16_t usRegAddress;
uint16_t usRegCount;
uint8_t *pucFrameCur;
uint16_t usRegAddress;
uint16_t usRegCount;
uint8_t *pucFrameCur;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
{
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
usRegAddress++;
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
usRegAddress++;
usRegCount = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF] << 8);
usRegCount |= (uint16_t)(pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF + 1]);
usRegCount = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF] << 8);
usRegCount |= (uint16_t)(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.
*/
/* 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))
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;
/* Set the current PDU data pointer to the beginning. */
/* First byte contains the function code. */
*pucFrameCur++ = MB_FUNC_READ_HOLDING_REGISTER;
*usLen += 1;
pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
*usLen = MB_PDU_FUNC_OFF;
/* Second byte in the response contain the number of bytes. */
*pucFrameCur++ = (uint8_t) (usRegCount * 2);
*usLen += 1;
/* First byte contains the function code. */
/* Make callback to fill the buffer. */
eRegStatus = eMBRegHoldingCB(pucFrameCur, usRegAddress, usRegCount, MB_REG_READ);
/* If an error occured convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
*pucFrameCur++ = MB_FUNC_READ_HOLDING_REGISTER;
*usLen += 1;
/* Second byte in the response contain the number of bytes. */
*pucFrameCur++ = (uint8_t) (usRegCount * 2);
*usLen += 1;
/* Make callback to fill the buffer. */
eRegStatus = eMBRegHoldingCB(pucFrameCur, usRegAddress, usRegCount, MB_REG_READ);
/* If an error occured convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
{
eStatus = prveMBError2Exception(eRegStatus);
eStatus = prveMBError2Exception(eRegStatus);
}
else
else
{
*usLen += usRegCount * 2;
*usLen += usRegCount * 2;
}
}
else
else
{
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
}
else
else
{
/* Can't be a valid request because the length is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
/* Can't be a valid request because the length is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
return eStatus;
return eStatus;
}
#endif
#ifdef CONFIG_MB_FUNC_READWRITE_HOLDING_ENABLED
eMBException
eMBFuncReadWriteMultipleHoldingRegister(uint8_t * pucFrame, uint16_t * usLen)
eMBException eMBFuncReadWriteMultipleHoldingRegister(uint8_t *pucFrame, uint16_t *usLen)
{
uint16_t usRegReadAddress;
uint16_t usRegReadCount;
uint16_t usRegWriteAddress;
uint16_t usRegWriteCount;
uint8_t ucRegWriteByteCount;
uint8_t *pucFrameCur;
uint16_t usRegReadAddress;
uint16_t usRegReadCount;
uint16_t usRegWriteAddress;
uint16_t usRegWriteCount;
uint8_t ucRegWriteByteCount;
uint8_t *pucFrameCur;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if (*usLen >= (MB_PDU_FUNC_READWRITE_SIZE_MIN + MB_PDU_SIZE_MIN))
if (*usLen >= (MB_PDU_FUNC_READWRITE_SIZE_MIN + MB_PDU_SIZE_MIN))
{
usRegReadAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_READ_ADDR_OFF] << 8U);
usRegReadAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_READ_ADDR_OFF + 1]);
usRegReadAddress++;
usRegReadAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_READ_ADDR_OFF] << 8U);
usRegReadAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_READ_ADDR_OFF + 1]);
usRegReadAddress++;
usRegReadCount = (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_READ_REGCNT_OFF] << 8U);
usRegReadCount |= (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_READ_REGCNT_OFF + 1]);
usRegReadCount = (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_READ_REGCNT_OFF] << 8U);
usRegReadCount |= (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_READ_REGCNT_OFF + 1]);
usRegWriteAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_WRITE_ADDR_OFF] << 8U);
usRegWriteAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_WRITE_ADDR_OFF + 1]);
usRegWriteAddress++;
usRegWriteAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_WRITE_ADDR_OFF] << 8U);
usRegWriteAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_WRITE_ADDR_OFF + 1]);
usRegWriteAddress++;
usRegWriteCount = (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_WRITE_REGCNT_OFF] << 8U);
usRegWriteCount |= (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_WRITE_REGCNT_OFF + 1]);
usRegWriteCount = (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_WRITE_REGCNT_OFF] << 8U);
usRegWriteCount |= (uint16_t)(pucFrame[MB_PDU_FUNC_READWRITE_WRITE_REGCNT_OFF + 1]);
ucRegWriteByteCount = pucFrame[MB_PDU_FUNC_READWRITE_BYTECNT_OFF];
ucRegWriteByteCount = pucFrame[MB_PDU_FUNC_READWRITE_BYTECNT_OFF];
if ((usRegReadCount >= 1) && (usRegReadCount <= 0x7D) &&
(usRegWriteCount >= 1) && (usRegWriteCount <= 0x79) &&
((2 * usRegWriteCount) == ucRegWriteByteCount))
if ((usRegReadCount >= 1) && (usRegReadCount <= 0x7D) &&
(usRegWriteCount >= 1) && (usRegWriteCount <= 0x79) &&
((2 * usRegWriteCount) == ucRegWriteByteCount))
{
/* Make callback to update the register values. */
eRegStatus = eMBRegHoldingCB(&pucFrame[MB_PDU_FUNC_READWRITE_WRITE_VALUES_OFF],
usRegWriteAddress, usRegWriteCount, MB_REG_WRITE);
/* Make callback to update the register values. */
if (eRegStatus == MB_ENOERR)
eRegStatus = eMBRegHoldingCB(&pucFrame[MB_PDU_FUNC_READWRITE_WRITE_VALUES_OFF],
usRegWriteAddress, usRegWriteCount, MB_REG_WRITE);
if (eRegStatus == MB_ENOERR)
{
/* Set the current PDU data pointer to the beginning. */
pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
*usLen = MB_PDU_FUNC_OFF;
/* Set the current PDU data pointer to the beginning. */
/* First byte contains the function code. */
*pucFrameCur++ = MB_FUNC_READWRITE_MULTIPLE_REGISTERS;
*usLen += 1;
pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
*usLen = MB_PDU_FUNC_OFF;
/* Second byte in the response contain the number of bytes. */
*pucFrameCur++ = (uint8_t) (usRegReadCount * 2);
*usLen += 1;
/* First byte contains the function code. */
/* Make the read callback. */
eRegStatus =
eMBRegHoldingCB(pucFrameCur, usRegReadAddress, usRegReadCount, MB_REG_READ);
if (eRegStatus == MB_ENOERR)
*pucFrameCur++ = MB_FUNC_READWRITE_MULTIPLE_REGISTERS;
*usLen += 1;
/* Second byte in the response contain the number of bytes. */
*pucFrameCur++ = (uint8_t) (usRegReadCount * 2);
*usLen += 1;
/* Make the read callback. */
eRegStatus = eMBRegHoldingCB(pucFrameCur, usRegReadAddress,
usRegReadCount, MB_REG_READ);
if (eRegStatus == MB_ENOERR)
{
*usLen += 2 * usRegReadCount;
*usLen += 2 * usRegReadCount;
}
}
if (eRegStatus != MB_ENOERR)
if (eRegStatus != MB_ENOERR)
{
eStatus = prveMBError2Exception(eRegStatus);
eStatus = prveMBError2Exception(eRegStatus);
}
}
else
else
{
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
}
return eStatus;
return eStatus;
}
#endif

128
modbus/functions/mbfuncinput.c
View File

@ -1,5 +1,7 @@
/*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
/****************************************************************************
* apps/functions/mbfuncinput.c
*
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*
@ -25,98 +27,112 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* File: $Id: mbfuncinput.c,v 1.10 2007/09/12 10:15:56 wolti Exp $
*/
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
/* ----------------------- System includes ----------------------------------*/
#include <nuttx/config.h>
#include <stdlib.h>
#include <string.h>
/* ----------------------- Platform includes --------------------------------*/
#include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h>
#include <apps/modbus/mbframe.h>
#include <apps/modbus/mbproto.h>
/* ----------------------- Defines ------------------------------------------*/
#define MB_PDU_FUNC_READ_ADDR_OFF ( MB_PDU_DATA_OFF )
#define MB_PDU_FUNC_READ_REGCNT_OFF ( MB_PDU_DATA_OFF + 2 )
#define MB_PDU_FUNC_READ_SIZE ( 4 )
#define MB_PDU_FUNC_READ_REGCNT_MAX ( 0x007D )
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define MB_PDU_FUNC_READ_RSP_BYTECNT_OFF ( MB_PDU_DATA_OFF )
#define MB_PDU_FUNC_READ_ADDR_OFF (MB_PDU_DATA_OFF)
#define MB_PDU_FUNC_READ_REGCNT_OFF (MB_PDU_DATA_OFF + 2)
#define MB_PDU_FUNC_READ_SIZE (4)
#define MB_PDU_FUNC_READ_REGCNT_MAX (0x007D)
/* ----------------------- Static functions ---------------------------------*/
eMBException prveMBError2Exception( eMBErrorCode eErrorCode );
#define MB_PDU_FUNC_READ_RSP_BYTECNT_OFF (MB_PDU_DATA_OFF)
/* ----------------------- Start implementation -----------------------------*/
/****************************************************************************
* External Function Prototypes
****************************************************************************/
eMBException prveMBError2Exception(eMBErrorCode eErrorCode);
/****************************************************************************
* Public Functions
****************************************************************************/
#ifdef CONFIG_MB_FUNC_READ_INPUT_ENABLED
eMBException
eMBFuncReadInputRegister( uint8_t * pucFrame, uint16_t * usLen )
eMBException eMBFuncReadInputRegister(uint8_t *pucFrame, uint16_t *usLen)
{
uint16_t usRegAddress;
uint16_t usRegCount;
uint8_t *pucFrameCur;
uint16_t usRegAddress;
uint16_t usRegCount;
uint8_t *pucFrameCur;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
if( *usLen == ( MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN ) )
if (*usLen == (MB_PDU_FUNC_READ_SIZE + MB_PDU_SIZE_MIN))
{
usRegAddress = ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8 );
usRegAddress |= ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1] );
usRegAddress++;
usRegAddress = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF] << 8);
usRegAddress |= (uint16_t)(pucFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1]);
usRegAddress++;
usRegCount = ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF] << 8 );
usRegCount |= ( uint16_t )( pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF + 1] );
usRegCount = (uint16_t)(pucFrame[MB_PDU_FUNC_READ_REGCNT_OFF] << 8);
usRegCount |= (uint16_t)(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 ) )
/* 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;
/* Set the current PDU data pointer to the beginning. */
/* First byte contains the function code. */
*pucFrameCur++ = MB_FUNC_READ_INPUT_REGISTER;
*usLen += 1;
pucFrameCur = &pucFrame[MB_PDU_FUNC_OFF];
*usLen = MB_PDU_FUNC_OFF;
/* Second byte in the response contain the number of bytes. */
*pucFrameCur++ = ( uint8_t )( usRegCount * 2 );
*usLen += 1;
/* First byte contains the function code. */
eRegStatus =
eMBRegInputCB( pucFrameCur, usRegAddress, usRegCount );
*pucFrameCur++ = MB_FUNC_READ_INPUT_REGISTER;
*usLen += 1;
/* If an error occured convert it into a Modbus exception. */
if( eRegStatus != MB_ENOERR )
/* Second byte in the response contain the number of bytes. */
*pucFrameCur++ = (uint8_t)(usRegCount * 2);
*usLen += 1;
eRegStatus = eMBRegInputCB(pucFrameCur, usRegAddress, usRegCount);
/* If an error occured convert it into a Modbus exception. */
if (eRegStatus != MB_ENOERR)
{
eStatus = prveMBError2Exception( eRegStatus );
eStatus = prveMBError2Exception(eRegStatus);
}
else
else
{
*usLen += usRegCount * 2;
*usLen += usRegCount * 2;
}
}
else
{
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
}
else
else
{
/* Can't be a valid read input register request because the length
* is incorrect. */
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
/* Can't be a valid read input register request because the length
* is incorrect.
*/
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
}
return eStatus;
return eStatus;
}
#endif

74
modbus/functions/mbfuncother.c
View File

@ -1,5 +1,7 @@
/*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
/****************************************************************************
* apps/functions/mbfuncother.c
*
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*
@ -25,64 +27,72 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* File: $Id: mbfuncother.c,v 1.8 2006/12/07 22:10:34 wolti Exp $
*/
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
/* ----------------------- System includes ----------------------------------*/
#include <nuttx/config.h>
#include <stdlib.h>
#include <string.h>
/* ----------------------- Platform includes --------------------------------*/
#include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h>
#include <apps/modbus/mbframe.h>
#include <apps/modbus/mbproto.h>
#ifdef CONFIG_MB_FUNC_OTHER_REP_SLAVEID_ENABLED
/* ----------------------- Static variables ---------------------------------*/
/****************************************************************************
* Private Data
****************************************************************************/
static uint8_t ucMBSlaveID[CONFIG_MB_FUNC_OTHER_REP_SLAVEID_BUF];
static uint16_t usMBSlaveIDLen;
/* ----------------------- Start implementation -----------------------------*/
/****************************************************************************
* Public Functions
****************************************************************************/
eMBErrorCode
eMBSetSlaveID( uint8_t ucSlaveID, bool xIsRunning,
uint8_t const *pucAdditional, uint16_t usAdditionalLen )
eMBErrorCode eMBSetSlaveID(uint8_t ucSlaveID, bool xIsRunning,
uint8_t const *pucAdditional,
uint16_t usAdditionalLen)
{
eMBErrorCode eStatus = MB_ENOERR;
eMBErrorCode eStatus = MB_ENOERR;
/* the first byte and second byte in the buffer is reserved for
* the parameter ucSlaveID and the running flag. The rest of
* the buffer is available for additional data. */
if( usAdditionalLen + 2 < CONFIG_MB_FUNC_OTHER_REP_SLAVEID_BUF )
/* the first byte and second byte in the buffer is reserved for
* the parameter ucSlaveID and the running flag. The rest of
* the buffer is available for additional data.
*/
if (usAdditionalLen + 2 < CONFIG_MB_FUNC_OTHER_REP_SLAVEID_BUF)
{
usMBSlaveIDLen = 0;
ucMBSlaveID[usMBSlaveIDLen++] = ucSlaveID;
ucMBSlaveID[usMBSlaveIDLen++] = ( uint8_t )( xIsRunning ? 0xFF : 0x00 );
if( usAdditionalLen > 0 )
usMBSlaveIDLen = 0;
ucMBSlaveID[usMBSlaveIDLen++] = ucSlaveID;
ucMBSlaveID[usMBSlaveIDLen++] = (uint8_t)(xIsRunning ? 0xFF : 0x00);
if (usAdditionalLen > 0)
{
memcpy( &ucMBSlaveID[usMBSlaveIDLen], pucAdditional,
( size_t )usAdditionalLen );
usMBSlaveIDLen += usAdditionalLen;
memcpy(&ucMBSlaveID[usMBSlaveIDLen], pucAdditional,
(size_t)usAdditionalLen);
usMBSlaveIDLen += usAdditionalLen;
}
}
else
else
{
eStatus = MB_ENORES;
eStatus = MB_ENORES;
}
return eStatus;
return eStatus;
}
eMBException
eMBFuncReportSlaveID( uint8_t * pucFrame, uint16_t * usLen )
eMBException eMBFuncReportSlaveID(uint8_t *pucFrame, uint16_t *usLen)
{
memcpy( &pucFrame[MB_PDU_DATA_OFF], &ucMBSlaveID[0], ( size_t )usMBSlaveIDLen );
*usLen = ( uint16_t )( MB_PDU_DATA_OFF + usMBSlaveIDLen );
return MB_EX_NONE;
memcpy(&pucFrame[MB_PDU_DATA_OFF], &ucMBSlaveID[0], (size_t)usMBSlaveIDLen);
*usLen = (uint16_t)(MB_PDU_DATA_OFF + usMBSlaveIDLen);
return MB_EX_NONE;
}
#endif

169
modbus/functions/mbutils.c
View File

@ -1,5 +1,7 @@
/*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
/****************************************************************************
* apps/functions/mbutils.c
*
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*
@ -25,119 +27,136 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* File: $Id: mbutils.c,v 1.6 2007/02/18 23:49:07 wolti Exp $
*/
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
/* ----------------------- System includes ----------------------------------*/
#include <nuttx/config.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
/* ----------------------- Platform includes --------------------------------*/
#include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h>
#include <apps/modbus/mbproto.h>
/* ----------------------- Defines ------------------------------------------*/
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define BITS_uint8_t 8U
/* ----------------------- Start implementation -----------------------------*/
void
xMBUtilSetBits( uint8_t * ucByteBuf, uint16_t usBitOffset, uint8_t ucNBits,
uint8_t ucValue )
/****************************************************************************
* Public Functions
****************************************************************************/
void xMBUtilSetBits(uint8_t *ucByteBuf, uint16_t usBitOffset,
uint8_t ucNBits, uint8_t ucValue)
{
uint16_t usWordBuf;
uint16_t usMask;
uint16_t usByteOffset;
uint16_t usNPreBits;
uint16_t usValue = ucValue;
uint16_t usWordBuf;
uint16_t usMask;
uint16_t usByteOffset;
uint16_t usNPreBits;
uint16_t usValue = ucValue;
ASSERT( ucNBits <= 8 );
ASSERT( ( size_t )BITS_uint8_t == sizeof( uint8_t ) * 8 );
ASSERT(ucNBits <= 8);
ASSERT((size_t)BITS_uint8_t == sizeof(uint8_t) * 8);
/* Calculate byte offset for first byte containing the bit values starting
* at usBitOffset. */
usByteOffset = ( uint16_t )( ( usBitOffset ) / BITS_uint8_t );
/* Calculate byte offset for first byte containing the bit values starting
* at usBitOffset.
*/
/* How many bits precede our bits to set. */
usNPreBits = ( uint16_t )( usBitOffset - usByteOffset * BITS_uint8_t );
usByteOffset = (uint16_t)((usBitOffset) / BITS_uint8_t);
/* Move bit field into position over bits to set */
usValue <<= usNPreBits;
/* How many bits precede our bits to set. */
/* Prepare a mask for setting the new bits. */
usMask = ( uint16_t )( ( 1 << ( uint16_t ) ucNBits ) - 1 );
usMask <<= usBitOffset - usByteOffset * BITS_uint8_t;
usNPreBits = (uint16_t)(usBitOffset - usByteOffset * BITS_uint8_t);
/* copy bits into temporary storage. */
usWordBuf = ucByteBuf[usByteOffset];
usWordBuf |= ucByteBuf[usByteOffset + 1] << BITS_uint8_t;
/* Move bit field into position over bits to set */
/* Zero out bit field bits and then or value bits into them. */
usWordBuf = ( uint16_t )( ( usWordBuf & ( ~usMask ) ) | usValue );
usValue <<= usNPreBits;
/* move bits back into storage */
ucByteBuf[usByteOffset] = ( uint8_t )( usWordBuf & 0xFF );
ucByteBuf[usByteOffset + 1] = ( uint8_t )( usWordBuf >> BITS_uint8_t );
/* Prepare a mask for setting the new bits. */
usMask = (uint16_t)((1 << (uint16_t) ucNBits) - 1);
usMask <<= usBitOffset - usByteOffset * BITS_uint8_t;
/* copy bits into temporary storage. */
usWordBuf = ucByteBuf[usByteOffset];
usWordBuf |= ucByteBuf[usByteOffset + 1] << BITS_uint8_t;
/* Zero out bit field bits and then or value bits into them. */
usWordBuf = (uint16_t)((usWordBuf & (~usMask)) | usValue);
/* move bits back into storage */
ucByteBuf[usByteOffset] = (uint8_t)(usWordBuf & 0xFF);
ucByteBuf[usByteOffset + 1] = (uint8_t)(usWordBuf >> BITS_uint8_t);
}
uint8_t
xMBUtilGetBits( uint8_t * ucByteBuf, uint16_t usBitOffset, uint8_t ucNBits )
uint8_t xMBUtilGetBits(uint8_t *ucByteBuf, uint16_t usBitOffset, uint8_t ucNBits)
{
uint16_t usWordBuf;
uint16_t usMask;
uint16_t usByteOffset;
uint16_t usNPreBits;
uint16_t usWordBuf;
uint16_t usMask;
uint16_t usByteOffset;
uint16_t usNPreBits;
/* Calculate byte offset for first byte containing the bit values starting
* at usBitOffset. */
usByteOffset = ( uint16_t )( ( usBitOffset ) / BITS_uint8_t );
/* Calculate byte offset for first byte containing the bit values starting
* at usBitOffset.
*/
/* How many bits precede our bits to set. */
usNPreBits = ( uint16_t )( usBitOffset - usByteOffset * BITS_uint8_t );
usByteOffset = (uint16_t)((usBitOffset) / BITS_uint8_t);
/* Prepare a mask for setting the new bits. */
usMask = ( uint16_t )( ( 1 << ( uint16_t ) ucNBits ) - 1 );
/* How many bits precede our bits to set. */
/* copy bits into temporary storage. */
usWordBuf = ucByteBuf[usByteOffset];
usWordBuf |= ucByteBuf[usByteOffset + 1] << BITS_uint8_t;
usNPreBits = (uint16_t)(usBitOffset - usByteOffset * BITS_uint8_t);
/* throw away unneeded bits. */
usWordBuf >>= usNPreBits;
/* Prepare a mask for setting the new bits. */
/* mask away bits above the requested bitfield. */
usWordBuf &= usMask;
usMask = (uint16_t)((1 << (uint16_t) ucNBits) - 1);
return ( uint8_t ) usWordBuf;
/* copy bits into temporary storage. */
usWordBuf = ucByteBuf[usByteOffset];
usWordBuf |= ucByteBuf[usByteOffset + 1] << BITS_uint8_t;
/* throw away unneeded bits. */
usWordBuf >>= usNPreBits;
/* mask away bits above the requested bitfield. */
usWordBuf &= usMask;
return (uint8_t) usWordBuf;
}
eMBException
prveMBError2Exception( eMBErrorCode eErrorCode )
eMBException prveMBError2Exception(eMBErrorCode eErrorCode)
{
eMBException eStatus;
eMBException eStatus;
switch ( eErrorCode )
switch (eErrorCode)
{
case MB_ENOERR:
eStatus = MB_EX_NONE;
break;
case MB_ENOERR:
eStatus = MB_EX_NONE;
break;
case MB_ENOREG:
eStatus = MB_EX_ILLEGAL_DATA_ADDRESS;
break;
case MB_ENOREG:
eStatus = MB_EX_ILLEGAL_DATA_ADDRESS;
break;
case MB_ETIMEDOUT:
eStatus = MB_EX_SLAVE_BUSY;
break;
case MB_ETIMEDOUT:
eStatus = MB_EX_SLAVE_BUSY;
break;
default:
eStatus = MB_EX_SLAVE_DEVICE_FAILURE;
break;
default:
eStatus = MB_EX_SLAVE_DEVICE_FAILURE;
break;
}
return eStatus;
return eStatus;
}

2
modbus/mb.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/mb.c
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

3
modbus/nuttx/portevent.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/nuttx/portevent.c
*
* FreeModbus Libary: NuttX Port
* FreeModbus Library: NuttX Port
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*
@ -90,3 +90,4 @@ bool xMBPortEventGet(eMBEventType * eEvent)
return xEventHappened;
}

2
modbus/nuttx/portother.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/nuttx/portother.c
*
* FreeModbus Libary: NuttX Port
* FreeModbus Library: NuttX Port
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
modbus/nuttx/portserial.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/nuttx/portserial.c
*
* FreeModbus Libary: NuttX Port
* FreeModbus Library: NuttX Port
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
modbus/nuttx/porttimer.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/nuttx/porttimer.c
*
* FreeModbus Libary: NuttX Port
* FreeModbus Library: NuttX Port
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
modbus/rtu/mbcrc.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/rtu/mbcrc.c
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
modbus/rtu/mbrtu.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/rtu/mbrtu.c
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
modbus/tcp/mbtcp.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/tcp/mbtcp.c
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*

2
modbus/tcp/mbtcp.h
View File

@ -1,7 +1,7 @@
/****************************************************************************
* apps/modbus/tcp/mbtcp.h
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
*