public SerialChannelSimple(string portName, int baudRate, int openingTimeout)
        {
            Log.Log(".ctor called");
            _openingTimeout = openingTimeout;
            //var AJ.Std.Serial.SerialPortExtender
            Log.Log("The line before <_port = new SerialPort(portName)>");
            _port = new SerialPortStream(portName)
            {
                BaudRate     = baudRate,
                Parity       = Parity.None,
                DataBits     = 8,
                StopBits     = StopBits.One,
                ReadTimeout  = int.MaxValue,
                WriteTimeout = 500,
            };
            Log.Log("The line after <_port = new SerialPort(portName)>");
            try {
                if (_port.IsOpen)
                {
                    _port.Close();
                }
                OpenPort();
            }
            catch (Exception ex) {
                Dispose();
                Log.Log(ex.ToString());
                throw;
            }

            Log.Log("Ready to setup port_opened_watcher");
            SetUpPortOpenedWatcher();
            Log.Log(".ctor returns");
        }
        public SerialPortHandler(Controller controller)
        {
            _controller = controller;

            _relayerPortA               = new SerialPortStream();
            _relayerPortA.DataBits      = 8;
            _relayerPortA.StopBits      = StopBits.One;
            _relayerPortA.Parity        = Parity.None;
            _relayerPortA.Handshake     = Handshake.None;
            _relayerPortA.DataReceived += _relayerPortA_DataReceived;

            _relayerPortB               = new SerialPortStream();
            _relayerPortB.DataBits      = 8;
            _relayerPortB.StopBits      = StopBits.One;
            _relayerPortB.Parity        = Parity.None;
            _relayerPortB.Handshake     = Handshake.None;
            _relayerPortB.DataReceived += _relayerPortB_DataReceived;

            _snifferPortAB           = new SerialPortStream();
            _snifferPortAB.DataBits  = 8;
            _snifferPortAB.StopBits  = StopBits.One;
            _snifferPortAB.Parity    = Parity.None;
            _snifferPortAB.Handshake = Handshake.None;

            _snifferPortBA           = new SerialPortStream();
            _snifferPortBA.DataBits  = 8;
            _snifferPortBA.StopBits  = StopBits.One;
            _snifferPortBA.Parity    = Parity.None;
            _snifferPortBA.Handshake = Handshake.None;
        }
        public void SerialPortStream_Flush()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
                using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                    src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                    dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                    src.Open(); Assert.IsTrue(src.IsOpen);
                    dst.Open(); Assert.IsTrue(dst.IsOpen);

                    byte[] sdata = new byte[512];
                    for (int i = 0; i < sdata.Length; i++)
                    {
                        sdata[i] = (byte)(64 + i % 48);
                    }

                    src.Write(sdata, 0, sdata.Length);
                    //System.Threading.Thread.Sleep(10);
                    src.Flush();
                    Assert.That(src.BytesToWrite, Is.EqualTo(0));

                    src.Write(sdata, 0, sdata.Length);
                    //System.Threading.Thread.Sleep(10);
                    src.Flush();
                    Assert.That(src.BytesToWrite, Is.EqualTo(0));
                }
        }
 public void PropertyBaudRate()
 {
     using (SerialPortStream src = new SerialPortStream(SourcePort)) {
         src.BaudRate = 115200;
         Assert.That(src.BaudRate, Is.EqualTo(115200));
     }
 }
 private void Close(SerialPortStream serialPort)
 {
     // Lock the keyboard
     //this.WriteLine(serialPort, NTIXL2Commands.UnLock);
     // Stop the sound level meter
     this.WriteLine(serialPort, NTIXL2Commands.Stop);
 }
        public void SerialPortStream_WriteReadLine_CharForChar()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
                using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                    src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                    dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                    src.Open(); Assert.IsTrue(src.IsOpen);
                    dst.Open(); Assert.IsTrue(dst.IsOpen);

                    bool   err = false;
                    string s   = null;

                    const string send = "A Brief History Of Time\n";

                    for (int i = 0; i < send.Length; i++)
                    {
                        src.Write(send[i].ToString());
                        try {
                            s = dst.ReadLine();
                        } catch (System.Exception e) {
                            if (e is TimeoutException)
                            {
                                err = true;
                            }
                        }
                        if (i < send.Length - 1)
                        {
                            Assert.IsTrue(err, "No timeout exception occurred when waiting for " + send[i].ToString() + " (position " + i.ToString() + ")");
                        }
                    }
                    Assert.AreEqual("A Brief History Of Time", s);
                }
        }
        public void SerialPortStream_ReadTo_Overflow()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
                using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                    src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                    dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                    src.Open(); Assert.IsTrue(src.IsOpen);
                    dst.Open(); Assert.IsTrue(dst.IsOpen);

                    // Send 2048 ASCII characters
                    Random r     = new Random();
                    byte[] sdata = new byte[2048];
                    for (int i = 0; i < sdata.Length; i++)
                    {
                        sdata[i] = (byte)r.Next(65, 65 + 26);
                    }

                    // Wait for the data to be received
                    src.Write(sdata, 0, sdata.Length);
                    src.Write("EOF");
                    while (dst.BytesToRead < sdata.Length)
                    {
                        System.Threading.Thread.Sleep(100);
                    }

                    string result = dst.ReadTo("EOF");
                    Assert.AreEqual(0, dst.BytesToRead);
                    Assert.AreEqual(1024 - 3, result.Length);
                    int offset = sdata.Length - result.Length;
                    for (int i = 0; i < result.Length; i++)
                    {
                        Assert.AreEqual((int)sdata[offset + i], (int)result[i]);
                    }
                }
        }
        public void SerialPortStream_ListPorts()
        {
            bool result = true;

            Dictionary <string, bool> ports1 = new Dictionary <string, bool>();
            Dictionary <string, bool> ports2 = new Dictionary <string, bool>();

            foreach (PortDescription desc in SerialPortStream.GetPortDescriptions())
            {
                Trace.WriteLine("GetPortDescriptions: " + desc.Port + "; Description: " + desc.Description);
                ports1.Add(desc.Port, false);
                ports2.Add(desc.Port, false);
            }

            foreach (string c in SerialPortStream.GetPortNames())
            {
                Trace.WriteLine("GetPortNames: " + c);
                if (ports1.ContainsKey(c))
                {
                    ports1[c] = true;
                }
                else
                {
                    Trace.WriteLine("GetPortNames() shows " + c + ", but not GetPortDescriptions()");
                    result = false;
                }
            }
            foreach (string c in ports1.Keys)
            {
                if (ports1[c] == false)
                {
                    Trace.WriteLine("GetPortDescriptions() shows " + c + ", but not GetPortnames()");
                    result = false;
                }
            }

            foreach (string c in System.IO.Ports.SerialPort.GetPortNames())
            {
                Trace.WriteLine("SerialPort.GetPortNames: " + c);
                if (ports2.ContainsKey(c))
                {
                    ports2[c] = true;
                }
                else
                {
                    Trace.WriteLine("System.IO.Ports.SerialPort.GetPortNames() shows " + c + ", but not GetPortDescriptions()");
                    result = false;
                }
            }
            foreach (string c in ports1.Keys)
            {
                if (ports2[c] == false)
                {
                    Trace.WriteLine("GetPortDescriptions() shows " + c + ", but not System.IO.Ports.SerialPort.GetPortNames()");
                    result = false;
                }
            }

            Assert.IsTrue(result);
        }
        public void SerialPortStream_WriteReadLine_Multilines()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
                using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                    src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                    dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                    src.Open(); Assert.IsTrue(src.IsOpen);
                    dst.Open(); Assert.IsTrue(dst.IsOpen);

                    bool err = false;

                    string s;
                    src.Write("Line1\nLine2\n");
                    s = dst.ReadLine();
                    Assert.AreEqual("Line1", s);
                    s = dst.ReadLine();
                    Assert.AreEqual("Line2", s);

                    try {
                        s = dst.ReadLine();
                    } catch (System.Exception e) {
                        if (e is TimeoutException)
                        {
                            err = true;
                        }
                    }
                    Assert.IsTrue(err, "No timeout exception occurred");
                }
        }
        public void ReadUntilDisconnectAndReadAgainThenClose()
        {
            byte[] buffer = new byte[8192];
            using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One)) {
                serialSource.ReadBufferSize  = 8192;
                serialSource.WriteBufferSize = 8192;
                serialSource.Open();
                Thread.Sleep(100);

                int read = 0;
                while (serialSource.Read(buffer, 0, buffer.Length) > 0)
                {
                    Console.WriteLine("In Read Loop");
                    /* throw away the data */
                }

                try {
                    read = serialSource.Read(buffer, 0, buffer.Length);
                } catch (System.IO.IOException) {
                    Console.WriteLine("IOException occurred");
                }
                Console.WriteLine("Second Read: {0}", read);
                serialSource.Close();
            }
        }
