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 on_switchMain_activate(self, switch,gparam): if switch.get_active(): self.client_1 = ModbusClient(manifold_host_1, port=manifold_port_1) self.client_p = ModbusClient(pump_host, port=pump_port) self.client_1.connect() self.client_p.connect() self.readDataSetupConfig() time.sleep(2) print "start connection" time_delay = 1 # 1 seconds delay self.loop = LoopingCall(f=self.logging_data, a=(self.client_1, builder.get_object("txtAIN1"),builder.get_object("txtAIN2"),builder.get_object("txtAIN1ENG"),builder.get_object("txtAIN2ENG"),builder.get_object("txtAIN12"),builder.get_object("txtAIN22"),builder.get_object("txtAIN1ENG2"),self.client_p,builder.get_object("txtPout"),builder.get_object("txtQout"))) self.loop.start(time_delay, now=False) # initially delay by time builder.get_object("btnOpenFile").set_sensitive(False) builder.get_object("btnOff").set_sensitive(False) self.btnAnalyze.set_sensitive(False) # self.ani = animation.FuncAnimation(self.figure, self.update_plot, interval = 1000) else: self.loop.stop() time.sleep(1) self.client_1.close() self.client_p.close() print "stop connection" time.sleep(2) builder.get_object("txtFilePath").set_text(export_csv_path) builder.get_object("btnOpenFile").set_sensitive(True) builder.get_object("btnOff").set_sensitive(True) if self.oneLogged: self.btnAnalyze.set_sensitive(True)
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 testTcpClientRegister(self): class CustomeRequest: function_code = 79 client = ModbusTcpClient() client.framer = Mock() client.register(CustomeRequest) assert client.framer.decoder.register.called_once_with(CustomeRequest)
def _run_single_client(client_id, host, port, units, results, N, delay, warmup, table): _log.info('Client %d connecting to %s (%s)', client_id, host, port) client = ModbusClient(host, port=port) client.connect() _log.info('Client %d connected to %s (%s)', client_id, host, port) measurements = [] errors = [] for i in xrange(N): if N >= 1000 and i % (N/10) == 0 and i > 0: _log.info('Client %d %.0f%% complete', client_id, 100.0*i/N) try: m = _make_random_request(client, units, table) if i >= warmup or N <= warmup: if i == warmup: _log.info('Client %d warmup complete.', client_id) measurements.append(m) except jem_exceptions.JemException, e: errors.append(e) _log.warn('Client %d received error response: %s', client_id, e) except Exception, e: from pymodbus import exceptions as es _log.error("Caught other exception: %s" % str(e)) _log.error("Is instance: %s", isinstance(e, es.ModbusException))
def testTcpClientSend(self): ''' Test the tcp client send method''' client = ModbusTcpClient() self.assertRaises(ConnectionException, lambda: client._send(None)) client.socket = mockSocket() self.assertEqual(0, client._send(None)) self.assertEqual(4, client._send('1234'))
def testTcpClientRecv(self): ''' Test the tcp client receive method''' client = ModbusTcpClient() self.assertRaises(ConnectionException, lambda: client._recv(1024)) client.socket = mockSocket() self.assertEqual('', client._recv(0)) self.assertEqual('\x00'*4, client._recv(4))
def connect_modbus(modbus_ip, modbus_port): try: client = ModbusClient(modbus_ip, port=modbus_port) except: return None if client.connect(): return client return None
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 __init__(self, *args, **kwargs): ''' Constructor default modbus port is 502''' #ip address self.addr = args[0] ModbusTcpClient.__init__(self, self.addr) self.connect()
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 testTcpClientConnect(self): ''' Test the tcp client connection method''' with patch.object(socket, 'create_connection') as mock_method: mock_method.return_value = object() client = ModbusTcpClient() self.assertTrue(client.connect()) with patch.object(socket, 'create_connection') as mock_method: mock_method.side_effect = socket.error() client = ModbusTcpClient() self.assertFalse(client.connect())
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 get_temp(self, addr): # connect to modbus slave try: client = ModbusClient(addr, port=502) client.connect() rr = client.read_holding_registers(0x00,1,unit=1) temp = rr.registers[0] return temp except: # if unable to connect, return None log_stuff("Unable to connect to " + self.addr) return None
def create_sunspec_sync_client(host): """ A quick helper method to create a sunspec client. :param host: The host to connect to :returns: an initialized SunspecClient """ modbus = ModbusTcpClient(host) modbus.connect() client = SunspecClient(modbus) client.initialize() return client
def main(host, port, delay, unit, table_num): client = ModbusClient(host, port=port) client.connect() min_response_time = 100 max_response_time = 0 sum_response_time = 0 N = 0 register_widths = diris_registers.TABLES[table_num-1].copy() register_labels = DEMO_REGISTERS.copy() registers = dict((addr, register_widths[addr]) \ for addr in DEMO_REGISTERS.keys() \ if addr in register_widths) label_width = max([len(label) for label in DEMO_REGISTERS.values()]) + 1 while True: start = time.time() try: response = modbus.read_registers(client, registers=registers, unit=unit) except exceptions.ModbusExceptionResponse, e: response=None response_time = time.time() - start os.system('clear') print "Request Times:" min_response_time = min(min_response_time, response_time) max_response_time = max(max_response_time, response_time) sum_response_time += response_time N += 1 print "Min".rjust(label_width) + ": " + str(min_response_time) print "Max".rjust(label_width) + ": " + str(max_response_time) print "Avg".rjust(label_width) + ": " + str(sum_response_time/N) print "Response Values:" for addr in sorted(registers.keys()): if response is None: break print (u"{label:>" + str(label_width) + u"s}: {value:f}").format( label=register_labels[addr], value=response.read_register(addr)) print time.sleep(delay)
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)
def __init__(self, indicator_list, coil_on_list, coil_off_list, command_list, coil_list, port, method="rtu", timeout=0.1, unit=0x01): self.unit = unit self.indicator_list = indicator_list self.coil_on_list = coil_on_list self.coil_off_list = coil_off_list self.coil_list = coil_list self.command_list = command_list self.lock = threading.Lock() if method == "rtu": self.client = ModbusSerialClient(method=method, port=port, baudrate=19200, stopbits=1, bytesize=8, timeout=timeout) elif method == "tcp": self.client = ModbusTcpClient(host=port)
class TcpRtuChannel(BaseChannel): def __init__(self, network, channel_name, channel_protocol, channel_params, manager, channel_type): self.server = channel_params.get("server", "") self.port = channel_params.get("port", "") self.modbus_client = None BaseChannel.__init__(self, network, channel_name, channel_protocol, channel_params, manager, channel_type) def run(self): self.modbus_client = ModbusTcpClient(host=self.server, port=self.port) try: self.modbus_client.connect() logger.debug("连接服务器成功.") except Exception, e: logger.error("连接服务器失败,错误信息:%r." % e)
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 run(self): self.modbus_client = ModbusTcpClient(host=self.server, port=self.port) try: self.modbus_client.connect() logger.debug("连接服务器成功.") except Exception, e: logger.error("连接服务器失败,错误信息:%r." % e)
def __init__(self, config=None): ApplicationSession.__init__(self, config) self.pfcIp = '192.168.1.52' self.modbusTcpPort = '502' self.client = ModbusClient(self.pfcIp, self.modbusTcpPort) self.oldState = {} self.elapsedTime = 0
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 __init__(self, i, p): self.ip = i self.port = p self.framer = ModbusFramer self.timeout = 1 self.rKeys = [] self.rValues = [] self.rAddress = [] self.rIndex = [] self.errors = [] self.errFlag = False # False = no errors, True = we had errors # Create the client try: if(LOG_LEVEL >= LOG_DEBUG): print "modbus client" self.client = ModbusClient(self.ip, self.port) #self.client = ModbusClient(self.ip, self.port, self.framer, self.timeout) #self.client = ModbusClient(self.ip, self.port, timeout=10) if(LOG_LEVEL >= LOG_DEBUG): print "modbus client connect" rc = self.client.connect() if(rc == False): self.errFlag = True self.errors.append(str()) print "modbus connect returned ", rc else: if(LOG_LEVEL >= LOG_DEBUG): print "modbus connect finished" except Exception, e: print "modbus device initialization exception ", e self.errors.append(str(e)) self.errFlag = True
def start(self): # Connect the client self.client = ModbusTcpClient(self.modbus_ip) logger=logging.getLogger("service") logger.info("Starting Service: " + self.componentId + " (ModbusIO: " + self.xmlname + ").") while (GlobalObjects.running): if(self.client.connect()): # Check if the output variables changed, if needed send the new state if (self.state_write_changed): self.state_write_changed = False try: self.client.write_registers(self.modbus_write_adres,self.state_write) except (AttributeError, ConnectionException): state_read_new=self.state_read_old pass # sleep a while time.sleep(self.modbus_period) # try to read new state of the inputs, if connection fails, continue try: state_read_new = self.client.read_holding_registers(self.modbus_read_adres, self.modbus_read_size).registers except (AttributeError, ConnectionException): state_read_new=self.state_read_old pass # Read check every register for changes for i in range( len(state_read_new)): if (state_read_new[i]!=self.state_read_old[i]): # When the change is in a DI if (self.modbus_read_type[i]=='D'): # Mark changed positions changed=state_read_new[i]^self.state_read_old[i] for j in range(16): if((changed >> j) & 1): # Generate event eventName=self.configuration["input"]["adres_definition"]["adres"][i]["event_" + str(j)] self.generateEvent(eventName,{'value':((state_read_new[i]>>j) & 1)}) #print str(time.time()) + " " + str(i) + "." + str(j) + ": " + str((state_read_new[i]>>j) & 1) ## Save the new state self.state_read_old[i]=state_read_new[i] # When the change is in a AI elif (self.modbus_read_type[i]=='A'): diff = (state_read_new[i]-self.state_read_old[i]) if ((diff>self.modbus_read_analog_threshold[i]) or (diff < -self.modbus_read_analog_threshold[i])): # Generate event eventName=self.configuration["input"]["adres_definition"]["adres"][i]["event"] value = float(state_read_new[i]) / self.modbus_read_analog_scale[i] self.generateEvent(eventName,{'value':value}) #print str(i) + ": " + str(value) ## Save new state self.state_read_old[i]=state_read_new[i] else: logger.warning("Lost connection to modbus module.") self.state_write_changed=True time.sleep(1)
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 main(): # connect to modbus slave client = ModbusClient(args.slave_addr, port=502) client.connect() try: while True: # get value of holding registers (first has the temperature value) rr = client.read_holding_registers(0x00,1,unit=1) temp = rr.registers[0] enable_light(temp) time.sleep(3) except KeyboardInterrupt: subprocess.call(['gpio', 'write', '0', '0']) subprocess.call(['gpio', 'write', '1', '0']) print "Exiting..."
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 connect(self): """Open Modbus connection """ if not self.connected: self.client = ModbusTcpClient("192.168.50.238", port=502) self.client.connect() self.connected = True
def __init__(self, ip='192.168.2.17'): self.ip = ip self.client = ModbusTcpClient(self.ip) self.connection = self.client.connect()
import struct import binascii import imp util_path = os.path.abspath( os.path.join(__file__, '..', '..', 'util', 'solaredge_util.py')) util = imp.load_source('solaredge_util', util_path) ipaddress = str(sys.argv[1]) slave1id = int(sys.argv[2]) batwrsame = int(sys.argv[3]) extprodakt = int(sys.argv[4]) from pymodbus.client.sync import ModbusTcpClient port = util.getPortNo('wr', ipaddress) client = ModbusTcpClient(ipaddress, port=port) #batterie auslesen und pv leistung korrigieren storagepower = 0 if batwrsame == 1: rr = client.read_holding_registers(62836, 2, unit=1) raw = struct.pack('>HH', rr.getRegister(1), rr.getRegister(0)) storagepower = int(struct.unpack('>f', raw)[0]) resp = client.read_holding_registers(40084, 2, unit=slave1id) multipli = resp.registers[0] multiplint = format(multipli, '04x') fmultiplint = int(struct.unpack('>h', multiplint.decode('hex'))[0]) respw = client.read_holding_registers(40083, 2, unit=slave1id) value1w = respw.registers[0]
from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient('10.0.0.57', port=9093) client.connect() print(client) rr = client.read_holding_registers(0, 92, unit=1) if rr is None: client.close() print("Failed to connect") exit(1) print("Connected") voltageScalingFactor = (float(rr.registers[0]) + (float(rr.registers[1]) / 100)) amperageScalingFactor = (float(rr.registers[2]) + (float(rr.registers[3]) / 100)) # Voltage Related Statistics batteryVoltage = float(rr.registers[24]) * voltageScalingFactor * 2**(-15) print("Battery Voltage: %.2f" % batteryVoltage) batterySenseVoltage = float(rr.registers[26]) * voltageScalingFactor * 2**(-15) print("Battery Sense Voltage: %.2f" % batterySenseVoltage) batteryVoltageSlow = float(rr.registers[38]) * voltageScalingFactor * 2**(-15) print("Battery Voltage (Slow): %.2f" % batteryVoltageSlow) batteryDailyMinimumVoltage = float(rr.registers[64]) * voltageScalingFactor * 2**(-15) print("Battery Daily Minimum Voltage: %.2f" % batteryDailyMinimumVoltage) batteryDailyMaximumVoltage = float(rr.registers[65]) * voltageScalingFactor * 2**(-15) print("Battery Daily Maximum Voltage: %.2f" % batteryDailyMaximumVoltage) targetRegulationVoltage = float(rr.registers[51]) * voltageScalingFactor * 2**(-15) print("Target Regulation Voltage: %.2f" % targetRegulationVoltage) arrayVoltage = float(rr.registers[27]) * voltageScalingFactor * 2**(-15) print("Array Voltage: %.2f" % arrayVoltage)
# LOGGING SAVE_TO_FILE = False LOG_LEVEL = logging.INFO LOG_FILE_NAME = "modbus.log" # PROGRAM if SAVE_TO_FILE: logging.basicConfig(filename=LOG_FILE_NAME, level=logging.DEBUG) else: logging.basicConfig(level=LOG_LEVEL) if CONNECT_MQTT: client = mqtt.Client(MQTT_CLIENT_NAME) client.connect(MQTT_BROKER_NAME) mbclient = ModbusTcpClient(MODBUS_IP, port=MODBUS_PORT) mbclient.connect() while True: for i in range(3): rectemp = -999 try: rec = None #logging.info("Connected to " + MODBUS_IP + " on Port " + MODBUS_PORT) rec = mbclient.read_input_registers(MODBUS_REGISTER_ADDRESSES[i], 3) if rec: rectemp = rec.registers[2] / 40 logging.info('Received ' + str(rectemp)) except: #mbclient.close() logging.warning('Failed to Connect to Modbus')
class Connection(): client = ModbusTcpClient() def connect(self, ip, port): self.client.host = ip self.client.port = port return self.client.connect() def disconnect(self): return self.client.close() def register_to_int(self, address): try: result = self.client.read_holding_registers(address, 1, unit=1).registers decoder = BinaryPayloadDecoder.fromRegisters(result, byteorder=Endian.Big, wordorder=Endian.Big) decoded = decoder.decode_16bit_int() return decoded except Exception as ex: print(ex) def int_to_register(self, address, value): try: # Create a builder builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) # Add num to builder builder.add_16bit_int(value) payload = builder.to_registers() payload = builder.build() registers = builder.to_registers() # Write value self.client.write_registers(address, registers, unit=1) except Exception as ex: print(ex) def write_coil(self, address, value): try: self.client.write_coil(address, value) except Exception as ex: print(ex) def read_coil(self, address): try: return self.client.read_discrete_inputs(address).bits[0] except Exception as ex: print(ex) def read_input_registers(self, address): try: result = self.client.read_input_registers(address, 1, unit=1).registers decoder = BinaryPayloadDecoder.fromRegisters(result, byteorder=Endian.Big, wordorder=Endian.Big) decoded = decoder.decode_16bit_int() return decoded except Exception as ex: print(ex) def read_string(self, address, length): try: # Read register result = self.client.read_holding_registers(address, length, unit=1).registers # Set decoder decoder = BinaryPayloadDecoder.fromRegisters(result, byteorder=Endian.Big, wordorder=Endian.Big) # Decode and format decoded = decoder.decode_string(8) decoded = decoded.decode('UTF-8') decoded = decoded.replace("\x00", "") return decoded except Exception as ex: print(ex)
def read_block(client, start, size): result = [] while size > 0: to_read = min( 76, size ) # important, only value I found that does not end up in the middle of some big register and thus fails result += client.read_holding_registers(start, count=to_read, unit=1).registers size -= to_read start += to_read return bytes(b for i in result for b in [i >> 8, i & 0xff]) client = ModbusTcpClient(host=MODBUSIP, port=MODBUSPORT, timeout=1) def decode(ty, data): orig = ty ty = ty.lower() if ty == "uint16": return struct.unpack('!H', data)[0] elif ty == "int16": return struct.unpack('!h', data)[0] elif ty == "uint32": if orig == "Uint32": data = bytes([data[2], data[3], data[0], data[1]]) return struct.unpack('!I', data)[0] elif ty == "acc32":
val = decimals_to_float32(val, next(data_iter)) elif tags[tag]["Data Type"] == "Word": pass elif tags[tag]["Data Type"] == "Int": val = twos_comp(val, 16) if tags[tag]['scale'] == 'x10': val /= 10 tags[tag]['value'] = val return tags # load file tags = csv_to_dict('plc_tags.csv') #connect Modbus mb = ModbusTcpClient('192.168.11.150', port=502, retries=3, timeout=3) mb.connect() #connect ELK es = Elasticsearch() #connect MQTT mqttc = mqtt.Client() mqttc.connect("test.mosquitto.org", 1883, 60) #connect settime time = datetime.now() while True: try: # Read Modbus (ID address,byte of count, MOdbus slave ID) rr = mb.read_holding_registers(address=0, count=103, unit=1) assert (rr.function_code < 0x80), "register error"
class client: """ Modbus client (Master) class """ def __init__(self, client): self._address = client.modbusclient.ip_address self._port = client.modbusclient.port self.trans_input_registers = [] self.trans_coils = [] self.trans_holding_registers = [] self.trans_discrete_inputs = [] self.variables = {} self._variable_config = self._prepare_variable_config(client) def _prepare_variable_config(self, client): for var in client.variable_set.filter(active=1): if not hasattr(var, 'modbusvariable'): continue FC = var.modbusvariable.function_code_read if FC == 0: continue address = var.modbusvariable.address bits_to_read = get_bits_by_class(var.value_class) events = Event.objects.filter(variable=var) self.variables[var.pk] = { 'value_class': var.value_class, 'writeable': var.writeable, 'record': var.record, 'name': var.name, 'adr': address, 'bits': bits_to_read, 'fc': FC, 'events': events } if FC == 1: # coils self.trans_coils.append([address, var.pk, FC]) elif FC == 2: # discrete inputs self.trans_discrete_inputs.append([address, var.pk, FC]) elif FC == 3: # holding registers self.trans_holding_registers.append( [address, var.value_class, bits_to_read, var.pk, FC]) elif FC == 4: # input registers self.trans_input_registers.append( [address, var.value_class, bits_to_read, var.pk, FC]) else: continue self.trans_discrete_inputs.sort() self.trans_holding_registers.sort() self.trans_coils.sort() self.trans_input_registers.sort() out = [] # input registers old = -2 regcount = 0 for entry in self.trans_input_registers: if (entry[0] != old) or regcount > 122: regcount = 0 out.append(InputRegisterBlock()) # start new register block out[-1].insert_item(entry[3], entry[0], entry[1], entry[2]) # add item to block old = entry[0] + entry[2] / 16 regcount += entry[2] / 16 # holding registers old = -2 regcount = 0 for entry in self.trans_holding_registers: if (entry[0] != old) or regcount > 122: regcount = 0 out.append(HoldingRegisterBlock()) # start new register block out[-1].insert_item(entry[3], entry[0], entry[1], entry[2]) # add item to block old = entry[0] + entry[2] / 16 regcount += entry[2] / 16 # coils old = -2 for entry in self.trans_coils: if (entry[0] != old + 1): out.append(CoilBlock()) # start new coil block out[-1].insert_item(entry[1], entry[0]) old = entry[0] # discrete inputs old = -2 for entry in self.trans_discrete_inputs: if (entry[0] != old + 1): out.append(DiscreteInputBlock()) # start new coil block out[-1].insert_item(entry[1], entry[0]) old = entry[0] return out def _connect(self): """ connect to the modbus slave (server) """ self.slave = ModbusClient(self._address, int(self._port)) status = self.slave.connect() return status def _disconnect(self): """ close the connection to the modbus slave (server) """ self.slave.close() def request_data(self): """ """ data = {} if not self._connect(): return False for register_block in self._variable_config: result = register_block.request_data(self.slave) if result is None: self._disconnect() self._connect() result = register_block.request_data(self.slave) if result is not None: data = dict(data.items() + result.items()) else: for variable_id in register_block.variable_id: log.error(("variable with id: %d is not accessible") % (variable_id)) data[variable_id] = None self._disconnect() return data def write_data(self, variable_id, value): """ write value to single modbus register or coil """ if not self.variables[variable_id]['writeable']: return False if self.variables[variable_id]['fc'] == 3: # write register if 0 <= self.variables[variable_id]['adr'] <= 65535: self._connect() if self.variables[variable_id]['bits'] / 16 == 1: # just write the value to one register self.slave.write_register( self.variables[variable_id]['adr'], int(value)) else: # encode it first self.slave.write_registers( self.variables[variable_id]['adr'], list( encode_value( value, self.variables[variable_id]['value_class']))) self._disconnect() return True else: log.error('Modbus Address %d out of range' % self.variables[variable_id]['adr']) return False elif self.variables[variable_id]['fc'] == 1: # write coil if 0 <= self.variables[variable_id]['adr'] <= 65535: self._connect() self.slave.write_coil(self.variables[variable_id]['adr'], bool(value)) self._disconnect() return True else: log.error('Modbus Address %d out of range' % self.variables[variable_id]['adr']) else: log.error('wrong function type %d' % self.variables[variable_id]['fc']) return False
import networkEncoder as ne from pymodbus.client.sync import ModbusTcpClient MODBUS_SLAVE = 'ms.ics.example.com' random.seed(100) response = '' client = ModbusTcpClient(MODBUS_SLAVE) print("Sensors online, enter injection attack type:") print("[r]esponse - Fake slave values to trigger overflow") print("[c]ommand - Fake master values to trigger overflow") print("[q]uit") while response != 'r' and response != 'c' and response != 'q': response = input('>') if response == 'q': exit(0) if response == 'r': print("Enter stealth level:") print("[1] - Blatantly obvious") print("[2] - Plausible") print("[3] - Harder to detect") print("[4] - Hard to detect") print("[q]uit") while response != '1' and response != '2' and response != '3' and response != '4' and response != 'q': response = input('>')
from pymodbus.client.sync import ModbusTcpClient #client = ModbusTcpClient(ipaddress, port=502) #resp= client.read_holding_registers(32066,1,unit=1) #value1 = resp.registers[0] #print(str(value1)) #all = format(value1, '04x') + format(value2, '04x') #final = int(struct.unpack('>i', all.decode('hex'))[0])*-1 #f = open('/var/www/html/openWB/ramdisk/pvwatt', 'w') #f.write(str(final)) #f.close() #print(str(final)) client = ModbusTcpClient(ipaddress, port=502) resp= client.read_holding_registers(32080,2,unit=1) value1 = resp.registers[0] value2 = resp.registers[1] #print(str(value1)) #print(str(value2)) all = format(value1, '04x') + format(value2, '04x') final = int(struct.unpack('>i', all.decode('hex'))[0])*-1 f = open('/var/www/html/openWB/ramdisk/pvwatt', 'w') f.write(str(final)) f.close() #print(str(final))
def __configure_master(self, config=None): current_config = self.__config if config is None else config master_config = dict() master_config[ "host"] = current_config[HOST_PARAMETER] if current_config.get( HOST_PARAMETER) is not None else self.__config.get( HOST_PARAMETER, "localhost") try: master_config["port"] = int( current_config[PORT_PARAMETER]) if current_config.get( PORT_PARAMETER) is not None else self.__config.get( int(PORT_PARAMETER), 502) except ValueError: master_config[ "port"] = current_config[PORT_PARAMETER] if current_config.get( PORT_PARAMETER) is not None else self.__config.get( PORT_PARAMETER, 502) master_config["baudrate"] = current_config[ BAUDRATE_PARAMETER] if current_config.get( BAUDRATE_PARAMETER) is not None else self.__config.get( BAUDRATE_PARAMETER, 19200) master_config["timeout"] = current_config[ TIMEOUT_PARAMETER] if current_config.get( TIMEOUT_PARAMETER) is not None else self.__config.get( TIMEOUT_PARAMETER, 35) master_config[ "method"] = current_config[METHOD_PARAMETER] if current_config.get( METHOD_PARAMETER) is not None else self.__config.get( METHOD_PARAMETER, "rtu") master_config["stopbits"] = current_config[ STOPBITS_PARAMETER] if current_config.get( STOPBITS_PARAMETER) is not None else self.__config.get( STOPBITS_PARAMETER, Defaults.Stopbits) master_config["bytesize"] = current_config[ BYTESIZE_PARAMETER] if current_config.get( BYTESIZE_PARAMETER) is not None else self.__config.get( BYTESIZE_PARAMETER, Defaults.Bytesize) master_config[ "parity"] = current_config[PARITY_PARAMETER] if current_config.get( PARITY_PARAMETER) is not None else self.__config.get( PARITY_PARAMETER, Defaults.Parity) master_config[ "strict"] = current_config[STRICT_PARAMETER] if current_config.get( STRICT_PARAMETER) is not None else self.__config.get( STRICT_PARAMETER, True) master_config["rtu"] = ModbusRtuFramer if current_config.get( METHOD_PARAMETER) == "rtu" or ( current_config.get(METHOD_PARAMETER) is None and self.__config.get(METHOD_PARAMETER) == "rtu") else ModbusSocketFramer if self.__previous_master_config != master_config: self.__previous_master_config = master_config if current_config.get(TYPE_PARAMETER) == 'tcp' or ( current_config.get(TYPE_PARAMETER) is None and self.__config.get(TYPE_PARAMETER) == "tcp"): master = ModbusTcpClient(master_config["host"], master_config["port"], master_config["rtu"], timeout=master_config["timeout"]) elif current_config.get(TYPE_PARAMETER) == 'udp' or ( current_config.get(TYPE_PARAMETER) is None and self.__config.get(TYPE_PARAMETER) == "udp"): master = ModbusUdpClient(master_config["host"], master_config["port"], master_config["rtu"], timeout=master_config["timeout"]) elif current_config.get(TYPE_PARAMETER) == 'serial' or ( current_config.get(TYPE_PARAMETER) is None and self.__config.get(TYPE_PARAMETER) == "serial"): master = ModbusSerialClient(method=master_config["method"], port=master_config["port"], timeout=master_config["timeout"], baudrate=master_config["baudrate"], stopbits=master_config["stopbits"], bytesize=master_config["bytesize"], parity=master_config["parity"], strict=master_config["strict"]) else: raise Exception("Invalid Modbus transport type.") else: master = self.__current_master available_functions = { 1: master.read_coils, 2: master.read_discrete_inputs, 3: master.read_holding_registers, 4: master.read_input_registers, 5: master.write_coil, 6: master.write_register, 15: master.write_coils, 16: master.write_registers, } return master, available_functions
__author__ = 'alvin' import sys from PyQt5 import QtCore, QtGui, QtWidgets from PyQt5.QtCore import pyqtSlot from PyQt5.QtWidgets import QApplication, QWidget, QSlider import PyQt5.QtCore from PyQt5.QtCore import QTimer # Create a Modbus TCP/IP Client from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient('192.168.0.10') # import the class 'Ui_batt' from 'battUI.py' from bidircontrolUI import Ui_bidirControl # import the class 'bidir' from 'bidirpymodbus.py' from bidirpymodbus import bidir # import the class 'panel3' from 'panel3pymodbus.py' # from panel3pymodbus import panel3 class Mainbidir(QWidget, Ui_bidirControl): def update_bidir_array(self): bidir.bidir_array(self) # panel3.p3_dc1_real_array(self) def update_bidir_gui(self): self.bidir_vdc.setText("" + str(self.BiDirCon_Vdc))
protocol_log = logging.getLogger("pysnmp.protocol") store_log = logging.getLogger("pysnmp.store") # Enable logging levels server_log.setLevel(logging.DEBUG) protocol_log.setLevel(logging.DEBUG) client_log.setLevel(logging.DEBUG) store_log.setLevel(logging.DEBUG) # Initialize the logging try: logging.basicConfig() except Exception, e: print "Logging is not supported on this system" from pymodbus.client.sync import ModbusTcpClient import sys client = ModbusTcpClient("10.10.10.1") result = client.read_holding_registers(6, 1) print(result.registers) result2 = client.read_holding_registers(7, 1) print(result2.registers) from pymodbus import mei_message rq = mei_message.ReadDeviceInformationRequest() result3 = client.execute(rq) print(result3.information) client.close()
def __init__(self, ip_address='localhost', port='5021'): Thread.__init__(self) self.alive = Event() self.alive.set() self.client = ModbusTcpClient(ip_address, port=port)
import sys import os import time import getopt import socket import struct import binascii import json devicenumber = str(sys.argv[1]) seradd = str(sys.argv[2]) sdmid = int(sys.argv[3]) port = int(sys.argv[4]) from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient(seradd, port=port) #KWH Total Import resp = client.read_input_registers(0x0048, 2, unit=sdmid) vwh = struct.unpack('>f', struct.pack('>HH', *resp.registers)) vwh2 = float("%.3f" % vwh[0]) * int(1000) vwh3 = str(vwh2) #Aktueller Verbrauch resp = client.read_input_registers(0x000C, 2, unit=sdmid) watti = struct.unpack('>f', struct.pack('>HH', *resp.registers)) watt = int(watti[0]) answer = '{"power":' + str(watt) + ',"powerc":' + str(vwh3) + '} ' f1 = open( '/var/www/html/openWB/ramdisk/smarthome_device_ret' + str(devicenumber),
#!/usr/bin/python import sys import os import time import getopt import socket import ConfigParser import struct import binascii ipaddress = str(sys.argv[1]) slave1id = int(sys.argv[2]) from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient(ipaddress, port=502) #batterie auslesen und pv leistung korrigieren resp= client.read_holding_registers(40084,2,unit=slave1id) multipli = resp.registers[0] multiplint = format(multipli, '04x') fmultiplint = int(struct.unpack('>h', multiplint.decode('hex'))[0]) respw= client.read_holding_registers(40083,2,unit=slave1id) value1w = respw.registers[0] allw = format(value1w, '04x') rawprodw = finalw = int(struct.unpack('>h', allw.decode('hex'))[0]) * -1 resp= client.read_holding_registers(40084,2,unit=slave1id) mult2ipli = resp.registers[0] mult2iplint = format(mult2ipli, '04x') fmult2iplint = int(struct.unpack('>h', mult2iplint.decode('hex'))[0]) if fmultiplint == fmult2iplint: if fmultiplint == 0: rawprodw = rawprodw
class modbus: def __init__(self, Pid, IP): # Class Variablen self._IP = IP self._client = '' self._pid = Pid # Plenticore als Modbus Client einrichten self._client = ModbusTcpClient(self._IP, port=1502) #self._wr.client.connect() def ReadRegister(self, address, count=1, **kwargs): return self._client.read_holding_registers(address, count, **kwargs) def ReadUInt16(self, addr): data = self._client.read_holding_registers(addr, 1, unit=71) UInt16register = BinaryPayloadDecoder.fromRegisters( data.registers, byteorder=Endian.Big, wordorder=Endian.Little) result = UInt16register.decode_16bit_uint() return (result) def ReadInt16(self, addr): data = self._client.read_holding_registers(addr, 1, unit=71) Int16register = BinaryPayloadDecoder.fromRegisters( data.registers, byteorder=Endian.Big, wordorder=Endian.Little) result = Int16register.decode_16bit_int() return (result) def ReadUInt32(self, addr): data = self._client.read_holding_registers(addr, 2, unit=71) UInt32register = BinaryPayloadDecoder.fromRegisters( data.registers, byteorder=Endian.Big, wordorder=Endian.Little) result = UInt32register.decode_32bit_uint() return (result) def ReadInt32(self, addr): data = self._client.read_holding_registers(addr, 2, unit=71) Int32register = BinaryPayloadDecoder.fromRegisters( data.registers, byteorder=Endian.Big, wordorder=Endian.Little) result = Int32register.decode_32bit_int() return (result) def ReadFloat32(self, addr): data = self._client.read_holding_registers(addr, 2, unit=71) Float32register = BinaryPayloadDecoder.fromRegisters( data.registers, byteorder=Endian.Big, wordorder=Endian.Little) result = Float32register.decode_32bit_float() return (result) def ReadUInt64(self, addr): data = self._client.read_holding_registers(addr, 4, unit=71) UInt64register = BinaryPayloadDecoder.fromRegisters( data.registers, byteorder=Endian.Big, wordorder=Endian.Little) result = UInt64register.decode_64bit_uint() return (result) def ReadString(self, addr): data = self._client.read_holding_registers(addr, 8, unit=71) Stringregister = BinaryPayloadDecoder.fromRegisters( data.registers, byteorder=Endian.Big, wordorder=Endian.Little) result = Stringregister.decode_string(8) return (result)
def setstat(ip,status): file_ip= '/var/www/html/openWB/ramdisk/keba_' + ip f1 = open(file_ip, 'w') f1.write(str(status)) f1.close() if os.path.isfile(file_string): f = open( file_string , 'a') else: f = open( file_string , 'w') ipaddress=str(sys.argv[1]) newcurr=int(sys.argv[2]) client = ModbusTcpClient(ipaddress, port=502) # maxcurr state 1100 resp= client.read_holding_registers(1100,2,unit=255) decoder = BinaryPayloadDecoder.fromRegisters(resp.registers,byteorder=Endian.Big,wordorder=Endian.Big) final = float( decoder.decode_32bit_uint()) / 1000 oldcurr = int("%.f" % final) # cabel state 1004 resp= client.read_holding_registers(1004,2,unit=255) decoder = BinaryPayloadDecoder.fromRegisters(resp.registers,byteorder=Endian.Big,wordorder=Endian.Big) final2 = float( decoder.decode_32bit_uint()) plugs = "%.f" % final2 # max supported curr 1110 resp= client.read_holding_registers(1110,2,unit=255)
class PataraControl(object): def __init__(self, ip="172.16.109.70", port=502, slave_id=1): self.client = None self.connected = False self.read_len = 64 self.ip = ip self.port = port self.slave_id = slave_id self.patara_data = pp.PataraHardwareParameters() self.command_queue = Queue.Queue() self.lock = threading.Lock() self.response_pending = False self.queue_pending_deferred = None self.state = "unknown" self.com0_state = "unknown" self.channel1_state = "unknown" self.shutter_state = False self.status = "" self.active_fault_list = list() self.active_interlock_list = list() self.setup_attr_params = dict() # self.setup_attr_params["shutter"] = False # self.setup_attr_params["emission"] = False # self.setup_attr_params["channel1_active_current"] = 13.4 self.standby_polling_attrs = dict() self.standby_polling_attrs["input_registers"] = 0.3 self.standby_polling_attrs["status"] = 0.3 self.standby_polling_attrs["control"] = 0.5 self.active_polling_attrs = dict() self.active_polling_attrs["input_registers"] = 0.3 self.active_polling_attrs["status"] = 0.3 self.active_polling_attrs["control"] = 0.5 self.state_notifier_list = list() self.logger = logging.getLogger("PataraControl") while len(self.logger.handlers): self.logger.removeHandler(self.logger.handlers[0]) # f = logging.Formatter("%(asctime)s - %(module)s. %(funcName)s - %(levelname)s - %(message)s") f = logging.Formatter( "%(asctime)s - %(name)s. %(funcName)s - %(levelname)s - %(message)s" ) fh = logging.StreamHandler() fh.setFormatter(f) self.logger.addHandler(fh) self.logger.setLevel(logging.INFO) def init_client(self): """ Initialize the connection with patara modbus device. :return: """ self.logger.info("Initialize client connection") self.close_client() self.client = ModbusClient(self.ip, self.port) d = TangoTwisted.defer_to_thread(self.client.connect) d.addCallback(self.init_client_cb) d.addErrback(self.command_error) return d def init_client_cb(self, result): if result is True: self.connected = True else: self.connected = False return self.connected def close_client(self): """ Close connection to client :return: """ self.logger.info("Close connection to client") with self.lock: self.command_queue = Queue.Queue() self.cancel_queue_cmd_from_deferred(self.queue_pending_deferred) self.queue_pending_deferred = None if self.client is not None: self.client.close() self.client = None self.connected = False def read_coils(self): for r in self.patara_data.coil_read_range: d = TangoTwisted.defer_to_thread(self.client.read_coils, address=r[0], count=r[1] - r[0] + 1, unit=self.slave_id) return d def read_control_state_queue_cmd(self): """ Read essential control bits from function 01, such as emission, standby, shutter :return: """ min_addr = self.patara_data.coil_read_range[0][0] max_addr = self.patara_data.coil_read_range[0][1] self.logger.debug("Reading control state from {0} to {1}".format( min_addr, max_addr)) d = TangoTwisted.defer_to_thread(self.client.read_coils, min_addr, max_addr - min_addr + 1, unit=self.slave_id) d.addCallbacks(self.process_control_state, self.client_error) return d def read_status_queue_cmd(self): """ Read status bit from function 02. :return: """ min_addr = self.patara_data.discrete_input_read_range[0][0] max_addr = self.patara_data.discrete_input_read_range[0][1] self.logger.debug("Reading status from {0} to {1}".format( min_addr, max_addr)) d = TangoTwisted.defer_to_thread(self.client.read_discrete_inputs, min_addr, max_addr - min_addr + 1, unit=self.slave_id, canceller=self.dummy_canceller) d.addCallbacks(self.process_status, self.client_error) return d def defer_to_queue(self, f, *args, **kwargs): self.logger.debug( "Deferring {0} with args {1}, kwargs {2} to queue".format( f, args, kwargs)) d = defer.Deferred(canceller=self.cancel_queue_cmd_from_deferred) # cmd = (d, f, args, kwargs) # cmd = d # d.addCallback(f, args, kwargs) # with self.lock: # self.command_queue.put(cmd) # return d # d.addCallback(self.queue_cb, f, *args, **kwargs) with self.lock: self.command_queue.put(d) return d def cancel_queue_cmd_from_deferred(self, d): self.logger.info("Cancelling {0}".format(d)) if isinstance(d, defer.Deferred): cmd_list = list() with self.lock: while self.command_queue.empty() is False: cmd = self.command_queue.get_nowait() if cmd != d: cmd_list.append(cmd) else: self.logger.info("Found deferred in list. Remove it.") for cmd in cmd_list: self.command_queue.put(cmd) def dummy_canceller(self, d): self.logger.info("Dummy cancelling {0}".format(d)) def queue_cb(self, d_called, f, *args, **kwargs): """ Start thread running function. Copy callbacks from calling deferred and clear them from the calling deferred, stalling callback execution until the thread completes. :param d_called: Result from callback of d_callback (it sends itself as result) :param f: Function to execute in thread :param args: Arguments to function :param kwargs: Keyword arguments to function :return: Nada """ d = TangoTwisted.defer_to_thread(f, canceller=self.dummy_canceller, *args, **kwargs) d.callbacks = d_called.callbacks d.addCallbacks(self.command_done, self.command_error) d_called.callbacks = [] def process_queue(self): if self.response_pending is False: try: with self.lock: if self.command_queue is not None: d_cmd = self.command_queue.get_nowait() except Queue.Empty: # self.logger.debug("Queue empty. Exit processing") return self.queue_pending_deferred = d_cmd self.logger.debug("Deferring {0}".format(d_cmd)) self.response_pending = True d_cmd.callback(d_cmd) def add_command(self, d_cmd): """ Add a deferred with command function as callback. *DO NOT USE* - use defer to queue instead :param d_cmd: Deferred with command as callback :return: """ self.logger.info("Adding command {0} to queue".format(str(d_cmd))) with self.lock: self.command_queue.put(d_cmd) def command_done(self, response): self.logger.debug("Command done.") self.response_pending = False try: if self.queue_pending_deferred.called is False: self.queue_pending_deferred.callback(response) except defer.AlreadyCalledError: self.logger.error("Pending deferred already called") self.process_queue() # self.logger.info("Command done finished. Returning response {0}".format(response)) return response def command_error(self, err): self.logger.error(str(err)) self.response_pending = False self.queue_pending_deferred.errback(err) return err def write_parameter(self, name, value, process_now=True, readback=True): """ Write a single named parameter to the Patara. If readback is True the same parameter is scheduled to be read after the write. The retured deferred fires when the result is ready. :param name: Name of the parameter according the eDrive User Manual :param value: Value to write :param process_now: True if the queue should be processes immediately :param readback: True if the value should be read back from the Patara :return: Deferred that fires when the result is ready """ p = self.get_parameter(name) if p is None: err = "Name {0} not in parameter dictionary".format(name) self.logger.error(err) d = defer.Deferred() fail = failure.Failure(AttributeError(err)) d.errback(fail) return d addr = p.get_address() func = p.get_function_code() (factor, offset) = p.get_conversion() w_val = np.uint16((value - offset) / factor) self.logger.info( "Writing to {0}. Addr: {1}, func {2}, value {3}".format( name, addr, func, w_val)) if func == 1: f = self.client.write_coil elif func == 3: f = self.client.write_register else: err = "Wrong function code {0}, should be 1, or 3".format(func) self.logger.error(err) d = defer.Deferred() fail = failure.Failure(AttributeError(err)) d.errback(fail) return d d = self.defer_to_queue(f, addr, w_val, unit=self.slave_id) # d = defer.Deferred() d.addErrback(self.client_error) if readback is True: d = self.read_parameter(name, process_now) if process_now is True: self.process_queue() return d def clear_fault(self): self.logger.info("Sending CLEAR FAULT command") self.write_parameter("clear_fault", True, process_now=True, readback=False) def read_parameter(self, name, process_now=True): """ Read a single named parameter from the Patara and store the result in the parameter dictionary. The retured deferred fires when the result is ready. :param name: Name of the parameter according the eDrive User Manual :param process_now: True if the queue should be processes immediately :return: Deferred that fires when the result is ready """ p = self.get_parameter(name) if p is None: err = "Name {0} not in parameter dictionary".format(name) self.logger.error(err) d = defer.Deferred() fail = failure.Failure(AttributeError(err)) d.errback(fail) return d addr = p.get_address() func = p.get_function_code() self.logger.debug("Reading {0}. Addr: {1}, func {2}".format( name, addr, func)) if func == 1: f = self.client.read_coils elif func == 2: f = self.client.read_discrete_inputs elif func == 3: f = self.client.read_holding_registers elif func == 4: f = self.client.read_input_registers else: err = "Wrong function code {0}, should be 1, 2, 3, or 4".format( func) self.logger.error(err) d = defer.Deferred() fail = failure.Failure(AttributeError(err)) d.errback(fail) return d d = self.defer_to_queue(f, addr, 1, unit=self.slave_id) d.addCallback(self.process_parameters, min_addr=addr) d.addErrback(self.client_error) if process_now is True: self.process_queue() return d def read_control_state(self, process_now=True, **kwargs): """ Place a read_coils command on the command queue. Returns a deferred that fires when the command has finsihed executing. Which read_coils to read are selected with range_id or min_addr + max_attr. If nothing is specified, range_id=0 is presumed. :param process_now: True if the queue should be processed immediately. :param kwargs: range_id: integer to index read_range variable in patara data min_addr: starting read_coil to read max_addr: end read_coil to read :return: """ if "range_id" in kwargs: range_id = kwargs["range_id"] else: range_id = 0 if "min_addr" in kwargs: min_addr = kwargs["min_addr"] else: min_addr = self.patara_data.coil_read_range[range_id][0] if "max_addr" in kwargs: max_addr = kwargs["max_addr"] else: max_addr = self.patara_data.coil_read_range[range_id][1] # min_addr = self.patara_data.coil_read_range[0][0] # max_addr = self.patara_data.coil_read_range[0][1] self.logger.debug("Reading control state from {0} to {1}".format( min_addr, max_addr)) d = self.defer_to_queue(self.client.read_coils, min_addr, max_addr - min_addr + 1, unit=self.slave_id) d.addCallback(self.process_control_state, min_addr=min_addr) d.addErrback(self.client_error) if process_now is True: self.process_queue() return d def read_status(self, process_now=True, **kwargs): """ Place a read_discrete_inputs command on the command queue. Returns a deferred that fires when the command has finsihed executing. Which discrete_inputs to read are selected with range_id or min_addr + max_attr. If nothing is specified, range_id=0 is presumed. :param process_now: True if the queue should be processed immediately. :param kwargs: range_id: integer to index read_range variable in patara data min_addr: starting discrete_input to read max_addr: end discrete_input to read :return: """ if "range_id" in kwargs: range_id = kwargs["range_id"] else: range_id = 0 if "min_addr" in kwargs: min_addr = kwargs["min_addr"] else: min_addr = self.patara_data.discrete_input_read_range[range_id][0] if "max_addr" in kwargs: max_addr = kwargs["max_addr"] else: max_addr = self.patara_data.discrete_input_read_range[range_id][1] # min_addr = self.patara_data.discrete_input_read_range[0][0] # max_addr = self.patara_data.discrete_input_read_range[0][1] self.logger.debug("Reading status from {0} to {1}".format( min_addr, max_addr)) d = self.defer_to_queue(self.client.read_discrete_inputs, min_addr, max_addr - min_addr + 1, unit=self.slave_id) d.addCallback(self.process_status, min_addr=min_addr) d.addErrback(self.client_error) if process_now is True: self.process_queue() return d def read_input_registers(self, process_now=True, **kwargs): """ Place a read_input_registers command on the command queue. Returns a deferred that fires when the command has finsihed executing. Which registers to read are selected with range_id or min_addr + max_attr. If nothing is specified, range_id=0 is presumed. :param process_now: True if the queue should be processed immediately. :param kwargs: range_id: integer to index read_range variable in patara data min_addr: starting register to read max_addr: end register to read :return: """ if "range_id" in kwargs: range_id = kwargs["range_id"] else: range_id = 0 if "min_addr" in kwargs: min_addr = kwargs["min_addr"] else: min_addr = self.patara_data.input_register_read_range[range_id][0] if "max_addr" in kwargs: max_addr = kwargs["max_addr"] else: max_addr = self.patara_data.input_register_read_range[range_id][1] self.logger.debug("Reading input registers from {0} to {1}".format( min_addr, max_addr)) d = self.defer_to_queue(self.client.read_input_registers, min_addr, max_addr - min_addr + 1, unit=self.slave_id) d.addCallback(self.process_input_registers, min_addr=min_addr) d.addErrback(self.client_error) if process_now is True: self.process_queue() return d def process_parameters(self, response, min_addr=0): self.logger.debug( "Processing parameters response: {0}".format(response)) func = response.function_code if func == 1 or func == 2: data = response.bits else: data = response.registers t = time.time() result = dict() for addr, reg in enumerate(data): self.logger.debug("Addr: {0}, reg {1}".format( addr + min_addr, reg)) if addr == 16: self.logger.info( "Read channel1_active_current: {0}".format(reg)) set_res = self.patara_data.set_parameter_from_modbus_addr( func, addr + min_addr, reg, t) self.logger.debug("Set result: {0}".format(set_res)) name = self.patara_data.get_name_from_modbus_addr( func, addr + min_addr) try: value = self.patara_data.parameters[name].get_value() except KeyError: self.logger.error("KeyError for name {0}, addr {1}".format( name, addr + min_addr)) continue self.logger.debug("Name: {0}, value: {1}".format(name, value)) result[name] = value return result def process_control_state(self, response, min_addr=0): self.logger.debug("Processing status response: {0}".format(response)) try: data = response.bits except ValueError: return response t = time.time() result = dict() for addr, bit in enumerate(data): self.patara_data.set_parameter_from_modbus_addr( 1, addr + min_addr, bit, t) name = self.patara_data.get_name_from_modbus_addr( 1, addr + min_addr) result[name] = bit return result def process_input_registers(self, response, min_addr=0): self.logger.debug( "Processing input registers response: {0}".format(response)) try: data = response.registers except ValueError: return response t = time.time() result = dict() for addr, reg in enumerate(data): # self.logger.debug("Addr: {0}, reg {1}".format(addr + min_addr, reg)) self.patara_data.set_parameter_from_modbus_addr( 4, addr + min_addr, reg, t) # self.logger.debug("Set result: {0}".format(set_res)) name = self.patara_data.get_name_from_modbus_addr( 4, addr + min_addr) try: value = self.patara_data.parameters[name].get_value() except KeyError: # self.logger.error("KeyError for name {0}, addr {1}".format(name, addr + min_addr)) continue # self.logger.debug("Name: {0}, value: {1}".format(name, value)) result[name] = value return result def process_status(self, response, min_addr=0): self.logger.debug("Processing status response: {0}".format(response)) try: data = response.bits except ValueError: return response t = time.time() faults = list() interlocks = list() state = None channel1_state = None shutter_state = None com0_state = None for addr, bit in enumerate(data): self.patara_data.set_parameter_from_modbus_addr( 2, addr + min_addr, bit, t) name = self.patara_data.get_name_from_modbus_addr( 2, addr + min_addr) try: value = self.patara_data.parameters[name].get_value() except KeyError: # self.logger.error("KeyError for name {0}, addr {1}".format(name, addr + min_addr)) continue self.logger.debug("Name: {0}, value: {1}".format(name, value)) if name in [ "fault_state", "off_state", "standby_state", "pre-fire_state", "active_state" ]: if value is True: state = name elif name in [ "channel1_off_state", "channel1_standby", "channel1_active", "channel1_fault_state" ]: if value is True: channel1_state = name elif name in [ "com0_off_state", "com0_standby_state", "com0_active_state", "com0_fault_state" ]: if value is True: com0_state = name elif name == "laser_shutter_state": shutter_state = value # if name is not None: # if addr < 5: # if bit == 1: # self.state = name # elif 32 <= addr <= 35: # if bit == 1: # self.channel1_state = name # elif 80 <= addr <= 83: # if bit == 1: # self.com0_state = name elif "fault" in name: if value is True: faults.append(name) elif "interlock" in name: if value is True: interlocks.append(name) self.channel1_state = channel1_state self.com0_state = com0_state self.set_state(state, shutter_state, faults, interlocks) # with self.lock: # self.active_fault_list = faults # self.active_interlock_list = interlocks return response def client_error(self, err): self.logger.error("Modbus error: {0}".format(err)) self.init_client() def get_parameter(self, name): """ Get a stored patara parameter with name. If the parameter is not in the dictionary return None. :param name: Name of parameter according to Patara eDrive User Manual :return: PataraParameter (Retrieve value with .get_value method) """ with self.lock: try: p = self.patara_data.parameters[name] except KeyError: p = None return p def get_parameters(self, name_list): p_list = list() for name in name_list: with self.lock: try: p = self.patara_data.parameters[name] except KeyError: p = None p_list.append(p) return p_list def get_fault_list(self): with self.lock: # Use copy here fl = self.active_fault_list return fl def get_interlock_list(self): with self.lock: # Use copy here il = self.active_interlock_list return il def set_status(self, new_status=None): if new_status is not None: self.status = new_status for notifier in self.state_notifier_list: new_status = self.get_status() new_state = self.get_state() notifier(new_state, new_status) def get_status(self): status = "State: {0}\n\n".format(self.get_state().upper()) status += self.status fault_string = "" interlock_string = "" if len(self.active_fault_list) > 0: fault_string = "\n--------------------------------\nActive FAULTS:\n" for fault in self.active_fault_list: fault_string += fault fault_string += "\n" if len(self.active_interlock_list) > 0: interlock_string = "\n--------------------------------\nActive INTERLOCKS:\n" for interlock in self.active_interlock_list: interlock_string += interlock interlock_string += "\n" final_status_string = status + fault_string + interlock_string return final_status_string def set_state(self, new_state, shutter_state=None, faults=None, interlocks=None): notify_state = False if new_state != self.state or shutter_state != self.shutter_state: self.state = new_state self.shutter_state = shutter_state notify_state = True if faults != self.active_fault_list or interlocks != self.active_interlock_list: self.active_fault_list = faults self.active_interlock_list = interlocks notify_state = True if notify_state is True: for notifier in self.state_notifier_list: new_status = self.get_status() notifier(new_state, new_status) def get_state(self): return self.state def get_shutterstate(self): return self.shutter_state def add_state_notifier(self, notifier): if notifier not in self.state_notifier_list: self.state_notifier_list.append(notifier)
def __configure_master(self, config=None): current_config = self.__config if config is None else config host = current_config['host'] if current_config.get( "host") is not None else self.__config.get("host", "localhost") try: port = int(current_config['port']) if current_config.get( "port") is not None else self.__config.get(int("port"), 502) except ValueError: port = current_config['port'] if current_config.get( "port") is not None else self.__config.get("port", 502) baudrate = current_config['baudrate'] if current_config.get( 'baudrate') is not None else self.__config.get('baudrate', 19200) timeout = current_config['timeout'] if current_config.get( "timeout") is not None else self.__config.get("timeout", 35) method = current_config['method'] if current_config.get( 'method') is not None else self.__config.get('method', 'rtu') stopbits = current_config['stopbits'] if current_config.get( 'stopbits') is not None else self.__config.get( 'stopbits', Defaults.Stopbits) bytesize = current_config['bytesize'] if current_config.get( 'bytesize') is not None else self.__config.get( 'bytesize', Defaults.Bytesize) parity = current_config['parity'] if current_config.get( 'parity') is not None else self.__config.get( 'parity', Defaults.Parity) strict = current_config["strict"] if current_config.get( "strict") is not None else self.__config.get("strict", True) rtu = ModbusRtuFramer if current_config.get("method") == "rtu" or ( current_config.get("method") is None and self.__config.get("method") == "rtu") else ModbusSocketFramer if current_config.get('type') == 'tcp' or ( current_config.get("type") is None and self.__config.get("type") == "tcp"): master = ModbusTcpClient(host, port, rtu, timeout=timeout) elif current_config.get('type') == 'udp' or ( current_config.get("type") is None and self.__config.get("type") == "udp"): master = ModbusUdpClient(host, port, rtu, timeout=timeout) elif current_config.get('type') == 'serial' or ( current_config.get("type") is None and self.__config.get("type") == "serial"): master = ModbusSerialClient(method=method, port=port, timeout=timeout, baudrate=baudrate, stopbits=stopbits, bytesize=bytesize, parity=parity, strict=strict) else: raise Exception("Invalid Modbus transport type.") available_functions = { 1: master.read_coils, 2: master.read_discrete_inputs, 3: master.read_holding_registers, 4: master.read_input_registers, 5: master.write_coil, 6: master.write_register, 15: master.write_coils, 16: master.write_registers, } return master, available_functions
class ModbusClient(object): """Establishes a secure connection with the Modbus slave. Will be able to read and write to all of the available I/O.""" def __init__(self, ip='192.168.2.17'): self.ip = ip self.client = ModbusTcpClient(self.ip) self.connection = self.client.connect() def isConnected(self): """Returns the connection status. Return: True if connected, False if not.""" return self.connection def sendInt(self, value, address): """Send a 32 bit value to the first modbus unit. Parameters: value and address where the value will be stored in. Return: Result if it was successful or not.""" builder = BinaryPayloadBuilder(byteorder=Endian.Big) builder.add_32bit_int(value) payload = builder.build() result = self.client.write_registers(address, payload, skip_encode=True, unit=1) return result def sendFloat(self, value, address): """Send a 32 bit value to the first modbus unit. Parameters: value and address where the value will be stored in. Return: Result if it was successful or not.""" builder = BinaryPayloadBuilder(byteorder=Endian.Big) builder.add_32bit_float(value) payload = builder.build() result = self.client.write_registers(address, payload, skip_encode=True, unit=1) return result def readInt(self, address=12288, size=20): """Reads the number of addresses that the size contains. The readings start from the given address. Return: An array of read values""" response = self.client.read_holding_registers(address, size, unit=1) return response.registers def readFloat(self, address=12301, size=2): """Reads two bytes from the given start address. Returns the decoded float value""" response = self.client.read_holding_registers(address, size, unit=1) decoder = BinaryPayloadDecoder.fromRegisters(response.registers, byteorder=Endian.Big, wordorder=Endian.Little) value = decoder.decode_32bit_float() return value def close(self): """Closes the connection with the port. Return: True when the connection is closed.""" self.client.close() return True
def cyclic(self, dt): global energie, Pinst, conn_to_ccgx, seconds, conn_status, time_check, state_of_charge, grid_power, state, battery_alarm, battery_voltage, battery_current, connect_to_db client = ModbusClient('192.169.1.107', port=502) if (conn_status or (conn_status == False and time_check > 10)): try: conn_to_ccgx = False if (client.connect()): conn_to_ccgx = True try: # print("connected") rr = client.read_holding_registers(12, 3, unit=246) #rr = 1 if rr.getRegister(0) > 32767: Pinst = rr.getRegister(0) - 65535 else: Pinst = rr.getRegister(0) if rr.getRegister(1) > 32767: Pinst += rr.getRegister(1) - 65535 else: Pinst += rr.getRegister(1) if rr.getRegister(2) > 32767: Pinst += rr.getRegister(2) - 65535 else: Pinst += rr.getRegister(2) soc = client.read_holding_registers(30, 2, unit=246) state_of_charge = soc.getRegister(0) / 10 state = soc.getRegister(1) battery_alarm_buffer = client.read_holding_registers( 35, 1, unit=246) battery_alarm = battery_alarm_buffer.getRegister(0) grid_ac = client.read_holding_registers(2600, 3, unit=30) if grid_ac.getRegister(0) > 32767: grid_power[0] = grid_ac.getRegister(0) - 65535 else: grid_power[0] = grid_ac.getRegister(0) if grid_ac.getRegister(1) > 32767: grid_power[1] = grid_ac.getRegister(1) - 65535 else: grid_power[1] = grid_ac.getRegister(1) if grid_ac.getRegister(2) > 32767: grid_power[2] = grid_ac.getRegister(2) - 65535 else: grid_power[2] = grid_ac.getRegister(2) battery_acvc = client.read_holding_registers(26, 2, unit=246) battery_voltage = battery_acvc.getRegister(0) battery_current = battery_acvc.getRegister(1) print grid_power print "Vittoria" time_check = 1 conn_status = True # print("connected") print grid_power except Exception: print "error" Pinst = 0 conn_status = False grid_power = [0, 0, 0] else: Pinst = 0 conn_status = False time_check = 1 conn_to_ccgx = False except Exception: print "error" Pinst = 0 conn_status = False # conn_to_ccgx = False grid_power = [0, 0, 0] time_check = 1 else: time_check = time_check + 1 Pinst = 0 # conn_to_ccgx = False seconds = seconds + 1 # Pinst = 30*10 #decomment ONLY for debug # conn_status = True #decomment ONLY for debug # seconds = seconds + 1 #decomment ONLY for debug Pinst = Pinst * 10 client.close() if (seconds % 10 == 0): with open("log.txt", "a") as myfile: data = [energie, Pinst, seconds] myfile.write( str(seconds) + "\t" + str(energie) + "\t" + str(Pinst) + "\t" + str(state_of_charge) + "\t" + str(conn_status) + "\t" + str(grid_power[0]) + "\t" + str(grid_power[1]) + "\t" + str(grid_power[2]) + "\t" + str(state) + "\t" + str(battery_alarm) + "\t" + str(battery_voltage) + "\t" + str(battery_current) + "\t" + str(conn_to_ccgx) + "\n") ts = time.time() timestamp = datetime.datetime.fromtimestamp(ts).strftime( '%Y-%m-%d %H:%M:%S') # string = 'INSERT INTO sql11172989.Nuvola ' + '(Seconds, Energy, Pinst, StateOfCharge, ConnStatus, GridPower1, GridPower2, GridPower3, State, BatteryAlarm, Date) VALUES (' + str(seconds) + " , " + str(energie) + " , " + str(Pinst) + " , " + str(state_of_charge) + " , " + str(conn_status) + " , " + str(grid_power[0]) + " , " + str(grid_power[1]) + " , " + str(grid_power[2]) + " , " + str(state) + " , " + str(battery_alarm) + ' , ' + str(timestamp) + ')' # print string try: ts = time.time() timestamp = datetime.datetime.fromtimestamp(ts).strftime( '%Y-%m-%d %H:%M:%S') db = MySQLdb.connect( host= "sql11.freesqldatabase.com", # your host, usually localhost user="******", # your username passwd="gxPNMb9mdQ", # your password db="sql11172989", connect_timeout=0.1) cur = db.cursor() cur.execute( 'INSERT INTO sql11172989.' + table + ' ' + '(Seconds, Energy, Pinst, StateOfCharge, ConnStatus, GridPower1, GridPower2, GridPower3, State, BatteryAlarm, BatteryVoltage, BatteryCurrent, ConnCCGX, Date_) ' 'VALUES (' + str(seconds) + " , " + str(energie) + " , " + str(Pinst) + " , " + str(state_of_charge) + " , " + str(conn_status) + " , " + str(grid_power[0]) + " , " + str(grid_power[1]) + " , " + str(grid_power[2]) + " , " + str(state) + " , " + str(battery_alarm) + " , " + str(battery_voltage) + " , " + str(battery_current) + " , " + str(conn_to_ccgx) + ' , "' + str(timestamp) + '")') print("sto scrivendo....") cur.close() db.commit() connect_to_db = True except Exception: connect_to_db = False print "Impossible to write to DB" #rr = 2 if Pinst > 0: energie += Pinst / 3600000.0 #rr = client.read_holding_registers(2700, 3, unit=0) print(energie / 1) #THIS WILL BE WRITTEN TOGETHER WITH backup3/5!! Every second! # print "Error %d: %s" % (e.args[0],e.args[1]) data = [energie, Pinst, seconds] call(["cp", "backup3.p", "backup5.p"]) write = open('backup3.p', 'wb') pickle.dump(data, write) client.close() #self.energy.text = str(round(energie/3600000.0,3))+" kWh" #self.euros.text = str(round(energie/3600000.0*0.15,3))+" eur" # client.close() #print("disconnected") # print "There was an exception" client.close()
#!/usr/bin/env python from pymodbus.client.sync import ModbusTcpClient as ModbusClient import modbus_utilities as utilities_modbus import vision_utilities as utilities_vision import cv2 import time import numpy as np # Create a client and connect to the camera server client = ModbusClient(utilities_modbus.IP, port=utilities_modbus.PORT) client.connect() if __name__ == "__main__": while True: # Read the result register rr = client.read_holding_registers(address=utilities_modbus.ADDRESS, count=3, unit=utilities_modbus.UNIT) # While the result register is on wait (no result published), read the result register while rr.registers[1] == utilities_modbus.RESULT_WAIT: rr = client.read_holding_registers( address=utilities_modbus.ADDRESS, count=3, unit=utilities_modbus.UNIT) time.sleep(utilities_modbus.VISUALIZER_REQUEST_RATE) # Load the images showing the different steps in the image processing (input/cropping/hsv_filter) state, image_0 = utilities_vision.loadImage("images/step_0.jpg")
from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient('127.0.0.1') client.write_coil(1, True) result = client.read_coils(1, 1) print result.bits[0] client.close()
def run_binary_payload_ex(): # ----------------------------------------------------------------------- # # We are going to use a simple client to send our requests # ----------------------------------------------------------------------- # client = ModbusClient('127.0.0.1', port=5020) client.connect() # ----------------------------------------------------------------------- # # If you need to build a complex message to send, you can use the payload # builder to simplify the packing logic. # # Here we demonstrate packing a random payload layout, unpacked it looks # like the following: # # - a 8 byte string 'abcdefgh' # - a 32 bit float 22.34 # - a 16 bit unsigned int 0x1234 # - another 16 bit unsigned int 0x5678 # - an 8 bit int 0x12 # - an 8 bit bitstring [0,1,0,1,1,0,1,0] # - an 32 bit uint 0x12345678 # - an 32 bit signed int -0x1234 # - an 64 bit signed int 0x12345678 # The packing can also be applied to the word (wordorder) and bytes in each # word (byteorder) # The wordorder is applicable only for 32 and 64 bit values # Lets say we need to write a value 0x12345678 to a 32 bit register # The following combinations could be used to write the register # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # # Word Order - Big Byte Order - Big # word1 =0x1234 word2 = 0x5678 # Word Order - Big Byte Order - Little # word1 =0x3412 word2 = 0x7856 # Word Order - Little Byte Order - Big # word1 = 0x5678 word2 = 0x1234 # Word Order - Little Byte Order - Little # word1 =0x7856 word2 = 0x3412 # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # # ----------------------------------------------------------------------- # combos = [(wo, bo) for wo in [Endian.Big, Endian.Little] for bo in [Endian.Big, Endian.Little]] for wo, bo in combos: print("-" * 60) print("Word Order: {}".format(ORDER_DICT[wo])) print("Byte Order: {}".format(ORDER_DICT[bo])) print() builder = BinaryPayloadBuilder(byteorder=bo, wordorder=wo) strng = "abcdefgh" builder.add_string(strng) builder.add_bits([0, 1, 0, 1, 1, 0, 1, 0]) builder.add_8bit_int(-0x12) builder.add_8bit_uint(0x12) builder.add_16bit_int(-0x5678) builder.add_16bit_uint(0x1234) builder.add_32bit_int(-0x1234) builder.add_32bit_uint(0x12345678) builder.add_16bit_float(12.34) builder.add_16bit_float(-12.34) builder.add_32bit_float(22.34) builder.add_32bit_float(-22.34) builder.add_64bit_int(-0xDEADBEEF) builder.add_64bit_uint(0x12345678DEADBEEF) builder.add_64bit_uint(0x12345678DEADBEEF) builder.add_64bit_float(123.45) builder.add_64bit_float(-123.45) payload = builder.to_registers() print("-" * 60) print("Writing Registers") print("-" * 60) print(payload) print("\n") payload = builder.build() address = 0 # Can write registers # registers = builder.to_registers() # client.write_registers(address, registers, unit=1) # Or can write encoded binary string client.write_registers(address, payload, skip_encode=True, unit=1) # ----------------------------------------------------------------------- # # If you need to decode a collection of registers in a weird layout, the # payload decoder can help you as well. # # Here we demonstrate decoding a random register layout, unpacked it looks # like the following: # # - a 8 byte string 'abcdefgh' # - a 32 bit float 22.34 # - a 16 bit unsigned int 0x1234 # - another 16 bit unsigned int which we will ignore # - an 8 bit int 0x12 # - an 8 bit bitstring [0,1,0,1,1,0,1,0] # ----------------------------------------------------------------------- # address = 0x0 count = len(payload) result = client.read_holding_registers(address, count, unit=1) print("-" * 60) print("Registers") print("-" * 60) print(result.registers) print("\n") decoder = BinaryPayloadDecoder.fromRegisters(result.registers, byteorder=bo, wordorder=wo) assert decoder._byteorder == builder._byteorder, \ "Make sure byteorder is consistent between BinaryPayloadBuilder and BinaryPayloadDecoder" assert decoder._wordorder == builder._wordorder, \ "Make sure wordorder is consistent between BinaryPayloadBuilder and BinaryPayloadDecoder" decoded = OrderedDict([ ('string', decoder.decode_string(len(strng))), ('bits', decoder.decode_bits()), ('8int', decoder.decode_8bit_int()), ('8uint', decoder.decode_8bit_uint()), ('16int', decoder.decode_16bit_int()), ('16uint', decoder.decode_16bit_uint()), ('32int', decoder.decode_32bit_int()), ('32uint', decoder.decode_32bit_uint()), ('16float', decoder.decode_16bit_float()), ('16float2', decoder.decode_16bit_float()), ('32float', decoder.decode_32bit_float()), ('32float2', decoder.decode_32bit_float()), ('64int', decoder.decode_64bit_int()), ('64uint', decoder.decode_64bit_uint()), ('ignore', decoder.skip_bytes(8)), ('64float', decoder.decode_64bit_float()), ('64float2', decoder.decode_64bit_float()), ]) print("-" * 60) print("Decoded Data") print("-" * 60) for name, value in iteritems(decoded): print("%s\t" % name, hex(value) if isinstance(value, int) else value) # ----------------------------------------------------------------------- # # close the client # ----------------------------------------------------------------------- # client.close()
#!/usr/bin/python import sys import os import time import getopt import socket import ConfigParser import struct import binascii ipaddress = str(sys.argv[1]) from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient(ipaddress, port=502) #print "SoC batt" resp= client.read_holding_registers(30845,2,unit=3) value1 = resp.registers[0] value2 = resp.registers[1] all = format(value1, '04x') + format(value2, '04x') final = int(struct.unpack('>i', all.decode('hex'))[0]) f = open('/var/www/html/openWB/ramdisk/speichersoc', 'w') f.write(str(final)) f.close() #print "be-entladen watt" resp= client.read_holding_registers(31393,2,unit=3) value1 = resp.registers[0] value2 = resp.registers[1] all = format(value1, '04x') + format(value2, '04x') ladung = int(struct.unpack('>i', all.decode('hex'))[0]) resp= client.read_holding_registers(31395,2,unit=3) value1 = resp.registers[0]
# ! You need to launch the server first ! from pymodbus.client.sync import ModbusTcpClient import time def number_to_raw_data(val): if val < 0: val = (1 << 15) - val return int(val) if __name__ == '__main__': print "--- START" client = ModbusTcpClient('192.168.1.52', port=5020) client.connect() print "Connected to modbus server" print "Update tool" client.write_register(500, 1) time.sleep(2) print "Enable TCP" client.write_register(600, 1) time.sleep(2) print "Set TCP" tcp_rpy = [0.2, -0.1, 0.0, 0.0, 1.5, 0.0] tcp_rpy_to_send = list(map(lambda x: number_to_raw_data(x * 1000),
'S16':1, 'U16':1, 'S32':2, 'U32':2, 'U64':4, 'STR16':8, 'STR32':16 } # Load the modbus register map for the inverter modmap_file = "modbus-" + config.model modmap = __import__(modmap_file) print ("Load ModbusTcpClient") client = ModbusTcpClient(config.inverter_ip, port=config.inverter_port) print("Connect") client.connect() try: mqtt_client = mqtt.Client('pv_data') mqtt_client.connect(config.mqtt_server, port=config.mqtt_port) except: mqtt_client = None try: flux_client = InfluxDBClient(config.influxdb_ip, config.influxdb_port, config.influxdb_user, config.influxdb_password, config.influxdb_database,
def main(args): global client print("# connecting to %s:%s id %s" % (args.ip, args.port, args.slave)) start_t = time.time() client = ModbusClient(args.ip, args.port, timeout=args.timeout) conn = client.connect() if not conn: exit("# unable to connect to %s:%s" % (args.ip, args.port)) end_t = time.time() time_t = (end_t - start_t) * 1000 print("# connection established in %dms" % time_t) print("# delay: %ss timeout: %ss" % (args.delay, args.timeout)) print("# smoothing factor %f" % args.factor) smoothing_factor = args.factor average = 100 errors = 0 while True: with open(args.csv_file) as csv_file: csv_reader = csv.reader(csv_file, delimiter=",") for row in csv_reader: if row[0].startswith("#"): continue function = row[0] register = int(row[1]) register_length = int(row[2]) try: multiplier = float(row[3]) except ValueError: multiplier = 1 encoding = row[4] start_t = time.time() if function == "3": result = client.read_holding_registers(register, register_length, unit=args.slave) elif function == "4": result = client.read_input_registers(register, register_length, unit=args.slave) else: log_error(register, "FUNCTION %s NOT SUPPORTED" % function) continue end_t = time.time() if result.isError(): if isinstance(result, ModbusIOException): log_error(register, "I/O ERROR (TIMEOUT)") else: log_error(register, "REGISTER NOT FOUND") continue decoder = BinaryPayloadDecoder.fromRegisters( result.registers, byteorder=Endian.Big, wordorder=Endian.Big, ) try: encoding = encoding.upper() if encoding not in ENCODINGS: log_error(encoding, "FORMAT NOT SUPPORTED") continue decoded = eval(ENCODINGS[encoding]) # Apply transformations if isinstance(decoded, bytes): decoded = decoded.decode().rstrip() else: decoded = round(decoded * multiplier, 3) except struct.error as e: decoded = "DECODE FAILED (e:'%s' raw:'%s')" % ( e, decoder.decode_string(register_length * 2).decode(), ) time_t = round((end_t - start_t) * 1000, 2) average = round((smoothing_factor * time_t) + (1 - smoothing_factor) * average, 2) print(separator.join( (str(datetime.now()), str(args.ip), str(register), str(decoded), str(time_t), str(average), str(errors))), flush=True) time.sleep(args.delay) if args.loop == 0: break time.sleep(args.loop)
import random import time import NetworkEncoder as ne from pymodbus.client.sync import ModbusTcpClient MODBUS_SLAVE = 'ms.ics.example.com' client = ModbusTcpClient(MODBUS_SLAVE) def readRegisters(): # Read values from slave result = client.read_holding_registers(0, 21, unit=1) addWater = ne.modbusDecode(0, 2, 2, result.registers) addFire = ne.modbusDecode(2, 2, 0, result.registers) waterLevel = ne.modbusDecode(3, 4, 4, result.registers) waterTemp = ne.modbusDecode(7, 2, 2, result.registers) powerOut = ne.modbusDecode(9, 6, 2, result.registers) steamStep = ne.modbusDecode(13, 2, 4, result.registers) powerIn = ne.modbusDecode(16, 6, 2, result.registers) serverSeconds = ne.modbusDecode(20, 2, 0, result.registers) return addWater, addFire, waterLevel, waterTemp, powerOut, steamStep, powerIn, serverSeconds response = '' serverSeconds = 0 print("Sensors online, enter injection attack type:") print("[r]esponse - Fake slave values to trigger overflow") print("[c]ommand - Fake master values to trigger overflow") print("[q]uit")