Modbus 串口

agile_modbus例程分享

发布于 2022-07-13 11:40:39 浏览：6043 订阅该版

40 条评论

aozima 2022-07-13

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

WKJay 2022-07-13

wkjay.com

Cfly 2022-07-13

这家伙很懒，什么也没写！

crystal266 2022-07-14

嵌入式

lqwuliang 2022-07-16

天下没有解决不了的bug，只有发现不了的bug.

吕蛋蛋 2022-08-02

这家伙很懒，什么也没写！

abcde1224 2022-08-08

这家伙很懒，什么也没写！

吕蛋蛋 2022-08-16

这家伙很懒，什么也没写！

吕蛋蛋 2022-08-16

这家伙很懒，什么也没写！

abcde1224 2022-08-17

这家伙很懒，什么也没写！

sxg2000 2022-10-11

这家伙很懒，什么也没写！

sxg2000 2022-10-12

这家伙很懒，什么也没写！

ZWH 2022-10-12

这个人很勤快，没空留下点什么

ZWH 2022-10-12

这个人很勤快，没空留下点什么

sxg2000 2022-10-13

这家伙很懒，什么也没写！

用户名由3_15位 2022-10-26

代码总在「分分钟搞定」的狂喜与「必有暗坑」的隐忧间往复

mumumu 2022-12-19

这家伙很懒，什么也没写！

按楼主的代码，给个单bit操作的函数代码，已测

```c
static int slave_callback(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info,const void *data)
{
    int function = slave_info->sft->function;
    int ret = 0;
    switch (function) {
    case AGILE_MODBUS_FC_READ_COILS:
    case AGILE_MODBUS_FC_READ_DISCRETE_INPUTS: {
        int address = slave_info->address;//读取开始位数
        int nb = slave_info->nb;//要读取的位数
        int send_index = slave_info->send_index;//有效数据开始字节数
        int is_input = (function == AGILE_MODBUS_FC_READ_DISCRETE_INPUTS);
        /*
        for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
            if (now_address >= 0 && now_address < TAB_MAX_NUM) {
                int index = now_address - 0;
                agile_modbus_slave_io_set(ctx->send_buf + send_index, i,
                                          is_input ? _tab_input_bits[index] : _tab_bits[index]);
            }
        }*/
        uint8_t *buf=is_input ? _tab_input_bits : _tab_bits;//获取位存储指针

for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
            if (now_address >= 0 && now_address < TAB_MAX_NUM) {
                agile_modbus_slave_io_set(ctx->send_buf + send_index, i,
                        agile_modbus_slave_io_get(buf,now_address));//复制位存储到返回存储
            }
        }
    } break;

case AGILE_MODBUS_FC_READ_HOLDING_REGISTERS:
    case AGILE_MODBUS_FC_READ_INPUT_REGISTERS: {
        int address = slave_info->address;
        int nb = slave_info->nb;
        int send_index = slave_info->send_index;
        int is_input = (function == AGILE_MODBUS_FC_READ_INPUT_REGISTERS);

for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
            if (now_address >= 0 && now_address < TAB_MAX_NUM) {
                int index = now_address - 0;
                agile_modbus_slave_register_set(ctx->send_buf + send_index, i,
                                                is_input ? _tab_input_registers[index] : _tab_registers[index]);
            }
        }
    } break;

case AGILE_MODBUS_FC_WRITE_SINGLE_COIL:
    case AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS: {
        int address = slave_info->address;

if (function == AGILE_MODBUS_FC_WRITE_SINGLE_COIL) {
            if (address >= 0 && address < TAB_MAX_NUM) {
                int index = address - 0;
                int data = *((int *)slave_info->buf);
                //_tab_bits[index] = data;
                agile_modbus_slave_io_set(_tab_bits,index,data);

}
        } else {
            int nb = slave_info->nb;
            for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
                if (now_address >= 0 && now_address < TAB_MAX_NUM) {
                    int index = now_address - 0;
                    uint8_t status = agile_modbus_slave_io_get(slave_info->buf, i);
                    //_tab_bits[index] = status;
                    agile_modbus_slave_io_set(_tab_bits,index,status);
                }
            }
        }
    } break;

case AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER:
    case AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS: {
        int address = slave_info->address;

if (function == AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER) {
            if (address >= 0 && address < TAB_MAX_NUM) {
                int index = address - 0;
                int data = *((int *)slave_info->buf);
                _tab_registers[index] = data;
            }
        } else {
            int nb = slave_info->nb;
            for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
                if (now_address >= 0 && now_address < TAB_MAX_NUM) {
                    int index = now_address - 0;
                    uint16_t data = agile_modbus_slave_register_get(slave_info->buf, i);
                    _tab_registers[index] = data;
                }
            }
        }

} break;

case AGILE_MODBUS_FC_MASK_WRITE_REGISTER: {
        int address = slave_info->address;
        if (address >= 0 && address < TAB_MAX_NUM) {
            int index = address - 0;
            uint16_t data = _tab_registers[index];
            uint16_t and = (slave_info->buf[0] << 8) + slave_info->buf[1];
            uint16_t or = (slave_info->buf[2] << 8) + slave_info->buf[3];

data = (data & and) | (or &(~and));

_tab_registers[index] = data;
        }
    } break;

case AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS: {
        int address = slave_info->address;
        int nb = (slave_info->buf[0] << 8) + slave_info->buf[1];
        uint16_t address_write = (slave_info->buf[2] << 8) + slave_info->buf[3];
        int nb_write = (slave_info->buf[4] << 8) + slave_info->buf[5];
        int send_index = slave_info->send_index;

/* Write first. 7 is the offset of the first values to write */
        for (int now_address = address_write, i = 0; now_address < address_write + nb_write; now_address++, i++) {
            if (now_address >= 0 && now_address < TAB_MAX_NUM) {
                int index = now_address - 0;
                uint16_t data = agile_modbus_slave_register_get(slave_info->buf + 7, i);
                _tab_registers[index] = data;
            }
        }

/* and read the data for the response */
        for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
            if (now_address >= 0 && now_address < TAB_MAX_NUM) {
                int index = now_address - 0;
                agile_modbus_slave_register_set(ctx->send_buf + send_index, i, _tab_registers[index]);
            }
        }
    } break;

default:
        ret = -AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION;
        break;
    }

return ret;
}

```