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;
}
/// <summary>
/// Creates a new ArduinoDriver instance. The relevant portname will be autodetected if possible.
/// </summary>
/// <param name="arduinoModel"></param>
/// <param name="autoBootstrap"></param>
public static async Task <ArduinoDriver> CreateAsync(ArduinoModel arduinoModel, bool autoBootstrap = false)
{
logger.Info(
"Instantiating ArduinoDriver (model {0}) with autoconfiguration of port name...",
arduinoModel);
var possiblePortNames = SerialPortStream.GetPortNames().Distinct();
string unambiguousPortName = null;
try
{
unambiguousPortName = possiblePortNames.SingleOrDefault();
}
catch (InvalidOperationException)
{
// More than one posible hit.
}
if (unambiguousPortName == null)
{
throw new IOException(
"Unable to autoconfigure ArduinoDriver port name, since there is not exactly a single "
+ "COM port available. Please use the ArduinoDriver with the named port constructor!");
}
var arduinoDriver = new ArduinoDriver();
await arduinoDriver.InitializeAsync(new ArduinoDriverConfiguration
{
ArduinoModel = arduinoModel,
PortName = unambiguousPortName,
AutoBootstrap = autoBootstrap
});
return(arduinoDriver);
}
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));
}
}
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);
}
static void Main(string[] args)
{
Console.WriteLine("Available ports:");
Console.WriteLine(String.Join(", ", SerialPortStream.GetPortNames()));
Console.WriteLine("Using first...");
Backpack pack = new Backpack(SerialPortStream.GetPortNames()[0]);
Bitmap bmp = (Bitmap)Bitmap.FromFile("/home/kevin/Downloads/unnamed.gif");
for (int i = 0; i < bmp.GetFrameCount(FrameDimension.Time); i++)
{
bmp.SelectActiveFrame(FrameDimension.Time, i);
pack.InitializeFrame();
pack.FillStrips(Color.Black);
pack.FillMatrix(bmp);
if (i == bmp.GetFrameCount(FrameDimension.Time) - 1)
{
i = 0;
}
}
Console.ReadLine();
}
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);
}
private void LoadSerialPorts()
{
foreach (var port in SerialPortStream.GetPortNames())
{
serial_ports.Items.Add(port);
}
}
public VirtualSerialPortServer(ILogger <VirtualSerialPortServer> logger)
{
_logger = logger;
this.OnLog += LogHandler;
#if DEBUG
#if LINUX
var ports = SerialPortStream.GetPortNames();
#else
var ports = System.IO.Ports.SerialPort.GetPortNames();
#endif
bool isTTY = false;
foreach (var prt in ports)
{
_Log($"Serial name: {prt}");
if (prt.Contains("ttyS0"))
{
isTTY = true;
}
}
if (!isTTY)
{
Console.WriteLine("No ttyS0 serial port!");
return;
}
#endif
}
public SerialPort(string portName, int baudRate, int timeoutMs = 250)
{
if (string.IsNullOrEmpty(portName))
{
throw new ArgumentNullException(nameof(portName));
}
if (!SerialPortStream.GetPortNames().ToList().Contains(portName))
{
throw new ArgumentException($"{portName} does not exist.");
}
if (!BaudRates.Contains(baudRate))
{
throw new ArgumentException($"Baud rate is invalid. Must be one of the following: {BaudRates.ToString().JoinStrings(",")}");
}
_serialStream = new SerialPortStream
{
PortName = portName,
BaudRate = baudRate,
DataBits = 8,
Parity = Parity.None,
StopBits = StopBits.One,
ReadTimeout = timeoutMs,
WriteTimeout = timeoutMs
};
DataReceivedObservable = DataReceived().Publish();
DataReceivedObservable.Connect();
DataSentObservable = new Subject <string>();
}
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}'.");
}
}
/// <summary>
/// Creates a new ArduinoDriver instance. The relevant port name will be auto-detected if possible.
/// </summary>
/// <param name="arduinoModel"></param>
/// <param name="autoBootstrap"></param>
public ArduinoDriver(ArduinoModel arduinoModel, bool autoBootstrap = false)
{
IEnumerable <string> possiblePortNames = SerialPortStream.GetPortNames().Distinct();
string unambiguousPortName = null;
try {
unambiguousPortName = possiblePortNames.SingleOrDefault();
}
catch (InvalidOperationException) {
// More than one possible hit.
}
if (unambiguousPortName == null)
{
throw new IOException(
"Unable to autoconfigure ArduinoDriver port name, since there is not exactly a single "
+ "COM port available. Please use the ArduinoDriver with the named port constructor!"
);
}
Initialize(
new ArduinoDriverConfiguration {
ArduinoModel = arduinoModel,
PortName = unambiguousPortName,
AutoBootstrap = autoBootstrap
}
);
}
public static string[] GetPortNames()
{
List <string> serailports = new List <string>();
serailports.AddRange(SerialPortStream.GetPortNames());
serailports.Sort();
return(serailports.ToArray());
}
public GpsDemoService(ILogger <GpsDemoService> logger, NmeaStreamReader nmeaStreamReader)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_nsr = nmeaStreamReader ?? throw new ArgumentNullException(nameof(nmeaStreamReader));
_nsr.Register(new GFDTA(), new GGA(), new GLL(), new GSA(), new GSV(), new RMC(), new VTG());
_nsr.AbortAfterUnparsedLines = 10;
_logger.LogInformation("Available Ports: {Ports}", String.Join(", ", SerialPortStream.GetPortNames()));
}
public ZWaveFramework(string port = "")
{
ZWavePortName = port;
if (string.IsNullOrEmpty(ZWavePortName))
{
ZWavePortName = SerialPortStream.GetPortNames().Last(element => element != "COM1");
}
}
protected bool IsPortValid(string port = null)
{
if (String.IsNullOrWhiteSpace(port))
{
port = PortName;
}
return(SerialPortStream.GetPortNames().Any(t => t.Equals(port, StringComparison.InvariantCultureIgnoreCase)));
}
private void RefreshPorts()
{
portSelect.Items.Clear();
portSelect.Items.Add("(none)");
foreach (string name in SerialPortStream.GetPortNames())
{
portSelect.Items.Add(name);
}
}
static void ListSerialPorts()
{
Console.WriteLine("Available serial ports:");
var names = SerialPortStream.GetPortNames();
foreach (var name in names)
{
Console.WriteLine(name);
}
}
public string SetPortName(string defaultPortName)
{
Console.WriteLine("Available Ports:");
foreach (string s in SerialPortStream.GetPortNames())
{
Console.WriteLine(" {0}", s);
}
_serialPort.PortName = defaultPortName;
return(defaultPortName);
}
static void Main(string[] args)
{
Console.WriteLine("Generic serial reader test app. Supply serial port name as argument.");
if (args.Length == 0)
{
Console.WriteLine("Available serial ports:");
var names = SerialPortStream.GetPortNames();
foreach (var name in names)
{
Console.WriteLine(name);
}
return;
}
var portName = args[0];
using (var r = new SerialReader(portName))
{
Console.WriteLine("Serial number: {0}", r.GetSerialNumber().Result);
var info = r.GetReaderInfo().Result;
Console.WriteLine("Model: {0}", info.Model);
Console.WriteLine("FirmwareVersion: {0}", info.FirmwareVersion);
Console.WriteLine("AntennaConfiguration: {0}", info.AntennaConfiguration);
Console.WriteLine("SupportedProtocols: {0}", info.SupportedProtocols);
Console.WriteLine("RFPower: {0}", info.RFPower);
Console.WriteLine("InventoryScanInterval: {0}", info.InventoryScanInterval);
Console.WriteLine("Performing inventory. Ctrl+C to stop");
var tags = new Dictionary <string, int>();
while (true)
{
try
{
var result = r.TagInventory().Result;
foreach (var tag in result.Tags)
{
tags.AddOrUpdate(tag.TagId, 1, (k, v) => v + 1);
}
Console.WriteLine($"#################################################");
foreach (var pair in tags.OrderBy(x => x.Key))
{
Console.WriteLine($"{pair.Key} {pair.Value}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
cmbPorts.Items.Clear();
cmbPorts.ItemsSource = SerialPortStream.GetPortNames();
int i = cmbPorts.Items.IndexOf(Settings.Default.PortName);
if (i > -1)
{
cmbPorts.SelectedIndex = i;
}
txtAveraging.Text = Settings.Default.Average.ToString();
txtDuration.Text = Settings.Default.AcquisitionDuration.ToString();
}
public static SerialPortStream find_ports()
{
string port_name = "COM9";
var searched_ports = SerialPortStream.GetPortNames();
var distinct_ports = searched_ports.Distinct().ToList();
if (distinct_ports.SingleOrDefault() != null)
{
port_name = distinct_ports.Single();
}
SerialPortStream port = new SerialPortStream(port_name, 115200);
return(port);
}
private static string DetectSerialPort(int baudrate, bool hdlcSendControlChar, bool ignoreUnsupportedCommands, Logger logger)
{
var ports = SerialPortStream.GetPortNames();
foreach (var port in ports)
{
if (QualcommSerialPortUtils.IsQualcommPort(port, baudrate, hdlcSendControlChar, ignoreUnsupportedCommands, logger))
{
return(port);
}
}
return(ports.FirstOrDefault());
}
public ObservableCollection <string> GetSerialPortList()
{
var serialPortList = new ObservableCollection <string>();
string[] serialPortArray = SerialPortStream.GetPortNames();
Array.Sort(serialPortArray, delegate(string a, string b) { // Sort COM port list according to "n" in "COMn"
return(int.Parse(a.Substring(3)).CompareTo(int.Parse(b.Substring(3))));
});
foreach (string s in serialPortArray)
{
serialPortList.Add(s);
}
return(serialPortList);
}
private static string DetectSerialPort(int baudrate)
{
var ports = SerialPortStream.GetPortNames();
foreach (var port in ports)
{
if (QualcommSerialPortUtils.IsQualcommPort(port, baudrate))
{
return(port);
}
}
return(ports.FirstOrDefault());
}
public AdvantechClient()
{
_stream = new SerialPortStream();
var defaultPortName = SerialPortStream.GetPortNames().FirstOrDefault();
if (defaultPortName != null)
{
_stream.PortName = defaultPortName;
}
BaudRate = 9600;
Parity = Parity.None;
StopBits = StopBits.One;
Handshake = Handshake.None;
}
protected override void Reset()
{
logger.Info("Issuing forced 1200bps reset...");
var currentPortName = SerialPort.PortName;
originalPorts = SerialPortStream.GetPortNames();
SerialPort.Close();
SerialPort = new SerialPortStream(currentPortName, 1200);
SerialPort.Open();
SerialPort.Close();
Thread.Sleep(VIRTUAL_COM_CREATION_TIMEOUT);
}
public string Find_Port_Name()
{
string _serialPortName = "COM9";
//Find Serial Port arduino is connected too
var allPortNames = SerialPortStream.GetPortNames();
var distinctPorts = allPortNames.Distinct().ToList();
// If we don't specify a COM port, automagically select one from list
if (distinctPorts.SingleOrDefault() != null)
{
_serialPortName = distinctPorts.Single();
}
return(_serialPortName);
}
/// <summary>
/// Get the available Com ports
/// </summary>
/// <param name="request"></param>
/// <param name="context"></param>
/// <returns></returns>
public override Task <ComList> RequestComList(ComListRequest request, ServerCallContext context)
{
var comList = new ComList();
try
{
var comPorts = SerialPortStream.GetPortNames();
comList.ComPort.AddRange(comPorts);
}
catch (Exception e)
{
comList.Error = ServiceHelper.BuildError(e, Fatal);
}
return(Task.FromResult <ComList>(comList));
}
public SerialPortStream Reset(SerialPortStream serialPort, SerialPortConfig config)
{
const int timeoutVirtualPortDiscovery = 10000;
const int virtualPortDiscoveryInterval = 100;
Logger?.Info("Issuing forced 1200bps reset...");
string currentPortName = serialPort.PortName;
string[] originalPorts = SerialPortStream.GetPortNames();
// Close port ...
serialPort.Close();
// And now open port at 1200 bps
serialPort = new SerialPortStream(currentPortName, 1200)
{
Handshake = Handshake.DtrRts
};
serialPort.Open();
// Close and wait for a new virtual COM port to appear ...
serialPort.Close();
string newPort = WaitHelper.WaitFor(
timeoutVirtualPortDiscovery, virtualPortDiscoveryInterval,
() => SerialPortStream.GetPortNames().Except(originalPorts).SingleOrDefault(),
(i, item, interval) =>
item == null
? $"T+{i * interval} - Port not found"
: $"T+{i * interval} - Port found: {item}"
);
if (newPort == null)
{
throw new ArduinoUploaderException($"No (unambiguous) virtual COM port detected (after {timeoutVirtualPortDiscovery}ms).");
}
return(new SerialPortStream {
BaudRate = config.BaudRate,
PortName = newPort,
DataBits = 8,
Parity = Parity.None,
StopBits = StopBits.One,
Handshake = Handshake.DtrRts
});
}
public Dictionary <string, int> GetAvailablePortsAndAutoDiscover()
{
trackers = new Dictionary <string, int>();
foreach (string portName in SerialPortStream.GetPortNames())
{
Console.WriteLine("Autodiscover port:");
Console.WriteLine(portName);
try
{
autoDiscoverPort = new SerialPortStream(portName, 115200, 8, Parity.None, StopBits.One)
{
StopBits = StopBits.One,
WriteTimeout = 1000,
ReadTimeout = 3000
};
stopWatch = new Stopwatch();
stopWatch.Start();
autoDiscoverPort.DataReceived += SerialPortAutoDiscover;
autoDiscoverPort.Open();
autoDiscoverPort.WriteLine(SerialMessageParser.Encode("DISCOVERY"));
}
catch (UnauthorizedAccessException)
{
autoDiscoverPort.Close();
}
catch (System.IO.IOException)
{
autoDiscoverPort.Close();
}
catch (TimeoutException)
{
autoDiscoverPort.Close();
}
while (autoDiscoverPort.IsOpen)
{
if (stopWatch.ElapsedMilliseconds >= 3000)
{
autoDiscoverPort.Close();
}
}
autoDiscoverPort.Dispose();
}
return(trackers);
}
