///* // * 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; //} //