master.impl.h

Go to the documentation of this file.

#ifndef LIGHTMODBUS_MASTER_IMPL_H
#define LIGHTMODBUS_MASTER_IMPL_H
 
#include "master.h"
#include "master_func.h"
 
ModbusMasterFunctionHandler modbusMasterDefaultFunctions[] =
{
#if defined(LIGHTMODBUS_F01M) || defined(LIGHTMODBUS_MASTER_FULL)
    {1, modbusParseResponse01020304},
#endif
 
#if defined(LIGHTMODBUS_F02M) || defined(LIGHTMODBUS_MASTER_FULL)
    {2, modbusParseResponse01020304},
#endif
 
#if defined(LIGHTMODBUS_F03M) || defined(LIGHTMODBUS_MASTER_FULL)
    {3, modbusParseResponse01020304},
#endif
 
#if defined(LIGHTMODBUS_F04M) || defined(LIGHTMODBUS_MASTER_FULL)
    {4, modbusParseResponse01020304},
#endif
 
#if defined(LIGHTMODBUS_F05M) || defined(LIGHTMODBUS_MASTER_FULL)
    {5, modbusParseResponse0506},
#endif
 
#if defined(LIGHTMODBUS_F06M) || defined(LIGHTMODBUS_MASTER_FULL)
    {6, modbusParseResponse0506},
#endif
 
#if defined(LIGHTMODBUS_F15M) || defined(LIGHTMODBUS_MASTER_FULL)
    {15, modbusParseResponse1516},
#endif
 
#if defined(LIGHTMODBUS_F16M) || defined(LIGHTMODBUS_MASTER_FULL)
    {16, modbusParseResponse1516},
#endif
 
#if defined(LIGHTMODBUS_F22M) || defined(LIGHTMODBUS_MASTER_FULL)
    {22, modbusParseResponse22},
#endif
 
    // Guard - prevents 0 size array
    {0, NULL}
};
 
const uint8_t modbusMasterDefaultFunctionCount = sizeof(modbusMasterDefaultFunctions) / sizeof(modbusMasterDefaultFunctions[0]) - 1;
 
LIGHTMODBUS_RET_ERROR modbusMasterInit(
    ModbusMaster *status,
    ModbusDataCallback dataCallback,
    ModbusMasterExceptionCallback exceptionCallback,
    ModbusAllocator allocator,
    const ModbusMasterFunctionHandler *functions,
    uint8_t functionCount)
{
    status->dataCallback = dataCallback;
    status->exceptionCallback = exceptionCallback;
    status->functions = functions;
    status->functionCount = functionCount;
    status->context = NULL;
 
    return modbusBufferInit(&status->request, allocator);
}
 
void modbusMasterDestroy(ModbusMaster *status)
{
    modbusBufferDestroy(&status->request, modbusMasterGetUserPointer(status));
}
 
