---

Config.json
{
  "KP_list": {
    "NPS_Tikh": 4842
  },
  "FS": 4000,
  "dtype": "float",
  "stype": "random",
  "hytory_len": 1000,
  "overlap": 4000,
  "CurrentTime": "ns=0;i=1100",
  "KP_structure": {
    "KT_1": {
      "hydrophone": "ns=0;i=1111",
      "pressure": "ns=0;i=1112"
    },
    "KT_2":
    {
      "hydrophone": "ns=0;i=1113",
      "pressure": "ns=0;i=1114"
    }
  }
}

























main.py
import PLC_opc_server


if __name__ == "__main__":
    Servers = PLC_opc_server.OPC_construct(debug_mode=False)
    Servers.start_srvs()










OPC_KP_point.py
import imp
from multiprocessing.spawn import import_main_path
from turtle import st
from opcua import Server, ua
import numpy as np
import datetime
import time
import collections
from threading import Thread


class OPC_KP:
    def __init__(self, name, config, debug_mode=False):
        self.name = name
        self.port = config['KP_list'][name]
        self.fs = config['FS']
        self.dtype = config['dtype']
        self.stype = config['stype']
        self.hytory_len = config["hytory_len"]
        self.KP_structure = config["KP_structure"]
        self.server_time_tag = config["CurrentTime"]
        self.overlap = int(config["overlap"])
        self.point_list = []

        self.server = Server()
        self.server.set_server_name(f'TIK-PLC {name}')
        self.server.set_endpoint(f"opc.tcp://0.0.0.0:{self.port}")
        self.addspace = self.server.register_namespace(f"OPCUA {self.name}_imit")
        # self.addspace = 0
        self.node = self.server.get_objects_node()

        self.h1_arr = collections.deque(maxlen=int(self.fs + self.overlap))
        self.h2_arr = collections.deque(maxlen=int(self.fs + self.overlap))
        self.p1_arr = collections.deque(maxlen=int(self.fs + self.overlap))
        self.p2_arr = collections.deque(maxlen=int(self.fs + self.overlap))

        self.create_three(self.KP_structure, self.node)

        self.server_time = self.node.add_variable(ua.NodeId.from_string(self.server_time_tag), "Server_status", 0)
        self.server_time.set_writable()

        if not debug_mode:
            self.server_start()

    def create_three(self, KP_structure, parent="", parent_name=''):
        for obj in KP_structure:
            if type(KP_structure) == type({}):
                param = parent.add_object(self.addspace, obj)
                self.create_three(KP_structure[obj], param, obj)
            else:

                point = parent.add_variable(ua.NodeId.from_string(KP_structure), parent_name, 0)
                point.set_writable()
                self.point_list.append(point)
                print(KP_structure)
                break

    def server_start(self):
        self.server.start()
        self.timer = 0
        for point in self.point_list:
            self.server.historize_node_data_change(point, period=datetime.timedelta(seconds=self.hytory_len),
                                                   count=0)
        tyme_var = ua.VariantType.DateTime
        var_type = ua.VariantType.Float
        if self.dtype == 'float':
            var_type = ua.VariantType.Float
        elif self.dtype == 'double':
            var_type = ua.VariantType.Double

        def h1_thr():
            h1 = np.random.random(self.fs)
            self.h1_arr.extend(h1)
            curr_arrh1 = np.array(self.h1_arr)
            self.point_list[0].set_data_value(curr_arrh1.tolist(), var_type)

        def p1_thr():
            p1 = np.random.random(self.fs) + 5
            self.p1_arr.extend(p1)
            curr_arrp1 = np.array(self.p1_arr)
            self.point_list[1].set_data_value(curr_arrp1.tolist(), var_type)

        def h2_thr():
            h2 = np.random.random(self.fs)
            self.h2_arr.extend(h2)
            curr_arrh2 = np.array(self.h2_arr)
            self.point_list[2].set_data_value(curr_arrh2.tolist(), var_type)

        def p2_thr():
            p2 = np.random.random(self.fs) + 5
            self.p2_arr.extend(p2)
            curr_arrp2 = np.array(self.p2_arr)
            self.point_list[3].set_data_value(curr_arrp2.tolist(), var_type)

        while True:
            ee = time.time()
            start_time = time.time()
            e2 = time.time()

            thr1_h = Thread(target=h1_thr)
            thr1_p = Thread(target=p1_thr)
            thr2_h = Thread(target=h2_thr)
            thr2_p = Thread(target=p2_thr)

            thr1_h.start()
            thr1_p.start()
            thr2_h.start()
            thr2_p.start()

            thr1_h.join()
            thr1_p.join()
            thr2_h.join()
            thr2_p.join()

            end_time = time.time()
            dt = (end_time - start_time)
            time.sleep(1 - dt - 0.001)

























PLC_opc_server.py
from opcua import Server, ua
from random import randint
import datetime
import time
from multiprocessing import Process
import OPC_KP_point
import json


class OPC_construct:
    def __init__(self, debug_mode=True):
        f = open('Config.json')
        config = json.loads(f.read())
        f.close()

        self.debug_mode = debug_mode
        self.KP_list = config['KP_list']
        self.procces_list = []
        self.servers_list = []

        for KP in self.KP_list:
            if not self.debug_mode:
                Proc = Process(target=OPC_KP_point.OPC_KP, args=(KP, config))
                self.procces_list.append(Proc)
            else:
                self.procces_list.append(OPC_KP_point.OPC_KP(name=KP, config=config, debug_mode=self.debug_mode))
            print(f'Created {KP}')

    def start_srvs(self):
        for proc in self.procces_list:
            if not self.debug_mode:
                proc.start()
            else:
                proc.server_start()
            print('Server started')