ATY_LIB/MODBUS_S_LOW_ATY.c

/**
* @file MODBUS_S_LOW_ATY.c
*
* @param Project DEVICE_GENERAL_ATY_LIB
*
* @author ATY
*
* @copyright
*       - Copyright 2017 - 2023 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*
* @brief Familiar functions of modbus for all device
*
* @note 4 byte per reg, save float or uint32
*
* @version
*       - 1_01_221029 > ATY
*           -# Preliminary version, first Release
*       - 1_02_240120 > ATY
*           -# add multy addr and channel
*           -# add lock
********************************************************************************
*/

#ifndef __MODBUS_S_LOW_ATY_C
#define __MODBUS_S_LOW_ATY_C

#include "MODBUS_S_LOW_ATY.h"

/******************************* For user *************************************/

/******************************************************************************/

/**
 * @brief   modbus process
 *
 * @param   buf
 * @param   len
 * @param   dev
 * @return  uint8_t
 * @note    only make 03/06/10 function code, others will return err 01
 */
uint8_t Modbus_Process(uint8_t* buf, uint8_t len, struct MODBUS_S_LOW_ATY_Dev* dev)
{
    uint8_t sendBuf[(MODBUS_REG_HOLDING_SIZE * 2) + 4] = {0x00};
    uint16_t sendBufSize = 4;

    __ATY_LOCK(dev);
    sendBuf[0] = buf[0];
    sendBuf[1] = buf[1];

    if(buf[0] == dev->addr){                        // check addr
        if(len < 4){                                // check buf min size
            sendBuf[1] = buf[1] + 0x80;
            sendBuf[2] = 0x02;
            sendBufSize = 6;
        }
        else if(CheckCrc16Modbus(buf, len)){        // check crc
            sendBuf[1] = buf[1] + 0x80;
            sendBuf[2] = 0x08;
            sendBufSize = 6;
        }
        else{
            switch(buf[1])                          // check function code
            {
                // case MODBUS_FUNC_READ_COILS:{break; }
                // case MODBUS_FUNC_READ_DISCRETE_INPUTS:{break; }
                case MODBUS_FUNC_READ_HOLDING_REGISTERS:{
                    uint16_t i = 0, startAddr = 0, regCount = 0;
                    startAddr = ((buf[2] << 8) + buf[3]);
                    regCount = ((buf[4] << 8) + buf[5]);
                    if(startAddr + regCount - 1 > MODBUS_REG_HOLDING_SIZE){
                        sendBuf[1] = buf[1] + 0x80;
                        sendBuf[2] = 0x02;
                        sendBufSize = 6;
                        break;
                    }
                    sendBuf[2] = regCount * 2;
                    sendBufSize += 1;
                    for(i = 0; i < regCount; i++){
                        if(dev->bigEndian){
                            sendBuf[2 + (i * 2) + 1] = dev->mbRegs[startAddr + i];
                            sendBuf[2 + (i * 2) + 2] = dev->mbRegs[startAddr + i] >> 8;
                        }
                        else{
                            sendBuf[2 + (i * 2) + 1] = dev->mbRegs[startAddr + i] >> 8;
                            sendBuf[2 + (i * 2) + 2] = dev->mbRegs[startAddr + i];
                        }
                        sendBufSize += 2;
                    }
                    break;
                }
            // case MODBUS_FUNC_READ_INPUT_REGISTERS:{break; }
            // case MODBUS_FUNC_WRITE_SINGLE_COIL:{break; }
                case MODBUS_FUNC_WRITE_SINGLE_HOLDING_REGISTERS:{
                    uint16_t startAddr = 0;
                    startAddr = (((uint16_t)buf[2] << 8) + (uint16_t)buf[3]);
                    if(startAddr >= MODBUS_REG_HOLDING_SIZE){
                        sendBuf[1] = buf[1] + 0x80;
                        sendBuf[2] = 0x02;
                        sendBufSize = 6;
                        break;
                    }
                    if(dev->bigEndian){
                        dev->mbRegs[startAddr] = buf[4] + buf[5] << 8;
                    }
                    else{
                        dev->mbRegs[startAddr] = buf[4] << 8 + buf[5];
                    }
                    sendBuf[2] = startAddr >> 8;
                    sendBuf[3] = startAddr;
                    if(dev->bigEndian){
                        sendBuf[4] = dev->mbRegs[startAddr];
                        sendBuf[5] = dev->mbRegs[startAddr] >> 8;
                    }
                    else{
                        sendBuf[4] = dev->mbRegs[startAddr] >> 8;
                        sendBuf[5] = dev->mbRegs[startAddr];
                    }
                    sendBufSize += 4;
                    dev->setFlag = 1;
                    break;
                }
                case MODBUS_FUNC_WRITE_MULTY_HOLDING_REGISTERS:{
                    uint16_t i = 0, startAddr = 0, regCount = 0;
                    startAddr = ((buf[2] << 8) + buf[3]);
                    regCount = ((buf[4] << 8) + buf[5]);
                    if(startAddr + regCount - 1 > MODBUS_REG_HOLDING_SIZE){
                        sendBuf[1] = buf[1] + 0x80;
                        sendBuf[2] = 0x02;
                        sendBufSize = 6;
                        break;
                    }
                    for(i = 0; i < regCount; i++)
                    {
                        if(dev->bigEndian){
                            dev->mbRegs[startAddr + i] = (buf[6 + (i * 2) + 1]) + (buf[6 + (i * 2) + 2] << 8);
                        }
                        else{
                            dev->mbRegs[startAddr + i] = (buf[6 + (i * 2) + 1] << 8) + (buf[6 + (i * 2) + 2]);
                        }
                    }

                    sendBuf[2] = startAddr >> 8;
                    sendBuf[3] = startAddr;
                    sendBuf[4] = regCount >> 8;
                    sendBuf[5] = regCount;
                    sendBufSize += 4;
                    dev->setFlag = 1;
                    break;
                }
                default:{
                    sendBuf[1] = buf[1] + 0x80;
                    sendBuf[2] = 0x01;
                    sendBufSize = 6;
                    break;
                }
            }
        }
        sendBuf[sendBufSize - 2] = GenCrc16ModbusHL(sendBuf, sendBufSize - 2, 1);
        sendBuf[sendBufSize - 1] = GenCrc16ModbusHL(sendBuf, sendBufSize - 2, 0);
        dev->uartSendBytes(sendBuf, sendBufSize);
    }
    __ATY_UNLOCK(dev);
    return 0;
}

#endif /* __MODBUS_S_LOW_ATY_C */

/******************************** End Of File *********************************/