slave.impl.h

Go to the documentation of this file.

#ifndef LIGHTMODBUS_SLAVE_IMPL_H
#define LIGHTMODBUS_SLAVE_IMPL_H
 
#include "slave.h"
#include "slave_func.h"
 
ModbusSlaveFunctionHandler modbusSlaveDefaultFunctions[] =
{
#if defined(LIGHTMODBUS_F01S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {1, modbusParseRequest01020304},
#endif
 
#if defined(LIGHTMODBUS_F02S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {2, modbusParseRequest01020304},
#endif
 
#if defined(LIGHTMODBUS_F03S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {3, modbusParseRequest01020304},
#endif
 
#if defined(LIGHTMODBUS_F04S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {4, modbusParseRequest01020304},
#endif
 
#if defined(LIGHTMODBUS_F05S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {5, modbusParseRequest0506},
#endif
 
#if defined(LIGHTMODBUS_F06S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {6, modbusParseRequest0506},
#endif
 
#if defined(LIGHTMODBUS_F15S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {15, modbusParseRequest1516},
#endif
 
#if defined(LIGHTMODBUS_F16S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {16, modbusParseRequest1516},
#endif
 
#if defined(LIGHTMODBUS_F22S) || defined(LIGHTMODBUS_SLAVE_FULL)
    {22, modbusParseRequest22},
#endif
 
    // Guard - prevents 0 array size
    {0, NULL}
};
 
const uint8_t modbusSlaveDefaultFunctionCount = sizeof(modbusSlaveDefaultFunctions) / sizeof(modbusSlaveDefaultFunctions[0]) - 1;
 
LIGHTMODBUS_RET_ERROR modbusSlaveInit(
    ModbusSlave *status,
    ModbusRegisterCallback registerCallback,
    ModbusSlaveExceptionCallback exceptionCallback,
    ModbusAllocator allocator,
    const ModbusSlaveFunctionHandler *functions,
    uint8_t functionCount)
{
    status->functions = functions;
    status->functionCount = functionCount;
    status->registerCallback = registerCallback;
    status->exceptionCallback = exceptionCallback;
    status->context = NULL;
 
    return modbusBufferInit(&status->response, allocator);
}
 
void modbusSlaveDestroy(ModbusSlave *status)
{
    modbusBufferDestroy(&status->response, modbusSlaveGetUserPointer(status));
}
 
