[RT-THREAD]agile—modbus移植记录

#include "agile_modbus_slave_app.h"

// ¼ì²éaddr
static int addr_check(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info) {
    int slave = slave_info->sft->slave;
    if ((slave != ctx->slave) && (slave != AGILE_MODBUS_BROADCAST_ADDRESS) && (slave != 0xFF)) {
        return -AGILE_MODBUS_EXCEPTION_UNKNOW;
    }
    return 0;
}

// ÏßȦ״̬
static uint8_t _tab_bits[8] = {0};

static int get_map_buf(void *buf, int bufsz) {
    uint8_t *ptr = (uint8_t *)buf;
    for (int i = 0; i < sizeof(_tab_bits); i++) {
        ptr[i] = _tab_bits[i];
    }
    return 0;
}

static int set_map_buf(int index, int len, void *buf, int bufsz) {
    uint8_t *ptr = (uint8_t *)buf;
    for (int i = 0; i < len; i++) {
        _tab_bits[index + i] = ptr[index + i];
    }
    return 0;
}

const agile_modbus_slave_util_map_t bit_maps = {0x00, 0x00 + sizeof(_tab_bits), get_map_buf, set_map_buf};

// ÊäÈë״̬
static uint8_t _tab_input_bits[8] = {0};

static int get_input_buf(void *buf, int bufsz) {
    uint8_t *ptr = (uint8_t *)buf;
    for (int i = 0; i < sizeof(_tab_input_bits); i++) {
        ptr[i] = _tab_input_bits[i];
    }
    return 0;
}

const agile_modbus_slave_util_map_t input_bit_maps = {0x00, 0x00 + sizeof(_tab_input_bits), get_input_buf, NULL};

// ÊäÈë¼Ä´æÆ÷
static uint16_t _tab_input_registers[20] = {0};

static int get_inputReg_buf(void *buf, int bufsz) {
    uint16_t *ptr = (uint16_t *)buf;
    for (int i = 0; i < sizeof(_tab_input_registers) / sizeof(_tab_input_registers[0]); i++) {
        ptr[i] = _tab_input_registers[i];
    }
    return 0;
}

const agile_modbus_slave_util_map_t input_register_maps = {0x00, 0x00 + sizeof(_tab_input_registers), get_inputReg_buf,
                                                           NULL};

// ±£³Ö¼Ä´æÆ÷
static uint16_t _tab_registers[20] = {0};

static int get_registers_buf(void *buf, int bufsz) {
    uint16_t *ptr = (uint16_t *)buf;
    for (int i = 0; i < sizeof(_tab_registers) / sizeof(_tab_registers[0]); i++) {
        ptr[i] = _tab_registers[i];
    }
    return 0;
}

static int set_registers_buf(int index, int len, void *buf, int bufsz) {
    uint16_t *ptr = (uint16_t *)buf;
    for (int i = 0; i < len; i++) {
        _tab_registers[index + i] = ptr[index + i];
    }
    return 0;
}

const agile_modbus_slave_util_map_t register_maps = {0x00, 0x00 + sizeof(_tab_registers), get_registers_buf,
                                                     set_registers_buf};

//
const agile_modbus_slave_util_t slave_util = {&bit_maps,
                                              sizeof(bit_maps),
                                              &input_bit_maps,
                                              sizeof(input_bit_maps),
                                              &register_maps,
                                              sizeof(register_maps),
                                              &input_register_maps,
                                              sizeof(input_register_maps),
                                              addr_check,
                                              NULL,
                                              NULL};

/**
 *  @brief agile_modbus³õʼ»¯
 *  @param
 *  @retval
 */
agile_modbus_rtu_t modbus_slaver           = {0}; // modbus´Ó»ú¾ä±ú
static uint8_t     SlaverRequestBuff[256]  = {0}; // ÇëÇ󻺳åÇø
static uint8_t     SlaverResponseBuff[256] = {0}; // ÏìÓ¦»º³åÇø

void agile_modbus_init() {
    agile_modbus_rtu_init(&modbus_slaver, SlaverResponseBuff, sizeof(SlaverResponseBuff), SlaverRequestBuff,
                          sizeof(SlaverRequestBuff));
    agile_modbus_set_slave(&modbus_slaver._ctx, ThisID);
}

/**
 *  @brief agile_modbusÈÎÎñ
 *  @param
 *  @retval
 */
void agile_modbus_slave_task() {
    memcpy(SlaverRequestBuff, RS485RxBuffer, RS485RxLenth);
    if (RS485RxLenth) {
        int SlaverResponseBufLength = agile_modbus_slave_handle(&modbus_slaver._ctx, RS485RxLenth, true,
                                                                agile_modbus_slave_util_callback, &slave_util, NULL);
        if (SlaverResponseBufLength > 0) {
            _printfh(SlaverResponseBuff, SlaverResponseBufLength);
        }
    }
}