public GenericCATRadio(RadioConnectionSettings connectionSettings)
        {
            ConnectionSettings = connectionSettings;
            m_SerialPort = new SerialPort { PortName = connectionSettings.Port, BaudRate = connectionSettings.BaudRate, DtrEnable = connectionSettings.UseDTR, RtsEnable = connectionSettings.UseRTS };
            switch (connectionSettings.FlowControl)
            {
                case FlowControl.None:
                    m_SerialPort.Handshake = Handshake.None;
                    break;
                case FlowControl.DsrDtr:
                case FlowControl.RtsCts:
                    m_SerialPort.Handshake = Handshake.RequestToSend;
                    break;
                case FlowControl.XonXoff:
                    m_SerialPort.Handshake = Handshake.XOnXOff;
                    break;
            }
            m_SerialPort.Open();

            string logsFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Cloudlog\\Logs");
            if (!Directory.Exists(logsFolder))
                Directory.CreateDirectory(logsFolder);
            string logPath = Path.Combine(logsFolder, "CloudlogCAT-" + DateTime.Now.ToString("yyyy-MM-dd-hhmmss") + ".txt");
            m_LogWriter = new StreamWriter(logPath);
            m_LogWriter.AutoFlush = true;

            m_PollThread = new Thread(PollMethod);
            m_PollThread.IsBackground = true;
            m_PollThread.Start();
        }

        /// <summary>
        ///     Simple Modbus serial ASCII master read holding registers example.
        /// </summary>
        public static void ModbusSerialAsciiMasterReadRegisters()
        {
            using (SerialPort port = new SerialPort("COM1"))
            {
                // configure serial port
                port.BaudRate = 9600;
                port.DataBits = 8;
                port.Parity = Parity.None;
                port.StopBits = StopBits.One;
                port.Open();

                // create modbus master
                IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(port);

                byte slaveId = 1;
                ushort startAddress = 1;
                ushort numRegisters = 5;

                // read five registers		
                ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters);

                for (int i = 0; i < numRegisters; i++)
                    Console.WriteLine("Register {0}={1}", startAddress + i, registers[i]);
            }

            // output: 
            // Register 1=0
            // Register 2=0
            // Register 3=0
            // Register 4=0
            // Register 5=0
        }

        public NodeConnection(string PortName)
        {
            serialPort = new SerialPort(PortName, 38400);
            serialPort.DataReceived += serialPort_DataReceived;

            currentReceiverMessage = new List<byte>();
        }

        private void btniniciar_Click(object sender, EventArgs e)
        {
            MSComm = new SerialPort();
            try
            {
                MSComm.PortName = cmbpuerto.Text.ToString();
                MSComm.BaudRate = Convert.ToInt32(cmbbaudios.Text.Trim());
                MSComm.Parity = System.IO.Ports.Parity.None;
                MSComm.DataBits = 8;
                MSComm.StopBits = System.IO.Ports.StopBits.One;
                MSComm.Handshake = System.IO.Ports.Handshake.None;
                MSComm.ReceivedBytesThreshold = 1;

                MSComm.DataReceived += serialPort_DataReceived;
                MSComm.Open();
                btniniciar.Enabled = false;
                btndetener.Enabled = true;
                Cambiar_Estado(false);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            CODBAR.Focus();
        }

        public SetupDialog(Data data)
        {
            InitializeComponent();

            _data = data;
            tbHeader.Enabled = false;
            tbFooter.Enabled = false;

            if (!string.IsNullOrEmpty(data.Header))
            {
                cbHeader.Checked = true;
                tbHeader.Enabled = true;
                tbHeader.Text = data.Header;
            }

            if (!string.IsNullOrEmpty(data.Footer))
            {
                cbFooter.Checked = true;
                tbFooter.Enabled = true;
                tbFooter.Text = data.Footer;
            }

            if (!string.IsNullOrEmpty(data.PortName))
            {
                _serialPort = new SerialPort(data.PortName, data.BaudRate, data.Parity, data.DataBits, data.StopBits);
                updateSettingLabel();
                btnOkay.Enabled = true;
            }
            else
            {
                lblSettings.Text = "Not Set";
                btnOkay.Enabled = false;
            }
        }

        /// <summary>
        /// Constructor taking a SerialCommunicator object so as to allow COM settings to be
        /// implemented.
        /// </summary>
        /// <param name="communicator"></param>
        public SerialDataHandler(SerialCommunicator communicator, Rule rule, Value value)
        {
            //Create temp variable to read the required values.
            var comm = (SerialCommunicator) communicator;

            //Initialise the COM Port settings.
            _sPort = new SerialPort(comm.ComPort)
            {
                BaudRate = comm.BaudRate,
                Parity = Parity.None,
                StopBits = StopBits.One,
                DataBits = comm.DataBits,
                Handshake = Handshake.None,
                DtrEnable=comm.IsDTR,
                RtsEnable = comm.IsRTS
            };

            //Make the Value available.
            _value = value;

            //Output the data required - any instance of [val] is replaced with the actual value
            StringBuilder builder = new StringBuilder(rule.Action.OutputValue);
            builder.Replace("[val]", _value.StringValue);

            //Output the string
            OutputValue(builder.ToString());
        }

        /*
         *         public string ComPort = String.Empty;
        public int BaudRate = 110;
        public StopBits StopBits = StopBits.None;
        public int DataBits = 7;
        public Parity Parity = Parity.None;
         * */
        public BalanceReader(string comPort = "COM1", int baudRate = 9600, StopBits stopBits = StopBits.One,
            int dataBits = 7, Parity parity = Parity.Even, string sicsCommand = "SI", bool rts = false)
        {
            _sicsCommand = sicsCommand;

            if (comPort == String.Empty) comPort = "COM1";
            _port = new SerialPort
            {
                PortName = comPort,
                BaudRate = baudRate,
                StopBits = stopBits,
                DataBits = 7,
                Parity = Parity.Even,
                RtsEnable = rts
            };

            // from Page 39 of NewClassic Balances METTLER TOLEDO manual for MS-S / MS-L Models
            //_port.Handshake = Handshake.XOnXOff;

            if (_port.IsOpen == false)
            {
                try
                {
                    _port.Open();
                }
                catch (Exception)
                {
                    // port will not be open, therefore will become null
                }
            }

            _port.DataReceived += _port_DataReceived;
        }

 public LCD43()
 {
     comLcdPri = new SerialPort(SerialPorts.COM1, 115200, Parity.None, 8, StopBits.One);
     comLcdPri.DataReceived += new SerialDataReceivedEventHandler(Lcd_DataReceived);
     comLcdPri.ReadTimeout = 100;
     comLcdPri.Open();
 }

 public ArduiPort(string name, int baud, Logger logger)
 {
     _Logger = logger;
     _port = new SerialPort(name, baud);
     SetName(name);
     SetBaudRate(baud);
 }

 //        public Serial2Matlab(string port, int baudRate = 115200, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
 public Serial2Matlab()
 {
     serialPort = new SerialPort("COM43", 115200, Parity.None, 8, StopBits.One);
     serialPort.ReadTimeout = 2;
     serialPort.Open();
     serialPort.DiscardInBuffer();
 }

        public GT730FLSController(string portName)
        {
            _com = new SerialPort(portName, 38400, Parity.None, 8, StopBits.One);

            _com.ReadTimeout = READ_TIMEOUT;
            _com.Open();
        }

        public SerialPortService()
        {
            _serialPort = new SerialPort();
            setDefaultValues();

            ComIsOpen = false;
        }

        public void Init()
        {
            try
            {
                try
                {
                    if (Port != null)
                    {
                        ConsoleOutputLogger.WriteLine("[COM] COM-Port soll reinitialisiert werden - schliesse alten COM-Port.");
                        Port.Close();
                    }
                }
                catch (Exception e)
                {
                    ConsoleOutputLogger.WriteLine("[[email protected]] Beim Versuch den COM-Port zu schliessen ist ein Fehler aufgetreten.");
                    ConsoleOutputLogger.WriteLine("[[email protected]] "+e.Message);
                }

                Port = new SerialPort("COM"+Convert.ToInt32(FFN_Switcher.Properties.Settings.Default.Comport));
                Port.Open();
                ConsoleOutputLogger.WriteLine("[COM] COM-Port " + Convert.ToInt32(FFN_Switcher.Properties.Settings.Default.Comport) + " geöffnet und bereit.");
            }
            catch (Exception e)
            {
                ConsoleOutputLogger.WriteLine("[[email protected]] " + e.Message);
                ConsoleOutputLogger.WriteLine("[COM] Kann COM-Port nicht öffnen - bitte Konfiguration überprüfen.");
                Pause();
            }
        }

        private static void Main()
        {
            using (var port = new SerialPort("COM3", 9600))
            {
                _xbee = new XBeeReader(port);

                CreatePipeListener();

                while (true)
                {
                    if (Console.KeyAvailable)
                    {
                        var c = char.ToUpper(Console.ReadKey(true).KeyChar);
                        if (c == 'X') break;
                        if (c == ' ') TriggerGarageDoor(_xbee);
                    }
                    else if (_xbee.FrameAvailable)
                    {
                        var frame = _xbee.ReadFrame();

                        if (frame.FrameType == XBeeFrameType.RXIOReceived)
                            ProcessTemperatureReading(new XBeeIOFrame(frame));
                        else
                            Console.WriteLine(frame);
                    }

                    Thread.Sleep(500);
                }
            }
        }

 /// <summary>Constructor con parámetros de puerto serie
 /// </summary>
 /// <param name="portName">nombre del port (generalmente "com1")
 /// se pueden obtener los nombres disponibles usando System.IO.Ports.SerialPort.GetPortNames()</param>
 /// <param name="bauds">velocidad (generalmente 9600)</param>
 /// <param name="parity">tipo de paridad (generalmente None)</param>
 /// <param name="dataBits">bits de datos (generalmente 8)</param>
 /// <param name="stopBits">bits de parada (generalmente One)</param>
 /// <param name="info"></param>
 public SerialTextOnly(PrinterInfo info)
     : base(info)
 {
     try
     {
         commPort = new SerialPort(Name, int.Parse(info.Parameters[kBouds]), Parity.None, int.Parse(info.Parameters[kDatabits]), StopBits.One);
         IsOnLine = true;
         LastError = null;
         PaperCut = CutMode.Partial;
         PaperCutJump = 32;
         UseCrLf = false;
     }
     catch (IOException ex)
     {
         IsOnLine = false;
         LastErrorDesc = "Configuración de puerto no válida";
         LastError = ex.ToString();
     }
     catch (Exception ex)
     {
         IsOnLine = false;
         LastErrorDesc = "Error no contemplado";
         LastError = ex.ToString();
     }
 }

 /// <summary>
 /// 构造函数,可以自定义串口的初始化参数
 /// </summary>
 /// <param name="comPortName">需要操作的COM口名称</param>
 /// <param name="baudRate">COM的速度</param>
 /// <param name="parity">奇偶校验位</param>
 /// <param name="dataBits">数据长度</param>
 /// <param name="stopBits">停止位</param>
 public SerialClass(string comPortName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
 {
     _serialPort = new SerialPort(comPortName, baudRate, parity, dataBits, stopBits);
     _serialPort.RtsEnable = true;  //自动请求
     _serialPort.ReadTimeout = 3000;//超时
     setSerialPort();
 }

        public ComPort(byte number, int baudrate, byte data_bits, byte parity, byte stop_bits, ushort write_timeout, ushort read_timeout, byte attemts)
        {
            m_name = "COM" + Convert.ToString(number);
            m_baudrate = baudrate;
            m_data_bits = data_bits;
            m_parity = (Parity)parity;
            m_stop_bits = (StopBits)stop_bits;
            m_write_timeout = write_timeout;
            m_read_timeout = read_timeout;
            m_attemts = attemts;

            try
            {
                m_Port = new SerialPort(m_name, m_baudrate, m_parity, m_data_bits, m_stop_bits);

                /*ELF: для работы с elf108*/
                m_Port.DtrEnable = true;
                m_Port.RtsEnable = true;
            }
            catch (Exception ex)
            {
                #if (DEBUG)
                    WriteToLog("Create " + m_name + ": " + ex.Message);
                #endif
            }
        }

 public void init(COMServer tmpcomServer, int j)
 {
     comServer = tmpcomServer;
     while (mRun)
     {
         Console.WriteLine("new SerialPort()", Environment.NewLine);
         portnr = j;
         _serialPort = new SerialPort();
         int i = 0;
         foreach (string s in SerialPort.GetPortNames())
         {
             if (j == i)
             {
                 Console.WriteLine(s);
                 _serialPort.PortName = s;
             }
             i++;
         }
         _serialPort.ReadTimeout = 500;
         _serialPort.WriteTimeout = 500;
         _serialPort.BaudRate = 9600;
         _serialPort.Parity = (Parity)Enum.Parse(typeof(Parity), _serialPort.Parity.ToString());
         _serialPort.DataBits = int.Parse(_serialPort.DataBits.ToString());
         _serialPort.StopBits = (StopBits)Enum.Parse(typeof(StopBits), _serialPort.StopBits.ToString());
         _serialPort.Handshake = (Handshake)Enum.Parse(typeof(Handshake), _serialPort.Handshake.ToString());
         _serialPort.Open();
         _serialPort.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);
         while (_serialPort.IsOpen == true)
         {
             Thread.Sleep(50);
         }
         Console.WriteLine("closed", Environment.NewLine);
     }
     Console.WriteLine("eind init", Environment.NewLine);
 }

        private void Reading()
        {
            var currentPort = new SerialPort(_name, 115200);
            currentPort.Open();
            while (!stop)
            {
                var line = currentPort.ReadLine();
                try
                {
                    var strings = line.Replace("\r", "").Split(',');
                    var x = (int)int.Parse(strings[0]) / 16384.0F;
                    var y = (int)int.Parse(strings[1]) / 16384.0F;
                    var z = (int)int.Parse(strings[2]) / 16384.0F;
                    if (!_valuesInitialized)
                    {
                        _x = x;
                        _y = y;
                        _z = z;
                        _valuesInitialized = true;
                    }

                    _x = (_x*3 + x)/4;
                    _y = (_y*3 + y)/4;
                    _z = (_z*3 + z)/4;
                }
                catch (Exception)
                {

                }

                HasNew = true;
            }
        }

        static void Main(string[] args)
        {
            int i = 0;
            SerialPort SP = null;
            Console.WriteLine("Specify which comport you want to connect to:");
            
            foreach (string s in SerialPort.GetPortNames())
            {
                Console.WriteLine($"{i++,2} {s}");
            }
            int PortNo = int.Parse(Console.ReadLine());
            try
            {
                SP = new SerialPort(SerialPort.GetPortNames()[PortNo]);
                SP.Open();
                while(true)
                {
                    Console.Write(SP.ReadExisting());
                }
            }
            finally
            {
                if (SP.IsOpen)
                {
                    SP.Close();
                }
            }

            Console.Read();
        }