Modbus-rtu/PLSR/Src/plsr_modbus_data.c

#include "plsr_modbus_data.h"
#include "modbus_data_store.h"
#include <stddef.h>

#ifndef PLSR_HOST_TEST
#include "stm32f4xx_hal.h"

typedef struct
{
    GPIO_TypeDef *port;
    uint16_t pin;
    uint8_t point;
    uint8_t activeLow;
} PLSR_MODBUS_INPUT_PIN;

/* Project attachment "实现PLSR指令.pdf", XDM-60T4-E page 3.
 * X13=PA14 is intentionally omitted because PA14 is SWDCLK while board
 * validation/debug is active.  X21..X43 have no supplied MCU mapping. */
static const PLSR_MODBUS_INPUT_PIN PlsrModbusInputPins[] =
{
    {GPIOH, GPIO_PIN_10, 0U, 0U},  /* X0  */
    {GPIOH, GPIO_PIN_11, 1U, 0U},  /* X1  */
    {GPIOG, GPIO_PIN_8,  2U, 0U},  /* X2  */
    {GPIOB, GPIO_PIN_4,  3U, 0U},  /* X3  */
    {GPIOB, GPIO_PIN_5,  4U, 0U},  /* X4  */
    {GPIOG, GPIO_PIN_12, 5U, 0U},  /* X5  */
    {GPIOB, GPIO_PIN_6,  6U, 0U},  /* X6  */
    {GPIOB, GPIO_PIN_7,  7U, 0U},  /* X7  */
    {GPIOF, GPIO_PIN_10, 10U, 0U}, /* X10 */
    {GPIOA, GPIO_PIN_15, 11U, 0U}, /* X11 */
    {GPIOB, GPIO_PIN_3,  12U, 0U}, /* X12 */
    {GPIOI, GPIO_PIN_4,  14U, 0U}, /* X14 */
    {GPIOI, GPIO_PIN_5,  15U, 0U}, /* X15 */
    {GPIOI, GPIO_PIN_6,  16U, 0U}, /* X16 */
    {GPIOI, GPIO_PIN_7,  17U, 0U}, /* X17 */
    {GPIOE, GPIO_PIN_2,  20U, 0U}  /* X20 */
};

#define PLSR_MODBUS_INPUT_PIN_COUNT \
    ((uint32_t)(sizeof(PlsrModbusInputPins) \
                / sizeof(PlsrModbusInputPins[0])))

static uint32_t PlsrModbusInputRawMask;
static uint32_t PlsrModbusInputLogicalMask;
static uint32_t PlsrModbusInputMappedMask;

static uint8_t PlsrModbusInputIsMapped(uint32_t point)
{
    return ((point < 32UL)
            && ((PlsrModbusInputMappedMask & (1UL << point)) != 0UL))
               ? 1U
               : 0U;
}
#endif

static uint8_t PlsrModbusDevice(PLSR_DEVICE_TYPE device,
                                MODBUS_DATA_DEVICE *modbusDevice)
{
    if ((modbusDevice == NULL) || (device > PLSR_DEVICE_FD))
    {
        return 0U;
    }
    *modbusDevice = (MODBUS_DATA_DEVICE)device;
    return 1U;
}

static uint8_t PlsrModbusValidateWords(void *context,
                                       PLSR_DEVICE_TYPE device,
                                       uint32_t firstAddress,
                                       uint32_t wordCount)
{
    MODBUS_DATA_DEVICE modbusDevice;

    (void)context;
    if (PlsrModbusDevice(device, &modbusDevice) == 0U)
    {
        return 0U;
    }
    return ModbusDataValidateWords(modbusDevice, firstAddress, wordCount);
}

static uint8_t PlsrModbusReadWord(void *context,
                                  PLSR_DEVICE_TYPE device,
                                  uint32_t address,
                                  uint16_t *value)
{
    MODBUS_DATA_DEVICE modbusDevice;

    (void)context;
    if (PlsrModbusDevice(device, &modbusDevice) == 0U)
    {
        return 0U;
    }
    return ModbusDataReadWord(modbusDevice, address, value);
}

static uint8_t PlsrModbusReadDword(void *context,
                                   PLSR_DEVICE_TYPE device,
                                   uint32_t address,
                                   int32_t *value)
{
    MODBUS_DATA_DEVICE modbusDevice;

    (void)context;
    if (PlsrModbusDevice(device, &modbusDevice) == 0U)
    {
        return 0U;
    }
    return ModbusDataReadDword(modbusDevice, address, value);
}

