def test_log_to_stream(): """ Test if handler is added correctly. """ log = getLogger('uModbus') # NullHandler is attached. assert len(log.handlers) == 1 log_to_stream() assert len(log.handlers) == 2 handler = log.handlers[1] assert handler.stream == sys.stderr assert handler.level == logging.NOTSET
def test_log_to_stream(): """ Test if handler is added correctly. """ log = getLogger('uModbus') # NullHandler is attached. assert len(log.handlers) == 1 log_to_stream() assert len(log.handlers) == 2 handler = log.handlers[1] assert handler.stream == sys.stderr assert handler.level == logging.NOTSET
def __init__(self, config_settings): # Reads settings configuration file self.settings = config_settings self.SOC_addr = self.settings.server["battery"]["SOCaddr"] self.power_addr = self.settings.server["battery"]["poweraddr"] self.slave_id = self.settings.server["battery"]["slave_id"] # Initialises Data Store self.data_store = defaultdict(int) # Enable values to be signed conf.SIGNED_VALUES = False # Add Stream Handler to Logger log_to_stream(level=logging.DEBUG) # Creates TCP Server TCPServer.allow_reuse_address = True ipaddr = str(self.settings.server["battery"]["ipaddr"]) port = self.settings.server["battery"]["ipport"] self.app = get_server(TCPServer, (ipaddr, port), RequestHandler) # Server read function @self.app.route(slave_ids=[self.slave_id], function_codes=[3, 4], addresses=list(range(0, 34))) def read_data_store(slave_id, function_code, address): return self.data_store[address] # Server write function @self.app.route(slave_ids=[self.slave_id], function_codes=[6, 16], addresses=list(range(0, 34))) def write_data_store(slave_id, function_code, address, value): self.data_store[address] = value if address == self.power_addr: self.predict_soc(value) # Starting server in background thread self.thread = threading.Thread(target=self._thread) self.thread.start() # Sets Initial Values self.initial_soc = self.settings.battery["initial_SOC"] self.SOC = self.initial_soc self.data_store[self.SOC_addr] = self.initial_soc self.dt = self.settings.control["data_time_step"] / 60 self.bat_cap = self.settings.battery["max_capacity"] * 1000
def __init__(self, house_data, config_settings): # Reads settings configuration file self.settings = config_settings self.power_addr = self.settings.server["house"]["poweraddr"] self.slave_id = self.settings.server["house"]["slave_id"] # Assigns Initial Data self.house_data = house_data # Initialises Data Store self.data_store = defaultdict(int) # Enable values to be signed conf.SIGNED_VALUES = True # Add Stream Handler to Logger log_to_stream(level=logging.DEBUG) # Creates TCP Server TCPServer.allow_reuse_address = True ipaddr = str(self.settings.server["house"]["ipaddr"]) port = self.settings.server["house"]["ipport"] self.app = get_server(TCPServer, (ipaddr, port), RequestHandler) # Sets Initial Value self.data_count = 0 # Server read function @self.app.route(slave_ids=[self.slave_id], function_codes=[3, 4], addresses=list(range(0, 1))) def read_data_store(slave_id, function_code, address): self.data_store[self.power_addr] = self.house_data[self.data_count] if self.data_count == len(self.house_data) - 1: self.data_count = 0 else: self.data_count += 1 return self.data_store[address] # Starting server in background thread self.thread = threading.Thread(target=self._thread) self.thread.start()
from umodbus.client.serial import rtu from umodbus.utils import log_to_stream import re try: import gnureadline as readline except ImportError: import readline ignore_timeouts = True ######################################################## # Set up logging ######################################################## log = getLogger('uModbus') log.setLevel(logging.DEBUG) log_to_stream(stream=sys.stderr, level=logging.DEBUG) log.debug("Logging is set to debug") baud = 9600 rsdev = "/dev/rs485" def get_serial_port(): """ Return serial.Serial instance, ready to use for RS485.""" port = Serial(port=rsdev, baudrate=baud, parity=PARITY_NONE, stopbits=1, bytesize=8, timeout=1)
#!/usr/bin/env python import logging from socketserver import TCPServer from collections import defaultdict import struct from umodbus import conf from umodbus.server.tcp import RequestHandler, get_server from umodbus.utils import log_to_stream log_to_stream(level=logging.DEBUG) data_store = defaultdict(int) conf.SIGNED_VALUES = True TCPServer.allow_reuse_address = True app = get_server(TCPServer, ('0.0.0.0', 502), RequestHandler) def form_sint32(value, startreg): secondreg=startreg +1 try: with open('/var/www/html/openWB/ramdisk/' + value, 'r') as var: readvar = int(float(var.read())) print(str(readvar)) binary32 = struct.pack('>l', readvar) high_byte, low_byte = struct.unpack('>hh', binary32) data_store[startreg] = high_byte data_store[secondreg] = low_byte except: data_store[startreg] = -1 data_store[secondreg] = -1 def form_lpkwhsint32(value, startreg): secondreg=startreg +1 try:
#!/usr/bin/env python # scripts/examples/simple_data_store.py import logging from socketserver import TCPServer from collections import defaultdict from umodbus import get_server, RequestHandler, conf from umodbus.utils import log_to_stream # Add stream handler to logger 'uModbus'. log_to_stream(level=logging.DEBUG) # A very simple data store which maps addresses against their values. data_store = defaultdict(int) # Enable values to be signed (default is False). conf.SIGNED_VALUES = True TCPServer.allow_reuse_address = True app = get_server(TCPServer, ('localhost', 502), RequestHandler) @app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(0, 10))) def read_data_store(slave_id, address): """" Return value of address. """ return data_store[address] @app.route(slave_ids=[1], function_codes=[5, 15], addresses=list(range(0, 10))) def write_data_store(slave_id, address, value): """" Set value for address. """
def __init__(self): self.window = Tk.Tk() self.window.title("Modbus TCP Server") self.window.protocol("WM_DELETE_WINDOW", self._delete_window) self.delay = 20 # Update Tkinter Window self.regs_store = defaultdict(int) #Store Holding Registers self.coil_store = defaultdict(bool) #Store Coils self.txt_regs = [] self.lbl_regs = [] self.coil_chbx = [] self.coil_chbx_sts = [] for i in range(100): self.coil_chbx_sts.append(Tk.IntVar()) self.regofs = 0 self.coilofs = 0 Tk.Label(self.window, text='Holding Register Offset (Functions 3,4):').grid( row=1, column=0, columnspan=3, sticky='w') Tk.Label(self.window, text='Coils Offset (Functions 1,2):').grid(row=1, column=12, columnspan=3, sticky='w') self.register_offset = Tk.Text(self.window, height=1, width=5) self.register_offset.grid(row=1, column=3, padx=1, sticky='ew') self.register_offset.insert('1.0', '0') self.coil_offset = Tk.Text(self.window, height=1, width=5) self.coil_offset.grid(row=1, column=15, padx=1, sticky='ew') self.coil_offset.insert('1.0', '0') self.base = 10 self.run = False self.btn_run = Tk.Button(self.window, text='Start', command=self.ctrl_server) self.btn_run.grid(row=13, column=0, sticky='w') for i in range(10): for j in range(1, 11): a = Tk.Text(self.window, height=1, width=7) self.txt_regs.append(a) a.grid(row=i + 3, column=j, padx=1, pady=1, sticky='ew') a.insert('1.0', '0') a.bind('<FocusOut>', self.rds) for i in range(3, 13): a = Tk.Label(self.window, text='Registers:') self.lbl_regs.append(a) a.grid(row=i, column=0) for i, item in enumerate(self.lbl_regs): item.config( text='Reg {:0>3d}:{:0>3d}'.format(self.regofs + 10 * i + 1, self.regofs + 10 * i + 10)) log_to_stream(level=logging.DEBUG) cnt = 0 for i in range(3, 13): for j in range(12, 22): a = Tk.Checkbutton(text='CC', onvalue=1, offvalue=0, variable=self.coil_chbx_sts[cnt]) self.coil_chbx.append(a) a.grid(row=i, column=j) cnt += 1 for i, item in enumerate(self.coil_chbx): item.config(text='{:0>3d}'.format(self.coilofs + i + 1)) conf.SIGNED_VALUES = True TCPServer.allow_reuse_address = True self.app = get_server(TCPServer, ('localhost', 502), RequestHandler) self.thread = threading.Thread(target=self.__Serve, args=(True, )) #self.app.serve_forever) self.thread.deamon = True self.update() self.window.mainloop()
from umodbus import conf from umodbus.server.tcp import RequestHandler, get_server from umodbus.utils import log_to_stream config = { 'log_level': logging.DEBUG, 'signed_values': True, 'ip-address': '192.168.1.122', 'port': 1502, 'data-file': '/home/pi/log_file.txt', 'tibber-data-file': '/home/pi/tibber-live-measurement.txt', 'value-separator': " ", 'address-range': list(range(100, 1000)) } log_to_stream(level=config['log_level']) conf.SIGNED_VALUES = config['signed_values'] TCPServer.allow_reuse_address = True app = get_server(TCPServer, (config['ip-address'], config['port']), RequestHandler) @app.route(slave_ids=[1], function_codes=[3, 4], addresses=config['address-range']) def read_data_store(slave_id, function_code, address): """" Return value of address. """ str_address = str(address) source_type = int(str_address[0])