import serial import struct import sqlite3 import time 打开串口 ser =…
- User
import serial import struct import sqlite3 import time
打开串口
ser = serial.Serial(port='COM1', baudrate=9600, bytesize=8, parity='N', stopbits=1, timeout=1)
创建数据库
conn = sqlite3.connect('data.db') cursor = conn.cursor() cursor.execute('CREATE TABLE IF NOT EXISTS data(id INTEGER PRIMARY KEY AUTOINCREMENT,data FLOAT,date DATE,time TIME,timestamp TIMESTAMP)')
def send_data(data): # 发送数据 ser.write(bytes.fromhex(data))
def byte2float(data): # 字节转浮点数 4到7位 result = struct.unpack('>f', bytes.fromhex(data)) return result[0].round(4)
def command(address, function_code, start_address, number_of_registers, write_bytes=None, write_data=None,CRC=None): # 构造命令 # address: 01 # function_code: 0x03读, 0x10写 # start_address: 00XX 取决于操作 # number_of_registers: 0001/0002 # write_bytes: 数据字节数 # write_data: 写入数据 # CRC: 校验码 comm = f"{address} {function_code} {start_address} {number_of_registers} {write_bytes} {write_data} {CRC}" comm = comm.replace(' ', '') comm = comm.encode('utf-8') comm = comm.hex() comm = comm.upper() return comm
def read_data(): # 读取数据段 ans = ser.read(8) # 从第四到第七位 result = ''.join([x for x in ans.split(' ')[3:7]]) return result
def relay_warning(): # 继电器报警 comm = command(0x01, 0x03, 0x002E, 0x0002, 0x8C3C) send_data(comm) result = read_data() war_HH = int(result[3]) #上上限 war_HI = int(result[4]) #上限 war_GO = int(result[5]) war_LO = int(result[6]) #下限 war_LL = int(result[7]) #下下限 return war_HH, war_HI, war_GO, war_LO, war_LL
def read_dp(): # 小数点位置 comm = command(0x01, 0x03, 0x001E, 0x0001, 0x8C3C) send_data(comm) result = read_data() return result[7]
def setting(current_ct, comm_addr, comm_bin, war_uperhigh, war_high, war_uperlow, war_low, out_delay, out_offset): comm = command() #todo pass
def crc_test(): #todo pass
try: # 持续记录数据 while True: # 发送数据 这里使用浮点数 ### address: 0x01 ### function code: 0x03 ### start address: 0x002A ### number of registers: 0x0002 ### CRC: 0xE5C3 comm = command(0x01, 0x03, 0x002A, 0x0002, 0xE5C3) send_data(comm)
# 接收数据 data = read_data() result = byte2float(data) # 存储数据 date = time.strftime("%Y-%m-%d", time.localtime()) current_time = time.strftime("%H:%M:%S", time.localtime()) timestamp = int(time.time()) cursor.execute('INSERT INTO data(data, date, time, timestamp) VALUES(?, ?, ?, ?)', (result, date, current_time, timestamp)) conn.commit() # 打印数据 print(f"Received data: {result}, Date: {date}, Time: {current_time}") # 等待1秒 time.sleep(1)except KeyboardInterrupt: # 关闭串口和数据库连接 print('KeyboardInterrupt') ser.close() cursor.close() conn.close() |||能请你把这段代码改成使用Modbus协议的rs486通信代码吗?
- Assistant
当然可以,以下是修改后的代码:
import struct import sqlite3 import time from pymodbus.client.sync import ModbusSerialClient as ModbusClient
打开串口
client = ModbusClient(method="rtu", port='COM1', baudrate=9600) client.connect()
创建数据库
conn = sqlite3.connect('data.db') cursor = conn.cursor() cursor.execute('CREATE TABLE IF NOT EXISTS data(id INTEGER PRIMARY KEY AUTOINCREMENT,data FLOAT,date DATE,time TIME,timestamp TIMESTAMP)')
def read_register(address, register_num): # 读取一个寄存器并返回值 rr = client.read_holding_registers(register_num, 2, unit=address) result = struct.unpack('>f', struct.pack('>HH', *rr.registers)) return result[0].round(4)
def write_register(address, register_num, value): # 往一个寄存器写入值 val = struct.unpack('>HH', struct.pack('>f', value)) client.write_registers(register_num, val, unit=address)
def relay_warning(): # 继电器报警 # 读取一个寄存器 war = client.read_holding_registers(0x002E, 2, unit=0x01).registers[0] war_HH = int(war & 0b1111000000000000) >> 12 #上上限 war_HI = int(war & 0b0000111100000000) >> 8 #上限 war_GO = int(war & 0b0000000011110000) >> 4 war_LO = int(war & 0b0000000000001111) #下限 war_LL = int(war & 0b1111000000000000) >> 12 #下下限 return war_HH, war_HI, war_GO, war_LO, war_LL
def read_dp(): # 小数点位置 dp = client.read_holding_registers(0x001E, 1, unit=0x01).registers[0] return bin(dp)[-1]
def setting(current_ct, comm_addr, comm_bin, war_uperhigh, war_high, war_uperlow, war_low, out_delay, out_offset): # 配置 # todo pass
try: # 持续记录数据 while True: # 读取寄存器 result = read_register(0x01, 0x002A)
# 存储数据 date = time.strftime("%Y-%m-%d", time.localtime()) current_time = time.strftime("%H:%M:%S", time.localtime()) timestamp = int(time.time()) cursor.execute('INSERT INTO data(data, date, time, timestamp) VALUES(?, ?, ?, ?)', (result, date, current_time, timestamp)) conn.commit() # 打印数据 print(f"Received data: {result}, Date: {date}, Time: {current_time}") # 等待1秒 time.sleep(1)except KeyboardInterrupt: # 关闭串口和数据库连接 print('KeyboardInterrupt') client.close() cursor.close() conn.close()
- User
需不需要加入CRC校检?
- Assistant
Modbus协议本身就内置了CRC校验机制,因此在使用Modbus协议时是不需要手动添加CRC校验的。可以在发送和接收数据时直接使用Modbus协议的格式,寻找合适的Modbus库来进行通信即可。
- User
如果CRC校检失败会怎么样?
- Assistant
如果CRC校验失败,设备通常会丢弃接收到的数据并不发送任何响应,因此发送请求后没有收到响应时,可能需要检查是否使用了正确的CRC校验。基本上,在使用Modbus协议进行通信时,设备会自动处理CRC校验,而在通信过程中出现CRC错误的原因可能是由于通讯线路不良、数据传输干扰、参数设置错误等因素导致的。CRC校验是数据传输中的一种修正错误的有效手段,可以大大提高通讯的可靠性和准确性。
- User
如何捕获这种异常?
- Assistant
如果使用库进行Modbus通信,并且在代码中没有手动使用CRC校验,那么库应该会自动进行CRC校验,如果出现CRC校验失败的情况,应该会抛出相应的异常。在Python中,一般会抛出
pymodbus.exceptions.ModbusInvalidResponseError异常,在出现这种异常时,可以通过捕获这个异常来处理。以下是一个简单的例子:
from pymodbus.client.sync import ModbusSerialClient from pymodbus.exceptions import ModbusInvalidResponseError client = ModbusSerialClient(method='rtu', port='/dev/ttyUSB0', baudrate=9600) client.connect() try: rr = client.read_holding_registers(0x100, 1, unit=0x01) print(rr.registers[0]) except ModbusInvalidResponseError as e: print(f"[ERROR] Modbus response error: {e}") finally: client.close()在上面的代码中,我们使用
ModbusSerialClient类从地址为0x01的设备的0x100号寄存器中读取一个寄存器的值,如果读取成功,则打印读取的值,如果发生了CRC校验错误,则捕获异常并打印错误信息。无论是否发生异常,我们都调用client.close()关闭Modbus通信。 - User
在之前我让你修改的代码里,def relay_warning():里能不能调用def read_register(address, register_num):?
- Assistant
可以的,可以将
read_register函数的代码移到relay_warning函数中,并且将地址和寄存器号写死,如下所示:def read_register(register_num): # 读取一个寄存器并返回值 rr = client.read_holding_registers(register_num, 2, unit=0x01) result = struct.unpack('>f', struct.pack('>HH', *rr.registers)) return result[0].__round__(4) def relay_warning(): # 继电器报警 war = read_register(0x002E) war_HH = int(war & 0b1111000000000000) >> 12 #上上限 war_HI = int(war & 0b0000111100000000) >> 8 #上限 war_GO = int(war & 0b0000000011110000) >> 4 war_LO = int(war & 0b0000000000001111) #下限 war_LL = int(war & 0b1111000000000000) >> 12 #下下限 return war_HH, war_HI, war_GO, war_LO, war_LL这样就可以通过
relay_warning函数中对read_register函数的调用来读取寄存器的值了。 - User
介绍一下client.read_holding_registers的用法?
- Assistant
client.read_holding_registers是PyModbus库中用于读取Modbus协议下的保持寄存器(Holding Register)的方法。下面是函数的参数介绍:read_holding_registers(address, count, **kwargs)address:保持寄存器的地址,类型为整数。在进行Modbus通信时,每个设备都有一个唯一的地址,可以通过该地址来指定要访问的是哪个设备,地址通常是一个整数,例如0x01。count:要读取的保持寄存器的数量,类型为整数。像其他的Modbus数据使用2个寄存器来表示一个32位长度的数据,这里的count表示将读取几个32位长度的数据。**kwargs:格式化Modbus要求的附加参数。通常情况下不需要配置。
该函数返回一个
ReadHoldingRegistersResponse对象,其中包含读取到的寄存器的值,以及其他相关的元数据。可以通过调用返回对象的属性来访问读取到的数据,例如:from pymodbus.client.sync import ModbusSerialClient client = ModbusSerialClient(method='rtu', port='/dev/ttyUSB0', baudrate=9600) client.connect() #读取地址为0x01的设备的0x100号保持寄存器 rr = client.read_holding_registers(0x100, 1, unit=0x01) #获取寄存器的值 value = rr.registers[0] #打印寄存器的值 print(value) client.close()在上述示例中,我们从地址为0x01的设备的0x100号保持寄存器中读取一个32位的数据,并将其打印到了终端中。
- User
def read_register(reg_num, reg_count): # 读取寄存器并返回值 rr = client.read_holding_registers(reg_num,reg_count) ans = rr.register[0] return ans[0] 那这段代码正确吗?
- Assistant
这段代码有一些问题,现在让我们来看看它的每一部分。
def read_register(reg_num, reg_count): # 读取寄存器并返回值 rr = client.read_holding_registers(reg_num,reg_count) ans = rr.register[0] return ans[0]在这个函数中,
read_register函数接受两个参数reg_num和reg_count,分别代表要读取的保持寄存器的地址和数量。接下来,我们执行了一次读取操作,调用了client.read_holding_registers函数,并将读取到的寄存器值存储在rr对象中。在接下来的一行代码中,出现了
rr.register[0],这里我们想要访问的是rr对象的registers属性,而不是register。可以将这一行的代码修改成以下代码,这样就可以正确地访问到一个保持寄存器了:ans = rr.registers[0]接下来,我们又有一个问题。在上面的代码中,读取到的寄存器值已经存储在了
ans变量中,而且我们使用值的方式似乎有点冗余。最后,返回值中包含了ans[0],这看起来并不正确。应该将函数的最后一行改成这样:return ans修复主要问题后,这个函数应该如下所示:
def read_register(reg_num, reg_count): # 读取寄存器并返回值 rr = client.read_holding_registers(reg_num, reg_count) ans = rr.registers[0] return ans函数将从Modbus设备读取保持寄存器的值,并返回读取到的结果。调用这个函数的时候,需要传入保持寄存器的地址和读取的寄存器数量。例如:
#读取地址为0x01的设备的0x100号到0x101号保持寄存器 value = read_register(0x100, 2) print(value) - User
读取地址为0x01 是什么意思?
- Assistant
地址为0x01这句话的意思是读取的这个设备的Modbus地址是0x01。在进行Modbus通信时,每个设备都有一个唯一的地址,可以使用该地址来指定要访问哪个设备。在使用PyModbus库进行通信时,通常在调用读写方法之前,需要先通过connect()方法建立连接,然后再在方法中使用unit参数来指定设备地址,例如unit=0x01。在本例中,使用client.read_holding_registers(0x100, 2, unit=0x01)来从地址为0x01的设备的0x100号和0x101号保持寄存器中读取2个寄存器的值。 - User
0x100号 是十进制还是十六进制?
- Assistant
0x100表示16进制数,等同于十进制数256。在Modbus协议中,通常使用的是十六进制数来表示地址和数据等信息,因此在
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.