示例#11
0
 private void Close()
 {
     lock (accessLock)
     {
         // Stop the Reader task
         if (reader != null)
         {
             if (!reader.Join(5000))
             {
                 readerCts.Cancel();
             }
             reader = null;
         }
         if (_serialPort != null)
         {
             _serialPort.ErrorReceived -= HandleErrorReceived;
             if (_serialPort.IsOpen)
             {
                 _serialPort.Close();
                 OnConnectionStatusChanged(new ConnectionStatusChangedEventArgs(false));
             }
             _serialPort.Dispose();
             _serialPort = null;
         }
         gotReadWriteError = true;
     }
 }
        public void ClosedWhenReadBlocked()
        {
            byte[] buffer = new byte[1024];

            using (ManualResetEvent closedEvent = new ManualResetEvent(false))
                using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One))
                    using (SerialPortStream serialDest = new SerialPortStream(DestPort, 115200, 8, Parity.None, StopBits.One)) {
                        serialSource.Open();
                        serialDest.Open();

                        new Thread(
                            () => {
                            Thread.Sleep(2000);
                            Console.WriteLine("Closing serialSource");

                            // It appears that the MSDN .NET implementation blocks here, never
                            // to return as we're blocked on another thread.
                            closedEvent.Set();
                            serialSource.Close();
                            Console.WriteLine("Closed serialSource");
                        }
                            ).Start();

                        int bytes = serialSource.Read(buffer, 0, buffer.Length);
                        Console.WriteLine("Read finished, returned {0} bytes", bytes);
                        if (!closedEvent.WaitOne(0))
                        {
                            Assert.Fail("Read returned before being disposed.");
                        }
                        Assert.That(bytes, Is.EqualTo(0));
                    }
        }
        public void DisconnectOnWriteAsyncBlocked()
        {
            byte[] buffer = new byte[8192];
            using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One))
                using (SerialPortStream serialDest = new SerialPortStream(DestPort, 115200, 8, Parity.None, StopBits.One)) {
                    serialSource.ReadBufferSize  = 8192;
                    serialSource.WriteBufferSize = 8192;
                    serialDest.ReadBufferSize    = 8192;
                    serialDest.WriteBufferSize   = 8192;
                    serialSource.Handshake       = Handshake.Rts;
                    serialSource.Open();
                    serialDest.Open();

                    serialDest.RtsEnable = false;
                    Thread.Sleep(100);

                    Assert.That(
                        () => {
                        while (true)
                        {
                            Console.WriteLine("DisconnectOnWriteAsyncBlocked BeginWrite");
                            IAsyncResult ar = serialSource.BeginWrite(buffer, 0, buffer.Length, null, null);
                            Console.WriteLine("DisconnectOnWriteAsyncBlocked EndWrite");
                            serialSource.EndWrite(ar);
                        }
                    }, Throws.InstanceOf <System.IO.IOException>());

                    // Device should still be open.
                    Assert.That(serialSource.IsOpen, Is.True);
                    serialSource.Close();
                }
        }
        private async Task <string> RunBootLoader(string nonBootLoaderPort, List <string> baselinePorts)
        {
            var port = new SerialPortStream(nonBootLoaderPort, 1200);

            port.Open();
            await Task.Delay(TimeSpan.FromSeconds(1));

            port.Close();
            int triesRemaining = 8;

            while (triesRemaining > 0)
            {
                await Task.Delay(TimeSpan.FromSeconds(1));

                var    candidates = SerialPortStream.GetPortNames().ToList();
                string candidateBootloaderPort = DetectNewPort(baselinePorts, candidates);
                if (!string.IsNullOrWhiteSpace(candidateBootloaderPort))
                {
                    return(candidateBootloaderPort);
                }
                --triesRemaining;
            }

            return(string.Empty);
        }
        public override void EstablishSync()
        {
            var ports   = SerialPortStream.GetPortNames();
            var newPort = ports.Except(originalPorts).SingleOrDefault();

            if (newPort == null)
            {
                UploaderLogger.LogErrorAndThrow(
                    string.Format(
                        "No (unambiguous) virtual COM port detected (after {0}ms).",
                        VIRTUAL_COM_CREATION_TIMEOUT));
            }

            SerialPort = new SerialPortStream
            {
                BaudRate  = 57600,
                PortName  = newPort,
                DataBits  = 8,
                Parity    = Parity.None,
                StopBits  = StopBits.One,
                Handshake = Handshake.DtrRts
            };
            try
            {
                SerialPort.Open();
            }
            catch (Exception ex)
            {
                UploaderLogger.LogErrorAndThrow(
                    string.Format("Unable to open serial port - {0}.", ex.Message));
            }
        }
