The idea of the project is to get the data from the RS485 devices and write it for visualisation later.
I have raspberry pi 4 with 4GB RAM with this hat and this sensor.
I'm not sure how should I send and receive the data from the sensor. From its documentation:
THT-02 follows the RTU information frame protocol. In order to ensure the integrity of the information
frame, a pause time of 3.5 characters or more is required at the beginning and end of each information
frame, each byte of the information frame needs to be transmitted continuously. If there is a pause time greater than 1.5
characters, the sensor will treat it as invalid information and will not respond.
The sensor allows the host to use the function code 03 to read the temperature and humidity measurement
value of the sensor and other information. The information frame format of the 03 code is as follows：
Field Description Example
Slave address 01
Function code 03
Register address high byte 00
Register address low byte 00
High byte of query quantity 00
Low byte of query quantity 08
CRC check code low byte 44
CRC check code high byte 0C
Sensor response information frame
Slave address 01
Function code 03
Return the number of bytes 10
Temperature data high byte 00
Temperature data low byte FA
Humidity data high byte 02
Low byte of humidity data 58
1 high byte reserved 00
1 low byte reserved 00
2 high byte reserved 00
2 low byte reserved 00
Address code high byte 00
Address code low byte 01
Baud rate high byte 25
Baud rate low byte 80
Hardware version high byte 06
Hardware version low byte 00
Software version high byte 00
Software version low byte 0A
CRC check code low byte D4
CRC check code high byte 64
As I don't really get the idea of the modbus communication I think that these values should be the request I send to the device to get a valid responce.
This is the code I'm trying to use with pyserial:
import time
import sys
import serial
ser = serial.Serial(
port='/dev/ttyS0', baudrate=9600,
parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS, xonxoff=False,
rtscts=True, dsrdtr=True, timeout=3)
print(ser.name)
ser.write(br'\x01\x03\x00\x00\x00\x08\x44\x0C\r\n')
ret=str(ser.readlines())
print(ret)
This gets me an empty list.
From here the message has a structure like 11 03 006B 0003 7687
How do I structure the messages to the device to get a proper response?
UPDATE
So as I read the gpio pins on the pi don't support parity. For that reason I managet to get a hold on one of these. With that the working code is utilising the pymodbus library:
from pymodbus.client.sync import ModbusSerialClient as ModbusClient
client= ModbusClient(
method = "RTU",
port = "/dev/ttyUSB0",
stopbits = 1,
bytesize = 8,
parity = 'N',
baudrate=9600)
client.strict = False
connection = client.connect()
FORMAT = ('%(asctime)-15s %(threadName)-15s'
' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
logging.basicConfig(format=FORMAT)
log = logging.getLogger()
log.setLevel(logging.DEBUG)
rr = client.read_holding_registers(0, 2, unit=5)
log.debug(rr)
print(rr.registers)
client.close()
Output is a list with all the data from the thermometer.
UPDATE 2 As stated in the comments the pymodbus serial is slow for a fast response like the device I have, so I managed to get a some response with this:
import time, serial
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT)
s = serial.Serial(
port = '/dev/ttyS0',
baudrate = 9600,
parity = serial.PARITY_NONE,
stopbits = serial.STOPBITS_ONE,
bytesize = serial.EIGHTBITS,
xonxoff = False,
rtscts = False,
dsrdtr =True,
timeout = 1
)
temp = b'\x05\x03\x00\x00\x00\x01\x85\x8e'
#temp response \x03\x02\x00\xea\xc8\x0b => \x00\xea = 234 => 23.4 C
humidity = b'\x05\x03\x00\x01\x00\x01\xd4\x4e'
# humidity response \x03\x02\x01\xda\xc9\x8f => \x01\xdd = 474 => 47.4 %
GPIO.output(12, 1)
time.sleep(0.01)
#s.write(temp)
s.write(humidity)
time.sleep(0.01)
GPIO.output(12, 0)
res = s.readlines()
print('reading')
print(res)
GPIO.cleanup()
s.close()
It's not the most elegant solution, but at least I get a responses from it. But again it's not always good for measurment - sometimes the response doesn't contain the whole message and I end up with unusable string.
UPDATE 3
After talking with @MarcosG for implementing the pymodbus and libmodbus method for communication:
from pylibmodbus import ModbusRtu
# For Python 3.x you have to explicitly indicate ASCII enconding
client=ModbusRtu(
device="/dev/ttyS0".encode("ascii"),
baud=9600,
parity="N".encode("ascii"),
data_bit=8,
stop_bit=1
)
#Read and set timeout
timeout_sec = client.get_response_timeout()
print(timeout_sec)
client.set_response_timeout(timeout_sec+1)
#Connect
client.connect()
SERVER_ID=5
BCM_PIN_DE=18
BCM_PIN_RE=17
#Set Slave ID number
client.set_slave(SERVER_ID)
#Enable RPi GPIO Functions
client.enable_rpi(1)
#Define pin numbers to be used as Read Enable (RE) and Drive Enable (DE)
client.configure_rpi_bcm_pins(BCM_PIN_DE,BCM_PIN_RE)
#Export pin direction (set as outputs)
client.rpi_pin_export_direction()
#Write Modbus registers, 10 starting from 0
#client.write_registers(0, [0]*10)
#Read 10 input registers starting from number 0
result=(client.read_registers(0, 1))
#Show register values
print(result[0])
#Release pins and close connection
client.rpi_pin_unexport_direction()
client.close()
The problem with the pylibmodbus not working was a conflict between the new and the original libmodbus library. The device responds to the code (blinks) and in terminal I receive the value I'm looking for - 247 => 24.7C.
