def main(args):
# for test get the server parameters and test data from the test database
db = dbfn.db("../test.sqlite3")
q_test_params = "SELECT {cols} from test_params where id = ?"
cols = ["id","modbus_servers", "field_name"]
test_params = db.getColDict( q_test_params, cols, (args.test, ) )
#print(test_params)
q_data = "select key, value from test_data where test = ? order by seq"
test_val = db.getRowDict(q_data, (args.test, ) )
#print(test_val)
#q_limit = "select key, match_type from test_data where test = ?"
#test_limit = db.getRowDict(q_limit, (args.test, ) )
#print(test_limit)
db.close()
# based on test server parameter load the serer details from the main database
#load server details
db = dbfn.db("../db.sqlite3")
#print(params)
#db.close()
store = dict()
for s in test_params["modbus_servers"].split(","):
server = int(s)
params = db.getConnectionParams(server)
section = db.getDataFormat(server,0)
block = make_block(section, test_val, test_params)
store1 = ModbusSlaveContext(
di=ModbusSequentialDataBlock(0, [17]*100),
co=ModbusSequentialDataBlock(0, [117]*100),
hr=block,
ir=ModbusSequentialDataBlock(0, [217]*100))
store[params["unit"]] = store1
db.close()
context = ModbusServerContext(slaves=store, single=False)
#for k in store:
# print(k)
# print(context[k])
#print("CTX", context)
for s in context:
print("********************Slave", s)
identity = ModbusDeviceIdentification()
identity.VendorName = 'Pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
identity.ProductName = 'Pymodbus Server'
identity.ModelName = 'Pymodbus Server'
identity.MajorMinorRevision = '2.2.0'
print("Starting Server at:", params["port"])
StartTcpServer(context, identity=identity, address=("localhost", params["port"]))
def run(self):
db = dbfn.db("../db.sqlite3")
dest = db.getConnectionParams(self.params["connect_id"])
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
if self.global_params["debug"] == "Y":
dest['ip'] = 'localhost'
while not self.exit.is_set():
time.sleep(1)
if self.q_udp.qsize() > 0:
data = self.q_udp.get()
print("UDP Received message", len(data), self.params["name"])
#try:
#ts = time.strftime(',%Y-%m-%d %H:%M:%S,', time.localtime(time.time()))
fo = open(self.params["name"] + ".csv",'a')
msg = b'\x02' + self.global_params["site"] + b"," + data + b'\x03'
fo.write(msg.decode())
fo.write("\n")
fo.close()
if len(dest['ip']) > 0 and dest['ip'] != "0":
server_address = (dest['ip'], int(dest['port']) )
sent = 0
#sent = sock.sendto(msg, server_address)
print("Sent: to:", server_address, sent)
#finally:
# print("Done")
logging.info("udpPublisher Run loop")
# TODO should be done only in debug mode
if self.global_params["debug"] == "Y":
sent = sock.sendto(b"exit", server_address)
logging.warning("udpPublisher Exit loop")
sock.close()
return
def load_db(self):
db = dbfn.db("../db.sqlite3")
self.params = db.getParams()
for server_id in self.server_id.split(","):
self.servers[server_id] = db.getConnectionParams(server_id)
self.sections[server_id] = db.getDataFormat(server_id, 0)
if self.params["debug"] == 'Y':
self.server_ip = "localhost"
else:
self.server_ip = self.servers[server_id]["ip"]
self.server_port = self.servers[server_id]["port"]
#print("Servers",self.servers)
db.close()
for server in self.servers:
block_length = 0
sections = self.sections[server]
for s in sections:
if s[0] in ["float16", "uint16", "bit16"]:
block_length += 1
elif s[0] in ["uint32", "int32", "float32"]:
block_length += 2
elif s[0][:3] == "str":
length = int(s[1]) / 2
block_length += length
self.servers[server]["block_length"] = block_length
def __init__(self, params, q_udp, q_udp_state):
super(udpPublisher, self).__init__()
self.params = params
self.q_udp = q_udp
self.q_udp_state = q_udp_state
self.exit = multiprocessing.Event()
db = dbfn.db("../db.sqlite3")
self.global_params = db.getParams()
db.close()
self.global_params["site"] = self.global_params["site"].encode()
print("Started UDP")
print("Started UDP", self.params, self.global_params)
def __init__(self, params, q_mqtt, q_mqtt_state):
super(mqttPublisher, self).__init__()
self.params = params
self.q_mqtt = q_mqtt
self.q_mqtt_state = q_mqtt_state
self.exit = multiprocessing.Event()
db = dbfn.db("../db.sqlite3")
self.global_params = db.getParams()
self.dest = db.getConnectionParams(self.params["connect_id"])
db.close()
self.sent_time = 0
self.connected = False
print("Started MQTT", self.params["name"])
def main(args):
db = dbfn.db("../db.sqlite3")
#server_id = int(sys.argv[1])
server_id = args.server
params = db.getConnectionParams(server_id)
modbus_ip = params['ip']
modbus_port = params['port']
modbus_unit = params['unit']
query_size = params['query_size']
sections = db.getDataFormat(server_id, 0)
totl_length = 0
for s in sections:
if s[0] in ["float16", "uint16", "bit16"]:
totl_length += 1
elif s[0] in ["uint32", "int32", "float32"]:
totl_length += 2
elif s[0] == "str":
length = int(s[1]) / 2
totl_length += length
else:
print("error")
print("Total length: ", totl_length)
ctr = 0
print("Connecting to modbus:", modbus_ip, modbus_port)
client = ModbusClient(modbus_ip, port=modbus_port)
#client.connect()
print("Connected")
if args.interval is None:
query_interval = 220000
else:
query_interval = args.interval * 1000
start_timer = datetime.now()
start = 0
while (ctr < 50):
if args.decrese:
query_interval -= 200
aft = datetime.now()
#print("Previous query ", start_timer , "This time ", aft)
delay = query_interval - (aft - start_timer).microseconds
if delay > 0:
time.sleep(delay / 1000000.0)
else:
time.sleep(.001)
new_start_timer = datetime.now()
# print("Delay", delay / 1000, start_timer)
#time.sleep(0.5)
ctr += 1
#print("read registers",start, length)
if start + query_size <= totl_length:
print("query interval", new_start_timer - start_timer, totl_length,
start, query_size)
rr = client.read_holding_registers(start,
query_size,
unit=modbus_unit)
else:
print("query interval", new_start_timer - start_timer, totl_length,
start, totl_length - start)
#print("read registers",start, totl_length - start)
rr = client.read_holding_registers(start,
totl_length - start,
unit=modbus_unit)
try:
print(rr)
start_timer = new_start_timer
data = rr.registers
print(data)
except:
print("error")
#print(rr)
#print(data)
start = start + query_size
if start >= totl_length:
start = 0
#print("New Start",start)
client.close()
import socket
import sys
import dbfn
# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
db = dbfn.db("../db.sqlite3")
params = db.getParams()
dest = db.getConnectionParams(21)
server_address = (dest['ip'], int(dest['port']) )
message = b'This is the message. It will be repeated.'
try:
# Send data
print('sending ', message)
sent = sock.sendto(message, server_address)
finally:
print('closing socket')
sock.close()
def runMainProcesses():
print("runMainProcesses")
db = dbfn.db("../db.sqlite3")
params = db.getParams()
# Create modbus masters
#modbus_master_ids = [1]
opcua_server_info = db.getServers('O', params["opcua_server"].split(","))
#print("OPCUS Servers:", opcua_server_info)
mqtt_server_info = db.getServers('Q', params["mqtt_publish"].split(","))
#print("MQTT Servers:", mqtt_server_info)
udp_server_info = db.getServers('U', params["udp_publish"].split(","))
#print("UDP Servers:", udp_server_info)
db.close()
q_modbus = multiprocessing.Queue()
modbusMasteres = dict()
for client in params["modbus_servers"].split(";"):
logging.info("Creating modbusMaster %d", client)
modbusMasteres[client] = modbusMaster(q_modbus, client)
logging.info("Starting modbusMaster %d", client)
modbusMasteres[client].start()
q_mqtt = dict()
q_mqtt_state = dict()
q_udp = dict()
q_udp_state = dict()
q_opcua = dict()
q_opcua_state = dict()
servers = dict()
q_out = dict()
q_state = dict()
for si in mqtt_server_info:
print(mqtt_server_info[si]["name"])
q_mqtt[si] = multiprocessing.Queue()
q_mqtt_state[si] = multiprocessing.Queue()
servers[si] = mqtt_server_info[si]
q_out[si] = q_mqtt[si]
q_state[si] = q_mqtt_state[si]
for si in udp_server_info:
print(udp_server_info[si]["name"])
q_udp[si] = multiprocessing.Queue()
q_udp_state[si] = multiprocessing.Queue()
servers[si] = udp_server_info[si]
q_out[si] = q_udp[si]
q_state[si] = q_udp_state[si]
for si in opcua_server_info:
print(opcua_server_info[si]["name"])
q_opcua[si] = multiprocessing.Queue()
q_opcua_state[si] = multiprocessing.Queue()
servers[si] = opcua_server_info[si]
q_out[si] = q_opcua[si]
q_state[si] = q_opcua_state[si]
# Create mqttPublisher
mqttPublisherProcess = dict()
for si in mqtt_server_info:
print(mqtt_server_info[si]["name"])
logging.info("Creating mqttPublisher")
mqttPublisherProcess[si] = mqttPublisher(mqtt_server_info[si],
q_mqtt[si], q_mqtt_state[si])
logging.info("Starting mqttPublisher")
mqttPublisherProcess[si].start()
# Create udpPublisher
udpPublisherProcess = dict()
for si in udp_server_info:
print(udp_server_info[si]["name"])
logging.info("Creating udpPublisher")
udpPublisherProcess[si] = udpPublisher(udp_server_info[si], q_udp[si],
q_udp_state[si])
logging.info("Starting udpPublisher")
udpPublisherProcess[si].start()
# Create opcuaServer
opcuaServerProcess = dict()
for si in opcua_server_info:
print(opcua_server_info[si]["name"])
logging.info("Creating opcuaServer")
opcuaServerProcess[si] = opcuaServer(opcua_server_info[si],
q_opcua[si], q_opcua_state[si])
logging.info("Starting opcuaServer")
opcuaServerProcess[si].start()
# Create dataHandler
logging.info("Creating dataHandler")
dataHandlerProcess = dataHandler(params, q_modbus, servers, q_out, q_state)
logging.info("Starting dataHandler")
dataHandlerProcess.start()
# Monitor the processes
stop_processes = False
ctr = 20
while (stop_processes == False and ctr > 0):
if params["debug"] == 'Y':
print("Debug Mode")
ctr -= 1
time.sleep(1)
for client in params["modbus_servers"].split(";"):
if not modbusMasteres[client].is_alive():
logging.warning("restarting modbusMaster %d ", client)
modbusMasteres[client] = modbusMaster(q_modbus, client)
modbusMasteres[client].start()
if not dataHandlerProcess.is_alive():
logging.warning("restarting dataHandler")
dataHandlerProcess = dataHandler(q_modbus, q_opcua)
dataHandlerProcess.start()
for si in mqtt_server_info:
if not mqttPublisherProcess[si].is_alive():
logging.warning("restarting mqttPublisher")
mqttPublisherProcess[si] = mqttPublisher(
mqtt_server_info[si], q_mqtt[si], q_mqtt_state[si])
mqttPublisherProcess[si].start()
for si in udp_server_info:
if not udpPublisherProcess[si].is_alive():
logging.warning("restarting udpPublisher")
udpPublisherProcess[si] = udpPublisher(udp_server_info[si],
q_udp[si],
q_udp_state[si])
udpPublisherProcess[si].start()
for si in opcua_server_info:
if not opcuaServerProcess[si].is_alive():
logging.warning("restarting opcuaPublisher")
opcuaServerProcess[si] = opcuaServer(opcua_server_info[si],
q_opcua[si],
q_opcua_state[si])
opcuaServerProcess[si].start()
# Stop Modbus
for client in params["modbus_servers"].split(";"):
logging.info("Stopping modbusMaster: %d", client)
modbusMasteres[client].stop()
logging.info("Joining modbusMaster: %d", client)
modbusMasteres[client].join()
logging.info("Done modbusMaster: %d", client)
# Stop dataHandler
logging.info("Stopping dataHandler")
dataHandlerProcess.stop()
logging.info("Joining dataHandler")
print("joining")
dataHandlerProcess.join()
logging.info("Done dataHandler")
print("Done dataHandler")
# Stop mqttPublisher
for si in mqtt_server_info:
logging.info("Stopping mqttPublisher")
mqttPublisherProcess[si].stop()
logging.info("Joining mqttPublisher")
mqttPublisherProcess[si].join()
logging.info("Done mqttPublisher")
# Stop udpPublisher
for si in udp_server_info:
logging.info("Stopping udpPublisher")
udpPublisherProcess[si].stop()
logging.info("Joining udpPublisher")
udpPublisherProcess[si].join()
logging.info("Done udpPublisher")
# Stop opcuaServer
for si in opcua_server_info:
logging.info("Stopping opcuaServer")
opcuaServerProcess[si].stop()
logging.info("Joining opcuaServer")
opcuaServerProcess[si].join()
logging.info("Done opcuaServer")
return
def run(self):
# data handler will send complete data every time
db = dbfn.db("../db.sqlite3")
self.global_params = db.getParams()
print("**** params:", self.params)
print("**** global_params:", self.global_params)
fields = []
for s_id in self.global_params["modbus_servers"].split(","):
for s in db.getDataFormat(s_id, 0):
field_name = self.global_params["field_name"].format(source=s[4], block=s[5], field=s[6] )
fields.append(field_name)
db.close()
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
dat = dict()
col_names = []
main_obj = objects.add_object(idx, self.global_params["site"])
ems_obj = main_obj.add_object(idx, "EMS")
for s in fields:
#print("Addding OPCUA Var:", s)
col_names.append(s)
v = ems_obj.add_variable(idx, s ,0)
dat[s] = v
# TODO solve this hardcoding
dat['timestamp'] = ems_obj.add_variable(idx, 'timestamp' ,'')
v = main_obj.add_variable(idx, "JSON" ,"")
dat["JSON"] = v
server.start()
full_data = dict()
while not self.exit.is_set():
time.sleep(1)
if self.q_opcua.qsize() == 0:
time.sleep(.1)
continue
data = self.q_opcua.get()
logging.debug("OPCUA Received : %s",data)
#print("OPCUA", len(data))
for c in data:
if c in dat:
dat[c].set_value(data[c])
else:
print("Missing field in OPCUA", c)
full_data[c] = data[c]
#print("&&&&&&& full_data", full_data)
dat["JSON"].set_value(json.dumps(full_data))
logging.info("opcuaServer %d Run loop", self.params["id"])
logging.warning("opcuaServer %d Exit loop", self.params["id"])
server.stop()
return
def main(args):
# for test get the server parameters and test data from the test database
db = dbfn.db("../db.sqlite3")
test_params = db.getParams(site=args.site)
db.close()
db = dbfn.db("../test.sqlite3")
#q_test_params = "SELECT {cols} from test_params where id = ?"
#cols = ["id","modbus_servers", "field_name"]
#test_params = db.getColDict( q_test_params, cols, (args.test, ) )
#print(test_params)
q_data = "select key, value from test_data where site = ? and test = ? order by seq"
test_val = db.getRowDict(q_data, (args.site, args.test))
#print(test_val)
#q_limit = "select key, match_type from test_data where test = ?"
#test_limit = db.getRowDict(q_limit, (args.test, ) )
#print(test_limit)
db.close()
# based on test server parameter load the serer details from the main database
#load server details
db = dbfn.db("../db.sqlite3")
#print(params)
#db.close()
store = dict()
#registers = dict()
unit_map = dict()
print(test_params["modbus_servers"])
for s in test_params["modbus_servers"].split(","):
server = int(s)
params = db.getConnectionParams(server)
if params["unit"] not in unit_map:
unit_map[params["unit"]] = dict()
section = db.getDataFormat(server, 0)
registers = make_block(section, test_val, test_params,
params['start_address'])
unit_map[params["unit"]][params['start_address']] = registers
print(unit_map)
data = dict()
for u in unit_map:
for start_address in unit_map[u]:
print("Address:", u, start_address)
for x in range(len(unit_map[u][start_address])):
print(x, unit_map[u][start_address][x])
data[start_address + x + 1] = unit_map[u][start_address][x]
print(data)
block = ModbusSparseDataBlock(data)
store1 = ModbusSlaveContext(
di=ModbusSequentialDataBlock(0, [15] * 10),
co=ModbusSequentialDataBlock(0, [115] * 10),
hr=block,
ir=ModbusSequentialDataBlock(0, [215] * 10))
store[params["unit"]] = store1
db.close()
context = ModbusServerContext(slaves=store, single=False)
#for k in store:
# print(k)
# print(context[k])
#print("CTX", context)
for s in context:
print("********************Slave", s)
identity = ModbusDeviceIdentification()
identity.VendorName = 'Pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
identity.ProductName = 'Pymodbus Server'
identity.ModelName = 'Pymodbus Server'
identity.MajorMinorRevision = '2.2.0'
print("Starting Server at:", params["port"])
StartTcpServer(context,
identity=identity,
address=("localhost", params["port"]))
def main(args):
db = dbfn.db("../test.sqlite3")
q_test_params = "SELECT {cols} from test_params where id = ?"
cols = ["id", "modbus_servers", "field_name"]
test_params = db.getColDict(q_test_params, cols, (args.test, ))
#print(test_params)
q_data = "select key, value from test_data where test = ?"
test_val = db.getRowDict(q_data, (args.test, ))
q_check = "select key, match_type from test_data where test = ?"
test_check = db.getRowDict(q_check, (args.test, ))
db.close()
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
db = dbfn.db("../db.sqlite3")
#sections = dict()
#for server_id in test_params["modbus_servers"].split(","):
# sections[server_id] = db.getDataFormat(server_id, 0)
udp_server_info = db.getServers('U')
#print("UDP Servers:", udp_server_info)
for si in udp_server_info:
print(udp_server_info[si]["name"])
server = udp_server_info[si]
break
print(server["connect_id"])
dest = db.getConnectionParams(server["connect_id"])
# Bind the socket to the port
server_address = ('0.0.0.0', int(dest['port']))
print('starting up on ', server_address)
sock.bind(server_address)
while True:
print('waiting to receive message')
data, address = sock.recvfrom(int(dest["query_size"]))
d = data.decode().split(",")
if data == "exit" or len(d) == 1:
break
f = udp_server_info[si]["fields"].split(",")
print("received ", len(data), "bytes from ", address)
#print (data.decode().split(","))
error_count = 0
ok_count = 0
for x in range(len(d)):
#print("Processing field :", f[x], d[x], "Expected:", test_val[f[x]] )
if test_check[f[x]] in ["1pct", "E"]:
if abs(float(d[x]) - float(test_val[f[x]])) > abs(
float(test_val[f[x]]) / 100):
print("Mismatch Float :", f[x], d[x], test_val[f[x]],
abs(float(d[x]) - float(test_val[f[x]])),
abs(float(test_val[f[x]]) / 100))
error_count += 1
else:
ok_count += 1
elif test_check[f[x]] == "S":
if d[x] != test_val[f[x]]:
print("Strings Mismatch:", d[x], test_val[f[x]])
else:
#print(f[x], d[x], test_val[f[x]] )
if float(d[x]) != float(test_val[f[x]]):
print("Mismatch :", f[x], d[x], test_val[f[x]])
error_count += 1
else:
ok_count += 1
print("********** Message check *************")
print("Ok:", ok_count, "Error:", error_count)