示例#16
0
 public SerialPortDevice(ILogger logger, string comPath, BitRate rate)
 {
     Logger       = logger;
     this.comPath = comPath;
     this.rate    = rate;
     device       = new SerialPortStream(comPath, Convert.ToInt32(rate));
 }
        public override void Open()
        {
            var portName = serialPortConfig.PortName;
            var baudRate = serialPortConfig.BaudRate;

            logger.Info("Opening serial port {0} - baudrate {1}", serialPortConfig.PortName, serialPortConfig.BaudRate);

            SerialPort = new SerialPortStream(portName, baudRate)
            {
                ReadTimeout  = serialPortConfig.ReadTimeOut,
                WriteTimeout = serialPortConfig.WriteTimeOut,
                DtrEnable    = true // This means the Arduino will reset the moment we open the serial connection.
            };
            try
            {
                SerialPort.Open();
            }
            catch (ObjectDisposedException ex)
            {
                UploaderLogger.LogErrorAndQuit(
                    string.Format("Unable to open serial port {0} - {1}.", portName, ex.Message));
            }
            catch (InvalidOperationException ex)
            {
                UploaderLogger.LogErrorAndQuit(
                    string.Format("Unable to open serial port {0} - {1}.", portName, ex.Message));
            }
            logger.Trace("Opened serial port {0} with baud rate {1}!", portName, baudRate);
        }
