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
