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)