示例#18
0
 public SerialPortStreamEngine()
     : base()
 {
     _serialPort = new SerialPortStream();
     //_serialPort.ErrorReceived += (_, e) => OnLogReceived(e.EventType);
     //_serialPort.PinChanged += (_, e) => OnLogReceived(e.EventType);
 }
        public void DtrDisableBeforeOpen()
        {
            SerialPortStream serial = null;

            try {
                serial = new SerialPortStream(SourcePort)
                {
                    BaudRate     = 115200,
                    DataBits     = 8,
                    Parity       = Parity.None,
                    DtrEnable    = false,
                    StopBits     = StopBits.One,
                    ReadTimeout  = -1,
                    WriteTimeout = -1
                };

                serial.Open();
                Assert.That(serial.DtrEnable, Is.False);
            } finally {
                if (serial != null)
                {
                    serial.Dispose();
                }
            }
        }
        public override void Close()
        {
            try {
                string currentPort = SerialPort.PortName;
                Logger?.Info($"Closing {currentPort}...");
                SerialPort.Close();
                Logger?.Info($"Waiting for virtual port {currentPort} to disappear...");

                const int timeoutVirtualPointDisappearance = 10000;
                const int virtualPortDisappearanceInterval = 100;
                string    result = WaitHelper.WaitFor(
                    timeoutVirtualPointDisappearance, virtualPortDisappearanceInterval,
                    () => SerialPortStream.GetPortNames().Contains(currentPort) ? null : currentPort,
                    (i, item, interval) =>
                    item == null
                            ? $"T+{i * interval} - Port still present..."
                            : $"T+{i * interval} - Port disappeared: {item}!"
                    );

                if (result == null)
                {
                    Logger?.Warn(
                        $"Virtual COM port {currentPort} was still present "
                        + "after {timeoutVirtualPointDisappearance} ms!"
                        );
                }
            }
            catch (Exception ex) {
                throw new ArduinoUploaderException($"Exception during close of the programmer: '{ex.Message}'.");
            }
        }
 public void VersionString()
 {
     using (SerialPortStream src = new SerialPortStream()) {
         Assert.That(src.Version, Is.Not.Null.Or.Empty);
         Console.WriteLine("Version: {0}", src.Version);
     }
 }
 public void DiscardOutBuffer()
 {
     using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One)) {
         serialSource.Open();
         serialSource.DiscardOutBuffer();
     }
 }
        public void SimpleConstructor()
        {
            SerialPortStream src = new SerialPortStream();

            src.Dispose();
            Assert.That(src.IsDisposed, Is.True);
        }
        public void ModemSignalsWithSleep10()
        {
            // On some chipsets (PL2303H Win7 x86), need small delays for this test case to work properly.
            using (SerialPortStream src = new SerialPortStream(SourcePort))
                using (SerialPortStream dst = new SerialPortStream(DestPort)) {
                    src.Handshake = Handshake.None;
                    dst.Handshake = Handshake.None;

                    src.Open();
                    dst.Open();

                    src.RtsEnable = false;
                    Thread.Sleep(10); // Required for PL2303H
                    Assert.That(dst.CtsHolding, Is.False);

                    src.RtsEnable = true;
                    Thread.Sleep(10); // Required for PL2303H
                    Assert.That(dst.CtsHolding, Is.True);

                    src.DtrEnable = false;
                    Thread.Sleep(10); // Required for PL2303H
                    Assert.That(dst.DsrHolding, Is.False);

                    src.DtrEnable = true;
                    Thread.Sleep(10); // Required for PL2303H
                    Assert.That(dst.DsrHolding, Is.True);
                }
        }
        private static void SetValues(Controller controller, XmlTemplate xmlTemplate)
        {
            var serialPortList = SerialPortStream.GetPortNames();

            if (serialPortList.Contains(xmlTemplate.RelayerPortAName))
            {
                controller.SerialPortHandler.SelectedRelayerPortAName = xmlTemplate.RelayerPortAName;
            }

            if (serialPortList.Contains(xmlTemplate.RelayerPortBName))
            {
                controller.SerialPortHandler.SelectedRelayerPortBName = xmlTemplate.RelayerPortBName;
            }

            if (serialPortList.Contains(xmlTemplate.SnifferPortABName))
            {
                controller.SerialPortHandler.SelectedSnifferPortABName = xmlTemplate.SnifferPortABName;
            }

            if (serialPortList.Contains(xmlTemplate.SnifferPortBAName))
            {
                controller.SerialPortHandler.SelectedSnifferPortBAName = xmlTemplate.SnifferPortBAName;
            }

            controller.SerialPortHandler.SelectedBaudRate = xmlTemplate.BaudRate;
        }
