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