private async void SaveSettingss(string port, int baud, Parity parity, Handshake handshake, int dataBits, StopBits stopBits)
        {
            writing = true;
            XmlWriterSettings settings = new XmlWriterSettings { Indent = true, NewLineOnAttributes = true };
            XmlWriter writer = XmlWriter.Create("Settings.xml", settings);

            writer.WriteStartDocument();
            writer.WriteStartElement("Settings");

            writer.WriteElementString("Port", port);
            writer.WriteElementString("Baudrate", baud.ToString());
            writer.WriteElementString("Parity", parity.ToString());
            writer.WriteElementString("Handshake", handshake.ToString());
            writer.WriteElementString("Data_Bits", dataBits.ToString());
            writer.WriteElementString("Stop_Bits", stopBits.ToString());

            writer.WriteEndElement();
            writer.WriteEndDocument();
            writer.Flush();
            writer.Close();
            writing = false;
            if(!initialization)
            {
                MessageDialogResult result = await MessageService.ShowMessage("Gespeichert!", "Settings wurden gespeichert!", MessageDialogStyle.Affirmative).ConfigureAwait(false);
            }
            
        }

 public BasicInformation(string portName, int baudRate, Parity parity, StopBits stopBits, int dataBits, Handshake handShake, string serviceCenter, bool pduMode)
 { 
     this.Connector = new ATController(portName, baudRate, parity, stopBits, dataBits, handShake);
     ServiceCenter = serviceCenter;
     PDUMode = pduMode;
     this.PortName = portName;
 }

        public FrostedSerialPortStream(string portName, int baudRate, int dataBits, Parity parity, StopBits stopBits,
                bool dtrEnable, bool rtsEnable, Handshake handshake, int readTimeout, int writeTimeout,
                int readBufferSize, int writeBufferSize)
        {


			fd = open_serial(portName);
			if (fd == -1) {
				ThrowIOException ();
			}

            TryBaudRate(baudRate);

			int canSetAttributes = set_attributes (fd, baudRate, parity, dataBits, stopBits, handshake);

			if (canSetAttributes != 0)
			{
				throw new IOException(canSetAttributes.ToString()); // Probably Win32Exc for compatibility
			}

            read_timeout = readTimeout;
            write_timeout = writeTimeout;

            SetSignal(SerialSignal.Dtr, dtrEnable);

            if (handshake != Handshake.RequestToSend &&
                    handshake != Handshake.RequestToSendXOnXOff)
                SetSignal(SerialSignal.Rts, rtsEnable);
        }

 public RS232Config(int baudrate, int dataBits, Parity p, StopBits s, Handshake h, string t)
 {
     Baudrate = baudrate;
     DataBits = dataBits;
     Parity = p;
     StopBits = s;
     Handshake = h;
     Terminator = t;
 }

 public XSerialParameter(string portName, int baudRate, Parity parity, 
     int dataBits, StopBits stopBits, Handshake handShake)
 {
     PortName = portName;
     Baudrate = baudRate;
     Parity = parity;
     DataBits = DataBits;
     StopBits = stopBits;
     Handshake = handShake;
 }

 public ConnectionParameters(string portName, int baudRate, int dataBitsCount, Parity parity, Handshake handshakeType, StopBits stopBitsType, EndMarker endMarker)
 {
     PortName = portName;
     BaudRate = baudRate;
     DataBits = dataBitsCount;
     Parity = parity;
     Handshake = handshakeType;
     StopBits = stopBitsType;
     EndMarker = endMarker;
 }

        public WinSerialStream (string port_name, int baud_rate, int data_bits, Parity parity, StopBits sb,
                bool dtr_enable, bool rts_enable, Handshake hs, int read_timeout, int write_timeout,
                int read_buffer_size, int write_buffer_size)
        {
            handle = CreateFile (port_name != null && !port_name.StartsWith(@"\\.\")
                    ? @"\\.\" + port_name : port_name,
                    GenericRead | GenericWrite, 0, 0, OpenExisting,
                    FileFlagOverlapped, 0);

            if (handle == -1)
                ReportIOError (port_name);

            // Set port low level attributes
            SetAttributes (baud_rate, parity, data_bits, sb, hs);

            // Clean buffers and set sizes
            if (!PurgeComm (handle, PurgeRxClear | PurgeTxClear) ||
                    !SetupComm (handle, read_buffer_size, write_buffer_size))
                ReportIOError (null);

            // Set timeouts
            this.read_timeout = read_timeout;
            this.write_timeout = write_timeout;
            timeouts = new Timeouts (read_timeout, write_timeout);
            if (!SetCommTimeouts(handle, timeouts))
                ReportIOError (null);

            /// Set DTR and RTS
            SetSignal(SerialSignal.Dtr, dtr_enable);

            if (hs != Handshake.RequestToSend &&
                    hs != Handshake.RequestToSendXOnXOff)
                SetSignal(SerialSignal.Rts, rts_enable);

            // Init overlapped structures
            NativeOverlapped wo = new NativeOverlapped ();
            write_event = new ManualResetEvent (false);
#if NET_2_0
            wo.EventHandle = write_event.Handle;
#else
            wo.EventHandle = (int) write_event.Handle;
#endif
            write_overlapped = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (NativeOverlapped)));
            Marshal.StructureToPtr (wo, write_overlapped, true);

            NativeOverlapped ro = new NativeOverlapped ();
            read_event = new ManualResetEvent (false);