示例#26
0
        public static List <List <double> > begin_test(SerialPortStream port)
        {
            port.Open();
            Console.WriteLine("Press any button to begin");
            Console.ReadKey(true);
            port.Write("<1>");
            List <List <double> > data = new List <List <double> >();
            bool collecting_data       = true;

            while (collecting_data)
            {
                if (port.BytesToRead > 0)
                {
                    string s = port.ReadLine();
                    s = Regex.Replace(s, @"\r", string.Empty);
                    if (s == "Done")
                    {
                        collecting_data = false;
                        break;
                    }
                    string[]      message = s.Split(',');
                    List <double> temp    = new List <double>();
                    foreach (string element in message)
                    {
                        double value = Convert.ToDouble(element);
                        temp.Add(value);
                        Console.WriteLine(element);
                    }
                    data.Add(temp);
                }
            }

            return(data);
        }
 public bool Initialize()
 {
     try
     {
         header = new byte[MAGIC.Length + 3];
         Array.Copy(MAGIC, header, MAGIC.Length);
         byte hi, lo, chk;
         hi  = (byte)((LedCount - 1) >> 8);
         lo  = (byte)((LedCount - 1) & 0xff);
         chk = (byte)(hi ^ lo ^ 0x55);
         header[MAGIC.Length]     = hi;
         header[MAGIC.Length + 1] = lo;
         header[MAGIC.Length + 2] = chk;
         if (port != null)
         {
             lock (port)
             {
                 port.Dispose();
             }
         }
         port          = new SerialPortStream();
         port.PortName = SerialPort;
         port.BaudRate = Baudrate;
         port.Open();
         AssignLeds();
         isInitialized = true;
         crashed       = false;
         return(true);
     }
     catch (Exception ex)
     {
         Crash(ex, "Initialization");
         return(false);
     }
 }
        [Timeout(2000)] // We abort the test after timeout. This tests the blocking behavior in ReadAsync and the test will fail if ReadAsync blocks.
        public async Task WriteAsync()
        {
            using (var serialPortStreamWrite = new SerialPortStream("COM1", 9600, 8, Parity.None, StopBits.One))
                using (var serialPortStreamRead = new SerialPortStream("COM2", 9600, 8, Parity.None, StopBits.One))
                {
                    serialPortStreamWrite.Open();
                    serialPortStreamRead.Open();

                    var buffer   = new byte[1024];
                    var readTask = Task.Run(async() => await serialPortStreamRead.ReadAsync(buffer, 0, buffer.Length));

                    var bytes = new byte[] { 0x01, 0x02, 0x03 };
                    await serialPortStreamWrite.WriteAsync(bytes, 0, bytes.Length);

                    await serialPortStreamWrite.FlushAsync();

                    // ReadAsync blocks here even if something gets written and flushed to the underlying COM device.
                    // Fails for netcoreapp3.1, works with net472
                    await readTask;

                    Assert.That(buffer[0], Is.EqualTo(0x01));
                    Assert.That(buffer[1], Is.EqualTo(0x02));
                    Assert.That(buffer[2], Is.EqualTo(0x03));
                }
        }
示例#29
0
        static public List <List <double> > poll_for_data(SerialPortStream port, string user_input = "0")
        {
            // Send Command to Start, send it desired speed to run at
            port.Write("<1>");
            bool quick_three = true;

            while (quick_three)
            {
                if (port.BytesToRead > 0)
                {
                    string s = port.ReadLine();
                    s = Regex.Replace(s, @"\r", string.Empty);

                    // Either prompt user for input, or take in function line arugment for a desired RPM to run at
                    if (s == "give")
                    {
                        port.WriteLine(user_input);

                        quick_three = false;
                        break;
                    }
                }
            }
            bool stop = true;

            Console.WriteLine("Test Started");


            //Collect data with this loop
            List <double>         temp = new List <double>();
            List <List <double> > data = new List <List <double> >();

            while (stop)
            {
                if (port.BytesToRead > 0)
                {
                    string s = port.ReadLine();
                    s = Regex.Replace(s, @"\r", string.Empty);
                    if (s == "end")
                    {
                        stop = false;
                        break;
                    }
                    string[] message = s.Split(',');

                    //temp.Add(Convert.ToDouble(s));
                    foreach (string element in message)
                    {
                        //Console.WriteLine(element);

                        double value = Convert.ToDouble(element);
                        temp.Add(value);
                        Console.WriteLine(element);
                    }
                    data.Add(temp);
                }
            }

            return(data);
        }
