Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

import serial import struct import sqlite3 import time 打开串口 ser =…

  1. 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通信代码吗?

  2. 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()

  3. User

    需不需要加入CRC校检?

  4. Assistant

    Modbus协议本身就内置了CRC校验机制,因此在使用Modbus协议时是不需要手动添加CRC校验的。可以在发送和接收数据时直接使用Modbus协议的格式,寻找合适的Modbus库来进行通信即可。

  5. User

    如果CRC校检失败会怎么样?

  6. Assistant

    如果CRC校验失败,设备通常会丢弃接收到的数据并不发送任何响应,因此发送请求后没有收到响应时,可能需要检查是否使用了正确的CRC校验。基本上,在使用Modbus协议进行通信时,设备会自动处理CRC校验,而在通信过程中出现CRC错误的原因可能是由于通讯线路不良、数据传输干扰、参数设置错误等因素导致的。CRC校验是数据传输中的一种修正错误的有效手段,可以大大提高通讯的可靠性和准确性。

  7. User

    如何捕获这种异常?

  8. 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通信。

  9. User

    在之前我让你修改的代码里,def relay_warning():里能不能调用def read_register(address, register_num):?

  10. 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函数的调用来读取寄存器的值了。

  11. User

    介绍一下client.read_holding_registers的用法?

  12. 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位的数据,并将其打印到了终端中。

  13. User

    def read_register(reg_num, reg_count): # 读取寄存器并返回值 rr = client.read_holding_registers(reg_num,reg_count) ans = rr.register[0] return ans[0] 那这段代码正确吗?

  14. 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)
    
  15. User

    读取地址为0x01 是什么意思?

  16. Assistant

    地址为0x01这句话的意思是读取的这个设备的Modbus地址是0x01。在进行Modbus通信时,每个设备都有一个唯一的地址,可以使用该地址来指定要访问哪个设备。在使用PyModbus库进行通信时,通常在调用读写方法之前,需要先通过connect()方法建立连接,然后再在方法中使用unit参数来指定设备地址,例如unit=0x01。在本例中,使用client.read_holding_registers(0x100, 2, unit=0x01)来从地址为0x01的设备的0x100号和0x101号保持寄存器中读取2个寄存器的值。

  17. User

    0x100号 是十进制还是十六进制?

  18. Assistant

    0x100表示16进制数,等同于十进制数256。在Modbus协议中,通常使用的是十六进制数来表示地址和数据等信息,因此在

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.