#if NET_2_0
            ro.EventHandle = read_event.Handle;
#else
            ro.EventHandle = (int) read_event.Handle;
#endif
            read_overlapped = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (NativeOverlapped)));
            Marshal.StructureToPtr (ro, read_overlapped, true);
        }

 /// <summary>
 /// Initializes a new instance of the SerialCommunication class using the specified serial port name.
 ///  A connection is not established until Open() or StartMonitoring() is called.
 /// </summary>
 /// <param name="serialPortName">The serial port to use (for example, COM1).</param>
 /// <param name="baudRate">The baud rate.</param>
 /// <param name="parity">One of the Parity values.</param>
 /// <param name="dataBits">The data bits value. Usually 8.</param>
 /// <param name="stopBits">One of the StopBits values. Usually 1.</param>
 /// <param name="handShake">The handshake protocol. Usually none.</param>
 public SerialCommunication(string serialPortName, int baudRate, Parity parity, int dataBits, StopBits stopBits, Handshake handShake, bool dtrEnable, bool rtsEnable)
 {
     _serialPortName = serialPortName;
     _baudRate = baudRate;
     _parity = parity;
     _dataBits = dataBits;
     _stopBits = stopBits;
     _handShake = handShake;
     _dtrEnable = dtrEnable;
     _rtsEnable = rtsEnable;
 }

 public static int ToInt(Handshake hs)
 {
     switch (hs)
     {
         case Handshake.None: return 0;
         case Handshake.XOnXOff: return 1;
         case Handshake.RequestToSend: return 2;
         case Handshake.RequestToSendXOnXOff: return 3;
     }
     return 0;
 }

 public static string ToString(Handshake hs)
 {
     switch (hs)
     {
         case Handshake.None: return "None";
         case Handshake.XOnXOff: return "XOnXOff";
         case Handshake.RequestToSend: return "RequestToSend";
         case Handshake.RequestToSendXOnXOff: return "RequestToSendXOnXOff";
     }
     return "None";
 }

 internal Configuration(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
 {
     PortIndex = System.IO.Ports.SerialPortName.ConvertNameToIndex(portName);
     Speed = baudRate;
     Parity = parity;
     DataBits = dataBits;
     StopBits = stopBits;
     Handshake = Handshake.None;
     ReadTimeout = Timeout.Infinite;
     WriteTimeout = Timeout.Infinite;
 }

        public SerialPortDriver(int baudRate , int dataBits ,StopBits stopBits, Parity parity , Handshake handShake)
        {
            BaudRate = baudRate;
            DataBits = dataBits;
            StopBits = stopBits;
            Parity = parity;
            Handshake = handShake;

            sleepOnWrite = int.Parse(ConfigurationSettings.AppSettings["SleepOnWrite"]);
            ReadTimeout = 10000;
            WriteTimeout = 10000;
        }

        public bool Load(XmlHelper xh, XmlNode parent)  // use new xml system -SHS
        {
            XmlNode cps = xh.FindSection(parent, "ComPortSettings");
            comname = xh.GetString(cps, "PortName", "Com1");
            speed = xh.GetInt(cps, "Speed", 115200);
            databits = xh.GetInt(cps, "Databits", 8);
            parity = (Parity)xh.GetEnum(cps, "Parity", typeof(Parity), Parity.None);
            stopbits = (StopBits)xh.GetEnum(cps, "Stopbits", typeof(StopBits), StopBits.One);
            handshake = (Handshake)xh.GetEnum(cps, "Handshake", typeof(Handshake), Handshake.None);
            return true;

        }

 private void InitPortProperties(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits,
                                 Handshake handshake, int readTimeout, int writeTimeout){
     _serialPort.Encoding = Encoding.ASCII;
     _serialPort.DataReceived += _serialPort_DataReceived;
     _serialPort.PortName = portName;
     _serialPort.BaudRate = baudRate;
     _serialPort.Parity = parity;
     _serialPort.DataBits = dataBits;
     _serialPort.StopBits = stopBits;
     _serialPort.Handshake = handshake;
     _serialPort.ReadTimeout = readTimeout;
     _serialPort.WriteTimeout = writeTimeout;
 }

 static SerialPortConfig()
 {
     config = new ConfigUtil("Base", @"Ini\serial_port.ini");
     servicePort = config.Get("ServicePort");
     zigBeeId = config.Get("ZigBeeId");
     portName = config.Get("PortName");
     portBaudRate = int.Parse(config.Get("BaudRate"));
     portParity = (Parity)int.Parse(config.Get("Parity"));
     dataBits = int.Parse(config.Get("DataBits"));
     portStopBits = (StopBits)int.Parse(config.Get("StopBits"));
     portHandshake = (Handshake)int.Parse(config.Get("Handshake"));
     readTimeout = int.Parse(config.Get("ReadTimeout"));
     writeTimeout = int.Parse(config.Get("WriteTimeout"));
 }

        private void Init(string portName, int baudRate, Parity parity, StopBits stopBits, int dataBits, Handshake handShake)
        {
            
            base.driver.ReadTimeout = 500;
            base.driver.WriteTimeout = 500;
            
            base.driver.ErrorReceived += driver_ErrorReceived;

            //receiveResponse = true;
            encode = new System.Text.UTF8Encoding(); 
            response = new StringBuilder();
            dataReceived = new StringBuilder();
            waitResponse = new AutoResetEvent(false); 
        }

 public MyCOMPortClass(String name, int baud, Parity parity, int bits, StopBits stop, Handshake hand)
 {
     comport = new SerialPort();
     val = new Queue<Int32>();
     log = new List<String>();
     // Set port parameters
     comport.PortName = name; //SetPortName (comport.PortName);
     comport.BaudRate = (int)SetPortBaudRate(baud);
     comport.Parity = SetPortParity(parity);
     comport.DataBits = SetPortDataBit(bits);
     comport.StopBits = SetPortStopBits(stop);
     comport.Handshake = SetPortHandshake(hand);
     // Set up timeouts
     comport.ReadTimeout = 500;
     comport.WriteTimeout = 500;
 }

        public AccessCardReader(string comport,
            int baudrate = 9600,
            Parity parity = Parity.None,
            StopBits stopbits = StopBits.One,
            int databits = 8,
            Handshake handshake = Handshake.None)
        {
            _sPort = new SerialPort(comport);

            _sPort.BaudRate = baudrate;
            _sPort.Parity = parity;
            _sPort.StopBits = stopbits;
            _sPort.DataBits = databits;
            _sPort.Handshake = handshake;

            _sPort.DataReceived += new SerialDataReceivedEventHandler(DataReceviedHandler);
        }

        public SerialStream(GenThreadManagement.GenThreadManager genThreadManager, SystemServices systemServices, String portName, int baudRate = 57600, Parity parity = Parity.None,
            int dataBits = 8, StopBits stopBits = StopBits.One, Handshake handshake = Handshake.None, int readTimeout = 3000, int writeTimeout = 20000)
            : base(genThreadManager, systemServices)
        {
            SerialPort = new SerialPort();
            PortName = portName;
            BaudRate = baudRate;
            DataBits = dataBits;
            StopBits = stopBits;
            Parity = parity;
            Handshake = handshake;
            ReadTimeout = readTimeout;
            WriteTimeout = writeTimeout;
            IsOpen = false;

            ConfigurePort();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="COM_Device" /> class.
        /// </summary>
        /// <param name="name">The serial port name.</param>
        /// <param name="baudrate">The serial port baudrate.</param>
        /// <param name="databits">The serial port databits.</param>
        /// <param name="parity">The serial port parity.</param>
        /// <param name="stopbits">The serial port stopbits.</param>
        /// <param name="handshake">The serial port handshake.</param>
        /// <param   name="isArduino">if set to <c>true</c> [is arduino] configures the Serial port accordingly.</param>
        public COM_Device(string name, int baudrate, int databits, Parity parity, StopBits stopbits, Handshake handshake, bool isArduino)
        {
            try
            {
                //  Create the serial port object
                _com = new SerialPort(name, baudrate, parity, databits, stopbits);
                //  Set-up the serial port parameters passed to the function
                _name = name;
                _databits = databits;
                _baudrate = baudrate;
                _stopbits = stopbits;
                _parity = parity;
                _com.Handshake = handshake;
                _handshake = handshake;
                //
                //  If it is an Arduino micro-controller, the USB driver needs to control DTS/RTS
                if (isArduino)
                {
                    _com.DtrEnable = true;
                    _com.RtsEnable = true;
                }
                //  Set-up the Read/Write timeouts
                _com.ReadTimeout = 5000;
                _com.WriteTimeout = 500;
                //  Defines the Serial Port received data Handler
                _com.DataReceived += new SerialDataReceivedEventHandler(RXHandler);
                //  Opens the Serial port
                _com.Open();

                //  Set-up a timer used as Timeout when connecting the device
                timeOut = new Timer();
                timeOut.Interval = 5000;
                timeOut.AutoReset = false;
                timeOut.Elapsed += new ElapsedEventHandler(timeOut_Elapsed);

                // Initialize the Queue storing the data received from the Serial Port
                datain = new Queue<string>();
            }
            catch (Exception ex)
            {
                // throw the exception
                throw ex;
            }
        }