public void InitializeService(Channel ch)
        {
            try
            {
                lock (this)
                {
                    Channels.Add(ch);



                    if (Channels == null)
                    {
                        return;
                    }
                    // Initialize


                    #region XGT.

                    IPLC_LS_Master PLC_LS = null;
                    switch (ch.ConnectionType)
                    {
                    case "SerialPort":
                        var dis = (DISerialPort)ch;
                        var sp  = new SerialPort(dis.PortName, dis.BaudRate, dis.Parity, dis.DataBits, dis.StopBits);
                        sp.Handshake = dis.Handshake;
                        var spAdaper = new SerialPortAdapter(sp);
                        PLC_LS = new LS_CNET();
                        PLC_LS.AllSerialPortAdapter(spAdaper);
                        _cnet.Add(ch.ChannelName, (LS_CNET)PLC_LS);
                        break;

                    case "Ethernet":
                        var die = (DIEthernet)ch;
                        PLC_LS = new LS_FENET(die.IPAddress, die.Port, 500);
                        FENET.Add(ch.ChannelName, (LS_FENET)PLC_LS);
                        break;
                    }

                    #endregion Initialize

                    foreach (var dv in ch.Devices)
                    {
                        foreach (var db in dv.DataBlocks)
                        {
                            foreach (var tg in db.Tags)
                            {
                                TagCollection.Tags.Add(
                                    $"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}.{tg.TagName}", tg);
                            }
                        }
                    }
                }
            }
            catch (CommunicationException ex)
            {
                EventscadaException?.Invoke(this.GetType().Name, ex.Message);
            }
        }
        public void InitializeService(List <Channel> chns)
        {
            try
            {
                //===============================================================
                mbe   = new Dictionary <string, ModbusTCPMaster>();
                rtu   = new Dictionary <string, ModbusRTUMaster>();
                ascii = new Dictionary <string, ModbusASCIIMaster>();
                //==================================================================
                cnet  = new Dictionary <string, LS_CNET>();
                FENET = new Dictionary <string, LS_FENET>();
                //=================================================================
                Panasonic = new Dictionary <string, PanasonicSerialReader>();
                //==================================================================
                _PLCS7  = new Dictionary <string, SiemensNet>();
                _PLCPPI = new Dictionary <string, SiemensComPPI>();
                //  ===============================================================
                Channels = chns;
                if (Channels == null)
                {
                    return;
                }
                foreach (Channel ch in Channels)
                {
                    IDriverAdapter DriverAdapter = null;

                    foreach (var dv in ch.Devices)
                    {
                        switch (ch.ConnectionType)
                        {
                        case "SerialPort":
                            var dis = (DISerialPort)ch;
                            var sp  = new SerialPort(dis.PortName, dis.BaudRate, dis.Parity, dis.DataBits, dis.StopBits);
                            sp.Handshake = dis.Handshake;
                            switch (ch.ChannelTypes)
                            {
                            case "Modbus":
                                switch (dis.Mode)
                                {
                                case "RTU":
                                    DriverAdapter = new ModbusRTUMaster(dv.SlaveId, sp);

                                    rtu.Add(ch.ChannelName, (ModbusRTUMaster)DriverAdapter);
                                    break;

                                case "ASCII":
                                    DriverAdapter = new ModbusASCIIMaster(dv.SlaveId, sp);

                                    ascii.Add(ch.ChannelName, (ModbusASCIIMaster)DriverAdapter);
                                    break;
                                }
                                break;

                            case "LSIS":
                                DriverAdapter = new LS_CNET(dv.SlaveId, sp);
                                cnet.Add(ch.ChannelName, (LS_CNET)DriverAdapter);
                                break;

                            case "Panasonic":
                                DriverAdapter = new PanasonicSerialReader(dv.SlaveId, sp);
                                Panasonic.Add(ch.ChannelName, (PanasonicSerialReader)DriverAdapter);
                                break;

                            case "Siemens":
                                DriverAdapter = new SiemensComPPI(dv.SlaveId, sp);
                                _PLCPPI.Add(ch.ChannelName, (SiemensComPPI)DriverAdapter);
                                break;

                            default:
                                break;
                            }
                            break;

                        case "Ethernet":
                            var die = (DIEthernet)ch;
                            switch (ch.ChannelTypes)
                            {
                            case "Modbus":

                                DriverAdapter = new ModbusTCPMaster(dv.SlaveId, die.IPAddress, die.Port);
                                mbe.Add(ch.ChannelName, (ModbusTCPMaster)DriverAdapter);
                                break;

                            case "LSIS":

                                DriverAdapter = new LS_FENET(die.IPAddress, die.Port, die.Slot);
                                FENET.Add(ch.ChannelName, (LS_FENET)DriverAdapter);
                                break;

                            case "Panasonic":
                                break;

                            case "Siemens":
                                var cpu = (SiemensPLCS)Enum.Parse(typeof(SiemensPLCS), die.CPU);
                                DriverAdapter = new SiemensNet(cpu, die.IPAddress, (short)die.Rack, (short)die.Slot);
                                _PLCS7.Add(ch.ChannelName, (SiemensNet)DriverAdapter);
                                break;

                            default:
                                break;
                            }
                            break;
                        }

                        foreach (var db in dv.DataBlocks)
                        {
                            foreach (var tg in db.Tags)
                            {
                                TagCollection.Tags.Add(
                                    $"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}.{tg.TagName}", tg);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                EventscadaException?.Invoke(this.GetType().Name, ex.Message);
            }
        }
        public void InitializeService(Channel ch)
        {
            try
            {
                //=================================================================

                if (Channels == null)
                {
                    return;
                }

                Channels.Add(ch);


                IDriverAdapter DriverAdapter = null;
                foreach (Device dv in ch.Devices)
                {
                    try
                    {
                        switch (ch.ConnectionType)
                        {
                        case "SerialPort":
                            DISerialPort dis = (DISerialPort)ch;
                            SerialPort   sp  = new SerialPort(dis.PortName, dis.BaudRate, dis.Parity, dis.DataBits, dis.StopBits)
                            {
                                Handshake = dis.Handshake
                            };

                            DriverAdapter = new LS_CNET(dv.SlaveId, sp);
                            cnet.Add(ch.ChannelName, (LS_CNET)DriverAdapter);
                            break;

                        case "Ethernet":
                            DIEthernet die = (DIEthernet)ch;

                            DriverAdapter = new LS_FENET(die.CPU, die.IPAddress, die.Port, (byte)die.Slot);
                            FENET.Add(ch.ChannelName, (LS_FENET)DriverAdapter);

                            break;
                        }
                    }
                    catch (Exception ex)
                    {
                        EventscadaException?.Invoke(GetType().Name, ex.Message);
                    }
                    foreach (DataBlock db in dv.DataBlocks)
                    {
                        DataBlockCollection.DataBlocks.Add($"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}", db);
                        foreach (Tag tg in db.Tags)
                        {
                            TagCollection.Tags.Add(
                                $"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}.{tg.TagName}", tg);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                EventscadaException?.Invoke(GetType().Name, ex.Message);
            }
        }