private bool DetectBaudRate()
{
//Try with 9600 default value
_port.Open();
if (TrySendReceive())
{
return(true);
}
_port.ClearReceiveBuffer();
_port.Close();
//Try all known baud rates in descending order
foreach (int key in BaudLookup.Keys.Reverse())
{
_port.BaudRate = key;
_port.Open();
if (TrySendReceive())
{
return(true);
}
_port.ClearReceiveBuffer();
_port.Close();
}
return(false);
}
/// <summary>
/// Connect to the Arduino serial port
/// </summary>
/// <param name="portName">e.g. Com1</param>
public async Task ConnectAsync(string portName)
{
await Task.Delay(0); // avoid CS1998
Logger?.LogTrace($@"Connect: {portName}");
// Create a new SerialPort object with default settings.
Aborted = false;
SetupCom(portName);
_serialPortCancellationTokenSource = new CancellationTokenSource();
_serialPort.Open();
_readThread = new Thread(Read);
_writeThread = new Thread(Write);
_readThread.Start();
_writeThread.Start();
// we need Dtr if not used as Reset
// otherwise reset if dtr is set
if (!DtrIsReset || ResetOnConnect)
{
_serialPort.DtrEnable = true;
}
else
{
_serialPort.DiscardOutBuffer();
_serialPort.WriteLine("");
}
// _serialPort.DtrEnable = true;
_serialPort.RtsEnable = true;
bool wasEmpty;
lock (_pendingCommands)
{
wasEmpty = _pendingCommands.Count == 0;
_pendingCommands.Clear();
}
lock (_commands)
{
_commands.Clear();
}
if (!wasEmpty)
{
OnCommandQueueChanged(new SerialEventArgs(0, null));
}
OnCommandQueueEmpty(new SerialEventArgs(0, null));
}
public ISerialPort OpenPort(string portName, int baudRate,
int dataBits, int readTimeout, int writeTimeout)
{
try
{
_serialPort.PortName = portName; //COM1
_serialPort.BaudRate = baudRate; //9600
_serialPort.DataBits = dataBits; //8
_serialPort.Parity = Parity.None; //None
_serialPort.StopBits = StopBits.One; //1
_serialPort.ReadTimeout = readTimeout; //300
_serialPort.WriteTimeout = writeTimeout; //300
_serialPort.Encoding = Encoding.GetEncoding("iso-8859-1");
_serialPort.DataReceived += new SerialDataReceivedEventHandler(port_DataReceived);
_serialPort.Open();
_serialPort.DtrEnable = true;
_serialPort.RtsEnable = true;
}
catch (Exception ex)
{
throw ex;
}
return(_serialPort); // Why???
}
public Vc0706(IIODevice device, SerialPortName portName, int baud)
{
serialPort = device.CreateSerialPort(portName, baud);
/*serialPort = device.CreateSerialMessagePort(
* portName: portName,
* suffixDelimiter: Encoding.ASCII.GetBytes("\r\n"),
* baudRate: baud,
* preserveDelimiter: true,
* readBufferSize: 512);*/
serialPort.Open();
switch (baud)
{
case 9600:
default:
SetBaud9600();
break;
case 19200:
SetBaud19200();
break;
case 38400:
SetBaud38400();
break;
case 57600:
SetBaud57600();
break;
}
}
public void ReadJson()
{
try
{
serialPort.Open();
if (serial.GetPort().IsOpen)
{
var result = json.ReadJson(serialPort);
Console.WriteLine(result.SensNr);
Console.WriteLine(result.InstNr);
Console.WriteLine(result.BRet);
/*for (int i = 0; i < json.Data.Count; i++)
* {
* Console.WriteLine(result.Data[i]);
* }*/
Console.WriteLine(result.Data[0]);
Console.WriteLine(result.Data[1]);
}
}
finally
{
serialPort.Close();
}
}
private bool OpenSerialPort()
{
if (Output == "SerialPortMock")
{
m_serialport = MockSerialPort.Instance;
}
else
{
m_serialport = (ISerialPort) new CSerialPort();
}
bool opened = m_serialport.Open(Output, Rate);
if (m_serialport.HasError())
{
Util.LogError($"{Name}: {m_serialport.GetError()}");
if (opened)
{
Util.Log($"{Name}: {Output} had a non fatal error, it might still work, continuing");
}
}
m_serialport.PrintToStdOut(m_debug); //print serial data to stdout when debug mode is on
return(opened);
}
/// <summary>
/// Try to open the serial port.
/// </summary>
private async void TriggerOpenConnection(ISerialPort serialPort)
{
this.Log(LoggingMessageType.Info, "Serial Port communication started");
var opened = false;
var connectionErrorCount = 0;
while ((!opened) && (_serialPort == serialPort))
{
try
{
serialPort.Open();
opened = true;
connectionErrorCount = 0;
_lastConnectTimestampUtc = DateTime.UtcNow;
this.Log(
LoggingMessageType.Info,
StringBuffer.Format("Successfully connected to port {0}", _portName));
}
catch (Exception ex)
{
this.Log(
LoggingMessageType.Error,
StringBuffer.Format("Error while connecting to port {0}: {1}", _portName, ex.Message),
exception: ex);
connectionErrorCount++;
await Task.Delay(this.ReconnectWaitTimeGetter.GetWaitTime(connectionErrorCount));
}
}
}
private void OpenSerialPort(bool isUnitTest)
{
try
{
if (isUnitTest)
{
serialPort = new TestSerialPort();
}
else
{
serialPort = new SerialPortImpl();
}
serialPort.Open("COM" + Properties.Settings.Default.ComPort, 115200);
AddInfo("Opened COM" + Properties.Settings.Default.ComPort);
stopReading = false;
if (!isUnitTest)
{
serialInputWorker = new BackgroundWorker();
serialInputWorker.DoWork += SerialInputWorker_DoWork;
serialInputWorker.RunWorkerAsync();
startToolStripMenuItem.Text = "Stop";
}
}
catch (Exception ex)
{
AddInfo("Failed to open COM" + Properties.Settings.Default.ComPort + ": " + ex.Message);
}
}
public void Open()
{
Port.Open();
_portReadTask.Start();
_processEventsTask.Start();
_transmitTask.Start();
}
/// <summary>
/// Open the hardware interface.
/// </summary>
public bool Open()
{
bool success = false;
//
try
{
//if (Environment.OSVersion.Platform.ToString().StartsWith("Win") == false)
if (!System.IO.File.Exists(portName))
{
logger.Error("port does not exist :" + portName);
return(success);
}
var controller = Platform.GetController();
if (controller == null)
{
logger.Error("controller not available");
return(success);
}
serialPort = controller.GetPort(portName);
/*serialPort = new SerialPort();
* serialPort.PortName = portName;*/
serialPort.SerialSettings.BaudRate_Int = 4800;
serialPort.SerialSettings.Parity = Parity.None;
serialPort.SerialSettings.DataBits = DataBits.D8;
serialPort.SerialSettings.StopBits = StopBits.One;
serialPort.SerialSettings.Handshake = Handshake.None;
serialPort.BufferSettings.ReadTimeout = 150;
serialPort.BufferSettings.WriteTimeout = 150;
serialPort.PinStates.Rts_Enable = false;
serialPort.PinStates.Dtr_Enable = false;
// DataReceived event won't work under Linux / Mono
//serialPort.DataReceived += HandleDataReceived;
//serialPort.ErrorReceived += HanldeErrorReceived;
if (serialPort.IsOpen == false)
{
serialPort.Open();
}
// Send status request on connection
//this.WriteData(new byte[] { (byte)X10CommandType.PLC_StatusRequest });
serialPort.Uart.DiscardInBuffer();
serialPort.Uart.DiscardOutBuffer();
success = true;
}
catch (Exception e)
{
logger.Error(e);
}
return(success);
}
/// <summary>
/// Open the serial port and start processing the data from the serial port.
/// </summary>
public void Open()
{
//Console.WriteLine("SerialTextFile: Open");
if (!serialPort.IsOpen)
{
//Console.WriteLine("SerialTextFile: _serialPort.Open");
serialPort.Open();
}
}
protected void OpenComPort(string port = "COM1", int baudRate = 38400)
{
CloseComPort();
//ToDo serialPort = new SerialPort(port, baudRate, Parity.None, 8, StopBits.One);
serialPort.ReadTimeout = 10 * 2;
// serialPort.WriteTimeout = 10 * 2;
serialPort.Open();
}
public async Task Open(bool softReset)
{
await Port.Open();
if (softReset)
{
await SoftReset();
}
_broker.Run(_cancellationSource.Token);
}
/// <summary>
/// Connect to the Arduino serial port
/// </summary>
/// <param name="portname">e.g. Com1</param>
public async Task ConnectAsync(string portname)
{
// Create a new SerialPort object with default settings.
Aborted = false;
SetupCom(portname);
_serialPortCancellationTokenSource = new CancellationTokenSource();
_serialPort.Open();
_readThread = new Thread(Read);
_writeThread = new Thread(Write);
_readThread.Start();
_writeThread.Start();
if (!ResetOnConnect)
{
_serialPort.DiscardOutBuffer();
_serialPort.WriteLine("");
}
bool wasempty;
lock (_pendingCommands)
{
wasempty = _pendingCommands.Count == 0;
_pendingCommands.Clear();
}
lock (_commands)
{
_commands.Clear();
}
if (!wasempty)
{
OnComandQueueChanged(new SerialEventArgs(0, null));
}
OnComandQueueEmpty(new SerialEventArgs(0, null));
}
public SerialDevice(string COM_Port)
{
sp.PortName = COM_Port;
sp.BaudRate = BAUDRATE;
sp.DtrEnable = true;
sp.Open();
var r = RunCommand(SysExMsg.MSG_GET_HANDSHAKE, CommandType.Get);
if (r.Values.Length != 2) throw new Exception($"Not a valid aDrum response in {COM_Port}");
aDrumVersion = new Version(r.Values[0], r.Values[1]);
}
public SerialDevice(ISerialPort serialPort)
{
_sp = serialPort;
_sp.BaudRate = BAUDRATE;
_sp.DtrEnable = true;
_sp.Open();
var r = RunCommand(SysExMsg.Handshake, CommandType.Get);
if (r.Values.Length != 2) throw new Exception($"Not a valid aDrum response in {serialPort.PortName}");
aDrumVersion = new Version(r.Values[0], r.Values[1]);
}
/// <summary>
/// Create a new SerialLcd object.
/// </summary>
/// <param name="config">TextDisplayConfig object defining the Lcd dimension (null will default to 16x2).</param>
/// <param name="baudRate">Baud rate to use (default = 9600).</param>
/// <param name="parity">Parity to use (default is None).</param>
/// <param name="dataBits">Number of data bits (default is 8 data bits).</param>
/// <param name="stopBits">Number of stop bits (default is one stop bit).</param>
public SerialLcd(IIODevice device, SerialPortName port, TextDisplayConfig config = null, int baudRate = 9600,
Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
{
if (config == null)
{
// assume a 16x2 Lcd.
DisplayConfig = new TextDisplayConfig()
{
Height = 2, Width = 16
};
}
else
{
DisplayConfig = config;
}
comPort = device.CreateSerialPort(port, baudRate, dataBits, parity, stopBits);
comPort.Open();
// configure the Lcd controller for the appropriate screen size
byte lines = 0;
byte characters = 0;
switch (DisplayConfig.Width)
{
case 16:
characters = (byte)LcdDimensions.Characters16Wide;
break;
case 20:
characters = (byte)LcdDimensions.Characters20Wide;
break;
default:
throw new ArgumentOutOfRangeException(nameof(config.Width), "Display width should be 16 or 20.");
}
switch (DisplayConfig.Height)
{
case 2:
lines = (byte)LcdDimensions.Lines2;
break;
case 4:
lines = (byte)LcdDimensions.Lines4;
break;
default:
throw new ArgumentOutOfRangeException(nameof(config.Height), "Display height should be 2 or 4 lines.");
}
Send(new[] { ConfigurationCommandCharacter, characters, ConfigurationCommandCharacter, lines });
Thread.Sleep(10);
}
protected Yx5300(ISerialPort serialPort)
{
this.serialPort = serialPort;
serialPort.Open();
SendCommand(Commands.Reset);
Thread.Sleep(100);
SendCommand(Commands.SelectDevice, 0, 2);
Thread.Sleep(500);
}
public override async Task <bool> Enable()
{
if (!await port.Open(115200))
{
return(false);
}
await Task.Delay(3000);
port.Flush();
isEnabled = true;
Console.WriteLine($"{id} Enabled");
return(true);
}
private void WriteSerialData(string msg)
{
switch (CurrentTransmissionType)
{
case TransmissionType.Text:
//first make sure the port is open
//if its not open then open it
if (!(comSerialPort.IsOpen == true))
{
comSerialPort.Open(_serialPortConnectInformation);
}
//send the message to the port
comSerialPort.Write(msg + "\r"); // Add 0x0D at the end, to match Nuvo Essentia needs
//display the message
DisplayData(MessageType.Outgoing, msg + "\n");
break;
case TransmissionType.Hex:
//display error message
DisplayData(MessageType.Error, "Transmission type 'Hex' is not supported for this serial port");
break;
default:
//first make sure the port is open
//if its not open then open it
if (!(comSerialPort.IsOpen == true))
{
comSerialPort.Open(_serialPortConnectInformation);
}
//send the message to the port
comSerialPort.Write(msg);
//display the message
DisplayData(MessageType.Outgoing, msg + "\n");
break;
}
}
private void ConfigurePort(ISerialPort serialPort)
{
serialPort.BaudRate = BAUD_RATE;
serialPort.NewLine = NEWLINE;
serialPort.StopBits = STOP_BITS;
serialPort.DataBits = DATA_BITS;
serialPort.Parity = PARITY;
serialPort.Handshake = HAND_SHAKE;
serialPort.ReadTimeout = READ_TIMEOUT;
serialPort.WriteTimeout = WRITE_TIMEOUT;
serialPort.Open();
serialPort.DiscardInBuffer();
serialPort.DiscardOutBuffer();
}
private bool EnsureSerialPortConnected()
{
lock (_serialPortLock)
{
if (_serialPort == null)
{
try
{
_serialPort = new SerialPort(_config.COMPort, BAUD_RATE, PARITY, DATA_BITS, STOP_BITS);
}
catch (Exception e)
{
_log.Error(e.Message, e);
return(false);
}
}
if (_serialPort != null && !_serialPort.IsOpen &&
_unsuccessfulConnectionAttempts < MAX_UNSUCCESSFUL_PORT_OPEN_ATTEMPTS)
{
try
{
_serialPort.Handshake = HANDSHAKE;
_serialPort.WriteTimeout = SERIAL_WRITE_TIMEOUT;
_serialPort.ErrorReceived += _serialPort_ErrorReceived;
_serialPort.WriteBufferSize = WRITE_BUFFER_SIZE;
_log.DebugFormat(
$"Opening serial port {_config.COMPort}: Handshake:{HANDSHAKE}, WriteTimeout:{SERIAL_WRITE_TIMEOUT}, WriteBufferSize:{WRITE_BUFFER_SIZE}");
_serialPort.Open();
GC.SuppressFinalize(_serialPort.BaseStream);
_serialPort.DiscardOutBuffer();
_unsuccessfulConnectionAttempts = 0;
return(true);
}
catch (Exception e)
{
_unsuccessfulConnectionAttempts++;
_log.Error(e.Message, e);
}
}
else if (_serialPort != null && _serialPort.IsOpen)
{
return(true);
}
return(false);
}
}
public void Open()
{
Port.Open();
// create tasks, on open or re-open
_eventQueue = new BlockingCollection <Message>();
_transmitQueue = new BlockingCollection <Message>();
_responseQueue = new BlockingCollection <Message>();
_processEventsTask = new Task(() => ProcessQueue(_eventQueue, OnNodeMessageReceived));
_transmitTask = new Task(() => ProcessQueue(_transmitQueue, OnTransmit));
_portReadTask = new Task(() => ReadPort(Port));
// start tasks
_portReadTask.Start();
_processEventsTask.Start();
_transmitTask.Start();
}
public TiDongle(ISerialPort Port, IGUI Gui)
{
_receiveParserThread = new Thread(ParseReceive);
_receiveParserThread.IsBackground = true;
_port = Port;
if (_port != null)
{
_port.Open();
FixComunicationProblem();
}
_gui = Gui;
init_success = false;
device_connected = false;
device_disconnected = false;
_receiveParserThread.Start();
}
/// <summary>
/// Open Arduino Com Port
/// </summary>
/// <exception cref="InvalidOperationException">Thrown in case of error while opening port</exception>
public void OpenArduinoComPort()
{
if (_comPort == null)
{
_comPort = new SerialPortWrapper(_comPortName, Communication.BAUDRATE);
}
try
{
Log.Print(String.Format("Opening Arduino port {0}...", _comPortName), eCategory.Info, LogTag.COMMUNICATION);
_comPort.Open();
}
catch (Exception ex)
{
throw new InvalidOperationException(String.Format("[{0}] Error opening Arduino port {1}. Reason: {2}",
MethodBase.GetCurrentMethod().Name, _comPortName, ex.Message), ex);
}
Log.Print(String.Format("Arduino port {0} is open!", _comPortName), eCategory.Info, LogTag.COMMUNICATION);
}
private void ConfigurePortForDiscovery(ISerialPort serialPort)
{
serialPort.ReadBufferSize = READ_BUFFER_SIZE;
serialPort.WriteBufferSize = WRITE_BUFFER_SIZE;
serialPort.BaudRate = BAUD_RATE;
serialPort.NewLine = NEWLINE;
serialPort.StopBits = STOP_BITS;
serialPort.DataBits = DATA_BITS;
serialPort.Parity = PARITY;
//Not sure why the following three are differnet during discovery.
serialPort.Handshake = Handshake.RequestToSendXOnXOff; //Because it works for either K24 or WK43
serialPort.ReadTimeout = 1000;
serialPort.WriteTimeout = 1000;
serialPort.Open();
serialPort.DiscardInBuffer();
serialPort.DiscardOutBuffer();
}
public MainPage()
{
InitializeComponent();
serialPort = DependencyService.Get <ISerialPort>();
serialPort.Received += (s, data) =>
{
recvCount += data.Length;
};
serialPort.Open("/dev/ttyS3", 115200);
Task.Run(() =>
{
var sendBuffer = new byte[234];
for (byte i = 0; i < sendBuffer.Length; i++)
{
sendBuffer[i] = i;
}
while (true)
{
//System.Diagnostics.Debug.WriteLine($"Count:{sendCount} {recvCount}");
//Device.BeginInvokeOnMainThread(() =>
//{
// labSend.Text = $"Send:{sendCount}";
// labRecv.Text = $"Recv:{recvCount}";
//});
serialPort.Send(sendBuffer);
sendCount += sendBuffer.Length;
Thread.Sleep(200);
}
});
Device.StartTimer(TimeSpan.FromMilliseconds(500), () =>
{
labSend.Text = $"Send:{sendCount}";
labRecv.Text = $"Recv:{recvCount}";
// do something every 60 seconds
return(true); // runs again, or false to stop
});
}
public void connect(ISerialPort sp)
{
if (connectionState == ConnectionState.Connected)
{
throw new InvalidOperationException();
}
if (sp == null)
{
throw new ArgumentNullException("sp");
}
if (!sp.IsOpen)
{
sp.Open();
}
_sp = sp;
connectionState = ConnectionState.Connected;
}
public bool Connect()
{
bool rt = false;
try
{
if (ISerialPort != null)
{
if (ISerialPort.IsOpen)
{
ISerialPort.DataReceived -= SerialPort_DataReceived;
ISerialPort.Close();
System.Threading.Thread.Sleep(100);
ISerialPort.Dispose();
}
ISerialPort.BaudRate = Property.BaudRate;
ISerialPort.Parity = Property.Parity;
ISerialPort.DataBits = Property.DataBits;
ISerialPort.StopBits = Property.StopBits;
//ISerialPort.ReceivedBytesThreshold = ComSerialPort.ReceivedBytesThreshold;
ISerialPort.NewLine = Property.NewLine;
ISerialPort.ReadTimeout = Property.ReceiveTimeOut;
ISerialPort.DtrEnable = Property.DtrEnable;
ISerialPort.RtsEnable = Property.RtsEnable;
ISerialPort.DataReceived += SerialPort_DataReceived;
System.AsyncCallback OnConnected = new System.AsyncCallback(ConnectedCallBack);
//当完成连接后回调:OnConnected委托
ISerialPort.Open();
OnConnected(null);
rt = true;
}
}
catch (Exception ex) { }
finally { }
return(rt);
}
private void Open()
{
//_session.IsTryingConnect = true;
try
{
_port.Open();
_port.DiscardInBuffer();
_session.Connected = true;
return;
}
catch (IOException e)
{
Console.WriteLine("Serial IO error in opening: {0}", e.Message);
_session.Connected = false;
StopConnection();
return;
}
catch (InvalidOperationException e)
{
Console.WriteLine("Serial invalid operation error: {0}", e.Message);
}
StopConnection();
_session.Connected = false;
}
private void CreateSerialPort()
{
if (_serialPort != null)
{
// Close already open port
Close();
}
if (_serialPortPassedByCaller != null)
{
_log.Debug(m => m("Start of NuvoTelegram .... use passed-in serial port object!"));
_serialPort = _serialPortPassedByCaller;
}
else
{
_log.Debug(m => m("Start of NuvoTelegram .... create own serial port object!"));
if (_serialPortConnectInformation.PortName.Equals(defaultPortSim))
{
// Create serial port simulator
_serialPort = new ProtocolDriverSimulator();
}
else if (_serialPortConnectInformation.PortName.Equals(defaultPortQueue))
{
// Create serial port queue
_serialPort = new SerialPortQueue();
}
else
{
_serialPort = new SerialPort();
}
}
// Register for events and open serial port
_serialPort.onDataReceived += new SerialPortEventHandler(serialPort_DataReceived);
_serialPort.Open(_serialPortConnectInformation);
}
public Dictionary<PropertyKey, int> Connect(InsteonConnection connection)
{
port?.Close();
port = SerialPortCreator.Create(connection);
port.Open();
byte[] input = { Constants.MessageStartByte, (byte)InsteonModemSerialCommand.GetImInfo };
var properties = new Dictionary<PropertyKey, int>();
var response = new List<byte>();
try
{
for (int i = 1; i <= Constants.negotiateRetries; ++i)
{
logger.DebugFormat("TX: {0}", Utilities.ByteArrayToString(input));
port.Write(input);
port.Wait(Constants.openTimeout);
var output = port.ReadAll();
if (output.Length <= 0)
{
Thread.Sleep(100);
continue; // try again
}
response.Clear();
response.AddRange(output);
while (output.Length > 0 && response.Count < 9)
{
port.Wait(Constants.openTimeout);
output = port.ReadAll();
response.AddRange(output);
}
logger.DebugFormat("RX: {0}", Utilities.ByteArrayToString(response.ToArray()));
int offset = 0;
// determins the start location of the actual message returned
for (int j = 0; j < response.Count; ++j)
{
if (response[j] == Constants.MessageStartByte)
{
offset = j;
}
}
if (response.Count >= offset + 9 &&
response[offset] == Constants.MessageStartByte &&
response[offset + 1] == (byte)InsteonModemSerialCommand.GetImInfo &&
response[offset + 8] == Constants.MessageEndByte)
{
properties[PropertyKey.Address] = response[offset + 2] << 16 | response[offset + 3] << 8 | response[offset + 4];
properties[PropertyKey.DevCat] = response[offset + 5];
properties[PropertyKey.SubCat] = response[offset + 6];
properties[PropertyKey.FirmwareVersion] = response[offset + 7];
break; // found
}
}
}
finally
{
if (response.Count == 0)
{
throw new IOException("Failed to open port, timeout waiting for response from port.");
}
if (properties.Keys.Count == 0)
{
port.Close();
port = null;
throw new IOException("Failed to open port, unable to negotiate with INSTEON controller.");
}
}
logger.DebugFormat("Successfully negotiated with INSTEON controller on connection '{0}'...", connection);
port.SetNotify(DataAvailable);
return properties;
}