示例#30
0
        internal static actionResult DestroyPort(SerialPortStream port)
        {
            var ar = new actionResult();

            if (!port.IsAlive())
            {
                ar.setError("Port already closed.");
                return(ar);
            }

            if (port == Plugin.SelectedPort)
            {
                Plugin.MainCtl.Log($"=========== {port.PortName}: log end ===========", false);
            }
            string portLongName = Plugin.OpenedPorts.First(kvp => kvp.Value == port).Key;

            Plugin.OpenedPorts.Remove(portLongName);
            if (port.IsOpen)
            {
                port.Close();
            }
            port.Dispose();
            // ReSharper disable once RedundantAssignment
            port = null;
            Plugin.MainCtl.UpdatePortsListView();
            ar.setInfo("Port closed.");
            Plugin.HostInstance.log(nameof(Serial) + ": destroyed port: " + portLongName);
            return(ar);
        }
        public void SerialPortStream_GetPortSettings()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One)) {
                src.GetPortSettings();

                SerialPortStream s2 = new SerialPortStream();
                bool err = false;
                try {
                    s2.GetPortSettings();
                } catch {
                    err = true;
                }
                Assert.IsTrue(err, "No exception raised when port not defined");
            }
        }
        public void SerialPortStream_Basic()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = 100;
                src.ReadTimeout = 100;

                Assert.IsTrue(src.CanRead);
                Assert.IsFalse(src.CanWrite);
                Assert.AreEqual(c_SourcePort, src.PortName);
                Assert.AreEqual(0, src.BytesToRead);
                Assert.AreEqual(0, src.BytesToWrite);

                src.Open();
                Assert.IsTrue(src.CanRead);
                Assert.IsTrue(src.CanWrite);
                Assert.IsTrue(src.IsOpen);

                src.Close();
                Assert.IsTrue(src.CanRead);
                Assert.IsFalse(src.CanWrite);
                Assert.IsFalse(src.IsOpen);
            }
        }
        public void SerialPortStream_WriteReadLine_MbcsByteForByte()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                src.Open(); Assert.IsTrue(src.IsOpen);
                dst.Open(); Assert.IsTrue(dst.IsOpen);

                bool err = false;
                string s = null;

                byte[] buf = new byte[] {
                0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
                0xE2, 0x82, 0xAC, 0x0A
            };

                for (int i = 0; i < buf.Length; i++) {
                    src.Write(buf, i, 1);
                    try {
                        s = dst.ReadLine();
                    } catch (System.Exception e) {
                        if (e is TimeoutException) err = true;
                    }
                    if (i < buf.Length - 1) {
                        Assert.IsTrue(err, "No timeout exception occurred when waiting for " + buf[i].ToString("X2") + " (position " + i.ToString() + ")");
                    }
                }
                Assert.AreEqual("ABCDEFGHIJ€", s);
            }
        }
        public void SerialPortStream_WriteReadLine_Timeout2()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                src.Open(); Assert.IsTrue(src.IsOpen);
                dst.Open(); Assert.IsTrue(dst.IsOpen);

                bool err = false;

                string s;
                src.Write("Test");
                try {
                    s = dst.ReadLine();
                } catch (System.Exception e) {
                    if (e is TimeoutException) err = true;
                }
                Assert.IsTrue(err, "No timeout exception occurred");

                src.WriteLine("String");
                s = dst.ReadLine();
                Assert.AreEqual("TestString", s);
            }
        }
        public void SerialPortStream_SendReceive()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                src.Open(); Assert.IsTrue(src.IsOpen);
                dst.Open(); Assert.IsTrue(dst.IsOpen);

                // Send Maximum data in one go
                byte[] sendbuf = new byte[src.WriteBufferSize];
            #if true
                Random r = new Random();
                r.NextBytes(sendbuf);
            #else
            for (int i = 0; i < sendbuf.Length; i++) {
                sendbuf[i] = (byte)((i % 77) + 1);
            }
            #endif
                src.Write(sendbuf, 0, sendbuf.Length);

                // Receive sent data
                int rcv = 0;
                int c = 0;
                byte[] rcvbuf = new byte[sendbuf.Length + 10];
                while (rcv < rcvbuf.Length) {
                    Trace.WriteLine("Begin Receive: Offset=" + rcv.ToString() + "; Count=" + (rcvbuf.Length - rcv).ToString());
                    int b = dst.Read(rcvbuf, rcv, rcvbuf.Length - rcv);
                    if (b == 0) {
                        if (c == 0) break;
                        c++;
                    } else {
                        c = 0;
                    }
                    rcv += b;
                }

                bool dump = false;
                if (rcv != sendbuf.Length) {
                    Trace.WriteLine("Read length not the same as the amount of data sent (got " + rcv.ToString() + " bytes)");
                    dump = true;
                }
                for (int i = 0; i < sendbuf.Length; i++) {
                    if (sendbuf[i] != rcvbuf[i]) {
                        Trace.WriteLine("Comparison failure at " + i.ToString());
                        dump = true;
                        break;
                    }
                }

                if (dump) {
                    Trace.WriteLine("Send Buffer DUMP");
                    for (int i = 0; i < sendbuf.Length; i++) {
                        Trace.WriteLine(sendbuf[i].ToString("X2"));
                    }

                    Trace.WriteLine("Receive Buffer DUMP");
                    for (int i = 0; i < rcv; i++) {
                        Trace.WriteLine(rcvbuf[i].ToString("X2"));
                    }
                }
                src.Close();
                dst.Close();
                Assert.IsFalse(dump, "Error in transfer");
            }
        }
        public void SerialPortStream_WriteReadLine_CharForChar()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                src.Open(); Assert.IsTrue(src.IsOpen);
                dst.Open(); Assert.IsTrue(dst.IsOpen);

                bool err = false;
                string s = null;

                const string send = "A Brief History Of Time\n";

                for (int i = 0; i < send.Length; i++) {
                    src.Write(send[i].ToString());
                    try {
                        s = dst.ReadLine();
                    } catch (System.Exception e) {
                        if (e is TimeoutException) err = true;
                    }
                    if (i < send.Length - 1) {
                        Assert.IsTrue(err, "No timeout exception occurred when waiting for " + send[i].ToString() + " (position " + i.ToString() + ")");
                    }
                }
                Assert.AreEqual("A Brief History Of Time", s);
            }
        }
        public void SerialPortStream_SendAndFlush1()
        {
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One)) {
                // Required for com0com to send the data (the remote side must receive it)
                dst.Open();

                src.Open();
                src.WriteLine("Connected");
                src.Flush();
            }
        }
        public void SerialPortStream_WriteReadLine()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                src.Open(); Assert.IsTrue(src.IsOpen);
                dst.Open(); Assert.IsTrue(dst.IsOpen);

                string s;
                src.WriteLine("TestString");
                s = dst.ReadLine();
                Assert.AreEqual("TestString", s);
            }
        }
        public void SerialPortStream_ReadTo_Normal()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                src.Open(); Assert.IsTrue(src.IsOpen);
                dst.Open(); Assert.IsTrue(dst.IsOpen);

                string s;

                src.Write("superfoobar");
                s = dst.ReadTo("foo");
                Assert.AreEqual("super", s);

                s = dst.ReadExisting();
                Assert.AreEqual("bar", s);
            }
        }
        public void SerialPortStream_SendAndFlush2()
        {
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One)) {
                // Required for com0com to send the data (the remote side must receive it)
                dst.Open();

                Trace.WriteLine("1. Open()");
                src.Open();
                Trace.WriteLine("2. WriteLine()");
                src.WriteLine("Connected");
                Trace.WriteLine("3. Sleep()");
                System.Threading.Thread.Sleep(100);
                Trace.WriteLine("4. WriteLine()");
                src.WriteLine("Disconnected");
                Trace.WriteLine("5. Flush()");
                src.Flush();
                Trace.WriteLine("6. Dispose()");
            }
        }
        public void SerialPortStream_OpenInUse()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One)) {
                src.Open();

                using (SerialPortStream s2 = new SerialPortStream(c_SourcePort, 9600, 8, Parity.None, StopBits.One)) {
                    bool err = false;
                    try {
                        s2.Open();
                    } catch {
                        err = true;
                    }
                    Assert.IsTrue(err, "Expected exception opening the port twice");
                }
            }
        }
        public void SerialPortStream_ReadTo_Overflow()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                src.Open(); Assert.IsTrue(src.IsOpen);
                dst.Open(); Assert.IsTrue(dst.IsOpen);

                // Send 2048 ASCII characters
                Random r = new Random();
                byte[] sdata = new byte[2048];
                for (int i = 0; i < sdata.Length; i++) {
                    sdata[i] = (byte)r.Next(65, 65 + 26);
                }

                // Wait for the data to be received
                src.Write(sdata, 0, sdata.Length);
                src.Write("EOF");
                while (dst.BytesToRead < sdata.Length) {
                    System.Threading.Thread.Sleep(100);
                }

                string result = dst.ReadTo("EOF");
                Assert.AreEqual(0, dst.BytesToRead);
                Assert.AreEqual(1024 - 3, result.Length);
                int offset = sdata.Length - result.Length;
                for (int i = 0; i < result.Length; i++) {
                    Assert.AreEqual((int)sdata[offset + i], (int)result[i]);
                }
            }
        }
        public void SerialPortStream_NewLine()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One)) {
                bool exception = false;
                try {
                    src.NewLine = "";
                } catch (System.ArgumentException) {
                    exception = true;
                }
                Assert.IsTrue(exception, "Expected exception when setting newline to empty string");

                exception = false;
                try {
                    src.NewLine = null;
                } catch (System.ArgumentNullException) {
                    exception = true;
                }
                Assert.IsTrue(exception, "Expected exception when setting newline to empty string");
            }
        }
        public void SerialPortStream_ReadTo_Cached()
        {
            using (SerialPortStream src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One))
            using (SerialPortStream dst = new SerialPortStream(c_DestPort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = c_Timeout; src.ReadTimeout = c_Timeout;
                dst.WriteTimeout = c_Timeout; dst.ReadTimeout = c_Timeout;
                src.Open(); Assert.IsTrue(src.IsOpen);
                dst.Open(); Assert.IsTrue(dst.IsOpen);

                bool err = false;
                string s;

                src.Write("foobar");
                try {
                    s = dst.ReadTo("baz");
                } catch (System.Exception e) {
                    if (e is TimeoutException) err = true;
                }
                Assert.IsTrue(err, "No timeout exception occurred when reading 'baz'");

                s = dst.ReadTo("foo");
                Assert.AreEqual("", s);

                s = dst.ReadTo("bar");
                Assert.AreEqual("", s);

                try {
                    s = dst.ReadTo("baz");
                } catch (System.Exception e) {
                    if (e is TimeoutException) err = true;
                }
                Assert.IsTrue(err, "No timeout exception occurred when reading 'baz' when empty");
            }
        }
        private void WriteLine(SerialPortStream serialPort, string line)
        {
            if (serialPort == null || !serialPort.IsOpen)
            {
                return;
            }

            logger.Trace("Sending \"{0}\" to NTI XL2 on port {1}", line, portName);
            serialPort.WriteLine(line);
        }
        public void SerialPortStream_OpenClose()
        {
            SerialPortStream src;
            using (src = new SerialPortStream(c_SourcePort, 115200, 8, Parity.None, StopBits.One)) {
                src.WriteTimeout = 100;
                src.ReadTimeout = 100;

                Assert.IsTrue(src.CanRead);
                Assert.IsFalse(src.CanWrite);
                Assert.IsFalse(src.IsOpen);
                Assert.IsFalse(src.IsDisposed);

                src.Open();
                Assert.IsTrue(src.CanRead);
                Assert.IsTrue(src.CanWrite);
                Assert.IsTrue(src.IsOpen);
                Assert.IsFalse(src.IsDisposed);

                src.Close();
                Assert.IsTrue(src.CanRead);
                Assert.IsFalse(src.CanWrite);
                Assert.IsFalse(src.IsOpen);
                Assert.IsFalse(src.IsDisposed);

                src.Open();
                Assert.IsTrue(src.CanRead);
                Assert.IsTrue(src.CanWrite);
                Assert.IsTrue(src.IsOpen);
                Assert.IsFalse(src.IsDisposed);

                src.Close();
                Assert.IsTrue(src.CanRead);
                Assert.IsFalse(src.CanWrite);
                Assert.IsFalse(src.IsOpen);
                Assert.IsFalse(src.IsDisposed);
            }
            Assert.IsTrue(src.IsDisposed);
        }
 private void Start(SerialPortStream serialPort)
 {
     // Rest the meter
     this.WriteLine(serialPort, NTIXL2Commands.ResetSLM);
     // Lock the keyboard
     //this.WriteLine(serialPort, NTIXL2Commands.Lock);
     // Start the loggin
     this.WriteLine(serialPort, NTIXL2Commands.StartLog);
     // Dt is between two measutments, if we don't do this will the first be -999
     this.WriteLine(serialPort, NTIXL2Commands.InitiateMeasurement);
 }
        /// <summary>
        /// Read to the line db, and disgards rest of the buffer
        /// </summary>
        /// <returns></returns>
        private string ReadToDB(SerialPortStream serialPort)
        {
            string result = string.Empty;
            // get the last line
            try
            {
                result = serialPort.ReadLine();
            }
            catch (Exception exp)
            {
                logger.Error(exp, "Failed to read the result fro NTI XL2 on port {0}", portName);
                return "-999";
            }

            logger.Trace("Read \"{0}\" from NTI XL2 on port {1}", result.Trim(), portName);

            string db = "-999";
            try
            {
                int dBindex = result.IndexOf("dB");
                if (dBindex > 0)
                {
                    db = result.Substring(0, dBindex).Trim();
                }
                else
                {
                    logger.Warn("Result did not contain the word \"dB\" as expected.");
                }
            }
            catch (Exception exp)
            {
                Console.WriteLine(exp.Message);
            }
            return db;
        }
        private bool DeviceAction(Action<SerialPortStream, CancellationToken> action)
        {
            CancellationToken token = new CancellationToken();
            DateTime start = DateTime.Now;
            var task = Task.Factory.StartNew(() =>
            {
                try
                {
                    if (serialPort == null || !serialPort.IsOpen)
                    {
                        if (serialPort != null && serialPort.IsOpen)
                        {
                            performClose();
                        }
                        
                        serialPort = new SerialPortStream(this.portName);
                        serialPort.Open();
                        Start(serialPort);
                    }

                    
                    // discard the input buffer after
                    if (serialPort.ReadBufferSize > 0)
                    {
                        try
                        {
                            serialPort.DiscardInBuffer();
                        }
                        catch (Exception exp)
                        {
                            logger.Warn(exp, "Failed to clear in buffer for NTI XL2 on port {0}", portName);
                        }
                    }
                    if (serialPort.WriteBufferSize > 0)
                    {
                        try
                        {
                            serialPort.DiscardOutBuffer();
                        }
                        catch (Exception exp)
                        {
                            logger.Warn(exp, "Failed to clear in buffer for NTI XL2 on port {0}", portName);
                        }
                    }

                    action(serialPort, token);
                    OnConnectionStatus(true);
                }
                catch (Exception exp)
                {
                    OnConnectionStatus(false);
                    logger.Error(exp, "Failed to execute NTI XL2 action on port {0}.", portName);
                    performClose();
                    return false;
                }

                return true;
            }, token);

            if (!task.Wait(this.TimeToTimeOut, token))
            {
                timeouts++;
                logger.Error("NTI XL2 device communication timed out after {0} ms.", (DateTime.Now - start).TotalMilliseconds);
                OnConnectionStatus(false);
                token = new CancellationToken();
                if (timeouts >= 2)
                {
                    timeouts = 0;
                    var closeTask = Task.Factory.StartNew(() =>
                    {
                        performClose(true);
                    }, token);
                    if (!closeTask.Wait(this.TimeToTimeOut, token))
                    {
                        logger.Trace("Time out trying to close the connection after a time out.");
                    }
                }
                return false;
            }
            return task.Result;
        }
 private void Close(SerialPortStream serialPort)
 {
     // Lock the keyboard
     //this.WriteLine(serialPort, NTIXL2Commands.UnLock);
     // Stop the sound level meter
     this.WriteLine(serialPort, NTIXL2Commands.Stop);
 }