def __init__(self): conf.SIGNED_VALUES = True TCPServer.allow_reuse_address = True self.app = get_server(TCPServer, ('localhost', 502), RequestHandler) self.mappings = list() self.input_registers = list() self.holding_registers = list() self.coils = list() self.discrete = list()
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()
def __init__(self, memory_store, server_ip='localhost', slave_id=1, sync_period=0.05): if not isinstance(memory_store, MemoryStore): raise ValueError("memory_store should be instance of MemoryStore") self.app = get_server(TCPServer, (server_ip, 502), RequestHandler) self.memory = memory_store self.sync_period = sync_period read_hr_routing = self.app.route(slave_ids=[slave_id], function_codes=[3], addresses=list( range(self.memory.get_size()))) self.read_holding_reg = read_hr_routing(self.read_holding_reg) write_hr_routing = self.app.route(slave_ids=[slave_id], function_codes=[6, 16], addresses=list( range(self.memory.get_size()))) self.write_holding_reg = write_hr_routing(self.write_holding_reg)
from socketserver import TCPServer from collections import defaultdict from umodbus import log, conf from umodbus.server.tcp import RequestHandler, get_server from umodbus.utils import log_to_stream # Add stream handler to logger 'uModbus'. #log_to_stream(level=logging.DEBUG) logging.basicConfig(level=logging.DEBUG) # Enable values to be signed (default is False). conf.SIGNED_VALUES = True TCPServer.allow_reuse_address = True app = get_server(TCPServer, ('localhost', 15020), RequestHandler) bit_data_store = defaultdict(int) # read coils and discrete inputs @app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(0, 10))) def read_data_store(slave_id, function_code, address): """" Return value of address. """ return bit_data_store[address] # Write Single Coil and Write Multiple Coils. @app.route(slave_ids=[1], function_codes=[5, 15], addresses=list(range(0, 10))) def write_data_store(slave_id, function_code, address, value): """" Set value for address. """
#!/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:
import threading import time from collections import defaultdict from socketserver import TCPServer 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 = False TCPServer.allow_reuse_address = True app = get_server(TCPServer, ('localhost', 5002), RequestHandler) @app.route(slave_ids=[1], function_codes=[1, 2, 3, 4], addresses=list(range(0, 10))) def read_data_store(slave_id, function_code, 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, function_code, address, value): """Set value for address.""" data_store[address] = value
# Enable values to be signed (default is False). conf.SIGNED_VALUES = True # Parse command line arguments parser = ArgumentParser() parser.add_argument("-b", "--bind", default="localhost:502") args = parser.parse_args() if ":" not in args.bind: args.bind += ":502" host, port = args.bind.rsplit(":", 1) port = int(port) TCPServer.allow_reuse_address = True try: app = get_server(TCPServer, (host, port), RequestHandler) except PermissionError: print("You don't have permission to bind on {}".format(args.bind)) print("Hint: try with a different port (ex: --bind localhost:50200)") exit(1) @app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(0, 10))) def read_data_store(slave_id, function_code, 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, function_code, address, value): """" Set value for address. """
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 addresss against their values. data_store = defaultdict(int) # Enable values to be signed (default is False). conf.SIGNED_VALUES = True TCPServer.allow_reuse_address = True address = "0.0.0.0" port = 502 app = get_server(TCPServer, (address, port), RequestHandler) @app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(7000, 7010))) def read_data_store(slave_id, function_code, address): """" Return value of address. """ print("read: ", address, data_store[address]) return data_store[address] @app.route(slave_ids=[1], function_codes=[6, 15], addresses=list(range(7000, 7010))) def write_data_store(slave_id, function_code, address, value):
dh_server = socketserver.TCPServer(("10.5.5.10", 7777), dhserver.Dh_Handler) dh_server.handle_request() # 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) # data_store[1] = 0 # Enable values to be signed (default is False). conf.SIGNED_VALUES = True TCPServer.allow_reuse_address = True app = get_server(TCPServer, ('10.5.5.10', 502), RequestHandler) @app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(0, 25))) def read_data_store(slave_id, function_code, address): """" Return value of address. """ return data_store[address] @app.route(slave_ids=[1], function_codes=[5, 15], addresses=list(range(0, 25))) def write_data_store(slave_id, function_code, address, value): """" Set value for address. """ data_store[address] = value # print("data_store", data_store) if __name__ == '__main__':
from umodbus.utils import log_to_stream # Add stream handler to logger 'uModbus'. log_to_stream(level=logging.DEBUG) # Extract the addresses from our default dict addresses = [r.register - 1 for r in MNS_REGISTER_TABLE] # A very simple data store which maps addresses against their values. data_store = dict(zip(addresses, range(0, len(addresses)))) # Enable values to be signed (default is False). conf.SIGNED_VALUES = True TCPServer.allow_reuse_address = True app = get_server(TCPServer, ("localhost", 54321), RequestHandler) @app.route(slave_ids=[0], function_codes=[3], addresses=addresses) def read_data_store(slave_id, function_code, address): """" Return value of address. """ return data_store[address] def serve(): try: app.serve_forever() finally: app.shutdown() app.server_close()
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()
try: from socketserver import TCPServer except ImportError: from SocketServer import TCPServer from umodbus import conf from umodbus.server.tcp import get_server, RequestHandler from tests.system import route conf.SIGNED_VALUES = True app = get_server(TCPServer, ('localhost', 0), RequestHandler) route.bind_routes(app)
api_instance = sundial.AdviceControllerApi( sundial.ApiClient(configuration, 'Authorization', f'Bearer {api_key}')) # Add stream handler to logger 'uModbus'. log_to_stream(level=logging.DEBUG) # Enable values to be signed (default is False). conf.SIGNED_VALUES = True class ThreadingServer(ThreadingMixIn, TCPServer): pass ThreadingServer.allow_reuse_address = True app = get_server(ThreadingServer, ('', port), RequestHandler) lock = Lock() # What was the last non-null recommendation Sundial provided? latest_non_null_supply_to_grid = False @cached(cache=TTLCache(maxsize=1024, ttl=10), lock=lock) def get_plant_recommendations(): datetime.utcnow().replace(tzinfo=pytz.utc) api_response = api_instance.advice_controller_get_plant_advice(plant_id) return api_response.recommendations def toSigned(n, byte_count): return int.from_bytes(n.to_bytes(byte_count, 'little'),
'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]) source_address = int(str_address[1:]) if source_type == 1: data = _read_file(config['data-file']) return int(data[source_address]) elif source_type == 2: data = _read_file(config['tibber-data-file'])
from umodbus import conf from umodbus.server.tcp import RequestHandler, get_server 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 address 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, ('0.0.0.0', 2459), RequestHandler) @app.route(slave_ids=[1], function_codes=[3, 4], addresses=list(range(0, 21))) def read_data_store(slave_id, function_code, address): return data_store[address] @app.route(slave_ids=[1], function_codes=[16], addresses=list(range(0, 21))) def write_data_store(slave_id, function_code, address, value): data_store[address] = value def initState(): data_store[1] = 1 data_store[4] = 1