def scan(): parser = argparse.ArgumentParser(description = "Read all holding registries from a TCP MODBUS Slave") parser.add_argument("ip", help="IP address of the slave") parser.add_argument("-p", "--port", dest="port", help="Modbus Port. Defaults to 502", type=int, metavar="PORT", default=502) parser.add_argument("-u", "--uid", dest="uid", help="Modbus Unit ID. Defaults to 1", type=int, metavar="UID", default=1) parser.add_argument("-sa", "--start-address", dest="start_address", help="Starting Address for the scanner. Defaults to 1", type=int, metavar="START", default=1) parser.add_argument("-ea", "--end-address", dest="end_address", help="Ending Address for the scanner. Defaults to 65535", type=int, metavar="END", default=65535) args = parser.parse_args() try: ip = args.ip except IndexError: print "ERROR: No target to scan\n\n" parser.print_help() exit() # ip address format verification if not validate_ipv4(ip): print "ERROR: IP address is invalid\n\n" parser.print_help() exit() print 'Connecting to %s...' % ip, # connect to modbus slave client = ModbusTcpClient(ip, args.port) client.connect() if client.socket == None: print "ERROR: Could not connect to %s." %ip exit() print ' Connected.' # TODO add ETA mechanism results = {} addr = 1 registers_tested = args.end_address - args.start_address + 1 if registers_tested == 1: hr = client.read_holding_registers(args.start_address, 1, unit=args.uid) # unit value is device id of the slave (UID) if hr.function_code == 3: # if we succeed reading stuff results[addr] = hr.registers[0] # if it fails, hr.function = 131 (0x83), cf modbus doc else: for addr in range(args.start_address, args.end_address): hr = client.read_holding_registers(addr, 1, unit=args.uid) # unit value is device id of the slave (UID) if hr.function_code == 3: # if we succeed reading stuff results[addr] = hr.registers[0] # if it fails, hr.function = 131 (0x83), cf modbus doc client.close() print 'Register scanning is finished (%d registers were tried)' % (registers_tested) # sorting dict for printing ordered_results = collections.OrderedDict(sorted(results.items())) for addr, value in ordered_results.iteritems(): print 'Addr {0} \t{1}'.format(addr,value)
def wren_gw_modbus_read(config): ''' read a value from the peer. @param config the configuration in the key/value type. ''' try: m = ModbusTcpClient(host=config['node'], port=config['port']) m.connect() unit = 0xff if config.has_key('unit_id'): unit = config['unit_id'] # sed data value = None if config['table'] == 'InputRegister': result = m.read_input_registers(config['address'], 1, unit=unit) if result: value = result.registers[config['address']] if config['table'] == 'HoldingRegister': result = m.read_holding_registers(config['address'], 1, unit=unit) if result: value = result.registers[config['address']] # close it. m.close() return {"status":True, "value":str(value)}; except Exception as e: return {"status":False, "value":str(e)};
class ModbusModule(): def __init__(self, io_module_name, ip): logger.debug('Creating new controller with name {} and address {}.'.format(io_module_name, ip)) self.io_module_name = io_module_name self.ip_address = ip self.controller_type = CONTROLLER_TYPE.Modbus # build connection object self.client = ModbusClient(ip, port=config.DEFAULT_MODBUS_PORT) self.client.connect() def __del__(self): self.client.close() def __str__(self): return 'Controller "{}" at address {}'.format(self.io_module_name, self.ip_address) def get_bit(self, address): try: result = self.client.read_coils(address) bit_value = result.bits[0] except ConnectionException: logger.error('Could not connect to Modbus module "{}"!' .format(self.io_module_name)) bit_value = False return bit_value def set_bit(self, address, value): try: self.client.write_coil(address, value) except ConnectionException: logger.error('Could not connect to Modbus module "{}"!' .format(self.io_module_name))
def runModBus(IOVariables): #---------------------------------------------------------------------------# # choose the client you want #---------------------------------------------------------------------------# # make sure to start an implementation to hit against. For this # you can use an existing device, the reference implementation in the tools # directory, or start a pymodbus server. #---------------------------------------------------------------------------# client = ModbusTcpClient('192.168.1.9') #rq = client.write_registers(2048, [0]) #rr = client.read_input_registers(000, 1) #print (rr.registers) #---------------------------------------------------------------------------# # configure io card #---------------------------------------------------------------------------# #Digital_In_1 = ModbusDigitalInputIOCard(0, client) #print('IOVariables in modbus.py: {IOVariables} '.format(IOVariables=IOVariables)) Digital_Out_1 = ModbusDigitalOutputIOCard(2048, client, IOVariables) #---------------------------------------------------------------------------# # Run io card #---------------------------------------------------------------------------# #Digital_In_1.ReadStatus() #---------------------------------------------------------------------------# # Run io card #---------------------------------------------------------------------------# Digital_Out_1.WriteStatus() #---------------------------------------------------------------------------# # close the client #---------------------------------------------------------------------------# client.close()
def main(): ### setup the client ### ipaddr = '192.168.201.21' port = 502 print 'Connecting to', (ipaddr, port) client = ModbusTcpClient(ipaddr, port=port) ### fetch data ### try: reg = client.read_input_registers(0, 8) # data request vlt = raw2volt(reg.registers) # convert bit to voltage (-10 -- 10[V]) except: print 'Data fetch error. Finishing...' client.close() return ### convert voltage to engineering values ### meas = vlt # TODO: CHANGE THIS ### show data ### print 'Raw measurement:', vlt print 'Engineering value:', meas ### finalizing ### client.close()
def wren_gw_modbus_write(config, value): ''' write a value to the peer. @param value a number in the string type. ''' try: m = ModbusTcpClient(host=config['node'], port=config['port']) # XXX # ModbusTcpClient.connect() does not look to do connect(2) actually. m.connect() unit = 0xff if config.has_key('unit_id'): unit = config['unit_id'] # send data result = False if config['table'] == 'HoldingRegister': result = m.write_register(config['address'], int(value), unit=unit) if result.value == int(value): result = True # close it. m.close() return {"status":True, "value":str(value)}; except Exception as e: return {"status":False, "value":str(e)};
class TestMbTcpClass1(unittest.TestCase): read_values = range(0xAA50, 0xAA60) write_values = range(0xBB50, 0xBB60) def setUp(self): self.client = ModbusTcpClient(SERVER_HOST) self.client.connect() def tearDown(self): self.client.close() def test_write_single_holding_register(self): rq = self.client.write_register(8, 0xCC) self.assertEqual(rq.function_code, 0x06) rr = self.client.read_holding_registers(8, 1) self.assertEqual(rr.registers[0], 0xCC) rq = self.client.write_register(16, 0x00) self.assertEqual(rq.function_code, 0x86) rq = self.client.write_register(8, 0xAA58) def test_write_coil(self): rq = self.client.write_coil(0, True) self.assertEqual(rq.function_code, 0x05) rq = self.client.write_coil(0, False) self.assertEqual(rq.function_code, 0x05) rq = self.client.write_coil(256, False) self.assertEqual(rq.function_code, 0x85) def test_read_coil(self): coil_read_values = [True, False, True, False, False, True, False, False]
class TestMbTcpClass0(unittest.TestCase): read_values = range(0xAA50, 0xAA60) write_values = range(0xBB50, 0xBB60) def setUp(self): self.client = ModbusTcpClient(SERVER_HOST) self.client.connect() def tearDown(self): self.client.close() def test_read_holding_registers(self): rv = self.client.read_holding_registers(0, 16) self.assertEqual(rv.function_code, 0x03) self.assertEqual(rv.registers, self.read_values) def test_read_holding_registers_exception(self): rv = self.client.read_holding_registers(16, 1) self.assertEqual(rv.function_code, 0x83) self.assertEqual(rv.exception_code, 0x02) def test_write_holding_registers(self): rq = self.client.write_registers(0, self.write_values) self.assertEqual(rq.function_code, 0x10) rr = self.client.read_holding_registers(0, 16) self.assertEqual(rr.registers, self.write_values) rq = self.client.write_registers(0, self.read_values) self.assertEqual(rq.function_code, 0x10) def test_write_holding_registers_exception(self): rq = self.client.write_registers(16, [0x00]) self.assertEqual(rq.function_code, 0x90) self.assertEqual(rq.exception_code, 0x02)
def setDeviceStatus(self, postmsg): setDeviceStatusResult = True try: client = ModbusTcpClient(self.get_variable('address'),port=502) client.connect() if (self.get_variable('model')=='VC1000'): if 'heat_setpoint' in postmsg.keys(): client.write_register(6,int(self.far2cel(float(postmsg.get('heat_setpoint')))*100.0),unit=self.get_variable('slave_id')) if 'cool_setpoint' in postmsg.keys(): client.write_register(6,int(self.far2cel(float(postmsg.get('cool_setpoint')))*100.0),unit=self.get_variable('slave_id')) if 'flap_override' in postmsg.keys(): if postmsg.get('flap_override') == 'ON' or postmsg.get('flap_override') == True: client.write_register(159,1,unit=self.get_variable('slave_id')) elif postmsg.get('flap_override') == 'OFF' or postmsg.get('flap_override') == False: client.write_register(159,0,unit=self.get_variable('slave_id')) if 'flap_position' in postmsg.keys(): client.write_register(160,int(postmsg.get('flap_position')),unit=self.get_variable('slave_id')) elif (self.get_variable('model')=='M1000'): if 'heat_setpoint' in postmsg.keys(): client.write_register(187,int(self.far2cel(float(postmsg.get('heat_setpoint')))*100.0),unit=self.get_variable('slave_id')) if 'cool_setpoint' in postmsg.keys(): client.write_register(188,int(self.far2cel(float(postmsg.get('cool_setpoint')))*100.0),unit=self.get_variable('slave_id')) if 'outside_damper_position' in postmsg.keys(): client.write_register(274,int(postmsg.get('outside_damper_position')),unit=self.get_variable('slave_id')) if 'bypass_damper_position' in postmsg.keys(): client.write_register(275,int(postmsg.get('bypass_damper_position')),unit=self.get_variable('slave_id')) if 'fan_status' in postmsg.keys(): if postmsg.get('fan_status') == 'ON' or postmsg.get('fan_status') == True: client.write_register(130,2,unit=self.get_variable('slave_id')) elif postmsg.get('fan_status') == 'OFF' or postmsg.get('fan_status') == False: client.write_register(130,1,unit=self.get_variable('slave_id')) if 'cooling_status' in postmsg.keys(): if postmsg.get('cooling_status') == 'ON': client.write_registers(124,[1,2,2,2],unit=self.get_variable('slave_id')) elif postmsg.get('cooling_status') == 'OFF': client.write_registers(124,[0,1,1,1],unit=self.get_variable('slave_id')) if 'cooling_mode' in postmsg.keys(): if postmsg.get('cooling_mode') == 'None': client.write_register(10,0,unit=self.get_variable('slave_id')) elif postmsg.get('cooling_mode') == 'STG1': client.write_register(10,1,unit=self.get_variable('slave_id')) elif postmsg.get('cooling_mode') == 'STG2': client.write_register(10,2,unit=self.get_variable('slave_id')) elif postmsg.get('cooling_mode') == 'STG3': client.write_register(10,3,unit=self.get_variable('slave_id')) elif postmsg.get('cooling_mode') == 'STG4': client.write_register(10,4,unit=self.get_variable('slave_id')) if 'heating' in postmsg.keys(): client.write_register(129,int(postmsg.get('heating')),unit=self.get_variable('slave_id')) client.close() except: try: client.close() except: print('Modbus TCP client was not built successfully at the beginning') setDeviceStatusResult=False return setDeviceStatusResult
class ModbusConnection(object): _max_retries_read = 10 _max_retries_write = 3 @property def max_retries_read(self): return self._max_retries_read @property def max_retries_write(self): return self._max_retries_write @property def client_address(self): return self.client.host @property def client_port(self): return str(self.client.port) def __init__(self, client_address, client_port): self.client = ModbusClient(host = client_address, port = int(client_port)) self.connect_to_client() def __del__(self): self.disconnect_from_client() def connect_to_client(self): self.client.connect() def disconnect_from_client(self): self.client.close() def read_input_registers(self, address, count, unit): k = 0 while k < self.max_retries_read: try: return self.client.read_input_registers(address = address, count = count, unit = unit).registers except: k += 1 sleep(1.5) def read_holding_registers(self, address, count, unit): k = 0 while k < self.max_retries_read: try: return self.client.read_holding_registers(address = address, count = count, unit = unit).registers except: k += 1 sleep(1.5) def write_register(self, address, unit, value): k = 0 while k < self.max_retries_write: try: return self.client.write_register(address = address, unit = unit, value = value) except: k += 1 sleep(1.5)
def get_point_sync(self, point_name): register = self.point_map[point_name] client = SyncModbusClient(self.ip_address, port=self.port) try: result = register.get_state_sync(client) except (ConnectionException, ModbusIOException, ModbusInterfaceException): result = None finally: client.close() return result
def set_point(self, point_name, value): register = self.get_register_by_name(point_name) client = SyncModbusClient(self.ip_address, port=self.port) result = None try: result = register.set_state(client, value) except (ConnectionException, ModbusIOException, ModbusInterfaceException): result = None finally: client.close() return result
def run(self): comm=server_addr[random.randint(0,len(serverlist)-1)] client = ModbusTcpClient(comm, self.port, source_address=(self.ipaddr,0), retries=1, retry_on_empty=True) while(not self.clientstop.is_set()): client.write_coil(1, True) print "coil write from:" + self.ipaddr + " --->" + comm time.sleep(random.randint(0,3)) print "stopping" client.socket.shutdown(1) client.close() return
def main(argv): syntax = os.path.basename(__file__) + " -p <first port> -n <number of servers> -i <ip:first port of pump server>" tcp_port = 502 inj_tcp = "localhost:502" no_server = 1 try: opts = getopt.getopt(argv, "hp:n:i:", ["port=", "noserver=","injport="])[0] except getopt.GetoptError: print syntax sys.exit(1) if len(opts) < 1: print syntax sys.exit(2) for opt, arg in opts: if opt == '-h': print syntax sys.exit() elif opt in ("-i", "--injport"): inj_tcp = arg elif opt in ("-p", "--port"): tcp_port = int(arg) elif opt in ("-n", "--noserver"): no_server = int(arg) port = tcp_port context_list = [] identity_list = [] address_list = [] splitted = inj_tcp.split(":") ip_pump = splitted[0] port_pump = int(splitted[1]) p_prev_client = None for srv in range(no_server): p_client = ModbusClient(ip_pump, port=port_pump) ret = p_client.connect() if ret: log.info("connection ok on {0}:{1}".format(ip_pump,port_pump)) p_client.close() else: p_client = p_prev_client log.info("Keep the previous pump on {0}:{1}".format(ip_pump,port_pump-1)) port_pump += 1 address_list.append(("127.0.0.1", port)) port += 1 context = context_factory() context_list.append(context) identity_list.append(identity_factory()) time = 1 # 1 seconds delay loop = LoopingCall(f=updating_writer, a=(context,srv,p_client)) p_prev_client = p_client loop.start(time, now=False) # initially delay by time StartMultipleTcpServers(context_list, identity_list, address_list)
class communication: def __init__(self): self.client = None self.lock = threading.Lock() def connectToDevice(self, address): """Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument.""" self.client = ModbusTcpClient(address) def disconnectFromDevice(self): """Close connection""" self.client.close() def sendCommand(self, data): """Send a command to the Gripper - the method takes a list of uint8 as an argument. The meaning of each variable depends on the Gripper model (see support.robotiq.com for more details)""" # make sure data has an even number of elements if len(data) % 2 == 1: data.append(0) # Initiate message as an empty list message = [] # Fill message by combining two bytes in one register for i in range(0, len(data) / 2): message.append((data[2 * i] << 8) + data[2 * i + 1]) # To do!: Implement try/except with self.lock: self.client.write_registers(0, message) def getStatus(self, numBytes): """Sends a request to read, wait for the response and returns the Gripper status. The method gets the number of bytes to read as an argument""" numRegs = int(ceil(numBytes / 2.0)) # To do!: Implement try/except # Get status from the device with self.lock: response = self.client.read_input_registers(0, numRegs) # Instantiate output as an empty list output = [] # Fill the output with the bytes in the appropriate order for i in range(0, numRegs): output.append((response.getRegister(i) & 0xFF00) >> 8) output.append(response.getRegister(i) & 0x00FF) # Output the result return output
class SynchronousTcpClient(Runner, unittest.TestCase): ''' These are the integration tests for the synchronous tcp client. ''' def setUp(self): ''' Initializes the test environment ''' self.initialize(["../tools/reference/diagslave", "-m", "tcp", "-p", "12345"]) self.client = ModbusClient(port=12345) def tearDown(self): ''' Cleans up the test environment ''' self.client.close() self.shutdown()
def search(): client = ModbusClient(HOST,port=PORT,framer=ModbusFramer) if not client.connect(): logger.error("cannot connect to [%s:%d]." %(HOST,PORT)) n=0 while n<247: rr=client.read_holding_registers(address=0x015e,count=2,unit=n) assert(rr.function_code < 0x80) if rr: print n else: print 'fail',n n=n+1 client.close() #search()
def LEDUpdateThread(pin, update_interval, e): print 'LEDUpdateThread' client = ModbusTcpClient(args.ip) GPIO.setup(pin, GPIO.OUT) while True: if not e.isSet(): result = client.read_coils(0, 1) if result is not None: pin_status = result.bits[0] GPIO.output(pin, pin_status) print pin_status time.sleep(update_interval) else: break client.close() print 'LED thread stoped'
def testConnection1(self, button): lblTest1 = builder.get_object("lblTest1") manifold_host_1 = builder.get_object("txtIP1").get_text() manifold_port_1 = int(builder.get_object("txtPort1").get_text()) client_1 = ModbusClient(manifold_host_1, port=manifold_port_1) self.ret_m1=client_1.connect() lblTest1.set_text(str(self.ret_m1)) if not smtConfig.has_section('Manifold_1'): smtConfig.add_section('Manifold_1') if self.ret_m1: builder.get_object("switchMain").set_sensitive(True) smtConfig.set('Manifold_1', 'host', manifold_host_1) smtConfig.set('Manifold_1', 'port', manifold_port_1) with open(sCFGName, 'wb') as configfile: smtConfig.write(configfile) client_1.close()
def scan(): parser = argparse.ArgumentParser(description = "Write all holding registries on a TCP MODBUS Slave") parser.add_argument("ip", help="IP address of the slave") parser.add_argument("-p", "--port", dest="port", help="Modbus Port. Defaults to 502", type=int, metavar="PORT", default=502) parser.add_argument("-u", "--uid", dest="uid", help="Modbus Unit ID. Defaults to 1", type=int, metavar="UID", default=1) parser.add_argument("-sa", "--start-address", dest="start_address", help="Starting Address for the writer. Defaults to 1", type=int, metavar="START", default=1) parser.add_argument("-ea", "--end-address", dest="end_address", help="Ending Address for the writer. Defaults to 65535", type=int, metavar="END", default=65535) parser.add_argument("-v", "--value", dest="value", help="Value that will be written. Defaults to 7777", type=int, metavar="VALUE", default=7777) args = parser.parse_args() try: ip = args.ip except IndexError: print "ERROR: No target given\n\n" parser.print_help() exit() # ip address format verification if not validate_ipv4(ip): print "ERROR: IP address is invalid\n\n" parser.print_help() exit() print 'Connecting to %s...' % ip, # connect to modbus slave client = ModbusTcpClient(ip, args.port) client.connect() if client.socket == None: print "ERROR: Could not connect to %s." %ip exit() print ' Connected.' # TODO add ETA mechanism results = [] addr = 1 for addr in range(args.start_address, args.end_address): hr = client.write_registers(addr, args.value, unit=args.uid) # unit value is device id of the slave (UID) if hr.function_code == 16: # if we succeeded writing stuff. code = 0x10 results.append(addr) # if it fails, hr.function = 144 (0x90), cf modbus doc client.close() print 'Register writing is finished (%d addresses were tried)' % (args.end_address-args.start_address+1) print 'Writing was successful on these %d addresses:' % len(results) print results
def ButtonUpdateThread(pin, update_interval, e): print 'ButtomUpdateThread' client = ModbusTcpClient(ip) # Setup pin mode GPIO.setup(pin, GPIO.IN) while True: if not e.isSet(): pin_status = GPIO.input(pin) print status client.write_coil(20, pin_status) time.sleep(update_interval) else: break client.close() print 'Button Stopped'
class RemoteSlaveContextTest(ContextRunner, unittest.TestCase): """ These are the integration tests for using the redis slave context. """ def setUp(self): """ Initializes the test environment """ self.context = RemoteSlaveContext(client=None) # for the log statment self.initialize(["../tools/reference/diagslave", "-m", "tcp", "-p", "12345"]) self.client = ModbusTcpClient(port=12345) self.context = RemoteSlaveContext(client=self.client) def tearDown(self): """ Cleans up the test environment """ self.client.close() self.shutdown()
def get_modbus(properties): try: print "Performing an action which may throw an exception." client = ModbusClient(properties['ip'], port=502) client.connect() log.debug(properties['registers']) log.debug(properties['coils']) modbus_values = {} # Get holding registers values modbus_registers = {} for i in properties['registers']: register_start_nb = i.split('-')[0] register_end_nb = i.split('-')[1] log.debug('Register start number : %s' % register_start_nb) log.debug('Register end number : %s' % register_end_nb) register_count = int(register_end_nb) - int(register_start_nb) log.debug('Number of registers to read : %s' % register_count) rr = client.read_holding_registers(int(register_start_nb),register_count, unit=0x01) modbus_registers[register_start_nb] = rr.registers log.debug('Registers values : %s' % rr.registers) # Get coils values modbus_coils = {} for i in properties['coils']: coil_start_nb = i.split('-')[0] coil_end_nb = i.split('-')[1] log.debug('Coil start number : ' + register_start_nb) log.debug('Coil end number : ' + register_end_nb) coil_count = int(coil_end_nb) - int(coil_start_nb) log.debug('Number of coils to read : ' + str(coil_count)) rr = client.read_coils(int(coil_start_nb),coil_count, unit=0x01) modbus_coils[coil_start_nb] = rr.bits log.debug('Coils values : ' + str(rr.bits)) log.debug('Modbus coils values : ' + str(modbus_coils)) client.close() modbus_values['registers'] = modbus_registers modbus_values['coils'] = modbus_coils log.debug(str(modbus_values)) return modbus_values except Exception, error: log.debug('Error connecting to %s' % properties['ip']) log.debug(str(error))
def TemperatureUpdateThread(update_interval, e): print 'TemperatureUpdateThread' client = ModbusTcpClient(ip) while True: if not e.isSet(): tfile = open("/sys/bus/w1/devices/28-00000625a0cd/w1_slave") text = tfile.read() tfile.close() secondline = text.split("\n")[1] temperaturedata = secondline.split(" ")[9] temperature = float(temperaturedata[2:]) client.write_register(0, temperature) print (temperature/1000) time.sleep(update_interval) else: break client.close() print 'Temperature sensor thread stoped'
def scrape_all(self): result_dict={} try: client = SyncModbusClient(self.ip_address, port=self.port) result_dict.update(self.scrape_byte_registers(client, True)) result_dict.update(self.scrape_byte_registers(client, False)) result_dict.update(self.scrape_bit_registers(client, True)) result_dict.update(self.scrape_bit_registers(client, False)) except (ConnectionException, ModbusIOException, ModbusInterfaceException) as e: print ("ERROR: Failed to scrape device at " + self.ip_address + ":" + str(self.port) + " " + "ID: " + str(self.slave_id) + str(e)) return None finally: client.close() return result_dict
def RGBLEDUpdateThread(pins, update_interval, e): print 'RGBLEDUpdateThread' client = ModbusTcpClient(ip) # Setup pins mode for i in range(0, 3): GPIO.setup(pins[i], GPIO.OUT) while True: if not e.isSet(): result = client.read_coils(10, 3) print 'RGB LED. R:', result.bits[0], 'G:', result.bits[1], 'B:', result.bits[2] for i in range(0, 3): GPIO.output(pins[i], result.bits[i]) time.sleep(update_interval) else: break client.close() print 'RGB LED Stopped'
def write_register(slave_addr, slave_port, reg_addr, reg_val): # Call modbustcp client to write register value client = ModbusTcpClient(host=slave_addr, port=slave_port) if client.connect() == False: print "Connection to Modbus slave %s:%d failed" %(slave_addr, slave_port) return reply = client.write_register(address=reg_addr, value=reg_val, unit=1) client.close() if reply == None: print "No reply while writing Modbus register" return if reply.function_code != 6: print "Writing Modbus register returned wrong function code" return
def testBasicSyncTcpClient(self): ''' Test the basic methods for the tcp sync client''' # receive/send client = ModbusTcpClient() client.socket = mockSocket() self.assertEqual(0, client._send(None)) self.assertEqual(1, client._send('\x00')) self.assertEqual('\x00', client._recv(1)) # connect/disconnect self.assertTrue(client.connect()) client.close() # already closed socket client.socket = False client.close() self.assertEqual("127.0.0.1:502", str(client))
def writeMBholdingregisters(clientIP, register, valuelist): from pymodbus.client.sync import ModbusTcpClient, ConnectionException client = ModbusTcpClient(clientIP) try: rawresult = client.write_registers(register, valuelist) except ConnectionException: statuscode = 7 else: if 'exception_code' in rawresult.__dict__: statuscode = rawresult.exception_code values = [] else: statuscode = 0 values = valuelist # result = client.read_holding_registers(register, len(valuelist)) client.close() result = {'message': messagefrommbstatuscode(statuscode), 'statuscode': statuscode, 'values': values} return result
def modbus_poller(id, stop_event, config): log = logging.getLogger("worker-" + str(id)) log.setLevel(logging.DEBUG) client = ModbusClient(host=config["address"], port=config["port"]) client.connect() log.info("Worker started") t_max = -1 while not stop_event.is_set(): log.info("Poller turn") t0 = time() address = 0 for i in poll_range(config["num_controls"], config["chunk_size"]): result = client.read_input_registers(address=address, count=i, unit=1) address += i if result is not None: if result.function_code >= 0x80 and result.function_code != 132: log.warn("Server returned error!") print result stop_event.set() break elif result.function_code == 132: print "Server fault: " + str(result) sleep(1) break t = time() - t0 log.info("Request took " + str(t) + " s") if t > t_max: t_max = t sleep(config["thread"]["interval"]) log.info("Worker shutting down") log.info("Max worker process time: " + str(t_max)) client.close()
def chart(response): global building, state client = ModbusClient(host=IP_MODBUS, port=PORT_MODBUS) if response.method == "POST": client.connect() if response.POST.get("failure"): # button clicked, send info about failure via MODBUS TCP/IP client.write_register(19, 5) elif response.POST.get("repair"): # button clicked, send info about failure's end via MODBUS TCP/IP client.write_register(19, 0) elif response.POST.get("B1"): building = "B1" elif response.POST.get("B2"): building = "B2" elif response.POST.get("B3"): building = "B3" client.close() if building == "B1": state = SystemState.objects.all() elif building == "B2": state = SystemState_2.objects.all() elif building == "B3": state = SystemState_3.objects.all() temps = list(state.values_list('temperature', flat=True)) recent_temp = 0 if temps: recent_temp = temps[-1] client.connect() write_32b_float(client, 2000, recent_temp) client.close() time = state.values_list('date', flat=True) time_str = [t.strftime("%d-%m %H:%M") for t in time] return render(response, "main/chart.html", { 'temps': temps, 'time': time_str, 'building': building })
def data_on_message(client, userdata, message): global device_in_use diu1 = device_in_use.decode( "utf-8") #to convert from binary array to string topic = message.topic value = int(message.payload) #Converting the bytearray to integer value. print('Data received.') print('Value :', value) reg = int(reg_config[locals()['diu1']]) UNIT = int(slave_config[locals()['diu1']]) print("Register to write into :\n") print(reg) print("Slave unit to write into :\n") print(UNIT) mclient = ModbusClient( host="localhost", port=502, framer=ModbusRtuFramer) #Initialise the ModbusTcpClient mclient.connect() rw = mclient.write_register(reg, value, unit=UNIT) mclient.close()
def scrape_all(self): result_dict = {} try: client = SyncModbusClient(self.ip_address, port=self.port) result_dict.update(self.scrape_byte_registers(client, True)) result_dict.update(self.scrape_byte_registers(client, False)) result_dict.update(self.scrape_bit_registers(client, True)) result_dict.update(self.scrape_bit_registers(client, False)) except (ConnectionException, ModbusIOException, ModbusInterfaceException) as e: print("ERROR: Failed to scrape device at " + self.ip_address + ":" + str(self.port) + " " + "ID: " + str(self.slave_id) + str(e)) return None finally: client.close() return result_dict
def testBasicSyncTcpClient(self, mock_select): ''' Test the basic methods for the tcp sync client''' # receive/send mock_select.select.return_value = [True] client = ModbusTcpClient() client.socket = mockSocket() self.assertEqual(0, client._send(None)) self.assertEqual(1, client._send(b'\x00')) self.assertEqual(b'\x00', client._recv(1)) # connect/disconnect self.assertTrue(client.connect()) client.close() # already closed socket client.socket = False client.close() self.assertEqual("ModbusTcpClient(127.0.0.1:502)", str(client))
class EthModbusCmd: def __init__(self, sensorID, IPaddr): self.sensorID=sensorID self.slaveAddr=IPaddr self.client = ModbusTcpClient(host=self.slaveAddr) def getClient(self): self.client.close() # kinda a POS if not self.client.connect(): # make sure it can be re-opened # TODO: throw exception pass return self.client def execute(self): # doesn't do anything pass def to_JSON_WWW_data(self,readingTime): # TODO: not supposed to be here, throw an exception return [] def __del__(self): self.client.close()
def ModbusTCP(URL, Reg, Value): #Modbus simple query #Example strings #client = ModbusTcpClient('127.0.0.1') #client.write_coil(1, True) #print result.bits[0] #client.close() #these are with a plus, since the my_data needs to be concatenated with the url try: client = ModbusTcpClient(URL) client.write_register(Reg, Value) client.close() #ActionData = 'reg: ' + Reg + ' val: ' + Value #if (debuging): xbmc.log('Modbus Commander: ModbusTCP: ' + URL + ActionData) ReturnValue = "success" #except: #ActionData = 'reg: ' + Reg + ' val: ' + Value #if (debuging): xbmc.log('Modbus Commander: ModbusTCP: ' + URL + ActionData + ' Event Failed') ReturnValue = "fail"
def sim_start_pause_stop(sim_length_min): IP = '131.243.41.14' PORT = 503 id = 2 # Connect to client client = ModbusClient(IP, port=PORT) try: # Read simulaiton time sim_start = client.read_input_registers(1, count=1, unit=id).registers[0] print('simulation start time:', sim_start) # start recording data (sim flag on) client.write_registers(int(1), int(1), unit=id) client.write_registers(int(1), int(3), unit=id) #sets simulation flag to 1 (ON) w = 1 while w > 0: sim_cur = client.read_input_registers(1, count=1, unit=id).registers[0] if sim_cur - sim_start >= sim_length_min * 60: break print('simulation end time', sim_cur) client.write_registers(int(1), int(0), unit=id) print('All Done.', client.read_input_registers(1, count=1, unit=id).registers[0]) except Exception as e: print(e) finally: client.close() print('client closed') return
def main(): config_file = 'config.ini' config = configparser.ConfigParser() config.read(config_file) host = config['modbus_host']['host'] port = config['modbus_host']['port'] reg_address = config['register']['address'] reg_count = config['register']['count'] slaves_id_collection = config['slave_id'].items() client = ModbusTcpClient(host=host, port=port) for name, slave_id in slaves_id_collection: try: sensor_readings = get_sensor_readings(client, reg_address, reg_count, slave_id) except pymodbus.exceptions.ConnectionException: print('Check [modbus_host] config section in config.ini') sys.exit(1) else: print(sensor_readings) finally: client.close()
def write(host, dataList, unit): starterAddress = 14 # print("HERE", host) try: client = ModbusTcpClient(host) except: print("[X](write)connection failed.") return False for registerIndex in range(0, len(dataList)): try: print("[-]Write regsiter register:%s (value: %s) to unit: %s." % (starterAddress + registerIndex, dataList[registerIndex], unit)) client.write_register(starterAddress + registerIndex, dataList[registerIndex], unit=unit) except: print("[X]unable to write data to unit:%d" % (unit)) return False client.close() return True
def rotate_vertical_stop(self): register = RegisterMapping(3004, 1) client = ModbusClient(host='192.168.1.101', port=3004, timeout=1, stopbits=1, bytesize=8, parity='N', baudrate=9600, framer=ModbusRtuFramer) # Set motor OFF coil_stop = register.get_coil_by_name('0001') stop_address = coil_stop.get_integer_address() integer_value = int('0') try: client.connect() client.write_register(stop_address, integer_value, unit=1) client.close() except pymodbus.exceptions.ConnectionException: return "No device connected"
def getModbusData(modeAwake, classicHost, classicPort): global isConnected, modbusClient try: if not isConnected: log.debug("Opening the modbus Connection") if modbusClient is None: modbusClient = ModbusClient(host=classicHost, port=classicPort) #Test for succesful connect, if not, log error and mark modbusConnected = False modbusClient.connect() result = modbusClient.read_holding_registers(4163, 2, unit=10) if result.isError(): # close the client log.error("MODBUS isError H:{} P:{}".format(classicHost, classicPort)) modbusClient.close() isConnected = False return {} isConnected = True theData = {} #Read in all the registers at one time theData[4100] = getRegisters(theClient=modbusClient,addr=4100,count=44) theData[4360] = getRegisters(theClient=modbusClient,addr=4360,count=22) theData[4163] = getRegisters(theClient=modbusClient,addr=4163,count=2) theData[4209] = getRegisters(theClient=modbusClient,addr=4209,count=4) theData[4243] = getRegisters(theClient=modbusClient,addr=4243,count=32) theData[16386]= getRegisters(theClient=modbusClient,addr=16386,count=4) #If we are snoozing, then give up the connection #log.debug("modeAwake:{}".format(modeAwake)) if not modeAwake : log.debug("Closing the modbus Connection, we are in Snooze mode") modbusClient.close() isConnected = False except: # Catch all modbus excpetions e = sys.exc_info()[0] log.error("MODBUS Error H:{} P:{} e:{}".format(classicHost, classicPort, e)) try: modbusClient.close() isConnected = False except: log.error("MODBUS Error on close H:{} P:{}".format(classicHost, classicPort)) return {} log.debug("Got data from Classic at {}:{}".format(classicHost,classicPort)) #Iterate over them and get the decoded data all into one dict decoded = {} for index in theData: decoded = {**dict(decoded), **dict(doDecode(index, getDataDecoder(theData[index])))} return decoded
def sim_stop(): IP = '131.243.41.14' PORT = 503 id = 2 client = ModbusClient(IP, port=PORT) try: client.write_registers(int(1), int(0), unit=id) print('simulation stop time:',client.read_input_registers(1, count=1, unit=id).registers[0]) print('epoch:',time.time()) print(dt.datetime.fromtimestamp(time.time())) print('All Done.',client.read_input_registers(1, count=1, unit=id).registers[0]) except Exception as e: print(e) finally: client.close() print('client closed [stop]') return
def run_sync_client(): client = ModbusClient('localhost', port=5020) client.connect() for i in range(5): log.debug("Reading Coils") client.read_coils(1, 1 + i, unit=UNIT) # first param - address: The starting address to read from # second param - count: The number of coils to read time.sleep(0.1) # 100ms przerwy między Reading Coils log.debug("Reading Coils") client.read_coils(2, 3 + i, unit=UNIT) time.sleep(0.1) log.debug("Write to a Coil") client.write_coils(1, 4, unit=UNIT) time.sleep(5) # 5s przerwy między write coils log.debug("Write to a Coil") client.write_coil(4, 3, unit=UNIT) time.sleep(5) # log.debug("Read discrete inputs") # client.read_discrete_inputs(0, 8, unit=UNIT) # # first param - The starting address to read from # # second param - The number of discretes to read # # log.debug("Write to a holding register and read back") # client.write_register(1, 10, unit=UNIT) # # first param - The starting address to write to # # second param - The value to write to the specified address # # log.debug("Read back") # client.read_holding_registers(1, 1, unit=UNIT) # # first param - The starting address to read from # # second param - The number of registers to read client.close()
class Get_Modbus_Data(object): def __init__(self): Config = configparser.ConfigParser() Config.read("config.ini") try: modbus_config = Config["modbus"] self.IP_ADDRESS = modbus_config.get("ip") self.START_REGISTER = modbus_config.getint("BASE_ADDRESS") self.NUM_REGISTERS = modbus_config.getint("NUM_REGISTERS") self.UNIT_ID = modbus_config.getint("UNIT_ID") self.names = modbus_config.get("names").split(',') self.start_offsets = modbus_config.get("start_offsets").split(',') self.lengths = modbus_config.get("lengths").split(',') # if except Exception as e: # self.logger.error("unexpected error while setting configuration from config_file=%s, error=%s"%(self.config_file, str(e))) raise e def initialize_modbus(self): self.client = ModbusClient(self.IP_ADDRESS) def get_data(self): output = {} for i in range(len(self.names)): rr = self.client.read_holding_registers( self.START_REGISTER+int(self.start_offsets[i])-1, int(self.lengths[i]), unit=self.UNIT_ID) dec = BinaryPayloadDecoder.fromRegisters( rr.registers, byteorder=Endian.Big, wordorder=Endian.Little) output[self.names[i]] = dec.decode_32bit_float() # print(output) return output def kill_modbus(self): self.client.close()
def writeMBholdingregisters(clientIP, register, valuelist): from pymodbus.client.sync import ModbusTcpClient, ConnectionException client = ModbusTcpClient(clientIP) try: rawresult = client.write_registers(register, valuelist) except ConnectionException: statuscode = 7 else: if 'exception_code' in rawresult.__dict__: statuscode = rawresult.exception_code values = [] else: statuscode = 0 values = valuelist # result = client.read_holding_registers(register, len(valuelist)) client.close() result = { 'message': messagefrommbstatuscode(statuscode), 'statuscode': statuscode, 'values': values } return result
def getModbus(config): rawValue = [] try: client = ModbusTcpClient(config['modbus_ip']) # address is -> {in_max: 1, in_min: 2, out_max: 1, out_min: 3} for address in config['Channels']: result = client.read_input_registers(address['channel'], 2) if result: raw = struct.pack('>HH', result.registers[1], result.registers[0]) value = struct.unpack('>f', raw)[0] rawValue.append(calculate(value, address)) client.close() except ConnectionException: GPIO.output(ledGreen, GPIO.HIGH) logger.critical('Error connect to modbus ip: {}'.format( config['modbus_ip'])) return 'Error' else: GPIO.output(ledGreen, GPIO.LOW) return rawValue
def save_model(self, request, obj, form, change): print('save_model(): ') slave = obj.sensor.slave try: client = ModbusTcpClient(slave.ip, slave.port) if obj.sensor.multiplication_factor != 1: obj.threshold = int(obj.threshold / obj.sensor.multiplication_factor) print('obj.threshold:', obj.threshold) value = client.write_register(address=obj.address, value=obj.threshold, unit=slave.sid) if value.isError(): raise Exception(value) else: super().save_model(request, obj, form, change) except Exception as err: print(err) raise err # XXX: print error on admin template finally: client.close()
def plc_status_check(target): client = ModbusTcpClient(target, timeout=time_out) try: status = client.read_coils(0x00, count=3) if status.bits == [1, 0, 0, 0, 0, 0, 0, 0]: status = "Running" elif status.bits == [0, 1, 0, 0, 0, 0, 0, 0]: status = "Idle" elif status.bits == [0, 0, 1, 0, 0, 0, 0, 0]: status = "Stopped" else: status = "Broken" pass except ConnectionException: status = "No connection" pass except (ModbusIOException, ParameterException, ModbusException, InvalidMessageReceivedException, MessageRegisterException, NoSuchSlaveException, NotImplementedException): status = "Connection was forcibly closed by the remote host" pass client.close() return status
class ReaderThread(Thread): def __init__(self, ip_address='localhost', port='5021'): Thread.__init__(self) self.alive = Event() self.alive.set() self.client = ModbusTcpClient(ip_address, port=port) def read_device(self): client = self.client read = False data = 0 data_read = client.read_holding_registers(0x00, 1) data = data_read.registers[0] read = True return (read, data) def run(self): try: self.client.connect() except: print('not connected') while self.alive.isSet(): time.sleep(1) read = False try: read, data = self.read_device() except: print('lost connection') if read: socketio.emit('newvalue', {'number': data}) if self.client: self.client.close() def join(self): self.alive.clear() Thread.join(self)
def main(): try: # read values from WAGO PLC start = timer() client = ModbusClient(wago_ip, port=502) try: client.connect() values = {} for name, addr in MODBUS_ADDR.items(): v = read_modbus_float(client, addr) #print("%s: %.2f" % (name, v)) values.update({name: v}) finally: client.close() end = timer() #pprint.pprint(values) # add values to the RRD st = rrdstorage.RrdStorage(rrd_file) st.add(values) # create log entry with open(log_file, 'a') as file: s = ["%s: %.3f" % (key, values[key]) for key in sorted(values)] file.write("[%s] OK : query took %.3f sec [ %s ]\n" % (datetime.now().isoformat(), (end - start), ", ".join(s))) print("query took %.3f sec [ %s ]" % ((end - start), ", ".join(s))) # create the graphs rd = rrdrender.RrdRender(rrd_file) rd.render(render_path) except Exception as e: with open(log_file, 'a') as file: file.write("[%s] ERR: %s\n" % (datetime.now().isoformat(), str(e))) print("error: %s\n" % str(e))
def writeMBcoils(clientIP, coil, valuelist): from pymodbus.client.sync import ModbusTcpClient, ConnectionException client = ModbusTcpClient(clientIP) try: rawresult = client.write_coils(coil, valuelist) except ConnectionException: # print('we were unable to connect to the host') statuscode = 7 else: if 'exception_code' in rawresult.__dict__: statuscode = rawresult.exception_code values = [] else: statuscode = 0 values = valuelist client.close() result = { 'message': messagefrommbstatuscode(statuscode), 'statuscode': statuscode, 'values': values } return result
def activate(self): rospy.init_node('niryo_node', anonymous=False) while not rospy.is_shutdown(): if (self.activate_plc == "Activated"): rospy.loginfo( "Niryo will do other action, PLC will be deactivated") self.pub.publish("plc_deactivate") else: rospy.loginfo( "PLC hasn't been activated, Niryo will activate PLC") self.pub.publish("Activate_plc") client = ModbusClient("192.168.1.7", port=502) client.connect() UNIT = 0x1 print("Escritura de salidas") rq = client.write_coil(0, [True] * 8, unit=UNIT) rr = client.read_coils(0, 8, unit=UNIT) print("Las salidas Q0.0-Q0.7 ", rr.bits) print("Leer entradas") rr = client.read_discrete_inputs(0, 8, unit=UNIT) print("Las entradas I0.0-I0.7 son ", rr.bits) print("Escritura de un HR") rq = client.write_register(0, 15, unit=UNIT) rr = client.read_holding_registers(0, 1, unit=UNIT) print("HR0 = ", rr.registers) print("Escritura de varios HR") rq = client.write_registers(1, [35] * 10, unit=UNIT) rr = client.read_holding_registers(1, 10, unit=UNIT) print("HR0 = ", rr.registers) print("Escritura de varios HR") rq = client.write_registers(11, [43] * 5, unit=UNIT) rr = client.read_holding_registers(0, 15, unit=UNIT) print("HR0 = ", rr.registers) client.close() rospy.sleep(1)
def battery_data(): values = {} # Datentypen der Register "float32","uint64","uint16" # 'string': decoder.decode_string(8), # 'float': decoder.decode_32bit_float(), # '16uint': decoder.decode_16bit_uint(), # '8int': decoder.decode_8bit_int(), # 'bits': decoder.decode_bits(), client = ModbusClient(MODBUS_HOST, port=502) client.connect() r = client.read_holding_registers(40327 - 1, 2, unit=1) inWRte = BinaryPayloadDecoder.fromRegisters( r.registers, byteorder=Endian.Big) # noqa E501 values['chg_pct'] = inWRte.decode_16bit_uint() / 100 logging.debug("From modbus chg_pct {}%".format(values['chg_pct'])) client.close() return values
def run_sync_client(): client = ModbusClient('localhost', port=5020) client.connect() # ------------------------------------------------------------------------# # specify slave to query # ------------------------------------------------------------------------# # The slave to query is specified in an optional parameter for each # individual request. This can be done by specifying the `unit` parameter # which defaults to `0x00` # ----------------------------------------------------------------------- # data = getChargeControllerData(client, modbusUnit=0x01) data2 = getRelayBoxData(client, modbusUnit=0x09) print( "\nCC: ", data) print( "\nRB: ", data2) # ----------------------------------------------------------------------- # # close the client # ----------------------------------------------------------------------- # client.close()
class CovertActuator(): def __init__(self, BIT_NUMBER=0, RESOLUTION=3): self.BIT_NUMBER = BIT_NUMBER self.client = ModbusTcpClient('127.0.0.1') self.encoded_message = [] self.last_value = '' self.last_time = '' self.RESOLUTION = RESOLUTION def meausre_time(self): return self.last_time def set_value(self, value=True): self.last_time = int(str( time.time()).split('.')[1][:self.RESOLUTION]) % 2 self.client.write_coil(self.BIT_NUMBER, value) if self.last_value != '' and self.last_value != value and self.last_value == True: # print ("Covert Actuator: \t", str(time.time()).split('.')[1][:3]) self.encoded_message.append( str(time.time()).split('.')[1][:self.RESOLUTION]) self.last_value = value def __del__(self): self.client.close()
class ModbusClient: def __init__(self, IP, port): self.client = ModbusTcpClient(host=IP, port=port) if (not self.Connect()): rospy.logerr("Could not connect to the modbus server...") else: rospy.loginfo("Connected to host[%s] via port[%s]", IP, port) def Connect(self): return self.client.connect() def Close(self): self.client.close() def readRegister(self, address): response = self.client.read_holding_registers(address, 1, unit=1) if (response.function_code == 3): return response.registers[0] else: return False def writeRegister(self, address, data): response = self.client.write_register(address, data) ## maximum 16 bit print(response)
class ModbusClient(): ''' Connects to modbus slaves ''' def __init__(self, server_addr='localhost', server_port=502): self.server_ip = server_addr self.server_port = server_port self.client = ModbusTcpClient(server_addr, port=server_port) def open_connection(self): self.client.connect() def close_connection(self): self.client.close() def read_single_coil(self): pass # Assumes 32-bit IEEE floating point number as used by ModbusPal: # 1 bit sign + 8 bits exponent + 23 bits fraction def read_holdingregister_float32(self, device_address, register_addr): translated_addr = register_addr - 1 # read two consecutive registers result = self.client.read_holding_registers(address=translated_addr, count=2, unit=1) assert (result.function_code < 0x80) # test that we are not an error msw = result.registers[0] lsw = result.registers[1] float32 = (msw << 16) + lsw value = struct.unpack('f', struct.pack('I', float32))[0] print "read float32 value:", value return value
def get_current_energy_production(self) -> float: for _ in range(10): client = ModbusTcpClient(self.config['gatewayIP'], port=self.config['gatewayPort']) client.connect() address = self.config['address'] unit = self.config['unit'] factor = self.config.get('factor', 1) result = client.read_holding_registers(address=address, count=2, unit=unit) client.close() if not result.isError(): registers = result.registers decoder = BinaryPayloadDecoder.fromRegisters( registers, Endian.Big, wordorder=Endian.Big) raw_value = decoder.decode_32bit_int() real_value = raw_value * factor return real_value else: self.logger.debug('Cannot read values from modbus, retry...') self.logger.error('All retries failed to read values for producer %s' % str(self.config)) return 0
class MB(): def __init__(self, ip, port=502): self.ip = ip self.port = port self.connect() def connect(self): self.client = ModbusTcpClient(self.ip, port=self.port, timeout=10) def read_reg(self): val = self.client.read_holding_registers(6, 2) return val.registers def write_reg(self, value): self.client.write_register(6, scada_value) return 0 def deviceinfo(self): rq = mei_message.ReadDeviceInformationRequest() val = self.client.execute(rq) return (val.information) def close(self): self.client.close()
def get_device_class(host, port, modbusid): client = ModbusClient(host=host, port=port) # connects even within if clause if client.connect() == False: print('Modbus Connection Error: Could not connect to', host) return None try: received = client.read_input_registers(address=30051, count=2, unit=3) except: thisdate = str(datetime.datetime.now()).partition('.')[0] thiserrormessage = thisdate + ': Connection not possible. Check settings or connection.' print(thiserrormessage) return None message = BinaryPayloadDecoder.fromRegisters(received.registers, byteorder=Endian.Big, wordorder=Endian.Big) interpreted = message.decode_32bit_uint() dclass = pvenums["DeviceClass"].get(interpreted) client.close() return dclass