private void OpenPort()
{
Log.Log("Opening port...");
_port.Open();
Log.Log("Port was opened OK");
//_port.ClearRtsControlToggle();
//_port.SetRtsControlToggle();
_port.DiscardInBuffer();
_port.DiscardOutBuffer();
SNetId = RetrieveSNetId(_openingTimeout);
Log.Log("SNetId retreived");
}
internal async Task WriteFrame(BaosFrame frame)
{
await _waitSemaphore.WaitAsync();
try
{
_stream.DiscardOutBuffer();
var buffer = frame.ToByteFrame();
Logger.LogHexOut(buffer);
await _stream.WriteAsync(buffer);
if (frame is AckFrame)
{
return;
}
ControlValueIndicator = !ControlValueIndicator;
}
catch (Exception e)
{
Logger.LogError($"Could not write frame {e}", e);
}
finally
{
_waitSemaphore.Release();
}
}
public void DiscardOutBuffer()
{
using (SerialPortStream serialSource = new SerialPortStream(SourcePort, 115200, 8, Parity.None, StopBits.One)) {
serialSource.Open();
serialSource.DiscardOutBuffer();
}
}
public async Task Disconnect()
{
await Task.Run(() =>
{
if (IoPort.IsOpen)
{
State = ConnectionState.Disconnecting;
try
{
//IoPort.DataReceived -= serialPort_DataReceived;
IoPort.DiscardInBuffer();
IoPort.DiscardOutBuffer();
IoPort.Close();
Console.Out.WriteLine("Closed serialport.");
}
catch (Exception)
{
Console.Out.WriteLine("Failed to close serialport.");
}
State = ConnectionState.Disconnected;
}
});
}
public override void CommClrBuff()
{
try
{
serial?.DiscardInBuffer();
serial?.DiscardOutBuffer();
}
catch (Exception ex) { throw new Bsl430NetException(771, ex); }
}
public static void WriteBytes(this SerialPortStream port, byte[] bytes, int offset, int count)
{
port.DiscardOutBuffer();
Log.Log("Удаление всех данных исходящего буфера последовательного порта...");
var discardedInBytes = port.ReadAllBytes();
Log.Log("Удалены следующие байты: " + discardedInBytes.ToText());
port.Write(bytes, 0, bytes.Length);
}
public void WriteBytes(byte[] bytes, int offset, int count)
{
Log("Удаление всех данных исходящего буфера последовательного порта...");
_port.DiscardOutBuffer();
Log("Очистка уже принятых байтов...");
var discardedInBytes = ReadAllBytes();
Log("Удалены следующие байты: " + discardedInBytes.ToText());
_port.Write(bytes, offset, count);
Log("В порт отправлены байты буфера: " + bytes.ToText() + " начиная с " + offset + " в количестве " + count);
}
public void Open(string Port, int BaudRate, int DataBit, DataParity Parity, DataStopBit StopBit, int BufferSize)
{
myserial.PortName = Port;
myserial.BaudRate = BaudRate;
myserial.DataBits = DataBit;
myserial.ParityReplace = 0;
switch (Parity)
{
case DataParity.Pariti_Odd:
myserial.Parity = RJCP.IO.Ports.Parity.Odd;
break;
case DataParity.Parity_Even:
myserial.Parity = RJCP.IO.Ports.Parity.Even;
break;
case DataParity.Parity_Mark:
myserial.Parity = RJCP.IO.Ports.Parity.Mark;
break;
case DataParity.Parity_None:
myserial.Parity = RJCP.IO.Ports.Parity.None;
break;
default:
myserial.Parity = RJCP.IO.Ports.Parity.None;
break;
}
switch (StopBit)
{
case DataStopBit.StopBit_1:
myserial.StopBits = StopBits.One;
break;
case DataStopBit.StopBit_2:
myserial.StopBits = StopBits.Two;
break;
default:
myserial.StopBits = StopBits.One;
break;
}
myserial.ReadTimeout = 75;
myserial.WriteTimeout = 75;
myserial.ReadBufferSize = BufferSize;
myserial.WriteBufferSize = BufferSize;
readbuffer = new byte[checked (BufferSize + 1)];
myserial.Open();
myserial.DiscardInBuffer();
myserial.DiscardOutBuffer();
//Thread.Sleep(100);
}
public void Open(string port, int baud)
{
IsOpen = true;
_arduinoPort.PortName = port;
_arduinoPort.BaudRate = baud;
_arduinoPort.DtrEnable = true;
_arduinoPort.ReadTimeout = 1;
_arduinoPort.WriteTimeout = 1;
_arduinoPort.Open();
_arduinoPort.DiscardInBuffer();
_arduinoPort.DiscardOutBuffer();
_arduinoPort.DataReceived += DataRecieved;
}
public void Close(bool auto)
{
if (com != null && com.IsOpen)
{
ComLogger.Log("com", string.Format("Close {0} [{1}]", com.PortName.ToUpper(), auto ? "CORE" : "USER"));
Logger.LogMessage("CloseCom", "Close {0} [{1}]", com.PortName.ToUpper(), auto ? "CORE" : "USER");
try { com.DiscardOutBuffer(); } catch { }
try { com.DiscardInBuffer(); } catch { }
try { com.Close(); } catch { }
try { com.Dispose(); } catch { }
}
com = null;
}
protected override async Task WriteFrame(MBusFrame frame)
{
try
{
_stream.DiscardOutBuffer();
var buffer = frame.ToByteFrame();
Logger.LogHexOut(buffer);
await _stream.WriteAsync(buffer);
}
catch (Exception e)
{
Logger.LogError($"Could not write frame {e}", e);
}
}
private async Task MoveFinished()
{
byte[] buffer = new byte[1024];
while (true)
{
await _serial.ReadAsync(buffer);
var response = System.Text.Encoding.Default.GetString(buffer);
if (response.Contains("ok"))
{
_serial.DiscardOutBuffer();
return;
}
}
}
public override async Task Send(string data)
{
await Task.Run(() =>
{
_serialStream.DiscardInBuffer();
_serialStream.DiscardOutBuffer();
var content = new List <byte>();
content.AddRange(Encoding.ASCII.GetBytes(data));
var buffer = content.ToArray();
_serialStream.Write(buffer, 0, buffer.Length);
DataSentObservable.OnNext(data);
});
}
public string ExecCommand(string command, int responseTimeout, string errorMessage)
{
try
{
port.DiscardOutBuffer();
port.DiscardInBuffer();
receiveNow.Reset();
port.Write(command + "\r");
string input = ReadResponse(responseTimeout);
if ((input.Length == 0) || ((!input.EndsWith("\r\n> ")) && (!input.EndsWith("\r\nOK\r\n"))))
{
throw new ApplicationException("No success message was received.");
}
return(input);
}
catch (Exception ex) { Log.Trace(ex.Message, ex.StackTrace, configuration.Verbose); }
return("");
}
private async Task SerialOpen()
{
byte[] buffer = new byte[128];
if (_serial.IsOpen == false)
{
Logger.Log("Opening serial port...");
_serial.Open();
}
Logger.Log("Awaiting handshake...");
while (true)
{
await _serial.ReadAsync(buffer);
var response = System.Text.Encoding.Default.GetString(buffer);
if (response.Contains("start"))
{
Logger.Log("Handshake successful...");
break;
}
await Task.Delay(250);
}
_serial.DiscardOutBuffer();
}
public SerialPortStream OpenPort(string portName)
{
SerialPortStream serialPort = null;
var retries = 3;
while (retries > 0)
{
try
{
serialPort = new SerialPortStream(portName, 9600, 8, Parity.None, StopBits.One);
serialPort.DiscardInBuffer();
serialPort.DiscardOutBuffer();
serialPort.ReadTimeout = 1000;
serialPort.Open();
break;
}
catch (Exception e)
{
if (serialPort != null)
{
if (serialPort.IsOpen)
{
serialPort.Close();
}
serialPort.Dispose();
serialPort = null;
}
Console.WriteLine("Exception in OpenPort " + e.Message);
retries--;
}
}
return(serialPort);
}
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);
}
public void WriteBytes(byte[] bytes, int offset, int count)
{
_port.DiscardOutBuffer();
ReadAllBytes();
_port.Write(bytes, offset, count);
}
public void Open()
{
if (!IsOpen)
{
try { Close(true); }
catch { }
try
{
com = new SerialPortStream();
com.PortName = mPortName;
com.BaudRate = mBaudRate;
com.DataBits = 8;
com.Parity = Parity.None;
com.StopBits = StopBits.One;
com.Handshake = Handshake.None;
com.NewLine = "\n";
com.WriteTimeout = 1000; //se si blocca in write
com.DtrEnable = Settings.GetObject("HardReset Grbl On Connect", false);
com.RtsEnable = Settings.GetObject("HardReset Grbl On Connect", false);
if (Settings.GetObject("Firmware Type", Firmware.Grbl) == Firmware.Marlin)
{
com.DtrEnable = true;
}
ComLogger.Log("com", string.Format("Open {0} @ {1} baud {2}", com.PortName.ToUpper(), com.BaudRate, GetResetDiagnosticString()));
Logger.LogMessage("OpenCom", "Open {0} @ {1} baud {2}", com.PortName.ToUpper(), com.BaudRate, GetResetDiagnosticString());
com.Open();
com.DiscardOutBuffer();
com.DiscardInBuffer();
}
catch (System.IO.IOException ioex)
{
if (char.IsDigit(mPortName[mPortName.Length - 1]) && char.IsDigit(mPortName[mPortName.Length - 2])) //two digits port like COM23
{
//FIX https://github.com/arkypita/LaserGRBL/issues/31
try
{
com.PortName = mPortName.Substring(0, mPortName.Length - 1); //remove last digit and try again
ComLogger.Log("com", string.Format("Open {0} @ {1} baud {2}", com.PortName.ToUpper(), com.BaudRate, GetResetDiagnosticString()));
Logger.LogMessage("OpenCom", "Retry opening {0} as {1} (issue #31)", mPortName.ToUpper(), com.PortName.ToUpper());
com.Open();
com.DiscardOutBuffer();
com.DiscardInBuffer();
}
catch
{
com = null;
throw ioex; //throw the original ex - not the new one!
}
}
else
{
com = null;
}
}
}
}
