/// <summary>
/// Initialize a ComPort using the supplied parameters.
/// </summary>
/// <param name="portName">The port name to connect too.</param>
/// <param name="portParameters">The parameters to use when setting up the ComPort</param>
public ComPortBase(string portName, ComParameters portParameters)
{
_portParameters.CopyFrom(portParameters);
_serialPort.PortName = portName;
_serialPort.ReadTimeout = portParameters.TimeoutMilliseconds;
_serialPort.WriteTimeout = portParameters.TimeoutMilliseconds;
_serialPort.BaudRate = portParameters.BaudRate;
}
/// <summary>
/// Checks to see if a ComPort responds to an given command.
/// </summary>
/// <param name="portName">The ComPort to check.</param>
/// <param name="portParameters">The parameters to use when connecting to the port and checking for responce.</param>
/// <returns>ComPort if the unit responds as expected, null otherwise.</returns>
public static T CheckPort <T>(string portName, ComParameters portParameters) where T : ComPortBase
{
var serialPort = (T)Activator.CreateInstance(typeof(T), portName, portParameters);
serialPort.Connect();
if (serialPort.SendConnectionTest())
{
return(serialPort);
}
serialPort.Disconnect();
return(null);
}
/// <summary>
/// Function to connect to the first ComPort in the provided list that responds to the ComParameters correctly.
/// </summary>
/// <param name="portsToCheck">A list of ComPorts to check. Format should be "COM#".</param>
/// <param name="portParameters">The ComParameters to use when checking each port for correct responce.</param>
/// <returns>ComPort if the unit responds as expected, null otherwise.</returns>
public static T AutoConnectComPort <T>(List <string> portsToCheck, ComParameters portParameters) where T : ComPortBase
{
if (!Monitor.TryEnter(AutoConnectingLock, portParameters.MaxDelayMilliseconds))
{
return(null);
}
// storage variable for return port
T connectedPort = null;
try
{
// kick off all the checkport tasks
var portCheckTasks = portsToCheck.Where(p => p != null)
.Select(port => Task.Factory.StartNew(() => CheckPort <T>(port, portParameters)))
.Cast <Task>().ToList();
// wait allotted time for ports to connect
Task.WaitAll(portCheckTasks.ToArray(), portParameters.TimeoutMilliseconds + portParameters.MaxDelayMilliseconds);
// pull the first connected port out of the list
connectedPort = portCheckTasks.Cast <Task <T> >().FirstOrDefault(s => s.Result != null)?.Result;
// close any other ports in the list that were connected
foreach (var task in portCheckTasks.Cast <Task <T> >().Where(s => s.Result != null && s.Result != connectedPort))
{
task.Result.Disconnect();
}
}
catch (Exception ex)
{
ex.ToString();
// ignored
}
finally
{
Monitor.Exit(AutoConnectingLock);
}
// return port, will be null if no port connected
return(connectedPort);
}
/// <summary>
/// Creates a new ThreadedComPortBase object.
/// </summary>
/// <param name="threadName">The threadname to report during closing and error events.</param>
/// <param name="closingWorker">The closing worker this thread should subscribe too.</param>
/// <param name="connectionParameters">The ComParameters to use when testing connections</param>
/// <param name="mode">Which connection mode to use when selecting ComPorts to test.</param>
/// <param name="selectionRule">The selectionRule to use when mode = SelectionRule.</param>
public ThreadedComPortBase(string threadName, ClosingWorker closingWorker, ComParameters connectionParameters,
ConnectionMode mode, Func <ComPortInfo, bool> selectionRule = null) : base(threadName)
{
_threadName = threadName;
closingWorker?.AddThread(this);
ConnectionParameters.CopyFrom(connectionParameters);
// initialize the StateMachine
WorkerState = new StateDefinition();
MachineFunctions.InitializeStates(WorkerStateMachine = new StepDefinition(threadName, true, WorkerState)
{
#region StateMachine
SubSteps = new List <StepDefinition>
{
new StepDefinition("Searching")
{
Delegate = StateMachine_Searching, DelayTimeMs = 200
},
new StepDefinition("Connection Check")
{
Delegate = StateMachine_ConnectionCheck, DelayTimeMs = 200
},
new StepDefinition("Complete")
{
Delegate = StateMachine_Complete, DelayTimeMs = 200
}
}
#endregion // StateMachine
});
// set the mode for this com port
ChangeMode(mode, selectionRule);
// initialize ThreadingBase
WorkerThreads = new List <ThreadInfo>
{
new ThreadInfo(new Thread(Worker), "State Machine", threadName, WorkerStateMachine)
};
}
/// <summary>
/// Initialize a VisiLEDComPort using the supplied parameters.
/// </summary>
/// <param name="portName">The port name to connect too.</param>
/// <param name="portParameters">The parameters to use when setting up the VisiLEDComPort</param>
public VisiLEDComPort(string portName, ComParameters portParameters) : base(portName, portParameters)
{
}
/// <summary>
/// AutoConnect function called by the CVLSThreadedComPort class. A derived class can override this function
/// to return a different derived type of CVLSComPort for the connect function. This allows for extension of
/// the CVLSThreadedComPort.
/// </summary>
/// <param name="portsToCheck">Which ports to check for a connection.</param>
/// <param name="portParameters">Which parameters to use when checking ports.</param>
/// <returns></returns>
protected override ComPortBase AutoConnectComPort(List <string> portsToCheck, ComParameters portParameters)
{
return(ComPortBase.AutoConnectComPort <CVLSComPort>(portsToCheck, portParameters));
}
/// <summary>
/// Create a TelnetSocket using specific ComParameters.
/// </summary>
/// <param name="comParameters"></param>
public TelnetSocket(ComParameters comParameters)
{
ComParameters.CopyFrom(comParameters);
}
/// <summary>
/// Initialize a CVLSComPort using the supplied parameters.
/// </summary>
/// <param name="portName">The port name to connect too.</param>
/// <param name="portParameters">The parameters to use when setting up the CVLSComPort</param>
public CVLSComPort(string portName, ComParameters portParameters) : base(portName, portParameters)
{
Protocol = new LegacyProtocol(this);
ProtocolEcho = new LegacyProtocol(this, true);
}
/// <summary>
/// Initialize a KL2500LEDComPort using the supplied parameters.
/// </summary>
/// <param name="portName">The port name to connect too.</param>
/// <param name="portParameters">The parameters to use when setting up the KL2500LEDComPort</param>
public KL2500LEDComPort(string portName, ComParameters portParameters) : base(portName, portParameters)
{
Protocol = new Protocol(this);
ProtocolEcho = new Protocol(this, true);
}
/// <summary>
/// Connect function called by the ThreadedComPortBase class. A derived class can override this function
/// to return a different derived type of ComPortBase for the connect function. This allows for extension of
/// the ThreadedComPortBase.
/// </summary>
/// <param name="port">Which ports to connect too.</param>
/// <param name="portParameters">Which parameters to use when checking ports.</param>
/// <returns></returns>
protected virtual ComPortBase ConnectComPort(string port, ComParameters portParameters)
{
return(new ComPortBase(port, portParameters));
}
/// <summary>
/// AutoConnect function called by the ThreadedComPortBase class. A derived class can override this function
/// to return a different derived type of ComPortBase for the connect function. This allows for extension of
/// the ThreadedComPortBase.
/// </summary>
/// <param name="portsToCheck">Which ports to check for a connection.</param>
/// <param name="portParameters">Which parameters to use when checking ports.</param>
/// <returns></returns>
protected virtual ComPortBase AutoConnectComPort(List <string> portsToCheck, ComParameters portParameters)
{
return(ComPortBase.AutoConnectComPort <ComPortBase>(portsToCheck, portParameters));
}