LIGHTMODBUS_RET_ERROR modbusBeginRequestPDU(ModbusMaster *status)
{
    modbusBufferModePDU(&status->request);
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusEndRequestPDU(ModbusMaster *status)
{
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusBeginRequestRTU(ModbusMaster *status)
{
    modbusBufferModeRTU(&status->request);
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusEndRequestRTU(ModbusMaster *status, uint8_t address)
{
    ModbusError err = modbusPackRTU(
        &status->request.data[0],
        status->request.length,
        address);
    
    if (err != MODBUS_OK)
        return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_GENERAL, err);
 
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusBeginRequestTCP(ModbusMaster *status)
{
    modbusBufferModeTCP(&status->request);
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusEndRequestTCP(ModbusMaster *status, uint16_t transactionID, uint8_t unitID)
{
    ModbusError err = modbusPackTCP(
        &status->request.data[0],
        status->request.length,
        transactionID,
        unitID);
 
    if (err != MODBUS_OK)
        return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_GENERAL, err);
 
    return MODBUS_NO_ERROR();
}
 
LIGHTMODBUS_RET_ERROR modbusParseResponsePDU(
    ModbusMaster *status,
    uint8_t address,
    const uint8_t *request,
    uint8_t requestLength,
    const uint8_t *response,
    uint8_t responseLength)
{
    // Check if lengths are ok
    if (!requestLength || requestLength > MODBUS_PDU_MAX)
        return MODBUS_REQUEST_ERROR(LENGTH);
    if (!responseLength || responseLength > MODBUS_PDU_MAX)
        return MODBUS_RESPONSE_ERROR(LENGTH);
    
    uint8_t function = response[0];
 
    // Handle exception frames
    if (function & 0x80 && responseLength == 2)
    {
        if (status->exceptionCallback)
            status->exceptionCallback(
                status,
                address,
                function & 0x7f,
                (ModbusExceptionCode) response[1]);
 
        return MODBUS_NO_ERROR();
    }
 
    // Check if function code matches the one in request frame
    if (function != request[0])
        return MODBUS_RESPONSE_ERROR(FUNCTION);
 
    // Find a parsing function
    for (uint16_t i = 0; i < status->functionCount; i++)
        if (function == status->functions[i].id)
            return status->functions[i].ptr(
                status,
                address,
                function,
                request,
                requestLength,
                response,
                responseLength);
 
    // No matching function handler
    return MODBUS_GENERAL_ERROR(FUNCTION);
}
 
LIGHTMODBUS_RET_ERROR modbusParseResponseRTU(
    ModbusMaster *status,
    const uint8_t *request,
    uint16_t requestLength,
    const uint8_t *response,
    uint16_t responseLength)
{
    // Unpack request
    const uint8_t *requestPDU;
    uint16_t requestPDULength;
    uint8_t requestAddress;
    ModbusError err = modbusUnpackRTU(
        request,
        requestLength,
#ifdef LIGHTMODBUS_MASTER_OMIT_REQUEST_CRC
        0,
#else
        1,
#endif
        &requestPDU,
        &requestPDULength,
        &requestAddress);
 
    if (err != MODBUS_OK)
        return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_REQUEST, err);
 
    // Unpack response
    const uint8_t *responsePDU;
    uint16_t responsePDULength;
    uint8_t responseAddress;
    err = modbusUnpackRTU(
        response,
        responseLength,
        1,
        &responsePDU,
        &responsePDULength,
        &responseAddress);
    
    if (err != MODBUS_OK)
        return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_RESPONSE, err);
 
    // Check addresses - response to a broadcast request or bad response address
    if (requestAddress == 0 || requestAddress != responseAddress)
        return MODBUS_RESPONSE_ERROR(ADDRESS);
 
    // Parse the PDU itself
    return modbusParseResponsePDU(
        status,
        requestAddress,
        requestPDU,
        requestPDULength,
        responsePDU,
        responsePDULength);
}
 
LIGHTMODBUS_RET_ERROR modbusParseResponseTCP(
    ModbusMaster *status,
    const uint8_t *request,
    uint16_t requestLength,
    const uint8_t *response,
    uint16_t responseLength)
{
    // Unpack request
    const uint8_t *requestPDU;
    uint16_t requestPDULength;
    uint16_t requestTransactionID;
    uint8_t requestUnitID;
    ModbusError err = modbusUnpackTCP(
        request,
        requestLength,
        &requestPDU,
        &requestPDULength,
        &requestTransactionID,
        &requestUnitID);
 
    if (err != MODBUS_OK)
        return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_REQUEST, err);
 
    // Unpack response
    const uint8_t *responsePDU;
    uint16_t responsePDULength;
    uint16_t responseTransactionID;
    uint8_t responseUnitID;
    err = modbusUnpackTCP(
        response,
        responseLength,
        &responsePDU,
        &responsePDULength,
        &responseTransactionID,
        &responseUnitID);
    
    if (err != MODBUS_OK)
        return MODBUS_MAKE_ERROR(MODBUS_ERROR_SOURCE_RESPONSE, err);
 
    // Check if transaction IDs match
    if (requestTransactionID != responseTransactionID)
        return MODBUS_RESPONSE_ERROR(BAD_TRANSACTION);
 
    // Check if unit IDs match
    if (requestUnitID != responseUnitID)
        return MODBUS_RESPONSE_ERROR(ADDRESS);
 
    // Parse the PDU itself
    return modbusParseResponsePDU(
        status,
        requestUnitID,
        requestPDU,
        requestPDULength,
        responsePDU,
        responsePDULength);
}
 
#endif