def _write_multiple_coils(self, request_pdu):
"""execute modbus function 15"""
call_hooks("modbus.Slave.handle_write_multiple_coils_request", (self, request_pdu))
# get the starting address and the number of items from the request pdu
(starting_address, quantity_of_x, byte_count) = struct.unpack(">HHB", request_pdu[1:6])
expected_byte_count = quantity_of_x // 8
if (quantity_of_x % 8) > 0:
expected_byte_count += 1
if (quantity_of_x <= 0) or (quantity_of_x > 1968) or (byte_count != expected_byte_count):
# maximum allowed size is 1968 coils
raise ModbusError(defines.ILLEGAL_DATA_VALUE)
# look for the block corresponding to the request
block, offset = self._get_block_and_offset(defines.COILS, starting_address, quantity_of_x)
count = 0
for i in range(byte_count):
if count >= quantity_of_x:
break
fmt = "B" if self.unsigned else "b"
(byte_value, ) = struct.unpack(">"+fmt, request_pdu[6+i])
for j in range(8):
if count >= quantity_of_x:
break
if byte_value & (1 << j):
block[offset+i*8+j] = 1
else:
block[offset+i*8+j] = 0
count += 1
return struct.pack(">HH", starting_address, count)
def _write_multiple_registers(self, request_pdu):
"""execute modbus function 16"""
call_hooks("modbus.Slave.handle_write_multiple_registers_request",
(self, request_pdu))
# get the starting address and the number of items from the request pdu
(starting_address, quantity_of_x,
byte_count) = struct.unpack(">HHB", request_pdu[1:6])
if (quantity_of_x <= 0) or (quantity_of_x >
123) or (byte_count !=
(quantity_of_x * 2)):
# maximum allowed size is 123 registers in one reading
raise ModbusError(defines.ILLEGAL_DATA_VALUE)
# look for the block corresponding to the request
block, offset = self._get_block_and_offset(defines.HOLDING_REGISTERS,
starting_address,
quantity_of_x)
count = 0
for i in range(quantity_of_x):
count += 1
fmt = "H" if self.unsigned else "h"
block[offset + i] = struct.unpack(
">" + fmt, request_pdu[6 + 2 * i:8 + 2 * i])[0]
return struct.pack(">HH", starting_address, count)
def _read_registers(self, block_type, request_pdu):
"""read the value of holding and input registers"""
(starting_address,
quantity_of_x) = struct.unpack(">HH", request_pdu[1:5])
if (quantity_of_x <= 0) or (quantity_of_x > 125):
# maximum allowed size is 125 registers in one reading
LOGGER.debug("quantity_of_x is %d", quantity_of_x)
raise ModbusError(defines.ILLEGAL_DATA_VALUE)
# look for the block corresponding to the request
block, offset = self._get_block_and_offset(block_type,
starting_address,
quantity_of_x)
# get the values
values = block[offset:offset + quantity_of_x]
# write the response header
response = struct.pack(">B", 2 * quantity_of_x)
# add the values of every register on 2 bytes
for reg in values:
fmt = "H" if self.unsigned else "h"
response += struct.pack(">" + fmt, reg)
return response
def _get_block_and_offset(self, block_type, address, length):
"""returns the block and offset corresponding to the given address"""
for block in self._memory[block_type]:
if address >= block.starting_address:
offset = address - block.starting_address
if block.size >= offset + length:
return block, offset
raise ModbusError(defines.ILLEGAL_DATA_ADDRESS)
def _read_write_multiple_registers(self, request_pdu):
"""execute modbus function 23"""
call_hooks("modbus.Slave.handle_read_write_multiple_registers_request", (self, request_pdu))
# get the starting address and the number of items from the request pdu
(starting_read_address, quantity_of_x_to_read, starting_write_address, quantity_of_x_to_write, byte_count_to_write) = struct.unpack(">HHHHB", request_pdu[1:10])
# read part
if (quantity_of_x_to_read <= 0) or (quantity_of_x_to_read > 125):
# maximum allowed size is 125 registers in one reading
LOGGER.debug("quantity_of_x_to_read is %d", quantity_of_x_to_read)
raise ModbusError(defines.ILLEGAL_DATA_VALUE)
# look for the block corresponding to the request
block, offset = self._get_block_and_offset(defines.HOLDING_REGISTERS, starting_read_address, quantity_of_x_to_read)
# get the values
values = block[offset:offset+quantity_of_x_to_read]
# write the response header
response = struct.pack(">B", 2 * quantity_of_x_to_read)
# add the values of every register on 2 bytes
for reg in values:
fmt = "H" if self.unsigned else "h"
response += struct.pack(">"+fmt, reg)
# write part
if (quantity_of_x_to_write <= 0) or (quantity_of_x_to_write > 123) or (byte_count_to_write != (quantity_of_x_to_write * 2)):
# maximum allowed size is 123 registers in one reading
raise ModbusError(defines.ILLEGAL_DATA_VALUE)
# look for the block corresponding to the request
block, offset = self._get_block_and_offset(defines.HOLDING_REGISTERS, starting_write_address, quantity_of_x_to_write)
count = 0
for i in range(quantity_of_x_to_write):
count += 1
fmt = "H" if self.unsigned else "h"
block[offset+i] = struct.unpack(">"+fmt, request_pdu[10+2*i:12+2*i])[0]
return response
def _write_single_coil(self, request_pdu):
"""execute modbus function 5"""
call_hooks("modbus.Slave.handle_write_single_coil_request", (self, request_pdu))
(data_address, value) = struct.unpack(">HH", request_pdu[1:5])
block, offset = self._get_block_and_offset(defines.COILS, data_address, 1)
if value == 0:
block[offset] = 0
elif value == 0xff00:
block[offset] = 1
else:
raise ModbusError(defines.ILLEGAL_DATA_VALUE)
# returns echo of the command
return request_pdu[1:]
def handle_request(self, request_pdu, broadcast=False):
"""
parse the request pdu, makes the corresponding action
and returns the response pdu
"""
# thread-safe
with self._data_lock:
try:
retval = call_hooks("modbus.Slave.handle_request",
(self, request_pdu))
if retval is not None:
return retval
# get the function code
(function_code, ) = struct.unpack(">B", request_pdu[0:1])
# check if the function code is valid. If not returns error response
if function_code not in self._fn_code_map:
raise ModbusError(defines.ILLEGAL_FUNCTION)
# if read query is broadcasted raises an error
cant_be_broadcasted = (defines.READ_COILS,
defines.READ_DISCRETE_INPUTS,
defines.READ_INPUT_REGISTERS,
defines.READ_HOLDING_REGISTERS)
if broadcast and (function_code in cant_be_broadcasted):
raise ModbusInvalidRequestError(
"Function %d can not be broadcasted" % function_code)
# execute the corresponding function
response_pdu = self._fn_code_map[function_code](request_pdu)
if response_pdu:
if broadcast:
call_hooks("modbus.Slave.on_handle_broadcast",
(self, response_pdu))
LOGGER.debug("broadcast: %s",
get_log_buffer("!!", response_pdu))
return ""
else:
return struct.pack(">B", function_code) + response_pdu
raise Exception("No response for function %d" % function_code)
except ModbusError as excpt:
LOGGER.debug(str(excpt))
call_hooks("modbus.Slave.on_exception",
(self, function_code, excpt))
return struct.pack(">BB", function_code + 128,
excpt.get_exception_code())
def _read_digital(self, block_type, request_pdu):
"""read the value of coils and discrete inputs"""
(starting_address,
quantity_of_x) = struct.unpack(">HH", request_pdu[1:5])
if (quantity_of_x <= 0) or (quantity_of_x > 2000):
# maximum allowed size is 2000 bits in one reading
raise ModbusError(defines.ILLEGAL_DATA_VALUE)
block, offset = self._get_block_and_offset(block_type,
starting_address,
quantity_of_x)
values = block[offset:offset + quantity_of_x]
# pack bits in bytes
byte_count = quantity_of_x // 8
if (quantity_of_x % 8) > 0:
byte_count += 1
# write the response header
response = struct.pack(">B", byte_count)
i, byte_value = 0, 0
for coil in values:
if coil:
byte_value += (1 << i)
if i >= 7:
# write the values of 8 bits in a byte
response += struct.pack(">B", byte_value)
# reset the counters
i, byte_value = 0, 0
else:
i += 1
# if there is remaining bits: add one more byte with their values
if i > 0:
fmt = "B" if self.unsigned else "b"
response += struct.pack(">" + fmt, byte_value)
return response
def execute(
self, slave, function_code, starting_address, quantity_of_x=0, output_value=0, data_format="", expected_length=-1):
"""
Execute a modbus query and returns the data part of the answer as a tuple
The returned tuple depends on the query function code. see modbus protocol
specification for details
data_format makes possible to extract the data like defined in the
struct python module documentation
"""
pdu = ""
is_read_function = False
nb_of_digits = 0
# open the connection if it is not already done
self.open()
# Build the modbus pdu and the format of the expected data.
# It depends of function code. see modbus specifications for details.
if function_code == defines.READ_COILS or function_code == defines.READ_DISCRETE_INPUTS:
is_read_function = True
pdu = struct.pack(">BHH", function_code, starting_address, quantity_of_x)
byte_count = quantity_of_x // 8
if (quantity_of_x % 8) > 0:
byte_count += 1
nb_of_digits = quantity_of_x
if not data_format:
data_format = ">" + (byte_count * "B")
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + bytcodeLen + bytecode + crc1 + crc2
expected_length = byte_count + 5
elif function_code == defines.READ_INPUT_REGISTERS or function_code == defines.READ_HOLDING_REGISTERS:
is_read_function = True
pdu = struct.pack(">BHH", function_code, starting_address, quantity_of_x)
if not data_format:
data_format = ">" + (quantity_of_x * "H")
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + bytcodeLen + bytecode x 2 + crc1 + crc2
expected_length = 2 * quantity_of_x + 5
elif (function_code == defines.WRITE_SINGLE_COIL) or (function_code == defines.WRITE_SINGLE_REGISTER):
if function_code == defines.WRITE_SINGLE_COIL:
if output_value != 0:
output_value = 0xff00
fmt = ">BH"+("H" if output_value >= 0 else "h")
pdu = struct.pack(fmt, function_code, starting_address, output_value)
if not data_format:
data_format = ">HH"
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + adress1 + adress2 + value1+value2 + crc1 + crc2
expected_length = 8
elif function_code == defines.WRITE_MULTIPLE_COILS:
byte_count = len(output_value) // 8
if (len(output_value) % 8) > 0:
byte_count += 1
pdu = struct.pack(">BHHB", function_code, starting_address, len(output_value), byte_count)
i, byte_value = 0, 0
for j in output_value:
if j > 0:
byte_value += pow(2, i)
if i == 7:
pdu += struct.pack(">B", byte_value)
i, byte_value = 0, 0
else:
i += 1
if i > 0:
pdu += struct.pack(">B", byte_value)
if not data_format:
data_format = ">HH"
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + adress1 + adress2 + outputQuant1 + outputQuant2 + crc1 + crc2
expected_length = 8
elif function_code == defines.WRITE_MULTIPLE_REGISTERS:
if output_value and data_format:
byte_count = struct.calcsize(data_format)
else:
byte_count = 2 * len(output_value)
pdu = struct.pack(">BHHB", function_code, starting_address, byte_count / 2, byte_count)
if output_value and data_format:
pdu += struct.pack(data_format, *output_value)
else:
for j in output_value:
fmt = "H" if j >= 0 else "h"
pdu += struct.pack(">" + fmt, j)
# data_format is now used to process response which is always 2 registers:
# 1) data address of first register, 2) number of registers written
data_format = ">HH"
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + adress1 + adress2 + outputQuant1 + outputQuant2 + crc1 + crc2
expected_length = 8
elif function_code == defines.READ_EXCEPTION_STATUS:
pdu = struct.pack(">B", function_code)
data_format = ">B"
if expected_length < 0:
# No length was specified and calculated length can be used:
expected_length = 5
elif function_code == defines.DIAGNOSTIC:
# SubFuncCode are in starting_address
pdu = struct.pack(">BH", function_code, starting_address)
if len(output_value) > 0:
for j in output_value:
# copy data in pdu
pdu += struct.pack(">B", j)
if not data_format:
data_format = ">" + (len(output_value) * "B")
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + SubFunc1 + SubFunc2 + Data + crc1 + crc2
expected_length = len(output_value) + 6
elif function_code == defines.READ_WRITE_MULTIPLE_REGISTERS:
is_read_function = True
byte_count = 2 * len(output_value)
pdu = struct.pack(
">BHHHHB",
function_code, starting_address, quantity_of_x, defines.READ_WRITE_MULTIPLE_REGISTERS,
len(output_value), byte_count
)
for j in output_value:
fmt = "H" if j >= 0 else "h"
# copy data in pdu
pdu += struct.pack(">"+fmt, j)
if not data_format:
data_format = ">" + (quantity_of_x * "H")
if expected_length < 0:
# No lenght was specified and calculated length can be used:
# slave + func + bytcodeLen + bytecode x 2 + crc1 + crc2
expected_length = 2 * quantity_of_x + 5
else:
raise ModbusFunctionNotSupportedError("The {0} function code is not supported. ".format(function_code))
# instantiate a query which implements the MAC (TCP or RTU) part of the protocol
query = self._make_query()
# add the mac part of the protocol to the request
request = query.build_request(pdu, slave)
# send the request to the slave
retval = call_hooks("modbus.Master.before_send", (self, request))
if retval is not None:
request = retval
if self._verbose:
LOGGER.debug(get_log_buffer("-> ", request))
self._send(request)
call_hooks("modbus.Master.after_send", (self, ))
if slave != 0:
# receive the data from the slave
response = self._recv(expected_length)
retval = call_hooks("modbus.Master.after_recv", (self, response))
if retval is not None:
response = retval
if self._verbose:
LOGGER.debug(get_log_buffer("<- ", response))
# extract the pdu part of the response
response_pdu = query.parse_response(response)
# analyze the received data
(return_code, byte_2) = struct.unpack(">BB", response_pdu[0:2])
if return_code > 0x80:
# the slave has returned an error
exception_code = byte_2
raise ModbusError(exception_code)
else:
if is_read_function:
# get the values returned by the reading function
byte_count = byte_2
data = response_pdu[2:]
if byte_count != len(data):
# the byte count in the pdu is invalid
raise ModbusInvalidResponseError(
"Byte count is {0} while actual number of bytes is {1}. ".format(byte_count, len(data))
)
else:
# returns what is returned by the slave after a writing function
data = response_pdu[1:]
# returns the data as a tuple according to the data_format
# (calculated based on the function or user-defined)
result = struct.unpack(data_format, data)
if nb_of_digits > 0:
digits = []
for byte_val in result:
for i in range(8):
if len(digits) >= nb_of_digits:
break
digits.append(byte_val % 2)
byte_val = byte_val >> 1
result = tuple(digits)
return result
def execute(
self, slave, function_code, starting_address, quantity_of_x=0, output_value=0, data_format="",
expected_length=-1, write_starting_address_fc23=0, number_file=None, pdu=""
):
"""
Execute a modbus query and returns the data part of the answer as a tuple
The returned tuple depends on the query function code. see modbus protocol
specification for details
data_format makes possible to extract the data like defined in the
struct python module documentation
For function Read_File_Record
starting_address, quantity_of_x, number_file must be tuple ()
of one long (by the number of requested sub_seq)
the result will be
((sub _ seq_0 _ data), (sub_seq_1_data),... (sub_seq_N_data)).
"""
is_read_function = False
nb_of_digits = 0
if number_file is None:
number_file = tuple()
# open the connection if it is not already done
self.open()
# Build the modbus pdu and the format of the expected data.
# It depends of function code. see modbus specifications for details.
if function_code == defines.READ_COILS or function_code == defines.READ_DISCRETE_INPUTS:
is_read_function = True
pdu = struct.pack(">BHH", function_code, starting_address, quantity_of_x)
byte_count = quantity_of_x // 8
if (quantity_of_x % 8) > 0:
byte_count += 1
nb_of_digits = quantity_of_x
if not data_format:
data_format = ">" + (byte_count * "B")
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + bytcodeLen + bytecode + crc1 + crc2
expected_length = byte_count + 5
elif function_code == defines.READ_INPUT_REGISTERS or function_code == defines.READ_HOLDING_REGISTERS:
is_read_function = True
pdu = struct.pack(">BHH", function_code, starting_address, quantity_of_x)
if not data_format:
data_format = ">" + (quantity_of_x * "H")
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + bytcodeLen + bytecode x 2 + crc1 + crc2
expected_length = 2 * quantity_of_x + 5
elif function_code == defines.READ_FILE_RECORD:
is_read_function = True
if (
isinstance(number_file, tuple)
and isinstance(starting_address, tuple)
and isinstance(quantity_of_x, tuple)
and len(number_file) == len(starting_address) == len(quantity_of_x) > 0
):
count_seq = len(number_file)
else:
raise ModbusInvalidRequestError(
'For function READ_FILE_RECORD param'
'starting_address, quantity_of_x, number_file must be tuple()'
'of one length > 0 (by the number of requested sub_seq)'
)
pdu = struct.pack(">BB", function_code, count_seq * 7) + b''.join(map(lambda zip_param: struct.pack(">BHHH", *zip_param), zip(count_seq * (6, ), number_file, starting_address, quantity_of_x)))
if not data_format:
data_format = ">BB" + 'BB'.join(map(lambda x: x*'H', quantity_of_x))
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + bytcodeLen + (byteLenSubReq+byteref+bytecode[] x 2)*countSubReq + crc1 + crc2
expected_length = 2 * sum(quantity_of_x) + 2 * count_seq + 5
elif (function_code == defines.WRITE_SINGLE_COIL) or (function_code == defines.WRITE_SINGLE_REGISTER):
if function_code == defines.WRITE_SINGLE_COIL:
if output_value != 0:
output_value = 0xff00
fmt = ">BHH"
else:
fmt = ">BH"+("H" if output_value >= 0 else "h")
pdu = struct.pack(fmt, function_code, starting_address, output_value)
if not data_format:
data_format = ">HH"
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + adress1 + adress2 + value1+value2 + crc1 + crc2
expected_length = 8
elif function_code == defines.WRITE_MULTIPLE_COILS:
byte_count = len(output_value) // 8
if (len(output_value) % 8) > 0:
byte_count += 1
pdu = struct.pack(">BHHB", function_code, starting_address, len(output_value), byte_count)
i, byte_value = 0, 0
for j in output_value:
if j > 0:
byte_value += pow(2, i)
if i == 7:
pdu += struct.pack(">B", byte_value)
i, byte_value = 0, 0
else:
i += 1
if i > 0:
pdu += struct.pack(">B", byte_value)
if not data_format:
data_format = ">HH"
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + adress1 + adress2 + outputQuant1 + outputQuant2 + crc1 + crc2
expected_length = 8
elif function_code == defines.WRITE_MULTIPLE_REGISTERS:
if output_value and data_format:
byte_count = struct.calcsize(data_format)
else:
byte_count = 2 * len(output_value)
pdu = struct.pack(">BHHB", function_code, starting_address, byte_count // 2, byte_count)
if output_value and data_format:
pdu += struct.pack(data_format, *output_value)
else:
for j in output_value:
fmt = "H" if j >= 0 else "h"
pdu += struct.pack(">" + fmt, j)
# data_format is now used to process response which is always 2 registers:
# 1) data address of first register, 2) number of registers written
data_format = ">HH"
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + adress1 + adress2 + outputQuant1 + outputQuant2 + crc1 + crc2
expected_length = 8
elif function_code == defines.READ_EXCEPTION_STATUS:
pdu = struct.pack(">B", function_code)
data_format = ">B"
if expected_length < 0:
# No length was specified and calculated length can be used:
expected_length = 5
elif function_code == defines.DIAGNOSTIC:
# SubFuncCode are in starting_address
pdu = struct.pack(">BH", function_code, starting_address)
if len(output_value) > 0:
for j in output_value:
# copy data in pdu
pdu += struct.pack(">B", j)
if not data_format:
data_format = ">" + (len(output_value) * "B")
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + SubFunc1 + SubFunc2 + Data + crc1 + crc2
expected_length = len(output_value) + 6
elif function_code == defines.READ_WRITE_MULTIPLE_REGISTERS:
is_read_function = True
byte_count = 2 * len(output_value)
pdu = struct.pack(
">BHHHHB",
function_code, starting_address, quantity_of_x, write_starting_address_fc23,
len(output_value), byte_count
)
for j in output_value:
fmt = "H" if j >= 0 else "h"
# copy data in pdu
pdu += struct.pack(">"+fmt, j)
if not data_format:
data_format = ">" + (quantity_of_x * "H")
if expected_length < 0:
# No length was specified and calculated length can be used:
# slave + func + bytcodeLen + bytecode x 2 + crc1 + crc2
expected_length = 2 * quantity_of_x + 5
elif function_code == defines.RAW:
# caller has to set arguments "pdu", "expected_length", and "data_format"
pass
elif function_code == defines.DEVICE_INFO:
# is_read_function = True
mei_type = 0x0E
pdu = struct.pack(
">BBBB",
# function_code = 43 (0x2B)
# MEI Type = 0x0E (Read Device Identification)
# output_value[0] = Read Device ID code
# output_value[1] = Object Id
function_code, mei_type, output_value[0], output_value[1]
)
else:
raise ModbusFunctionNotSupportedError("The {0} function code is not supported. ".format(function_code))
# instantiate a query which implements the MAC (TCP or RTU) part of the protocol
query = self._make_query()
# add the mac part of the protocol to the request
request = query.build_request(pdu, slave)
# send the request to the slave
retval = call_hooks("modbus.Master.before_send", (self, request))
if retval is not None:
request = retval
if self._verbose:
LOGGER.debug(get_log_buffer("-> ", request))
self._send(request)
call_hooks("modbus.Master.after_send", (self, ))
if slave != 0:
# receive the data from the slave
response = self._recv(expected_length)
retval = call_hooks("modbus.Master.after_recv", (self, response))
if retval is not None:
response = retval
if self._verbose:
LOGGER.debug(get_log_buffer("<- ", response))
# extract the pdu part of the response
response_pdu = query.parse_response(response)
# analyze the received data
(return_code, byte_2) = struct.unpack(">BB", response_pdu[0:2])
if return_code > 0x80:
# the slave has returned an error
exception_code = byte_2
raise ModbusError(exception_code)
else:
if is_read_function:
# get the values returned by the reading function
byte_count = byte_2
data = response_pdu[2:]
if byte_count != len(data):
# the byte count in the pdu is invalid
raise ModbusInvalidResponseError(
"Byte count is {0} while actual number of bytes is {1}. ".format(byte_count, len(data))
)
elif function_code == defines.DEVICE_INFO:
data = response_pdu[1:]
data_format = ">" + (len(data) * "B")
else:
# returns what is returned by the slave after a writing function
data = response_pdu[1:]
# returns the data as a tuple according to the data_format
# (calculated based on the function or user-defined)
if (re.match("[>]?[sp]?",data_format)):
result = data.decode()
else:
result = struct.unpack(data_format, data)
if nb_of_digits > 0:
digits = []
for byte_val in result:
for i in range(8):
if len(digits) >= nb_of_digits:
break
digits.append(byte_val % 2)
byte_val = byte_val >> 1
result = tuple(digits)
if function_code == defines.READ_FILE_RECORD:
sub_seq = list()
ptr = 0
while ptr < len(result):
sub_seq += ((ptr + 2, ptr + 2 + result[ptr] // 2), )
ptr += result[ptr] // 2 + 2
result = tuple(map(lambda sub_seq_x: result[sub_seq_x[0]:sub_seq_x[1]], sub_seq))
return result
