/* * 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; //每个寄存器存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; }