def thread_poll(self):
startaddr = self.input_startaddr.value()
endaddr = self.input_endaddr.value()
while self.swjk < 10:
if self.swjk > 1:
print('break ok')
break
else:
print('polling start')
holdingRegisters_list = []
for addrlist in range(startaddr, endaddr + 1):
try:
if self.fncode == 1:
msg_adu = tcp.read_coils(1, addrlist, 1)
holdingRegisters = tcp.send_message(
msg_adu, self.sock)
elif self.fncode == 10001:
msg_adu = tcp.read_discrete_inputs(1, addrlist, 1)
holdingRegisters = tcp.send_message(
msg_adu, self.sock)
elif self.fncode == 40001:
msg_adu = tcp.read_holding_registers(
1, addrlist, 1)
holdingRegisters = tcp.send_message(
msg_adu, self.sock)
elif self.fncode == 30001:
msg_adu = tcp.read_input_registers(1, addrlist, 1)
holdingRegisters = tcp.send_message(
msg_adu, self.sock)
holdingRegisters_list.append(holdingRegisters[0])
except AttributeError:
print('Register Addr Over')
holdingRegisters_list.append('None')
print("Register " + str(addrlist) + " poll.")
print(holdingRegisters_list)
items_list = []
for registersData in holdingRegisters_list:
item_holdingRegisters = QTableWidgetItem()
item_holdingRegisters.setText(str(registersData))
items_list.append(item_holdingRegisters)
for item_num in range(0, len(items_list)):
self.swjTableSignal.emit(item_num, 2, items_list[item_num])
time.sleep(1)
def send_message():
message = tcp.read_holding_registers(slave_id=1,
starting_address=0,
quantity=4)
try:
response = tcp.send_message(message, sock)
return response
except ValueError:
print("Whoops... WTS seems to be not responding")
def read_holding_registers(self, starting_address, quantity):
"""Returns the sequence of holding registers at given addresses
"""
with self.__lock:
message = tcp.read_holding_registers(
slave_id=1,
starting_address=starting_address - 1,
quantity=quantity)
return self.__send_modbus_message(message)
def write_bit(self, slave_id, address, bit,value):
message = tcp.read_holding_registers(slave_id, address, 1)
current_value = tcp.send_message(message, self.sock)[0]
new_value = set_bit(current_value,bit,value)
message = tcp.write_single_register(slave_id, address,new_value)
response = tcp.send_message(message, self.sock)
return response
async def readsensor(self, sensor: Sensor):
"""
Reads a single sensor
"""
r, w = await asyncio.open_connection(*self.client)
msg = tcp.read_holding_registers(sensor.mdbunit, sensor.startaddress, sensor.length)
resp = await send_message(msg, r, w)
w.close()
return [vf(resp[vf.id-sensor.startaddress]) for vf in sensor.valuefactories]
def read_holding(self):
""" Read all the holding registers from inverter."""
ret_status = True
message = tcp.read_holding_registers(slave_id=self.slave_id,
starting_address=self.ME_HOLDING,
quantity=self.NUM_HOLDING)
try:
response = tcp.send_message(message, self.modbus_tcp)
except:
ret_status = False
response = 0
return ret_status, response
def get_inverter_state(self):
""" Return the inverter state."""
ret_status = True
message = tcp.read_holding_registers(slave_id=self.slave_id,
starting_address=self.ME_STATE,
quantity=1)
try:
response = tcp.send_message(message, self.modbus_tcp)
except:
ret_status = False
response = [-1]
return ret_status, response[0], self.INV_STATES[response[0]]
def get_battery_percentage(self):
""" Return the current charge percentage of the batteries."""
ret_status = True
message = tcp.read_holding_registers(slave_id=self.slave_id,
starting_address=self.BATTPCT,
quantity=1)
try:
response = tcp.send_message(message, self.modbus_tcp)
except:
ret_status = False
response = [-1]
return ret_status, response[0]
def read_multiple_reg(self, starting_addr, count, slave_id=None):
slv_id = self.default_slave_id if slave_id is None else slave_id
response = [None] * count
for starting_idx, ending_idx in self.get_chunk_indices(
range(count), 125):
request_adu = tcp.read_holding_registers(
slv_id, starting_addr + starting_idx,
ending_idx - starting_idx)
response[starting_idx:ending_idx] = tcp.send_message(
request_adu, self.socket)
return response
def read(self, sock, slave_id=0):
"""
Attempt to read a raw value from the register.
This function has debugging logging that will print all bytes returned
from the server.
"""
# NOTE: Addresses are 0 indexed, but the documented registers are 1 indexed.
msg = tcp.read_holding_registers(slave_id, self.register - 1, 1)
resp = tcp.send_message(msg, sock)
# Extract the single value from the results
val = resp[0]
print("{} ({}): {}".format(self.name, self.register, val))
return val
def gateway_config_write_read(self,add, value):
config_id = 4
message = tcp.write_multiple_registers(slave_id=config_id, starting_address=add, values=[value])
response = tcp.send_message(message, self.sock)
time.sleep(0.1)
message = tcp.read_holding_registers(config_id, add, 1)
response = tcp.send_message(message, self.sock)
print("..")
if response[0] != value:
raise ValueError("Value not writen!")
def get_data(ip_address, port=502):
"""get_data is excpected to return a unique value."""
try:
# Start of your code (example below)
conf.SIGNED_VALUES = False
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip_address, port))
message = tcp.read_holding_registers(slave_id=1,
starting_address=0,
quantity=1)
response = tcp.send_message(message, sock)
sock.close()
return response[0]
# End of your code
except ConnectionRefusedError as e:
raise GetDataException(e)
def write_hr(self, new_value):
if self.bit is not None:
message = tcp.read_holding_registers(slave_id=self.slave_id,
starting_address=self.addr,
quantity=1)
response = self.server.send_message(message)
current_value = response[0]
if new_value:
new_value = current_value | 1 << self.bit
else:
new_value = current_value & ~(1 << self.bit)
message = tcp.write_multiple_registers(slave_id=self.slave_id,
starting_address=self.addr,
values=[int(new_value)])
response = self.server.send_message(message)
return response
def read_registers(self, address, number_of_registers):
"""
Low level register access.
Performs a modbus read registers request to the MAQ20
:param address: starting address.
:param number_of_registers: number of registers to be read in sequence.
:return: list(int) [-32767, 32767]
"""
if MODBUS_BACKEND == pymodbus:
result = self._client.read_holding_registers(address=address, count=number_of_registers)
# converts the returned values to signed.
try:
return [unsigned16_to_signed16(value) for value in result.registers]
except AttributeError:
return None
if MODBUS_BACKEND == UMODBUS:
message = tcp.read_holding_registers(0, address, number_of_registers)
result = tcp.send_message(message, self._sock)
return [unsigned16_to_signed16(value) for value in result]
def read(self):
message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=4)
# time.sleep(.5)
while True:
try:
response = tcp.send_message(message, self.client)
break
except OSError as e:
print('No he poodido escribir. Error {e}')
while True:
try:
self.client.connect((self.ip, self.port))
print('Socket conectado')
break
except OSError as e:
print('No he poodido conectar. Error {e}')
time.sleep(1)
continue
os.system('clear')
print(self._output_regs)
print(Text.from_markup(str(self)))
self._input_regs=response
def read_hr(self):
message = tcp.read_holding_registers(slave_id=self.slave_id,
starting_address=self.addr,
quantity=1)
response = self.server.send_message(message)
if response is not None:
if self.bit is None:
return response[0]
else:
def get_bit(decimal, N):
mask = 1 << N
if decimal & mask:
return 1
else:
return 0
return (get_bit(response[0], self.bit))
else:
return None
def read_holding_registers(self, start_register_address,
number_of_registers):
""" Modbus command : Read data to holding registers (function code = 03)
@Argument :
start_register_address (int16) : Start address where to read a data
number_of_registers (int) : number of register(s) in register-line where to read a data
@Return :
response : Read data(s). Return as list of read data (sequently) if number_of_register > 1
"""
response = None
# Enable byte system of modbus to be signed-value type
if self.signed_type == True:
conf.SIGNED_VALUES = True
else:
conf.SIGNED_VALUES = False
# Generate modbus TCP message
try:
message = modbus_tcp.read_holding_registers(
slave_id=self.device_id,
starting_address=start_register_address,
quantity=number_of_registers)
except Exception as e:
print("Error during generate modbus message.")
# Send message via TCP socket
try:
self._connect()
response = modbus_tcp.send_message(message, self.tcp_socket)
print("response={}".format(response))
self._disconnect()
except Exception as e:
print("Error during send modbus message.")
print(e)
return response
def read_bit(self, slave_id, address, bit):
message = tcp.read_holding_registers(slave_id, address, 1)
return get_bit(tcp.send_message(message, self.sock)[0],bit)
parser.add_argument('-p',
'--port',
type=int,
help="Port of modbus server (Ex: 502)")
parser.add_argument('-s', '--slaveid', type=int, help="Slave ID")
parser.add_argument('-a', '--address', type=int, help="Starting address")
parser.add_argument('-q', '--quantity', type=int, help="Quantity")
args = parser.parse_args()
# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((args.host, args.port))
# Returns a message or Application Data Unit (ADU) specific for doing
# Modbus TCP/IP.
begin_time = time.time()
message = tcp.read_holding_registers(slave_id=args.slaveid,
starting_address=args.address,
quantity=args.quantity)
# Response depends on Modbus function code. This particular returns the
# amount of coils written, in this case it is.
response = tcp.send_message(message, sock)
print(response)
print("data size: %d bytes" % (args.quantity * 2))
print("Time elapsed: %f s" % (time.time() - begin_time))
sock.close()
def read_holding_reg(self, address, slave_id=None):
slv_id = self.default_slave_id if slave_id is None else slave_id
request_adu = tcp.read_holding_registers(slv_id, address, 1)
response = tcp.send_message(request_adu, self.socket)
return response[0]
def button(func, state): state = not state ret_word = "" ret_state = False conf.SIGNED_VALUES = True plc_ip = '192.168.10.35' port_id = 502 sl_id = 0 writing_value = 1 # socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 502 is the port sock.connect((plc_ip, port_id)) if (func == 0): message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1) response = tcp.send_message(message, sock) if (response[0]): message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) ret_word = "Failed to flush all" return ret_state,ret_word else: row_Entry_message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1) row_Entry_response = tcp.send_message(row_Entry_message, sock) row_Entry_state = row_Entry_response[0] if (row_Entry_state): message = tcp.write_single_coil(slave_id = 1, address = func, value = 1) response = tcp.send_message(message, sock) message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1) response = tcp.send_message(message, sock) if(response[0]): ret_word = "Flush all once" ret_state = True time.sleep(1) message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) return ret_state,ret_word else: ret_word = "Failed to flush all once" return ret_state,ret_word else: ret_word = "Harvester not on row_Entry state" return ret_state,ret_word elif (func == 1): # Make sure it is not shutdown message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=1) response = tcp.send_message(message, sock) if(response[0]): # Make sure row_Out state is 0 message = tcp.write_single_coil(slave_id = 1, address = 2, value = 0) response = tcp.send_message(message, sock) message = tcp.read_coils(slave_id = 1, starting_address = 2, quantity = 1) response = tcp.send_message(message, sock) if (not response[0]): # Make sure clean state is 0 message = tcp.write_single_coil(slave_id = 1, address = 3, value = 0) response = tcp.send_message(message, sock) message = tcp.write_single_coil(slave_id = 1, address = func, value = 1) response = tcp.send_message(message, sock) message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1) response = tcp.send_message(message, sock) if(response[0]): ret_state = True ret_word = "Standby/row_entry on" return ret_state,ret_word else: ret_word = "Failed to standby" return ret_state,ret_word else: ret_word = "You are in shutdown mode" return ret_state, ret_word elif (func == 2): message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=1) response = tcp.send_message(message, sock) if(response[0]): # Make sure row_Entry state is 0 message = tcp.write_single_coil(slave_id = 1, address = 1, value = 0) response = tcp.send_message(message, sock) message = tcp.read_coils(slave_id = 1, starting_address = 2, quantity = 1) response = tcp.send_message(message, sock) if (not response[0]): message = tcp.write_single_coil(slave_id = 1, address = func, value = 1) response = tcp.send_message(message, sock) message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1) response = tcp.send_message(message, sock) if(response[0]): ret_state = True ret_word = "Navigation/Row_Out on" return ret_state,ret_word else: ret_word = "Failed to set Navigation/Row_Out mode" return ret_state,ret_word else: ret_word = "You are in shutdown mode" return ret_state, ret_word elif (func == 3): message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1) response = tcp.send_message(message, sock) if (response[0]): message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) else: message = tcp.read_coils(slave_id = 1, starting_address = 2, quantity = 1) response = tcp.send_message(message, sock) if (response[0] != 1): ret_word = "row_Out is not on, make sure row_Out is on first" return ret_state,ret_word else: message = tcp.write_single_coil(slave_id = 1, address = func, value = 1) response = tcp.send_message(message, sock) message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1) response = tcp.send_message(message, sock) if(response[0]): ret_state = True ret_word = "clean on" return ret_state,ret_word else: ret_word = "failed to set clean on" return ret_state,ret_word elif (func == 4): message = tcp.write_single_register(slave_id = 1, address = 0, value = 16) response = tcp.send_message(message, sock) message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=1) response = tcp.send_message(message, sock) if response[0] == 16: ret_word = "Startup" ret_state = True return ret_state,ret_word else: ret_word = "Unable to startup" return ret_state,ret_word elif (func == 5): message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1) response = tcp.send_message(message, sock) if response[0]: message = tcp.write_single_coil(slave_id=1, address=func,value=1) response = tcp.send_message(message,sock) time.sleep(1) message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) ret_word = "Trough 1 flush once" return ret_state,ret_word else: ret_word = "Not in Standby/Row_Entry state" return ret_state, ret_word elif (func == 6): message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1) response = tcp.send_message(message, sock) if response[0]: message = tcp.write_single_coil(slave_id=1, address=func,value=1) response = tcp.send_message(message,sock) time.sleep(1) message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) ret_word = "Trough 2 flush once" return ret_state,ret_word else: ret_word = "Not in Standby/Row_Entry state" return ret_state, ret_word elif (func == 7): message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1) response = tcp.send_message(message, sock) if response[0]: message = tcp.write_single_coil(slave_id=1, address=func,value=1) response = tcp.send_message(message,sock) time.sleep(1) message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) ret_word = "Trough 3 flush once" return ret_state,ret_word else: ret_word = "Not in Standby/Row_Entry state" return ret_state, ret_word elif (func == 8): message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1) response = tcp.send_message(message, sock) if response[0]: message = tcp.write_single_coil(slave_id=1, address=func,value=1) response = tcp.send_message(message,sock) time.sleep(1) message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) ret_word = "Trough 4 flush once" return ret_state,ret_word else: ret_word = "Not in Standby/Row_Entry state" return ret_state, ret_word elif (func == 9): message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1) response = tcp.send_message(message, sock) if response[0]: message = tcp.write_single_coil(slave_id=1, address=func,value=1) response = tcp.send_message(message,sock) time.sleep(1) message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) ret_word = "Trough 5 flush once" return ret_state,ret_word else: ret_word = "Not in Standby/Row_Entry state" return ret_state, ret_word if (func == 10): message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1) response = tcp.send_message(message, sock) if (response[0]): message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) else: row_Entry_message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1) row_Entry_response = tcp.send_message(row_Entry_message, sock) row_Entry_state = row_Entry_response[0] if (row_Entry_state): message = tcp.write_single_coil(slave_id = 1, address = func, value = 1) response = tcp.send_message(message, sock) message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1) response = tcp.send_message(message, sock) if(response[0]): ret_state = True ret_word = "Flush_with_delay once" time.sleep(1) message = tcp.write_single_coil(slave_id = 1, address = func, value = 0) response = tcp.send_message(message, sock) return ret_state,ret_word else: ret_word = "Failed to delay flush once" return ret_state,ret_word else: ret_word = "Harvester not on Standby/Row_Entry state" return ret_state,ret_word elif (func == -1): message = tcp.write_single_register(slave_id = 1, address = 0, value = 0) response = tcp.send_message(message, sock) message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=1) response = tcp.send_message(message, sock) if response[0] == 0: ret_state = True ret_word = "Close all" return ret_state,ret_word return ret_state,ret_word sock.close()
def getMaxAllowedCurrent(self, powerWallbox, modeID):
try:
# Enable values to be signed (default is False).
conf.SIGNED_VALUES = False
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((self.IPaddress, 502))
# Request the current total power
message = tcp.read_holding_registers(slave_id=1,
starting_address=41017,
quantity=2)
response_totalPower = tcp.send_message(message, sock)
# Request the current power sent to the analog output
message = tcp.read_holding_registers(slave_id=1,
starting_address=41041,
quantity=2)
response_analogOutPower = tcp.send_message(message, sock)
sock.close()
# Convert response of total power in INT32 to a normal number in kW
temp = struct.pack(">HH", response_totalPower[0],
response_totalPower[1])
totalPowerTuple = struct.unpack(">l", temp)
totalPowerkW = totalPowerTuple[0] / 1000
# Convert response of analogout power in UINT32 to a normal number in kW
temp = struct.pack(">HH", response_analogOutPower[0],
response_analogOutPower[1])
analogOutPowerTuple = struct.unpack(">L", temp)
analogOutPowerkW = analogOutPowerTuple[0] / 1000
# Add both powers in the correct way to get the current power produced and available
currentPowerkW = analogOutPowerkW + (
(-1) * totalPowerkW) + powerWallbox
print('currentPowerkW Smartfox:' + str(currentPowerkW))
# Select correct mode and thresholds
for mode in self.modes:
if mode["id"] == modeID:
thresholds = mode["thresholds"]
if thresholds != None:
# Sort list so the maximum power is first
thresholds.sort(key=lambda x: x["minPowerProductionKW"],
reverse=True)
for threshold in thresholds:
if currentPowerkW >= threshold["minPowerProductionKW"]:
return threshold["chargeCurrentAmpere"]
# If no threshold is reached, return 0
return 0
else:
print("Smartfox Error: Mode not found")
return 0
except:
raise IOError
#!/usr/bin/env python
# scripts/examples/simple_tcp_client.py
import socket
from umodbus import conf
from umodbus.client import tcp
# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 502))
# Returns a message or Application Data Unit (ADU) specific for doing
# Modbus TCP/IP.
message = tcp.read_holding_registers(slave_id=1,
starting_address=1,
quantity=5)
# Response depends on Modbus function code. This particular returns the
# amount of coils written, in this case it is.
response = tcp.send_message(message, sock)
print(response)
sock.close()
async def read(self, client):
message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=4)
response = tcp.send_message(message, client)
print(response)
#!/usr/bin/env python
# scripts/examples/simple_tcp_client.py
import socket
import time
from umodbus import conf
from umodbus.client import tcp
from datetime import datetime
# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('10.10.53.10', 502))
# Returns a message or Application Data Unit (ADU) specific for doing
# Modbus TCP/IP.
starttime = time.time()
while True:
message = tcp.read_holding_registers(slave_id=2,
starting_address=3205,
quantity=1)
response = tcp.send_message(message, sock)
print(datetime.now().strftime("%d-%b-%Y (%H:%M:%S.%f): "), response)
time.sleep(1.0 - ((time.time() - starttime) % 1.0))
# Response depends on Modbus function code. This particular returns the
# amount of coils written, in this case it is.
sock.close()
def readWords(self,address,length):
message = tcp.read_holding_registers(self.slaveNbr, address,length)
response = self.__doRequest(message)
return response
def read_holding_registers(self, slave_id, starting_address, quantity):
message = tcp.read_holding_registers(slave_id, starting_address, quantity)
response = tcp.send_message(message, self.sock)
return response
