#include "bsp_modbus.h" #include "kit_time.h" #include "kit_data.h" //#include "kit_debug.h" /******************************************************************************************************************************************************************************** 1.Modbus数据结构 0x01 读线圈 设备地址/1B 功能码/1B 起始地址/2B 线圈数量/2B 设备地址/1B 功能码/1B 字节数/1B 线圈状态/NB 0x02 读离散量输入 设备地址/1B 功能码/1B 起始地址/2B 输入数量/2B 设备地址/1B 功能码/1B 字节数/1B 输入状态/NB 0x03 读保持寄存器 设备地址/1B 功能码/1B 起始地址/2B 寄存器数量/2B 设备地址/1B 功能码/1B 字节数/1B 寄存器值/2NB 0x04 读输入寄存器 设备地址/1B 功能码/1B 起始地址/2B 输入寄存器数量/2B 设备地址/1B 功能码/1B 字节数/1B 输入寄存器/2NB 0x05 写单个线圈 设备地址/1B 功能码/1B 输出地址/2B 输出值/2B 设备地址/1B 功能码/1B 输出地址/2B 输出值/2B 0x06 写单个寄存器 设备地址/1B 功能码/1B 寄存器地址/2B 寄存器值/2B 设备地址/1B 功能码/1B 寄存器地址/2B 寄存器值/2B 0x0F 写多个线圈 设备地址/1B 功能码/1B 起始地址/2B 输出数量/2B 字节数/1B 输出值/NB 设备地址/1B 功能码/1B 起始地址/2B 输出数量/2B 0x10 写多个寄存器 设备地址/1B 功能码/1B 起始地址/2B 寄存器数量/2B 字节数/1B 寄存器值/2NB 设备地址/1B 功能码/1B 起始地址/2B 寄存器数量/2B 2.Modbus TCP MBAP报文头 地址 功能码 数据 CRC校验 事务处理标识符 协议标识符 长度 单元标识符 功能码 数据 0001 0000 0006 01 04 00000005 0001 0000 000D 01 04 0A00000001000200030004 ----------------------------------------------------------------------------------- 事务处理标识符 2字节 Modbus请求/响应事务处理的标识 客户机启动 复制响应 协议标识符 2字节 0=Modbus协议 客户机启动 复制响应 长度 2字节 长度之后的字节总数 客户机启动 服务器启动 单元标识符 1字节 串行链路或其它总线的从站识别 客户端启动 复制响应 3.写线圈 十六进制值0xFF00，请求线圈为 ON。十六进制值0x0000请求线圈为OFF。其它所有值均为非法的，并且对线圈不起作用。 ********************************************************************************************************************************************************************************/ #define BRROCAST_ADDR (0u) #define MB_DEV_ADDR_POS (0u) #define MB_FUN_CODE_POS (1u) #define MB_REG_ADDR_POS (2u) #define MB_DATA_POS (2u) #define MB_REG_NUM_POS (4u) #define MB_MIN_LEN (3u) //TCP比RTU多了事务处理标识符、协议标识符和长度，总共6B #define MB_TCP_OFFSET (6u) #define MB_TCP_DATA_LEN_POS (4u) #define MB_TCP_DEV_ADDR_POS (6u) ModbusCommData modbus_comm_data __attribute__((section (".CCM_RAM"))); const uint8_t modbus_offset_len[kModbusType_End] = {0, MB_TCP_OFFSET}; static void bsp_modbus_task_poll(uint32_t base_time, ModbusItem * const item, ModbusTask *cur_task, GateItem *gate); void bsp_modbus_poll(ModbusItem * const item, bool is_enable_call) { uint8_t fun_code; uint16_t tmp, pos, addr, reg_num; uint32_t i, data, tick_diff; bool cond[kModbusType_End]; GateItem *gate; ModbusTask *cur_task = NULL; BspMdExCode err = kBspMdEx_InvalidFunc; if((item != NULL) && (item->ctrl_rx_int_call != NULL)) { if(item->task_num > 0) { cur_task = &item->modbus_task[item->cur_task_idx]; } //判断超时时关闭接收中断，防止刚判断完超时后，马上收到数据，导致数据丢失 item->ctrl_rx_int_call(item->comm_dev, false); tick_diff = kit_time_get_interval_by_now(item->tick); if(tick_diff >= 5) { pos = item->buf_pos; item->buf_pos = 0; item->tick = kit_time_get_tick(); item->ctrl_rx_int_call(item->comm_dev, true); tmp = modbus_offset_len[item->type]; addr = item->buf[MB_DEV_ADDR_POS + tmp]; //当为主设备时接收任何addr设备数据，从设备时需要判断地址 if (((item->is_master == true) || ((item->is_master == false) && ((item->addr == addr) || (addr == BRROCAST_ADDR)))) && (pos > MB_MIN_LEN)) { if(addr < MODBUS_MAX_DEV) { item->time_out[addr] = 0; } //modbus RTU校验CRC cond[kModbusType_RTU] = (kit_check_crc16(item->buf, pos) == 0); cond[kModbusType_TCP] = (pos == (READ_BT_INT16U_BY_CONST_POS(item->buf, MB_TCP_DATA_LEN_POS) + 6)); if(cond[item->type] == true) { //做从机，起始地址直接从数据中获取 //做主机，主动发送数据时会记录起始地址，用于接收从设备数据时使用 addr = (item->is_master == true) ? addr = item->start_addr : READ_BT_INT16U_BY_CONST_POS(item->buf, MB_REG_ADDR_POS + tmp); fun_code = item->buf[MB_FUN_CODE_POS + tmp]; if((item->fun_call_array[fun_code] != NULL) || (item->task_num != 0)) { gate = item->gate; reg_num = READ_BT_INT16U_BY_CONST_POS(item->buf, MB_REG_NUM_POS + tmp); switch(fun_code) { case kModbusFun_0x01: case kModbusFun_0x02: case kModbusFun_0x03: case kModbusFun_0x04: //对于接收RTC数据长度 = 报文总长度-（地址 功能码 CRC校验），TCP数据长度 = 报文总长度-（MBAP报文头 功能码） pos = (item->type == kModbusType_RTU)? (pos - 1 - 1 - 2 - 1) : (pos - 7 - 1); if(item->task_num == 0) { //对于Master addr为请求起始地址 reg_num 无意义 buf为数据 pos为buf长度 //对于Slaver addr为请求起始地址 reg_num 线圈/寄存器数量 buf为要写入回复数据地址 pos无意义，更具reg_num填数据 //MB_DATA_POS + tmp + 1，+1为字节数 err = item->fun_call_array[fun_code](addr, reg_num, &item->buf[MB_DATA_POS + tmp + 1], &pos); //数据长度 pos = (fun_code < kModbusFun_0x03) ? ((reg_num + 7) >> 3) : (reg_num << 1); item->buf[MB_DATA_POS + tmp] = pos; pos++; //增加字节数 } //通过建模方式进行modbus通信 else if(cur_task != NULL) { cur_task->tick += 900; //读读数据 if(cur_task->head->fun_code < 3) { tmp = (pos == 1) ? ((uint16_t)item->buf[MB_DATA_POS + tmp + 1] << 8) : READ_BT_INT16U_BY_CONST_POS(item->buf, MB_DATA_POS + tmp + 1); item->gate->read_buf[cur_task->buf_addr] = tmp; } else if(cur_task->head->fun_code < 5) { item->gate->read_buf[cur_task->buf_addr] = tmp; bsp_gate_push_read_data(item->gate, cur_task->buf_addr, &item->buf[MB_DATA_POS + tmp + 1], pos); } //读写数据 else { if(fun_code < kModbusFun_0x03) { //一个task最多限制32个线圈，每个线圈在写buf中占2字节 data = kit_bt_read_buf(&item->buf[MB_DATA_POS + tmp + 1], 0, pos); for(i = 0; i < cur_task->head->reg_num; i++) { pos = (KIT_GET_BIT(data, i) != 0) << 8; bsp_gate_push_write_data(gate, cur_task->buf_addr + i, (uint8_t *)&pos, 2); } } else { bsp_gate_push_write_data(gate, cur_task->buf_addr, &item->buf[MB_DATA_POS + tmp + 1], pos); } } } break; case kModbusFun_0x05: case kModbusFun_0x06: if(item->task_num == 0) { //对于Master addr为请求起始地址 reg_num 输出值 buf无意义 pos 无意义 //对于Slaver addr为请求起始地址 reg_num 输出值 buf无意义 pos 无意义 err = item->fun_call_array[fun_code](addr, reg_num, &item->buf[MB_REG_NUM_POS + tmp], &pos); pos = 4;//起始地址+输出数量 } //通过建模方式进行modbus通信 else if(cur_task != NULL) { cur_task->tick += 900; pos = modbus_offset_len[item->type] + 4; data = READ_LT_INT16U_BY_CONST_POS(item->buf, pos); if(item->gate_write_data_absolute_addr == addr) { if(fun_code == kModbusFun_0x05) { data = (data == 0xFF) ? 0x0100 : 0; } if(data == item->gate_write_data_value) { gate->write_buf[item->gate_write_data_addr] = data; item->gate_write_data_absolute_addr = MODBUS_GATE_FREE_ADDR; } } } break; case kModbusFun_0x0F: case kModbusFun_0x10: //对于Master addr为请求起始地址 reg_num 线圈/寄存器数量 buf无意义 pos无意义 //对于Slaver addr为请求起始地址 reg_num 线圈/寄存器数量 buf寄存器值 pos为buf长度 tmp += 7; //buf 地址7为要写数据 err = item->fun_call_array[fun_code](addr, reg_num, &item->buf[tmp], &pos); pos = 4;//起始地址+输出数量 break; default: break; } } else { err = kBspMdEx_InvalidFunc; } //做主机时不回复从机报文 if(item->is_master == false) { if(err == kBspMdEx_None) { bsp_modbus_pos_send(item, pos); } else { bsp_modbus_neg_send(item, err); } } } } if(cur_task != NULL) { bsp_modbus_task_poll(tick_diff, item, cur_task, item->gate); } if((item->master_call != NULL) && (is_enable_call == true)) { item->master_call(item, tick_diff); } for(i = 0; i < MODBUS_MAX_DEV; i++) { if(item->time_out[i] < 60000) { item->time_out[i] += tick_diff; } } } else { item->ctrl_rx_int_call(item->comm_dev, true); } } } uint16_t bsp_modbus_get_time_out(ModbusItem * const item, uint8_t addr) { uint16_t tmp = 65000; if(addr < MODBUS_MAX_DEV) { tmp = item->time_out[addr]; } return tmp; } static void bsp_modbus_task_poll(uint32_t base_time, ModbusItem * const item, ModbusTask *cur_task, GateItem *gate) { uint8_t fun_code; uint16_t tmp, data; int32_t addr; uint32_t cur_idx; ModbusHead *head; cur_task->tick += base_time; if(cur_task->tick >= cur_task->head->time_out + 1000) { cur_task->tick = 0; if(item->task_cashe != 0xFF) { cur_idx = item->task_cashe; item->task_cashe = 0xFF; } else { //查找下一个读指令，当轮询完一轮后首个即默认为读指令，故第一个task必须为读指令 cur_idx = item->cur_task_idx; if(item->is_read_write_data == true) { if(++cur_idx >= item->task_num) { cur_idx = 0; } } else { while(true) { if(++cur_idx >= item->task_num) { cur_idx = 0; } if(item->modbus_task[cur_idx].head->fun_code < 0x05) { break; } } } } addr = item->gate_write_data_absolute_addr; if(addr != MODBUS_GATE_FREE_ADDR) { //每一次请求写数据gate 重试次数+1 if(item->gate_write_try_cnt++ >= 3) { item->gate_write_data_absolute_addr = MODBUS_GATE_FREE_ADDR; } else { head = item->gate_write_data_head; tmp = item->gate_write_data_value; if(head->fun_code == 0x05) { data = (tmp != 0)? 0xFF00 : 0; } else { data = tmp >> 8; data |= tmp << 8; } bsp_modbus_master_single_write(item, head->slave_addr, head->fun_code, addr, data); item->task_cashe = cur_idx; return; } } item->cur_task_idx = cur_idx; head = item->modbus_task[cur_idx].head; fun_code = head->fun_code; if(fun_code > 4) { fun_code = head->time_out; } //head->time_out 为0时为主动上送 if(head->time_out != 0) { bsp_modbus_master_read(item, head->slave_addr, fun_code, head->reg_addr, head->reg_num); } } } void bsp_modbus_pos_send(ModbusItem * const item, uint16_t len) { uint16_t mb_crc; uint32_t cnt; if((item != NULL) && (item->send_call != NULL) &&(item->buf[MB_DEV_ADDR_POS + modbus_offset_len[item->type]] != BRROCAST_ADDR)) { cnt = len + 1 + 1;//addr and code if(item->type == kModbusType_RTU) { mb_crc = kit_check_crc16(item->buf, cnt); WRITE_LT_INT16U(item->buf, cnt, mb_crc); } else { WRITE_BT_INT16U_BY_CONST_POS(item->buf, MB_TCP_DATA_LEN_POS, cnt) } item->send_call(item->comm_dev, item->buf, cnt + modbus_offset_len[item->type]); } } void bsp_modbus_neg_send(ModbusItem * const item, BspMdExCode ex_code) { uint16_t mb_crc; uint32_t cnt; if((item != NULL) && (item->send_call != NULL) &&item->buf[MB_DEV_ADDR_POS + modbus_offset_len[item->type]] != BRROCAST_ADDR) { cnt = 3; item->buf[1 + modbus_offset_len[item->type]] |= 0x80; item->buf[2 + modbus_offset_len[item->type]] = ex_code; if(item->type == kModbusType_RTU) { mb_crc = kit_check_crc16(item->buf, cnt); WRITE_LT_INT16U(item->buf, cnt, mb_crc); } else { item->buf[5] = 3; } item->send_call(item->comm_dev, item->buf, cnt + modbus_offset_len[item->type]); } } void bsp_modbus_push_data(ModbusItem * const item, uint8_t *buf, uint16_t len) { uint32_t i; if((item != NULL) && (item->buf_pos + len < item->buf_size)) { for (i = 0; i < len; i++) { item->buf[item->buf_pos++] = buf[i]; } if(item->type == kModbusType_RTU) { item->tick = kit_time_get_tick(); } else { item->tick = 0; //tcp使用同步接口时，不用poll //bsp_modbus_poll(item); } } } void bsp_modbus_set_slaver_addr(ModbusItem * const item, uint8_t addr) { if(item != NULL) { item->addr = addr; } } uint16_t bsp_modbus_fill_mbap_head(ModbusItem * const item, uint8_t dev_addr, uint16_t len) { uint32_t cnt = 0; if(item->type == kModbusType_TCP) { //事务元标识符：服务器从接收的请求中复制 客户端每次++ item->tcp_transaction++; WRITE_BT_INT16U(item->buf, cnt, item->tcp_transaction); //协议标识符：0=MODBUS 协议 WRITE_BT_INT16U(item->buf, cnt, 0); //长度：单元标识符1B + 功能码1B + 数据4B WRITE_BT_INT16U(item->buf, cnt, len); } //单元标识符：从设备地址 RTU TCP都需要填地址 WRITE_BT_INT8U(item->buf, cnt, dev_addr); return cnt; } //start_addr 用于做主站时记录请求的地址 支持0x01 0x02 0x03 0x04 void bsp_modbus_master_read(ModbusItem * const item, uint8_t dev_addr, uint8_t fun_code, uint16_t start_addr, uint16_t reg_num) { uint16_t mb_crc; uint32_t cnt; if((item != NULL) && (item->send_call != NULL)) { item->buf_pos = 0; item->is_master = true; item->start_addr = start_addr; //6 = 单元标识符1Byte + 功能码1Byte + 起始地址2Byte + 寄存器数2Byte cnt = bsp_modbus_fill_mbap_head(item, dev_addr, 6); item->buf[cnt++] = fun_code; WRITE_BT_INT16U(item->buf, cnt, start_addr); WRITE_BT_INT16U(item->buf, cnt, reg_num); if(item->type != kModbusType_TCP) { mb_crc = kit_check_crc16(item->buf, cnt); WRITE_LT_INT16U(item->buf, cnt, mb_crc); } item->send_call(item->comm_dev, item->buf, cnt); } } //做从站时主动发送数据 支持0x01 0x02 0x03 0x04 void bsp_modbus_slaver_send_read(ModbusItem * const item, uint8_t dev_addr, uint8_t fun_code, uint8_t *buf, uint16_t len) { uint16_t mb_crc; uint32_t cnt; if((item != NULL) && (item->send_call != NULL)) { item->buf_pos = 0; cnt = bsp_modbus_fill_mbap_head(item, dev_addr, 1 + 1 + 1 + len); item->buf[cnt++] = fun_code; WRITE_BT_INT8U(item->buf, cnt, len); kit_copy_buf(&item->buf[cnt], buf, len); cnt += len; if(item->type != kModbusType_TCP) { mb_crc = kit_check_crc16(item->buf, cnt); WRITE_LT_INT16U(item->buf, cnt, mb_crc); } item->send_call(item->comm_dev, item->buf, cnt); } } //支持 0x05 0x06 void bsp_modbus_master_single_write(ModbusItem * const item, uint8_t dev_addr, uint8_t fun_code, uint16_t start_addr, uint16_t value) { bsp_modbus_master_read(item, dev_addr, fun_code, start_addr, value); } //支持 0x0F 0x10 void bsp_modbus_master_series_write(ModbusItem * const item, uint8_t dev_addr, uint8_t fun_code, uint16_t start_addr, uint16_t reg_num, uint8_t *buf) { uint16_t mb_crc, len; uint32_t cnt = 0; if((item != NULL) && (item->send_call != NULL)) { item->buf_pos = 0; item->is_master = true; item->start_addr = start_addr; //数据计算字节数 if(fun_code == 0x10) { len = reg_num << 1; } else { len = reg_num / 8; len = ((reg_num % 8) == 0) ? len : (len + 1); } cnt = bsp_modbus_fill_mbap_head(item, dev_addr, 2 + 4 + 1 + len); item->buf[cnt++] = fun_code; WRITE_BT_INT16U(item->buf, cnt, start_addr); WRITE_BT_INT16U(item->buf, cnt, reg_num); WRITE_BT_INT8U(item->buf, cnt, len); kit_copy_buf(&item->buf[cnt], buf, len); cnt += len; if(item->type != kModbusType_TCP) { mb_crc = kit_check_crc16(item->buf, cnt); WRITE_LT_INT16U(item->buf, cnt, mb_crc); } item->send_call(item->comm_dev, item->buf, cnt); } } void bsp_modbus_link_list(ModbusItem * const item) { ModbusItem ** cur_item = &modbus_comm_data.head_item; while(*cur_item != NULL) { if(*cur_item == item) { return; } else { cur_item = &(*cur_item)->next_item; } } *cur_item = item; } void bsp_modbus_register_master_fun(ModbusItem * const item, MasterCall master_call) { if((item != NULL) && (master_call != NULL)) { item->master_call = master_call; bsp_modbus_link_list(item); } } void bsp_modbus_register_fun(ModbusItem * const item, ModbusFun fun_code, ModbusFunCall register_call) { if((item != NULL) && (fun_code < kModbusFun_End)) { item->fun_call_array[fun_code] = register_call; bsp_modbus_link_list(item); } } //为了方便统一处理 //05写单个线圈也占用2个字节，ON为1 OFF为0，发送时将数据转换ON为0xFF00 OFF为0 // bool bsp_modbus_register_task(ModbusItem * const item, ModbusHead *head) { uint16_t len; bool res = false; ModbusTask *task; if((item != NULL) && (item->gate != NULL) && (modbus_comm_data.max_task_num < MODBUS_MAX_TASK)) { res = true; item->is_master = true; if(item->modbus_task == NULL) { item->gate_write_data_end_addr = item->gate_write_data_start_addr = modbus_comm_data.gate_write_data_cnt; item->modbus_task = &modbus_comm_data.modbus_task_buf[modbus_comm_data.max_task_num]; } modbus_comm_data.max_task_num++; task = &item->modbus_task[item->task_num++]; len = head->reg_num; if(head->fun_code < 3) { len = (len + 15) / 16; task->buf_addr = bsp_gate_get_read_buf_addr(item->gate, len); } else if(head->fun_code < 5) { task->buf_addr = bsp_gate_get_read_buf_addr(item->gate, len); } else { modbus_comm_data.gate_write_data_cnt += len; item->gate_write_data_end_addr += len; task->buf_addr = bsp_gate_get_write_buf_addr(item->gate, len); } task->tick = 0; task->head = head; bsp_modbus_link_list(item); } return res; }