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])