LIGHTMODBUS_RET_ERROR modbusBuildException(
    ModbusSlave *status,
    uint8_t function,
    ModbusExceptionCode code)
{
    // Call the exception callback
    if (status->exceptionCallback)
        status->exceptionCallback(status, function, code);
 
    if (modbusSlaveAllocateResponse(status, 2))
        return MODBUS_GENERAL_ERROR(ALLOC);
 
    status->response.pdu[0] = function | 0x80;
    status->response.pdu[1] = code;
 
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusBuildExceptionPDU(
    ModbusSlave *status,
    uint8_t function,
    ModbusExceptionCode code)
{
    status->response.pduOffset = 0;
    status->response.padding = 0;
 
    ModbusErrorInfo err = modbusBuildException(status, function, code);
    if (!modbusIsOk(err))
        return err;
 
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusBuildExceptionRTU(
    ModbusSlave *status,
    uint8_t address,
    uint8_t function,
    ModbusExceptionCode code)
{
    if (address == 0)
        return MODBUS_GENERAL_ERROR(ADDRESS);
 
    status->response.pduOffset = MODBUS_RTU_PDU_OFFSET;
    status->response.padding = MODBUS_RTU_ADU_PADDING;
 
    ModbusErrorInfo errinfo = modbusBuildException(status, function, code);
 
    if (!modbusIsOk(errinfo))
        return errinfo;
 
    ModbusError err = modbusPackRTU(
        &status->response.data[0],
        status->response.length,
        address);
 
    // There's literally no reason for modbusPackRTU()
    // to return MODBUS_ERROR_LENGTH here
    (void) err;
 
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusBuildExceptionTCP(
    ModbusSlave *status,
    uint16_t transactionID,
    uint8_t unitID,
    uint8_t function,
    ModbusExceptionCode code)
{
    status->response.pduOffset = MODBUS_TCP_PDU_OFFSET;
    status->response.padding = MODBUS_TCP_ADU_PADDING;
 
    ModbusErrorInfo errinfo = modbusBuildException(status, function, code);
 
    if (!modbusIsOk(errinfo))
        return errinfo;
 
    ModbusError err = modbusPackTCP(
        &status->response.data[0],
        status->response.length,
        transactionID,
        unitID);
 
    // There's literally no reason for modbusPackTCP()
    // to return MODBUS_ERROR_LENGTH here
    (void) err;
 
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusParseRequest(ModbusSlave *status, const uint8_t *request, uint8_t requestLength)
{
    uint8_t function = request[0];
 
    // Look for matching function
    for (uint16_t i = 0; i < status->functionCount; i++)
        if (function == status->functions[i].id)
            return status->functions[i].ptr(status, function, &request[0], requestLength);
 
    // No match found
    return modbusBuildException(status, function, MODBUS_EXCEP_ILLEGAL_FUNCTION);
}
 
LIGHTMODBUS_RET_ERROR modbusParseRequestPDU(ModbusSlave *status, const uint8_t *request, uint8_t requestLength)
{
    // Check length
    if (!requestLength || requestLength > MODBUS_PDU_MAX)
        return MODBUS_REQUEST_ERROR(LENGTH);
 
    modbusBufferModePDU(&status->response);
    return modbusParseRequest(status, request, requestLength);
}
 
LIGHTMODBUS_RET_ERROR modbusParseRequestRTU(ModbusSlave *status, uint8_t slaveAddress, const uint8_t *request, uint16_t requestLength)
{
    // Unpack the request
    const uint8_t *pdu     = NULL;
    uint16_t pduLength     = 0;
    uint8_t requestAddress = 0;
    ModbusError err = modbusUnpackRTU(
        request,
        requestLength,
        1,
        &pdu,
        &pduLength,
        &requestAddress
    );
 
    if (err != MODBUS_OK)
        return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_REQUEST, err);
 
    // Verify if the frame is meant for us
    if (requestAddress != 0 && requestAddress != slaveAddress)
        return MODBUS_REQUEST_ERROR(ADDRESS);
 
    // Parse the request
    ModbusErrorInfo errinfo;
    modbusBufferModeRTU(&status->response);
    if (!modbusIsOk(errinfo = modbusParseRequest(status, pdu, pduLength)))
        return errinfo;
 
    if (status->response.length)
    {
        // Discard any response frames if the request
        // was broadcast
        if (requestAddress == 0)
        {
            modbusSlaveFreeResponse(status);
            return MODBUS_NO_ERROR();
        }
 
        // Pack the response frame
        err = modbusPackRTU(
            &status->response.data[0],
            status->response.length,
            slaveAddress);
 
        if (err != MODBUS_OK)
            return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_GENERAL, err);
    }
 
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusParseRequestTCP(ModbusSlave *status, const uint8_t *request, uint16_t requestLength)
{
    // Unpack the request
    const uint8_t *pdu;
    uint16_t pduLength;
    uint16_t transactionID;
    uint8_t unitID;
    ModbusError err = modbusUnpackTCP(
        request,
        requestLength,
        &pdu,
        &pduLength,
        &transactionID,
        &unitID
    );
 
    if (err != MODBUS_OK)
        return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_REQUEST, err);
 
    // Parse the request
    ModbusErrorInfo errinfo;
    modbusBufferModeTCP(&status->response);
    if (!modbusIsOk(errinfo = modbusParseRequest(status, pdu, pduLength)))
        return errinfo;
 
    // Write MBAP header
    if (status->response.length)
    {
        // Pack the resonse
        err = modbusPackTCP(
            &status->response.data[0],
            status->response.length,
            transactionID,
            unitID
        );
 
        if (err != MODBUS_OK)
            return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_GENERAL, err);
    }
 
    return MODBUS_NO_ERROR();
}
 
#endif