static uint8_t PlsrModbusBitDevice(PLSR_DEVICE_TYPE device,
                                   MODBUS_BIT_DEVICE *modbusDevice)
{
    if ((modbusDevice == NULL) || (device < PLSR_DEVICE_X)
        || (device > PLSR_DEVICE_HM))
    {
        return 0U;
    }
    *modbusDevice = (MODBUS_BIT_DEVICE)(device - PLSR_DEVICE_X);
    return 1U;
}

static uint8_t PlsrModbusReadBit(void *context,
                                 PLSR_DEVICE_TYPE device,
                                 uint32_t address,
                                 uint8_t *value)
{
    MODBUS_BIT_DEVICE modbusDevice;

    (void)context;
    if (PlsrModbusBitDevice(device, &modbusDevice) == 0U)
    {
        return 0U;
    }
#ifndef PLSR_HOST_TEST
    if ((device == PLSR_DEVICE_X)
        && (PlsrModbusInputIsMapped(address) == 0U))
    {
        return 0U;
    }
#endif
    return ModbusDataReadBit(modbusDevice, address, value);
}

void PlsrModbusDataSourceInit(PLSR_DATA_SOURCE *source)
{
    if (source == NULL)
    {
        return;
    }
    source->context = NULL;
    source->validateWords = PlsrModbusValidateWords;
    source->readWord = PlsrModbusReadWord;
    source->readDword = PlsrModbusReadDword;
    source->readBit = PlsrModbusReadBit;
}

PLSR_RESULT PlsrModbusInputInit(void)
{
#ifdef PLSR_HOST_TEST
    return PLSR_RESULT_OK;
#else
    GPIO_InitTypeDef gpio;
    uint32_t index;

    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    __HAL_RCC_GPIOE_CLK_ENABLE();
    __HAL_RCC_GPIOF_CLK_ENABLE();
    __HAL_RCC_GPIOG_CLK_ENABLE();
    __HAL_RCC_GPIOH_CLK_ENABLE();
    __HAL_RCC_GPIOI_CLK_ENABLE();

    gpio.Mode = GPIO_MODE_INPUT;
    gpio.Pull = GPIO_NOPULL;
    gpio.Speed = GPIO_SPEED_FREQ_LOW;
    gpio.Alternate = 0U;
    PlsrModbusInputMappedMask = 0UL;
    for (index = 0UL; index < PLSR_MODBUS_INPUT_PIN_COUNT; index++)
    {
        gpio.Pin = PlsrModbusInputPins[index].pin;
        HAL_GPIO_Init(PlsrModbusInputPins[index].port, &gpio);
        PlsrModbusInputMappedMask |=
            1UL << PlsrModbusInputPins[index].point;
    }
    PlsrModbusInputPoll();
    return PLSR_RESULT_OK;
#endif
}

void PlsrModbusInputPoll(void)
{
#ifndef PLSR_HOST_TEST
    uint32_t rawMask = 0UL;
    uint32_t logicalMask = 0UL;
    uint32_t index;

    for (index = 0UL; index < PLSR_MODBUS_INPUT_PIN_COUNT; index++)
    {
        const PLSR_MODBUS_INPUT_PIN *input = &PlsrModbusInputPins[index];
        uint8_t raw = ((input->port->IDR & input->pin) != 0UL) ? 1U : 0U;
        uint8_t logical = (input->activeLow != 0U)
                              ? ((raw == 0U) ? 1U : 0U)
                              : raw;

        if (raw != 0U)
        {
            rawMask |= 1UL << input->point;
        }
        if (logical != 0U)
        {
            logicalMask |= 1UL << input->point;
        }
        (void)ModbusDataWriteBit(MODBUS_BIT_DEVICE_X,
                                 input->point,
                                 logical);
    }
    PlsrModbusInputRawMask = rawMask;
    PlsrModbusInputLogicalMask = logicalMask;
#endif
}

uint32_t PlsrModbusInputGetRawMask(void)
{
#ifdef PLSR_HOST_TEST
    return 0UL;
#else
    return PlsrModbusInputRawMask;
#endif
}

uint32_t PlsrModbusInputGetLogicalMask(void)
{
#ifdef PLSR_HOST_TEST
    return 0UL;
#else
    return PlsrModbusInputLogicalMask;
#endif
}

uint32_t PlsrModbusInputGetMappedMask(void)
{
#ifdef PLSR_HOST_TEST
    return 0UL;
#else
    return PlsrModbusInputMappedMask;
#endif
}