///////////////////////////////////////////////////////////////////////////////////////////////////////////
//private void port_DataReceived_1(object sender, SerialDataReceivedEventArgs e)
//{
// //if (!ComPort.IsOpen) return;
// // int bytes = ComPort.BytesToRead;
// int bytes_rs = ComPort.ReadByte();
// //InputData = ComPort.ReadExisting();
// //if (bytes_rs != null)
// //{
// this.BeginInvoke(new SetTextCallback(SetText), new object[] { bytes_rs });
// //}
//}
//private void SetText(int buffer)
//{
// string s2 = buffer.ToString();
// //rtbIncoming.Clear();
// rtbIncoming.AppendText(s2);
// rtbIncoming.AppendText("-");
// // //this.rtbIncoming.Text += text;
// // byte[] uart_data_byte = Encoding.UTF8.GetBytes(text);
// // BitArray b = new BitArray(uart_data_byte);
// // var sb = new StringBuilder();
// // for (int i = 0; i < b.Count; i++)
// // {
// // char c = b[i] ? '1' : '0';
// // sb.Append(c);
// // }
// // string s2 = sb.ToString();
// // rtbIncoming.Clear();
// // rtbIncoming.AppendText(s2);
//}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//private void port_DataReceived_1(object sender, SerialDataReceivedEventArgs e)
//{
// InputData = ComPort.ReadExisting();
// if (InputData != String.Empty)
// {
// this.BeginInvoke(new SetTextCallback(SetText), new object[] { InputData });
// }
//}
//private void SetText(string text)
//{
// byte[] uart_data_byte = Encoding.UTF8.GetBytes(text);
// BitArray b = new BitArray(uart_data_byte);
// var sb = new StringBuilder();
// for (int i = 0; i < b.Count; i++)
// {
// char c = b[i] ? '1' : '0';
// sb.Append(c);
// }
// string s2 = sb.ToString();
// rtbIncoming.Clear();
// rtbIncoming.AppendText(s2);
//}
internal void PinChanged(object sender, SerialPinChangedEventArgs e)
{
SerialPinChange SerialPinChange1 = 0;
bool signalState = false;
SerialPinChange1 = e.EventType;
switch (SerialPinChange1)
{
case SerialPinChange.Break:
//MessageBox.Show("Break is Set");
break;
case SerialPinChange.CDChanged:
signalState = ComPort.CtsHolding;
// MessageBox.Show("CD = " + signalState.ToString());
break;
case SerialPinChange.CtsChanged:
signalState = ComPort.CDHolding;
//MessageBox.Show("CTS = " + signalState.ToString());
break;
case SerialPinChange.DsrChanged:
signalState = ComPort.DsrHolding;
// MessageBox.Show("DSR = " + signalState.ToString());
break;
case SerialPinChange.Ring:
//MessageBox.Show("Ring Detected");
break;
}
}
private static SerialPinChange SignalsToPinChanges(Signals signals)
{
SerialPinChange pinChanges = default;
if (signals.HasFlag(Signals.SignalCts))
{
pinChanges |= SerialPinChange.CtsChanged;
}
if (signals.HasFlag(Signals.SignalDsr))
{
pinChanges |= SerialPinChange.DsrChanged;
}
if (signals.HasFlag(Signals.SignalDcd))
{
pinChanges |= SerialPinChange.CDChanged;
}
if (signals.HasFlag(Signals.SignalRng))
{
pinChanges |= SerialPinChange.Ring;
}
return(pinChanges);
}
/// <summary>
/// Respond to a pin change detection on the port.
/// </summary>
/// <param name="change">The pin that changed.</param>
private void PortPinChanged(SerialPinChange change)
{
if (this.port.IsOpen && this.PinChanged != null)
{
this.PinChanged(change);
}
}
private void OnPortPinChanged(object sender, SerialPinChange pinChange)
// ReSharper restore UnusedParameter.Local
{
switch (pinChange)
{
case SerialPinChange.Break:
Log.Info("break received! => might be ZAE reset");
break;
case SerialPinChange.CDChanged:
Log.Info("CDChanged received!");
break;
case SerialPinChange.CtsChanged:
Log.Info("CtsChanged received!");
break;
case SerialPinChange.DsrChanged:
// ignore
// log.Info("DsrChanged received!");
break;
case SerialPinChange.Ring:
#if DEBUG
// Ring Indicator (RI), pin 9, is not connected for the Transliner
// Ringbus cable
// ==> no need to track or to display
Log.Info("Ring received!");
#endif
break;
} // switch
} // OnPortPinChanged()
private void PinChangeThread()
{
while (m_MonitorPins)
{
if (m_StopRunning.WaitOne(0))
{
m_MonitorPins = false;
continue;
}
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0,
"{0}: PinChangeThread: Waiting", m_Name);
}
WaitForModemEvent mevent = m_Dll.serial_waitformodemevent(m_Handle, c_ModemEvents);
if (mevent == WaitForModemEvent.Error)
{
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Error))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Error, 0,
"{0}: PinChangeThread: Error aborting event; errno={1}; description={2}",
m_Name, m_Dll.errno, m_Dll.serial_error(m_Handle));
}
m_MonitorPins = false;
return;
}
if (mevent != WaitForModemEvent.None)
{
SerialPinChange pins = SerialPinChange.NoChange;
if ((mevent & WaitForModemEvent.ClearToSend) != 0)
{
pins |= SerialPinChange.CtsChanged;
}
if ((mevent & WaitForModemEvent.DataCarrierDetect) != 0)
{
pins |= SerialPinChange.CDChanged;
}
if ((mevent & WaitForModemEvent.DataSetReady) != 0)
{
pins |= SerialPinChange.DsrChanged;
}
if ((mevent & WaitForModemEvent.RingIndicator) != 0)
{
pins |= SerialPinChange.Ring;
}
// TODO: Break not implemented
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0,
"{0}: PinChangeThread: Event Received: {1}", m_Name, mevent);
}
OnPinChanged(this, new SerialPinChangedEventArgs(pins));
}
}
}
private void RaisePinChanged(SerialPinChange pinChanged)
{
if (_pinChanged != null)
{
ThreadPool.QueueUserWorkItem(s => {
var thisRef = (SerialStream)s;
thisRef._pinChanged?.Invoke(thisRef, new SerialPinChangedEventArgs(pinChanged));
}, this);
}
}
private void CommOverlappedIo_CommEvent(object sender, CommEventArgs e)
{
SerialData dataFlags = (SerialData)(e.EventType & c_DataFlags);
if (dataFlags != 0)
{
OnDataReceived(this, new SerialDataReceivedEventArgs(dataFlags));
}
SerialPinChange pinFlags = (SerialPinChange)(e.EventType & c_PinFlags);
if (pinFlags != 0)
{
OnPinChanged(this, new SerialPinChangedEventArgs(pinFlags));
}
}
public SyncFotoManager(SerialPort syncPort, SerialPinChange inputPin)
{
try
{
this.inputPin = inputPin;
this.syncPort = syncPort;
this.syncPort.PinChanged += new SerialPinChangedEventHandler(PlcMacchinaInputChanged);
syncInpuntTimer = new System.Timers.Timer();
syncInpuntTimer.Interval = 10;
syncInpuntTimer.Elapsed += new System.Timers.ElapsedEventHandler(syncInpuntTimer_Tick);
}
catch (Exception)
{
throw;
}
}
internal void PinChanged(object sender, SerialPinChangedEventArgs e)
{
SerialPinChange SerialPinChange1 = 0;
bool signalState = false;
SerialPinChange1 = e.EventType;
lblCTSStatus.BackColor = Color.Green;
lblDSRStatus.BackColor = Color.Green;
lblRIStatus.BackColor = Color.Green;
lblBreakStatus.BackColor = Color.Green;
switch (SerialPinChange1)
{
case SerialPinChange.Break:
lblBreakStatus.BackColor = Color.Red;
MessageBox.Show("Break is Set");
break;
case SerialPinChange.CDChanged:
signalState = ComPort.CtsHolding;
MessageBox.Show("CD = " + signalState.ToString());
break;
case SerialPinChange.CtsChanged:
signalState = ComPort.CDHolding;
lblCTSStatus.BackColor = Color.Red;
MessageBox.Show("CTS = " + signalState.ToString());
break;
case SerialPinChange.DsrChanged:
signalState = ComPort.DsrHolding;
lblDSRStatus.BackColor = Color.Red;
MessageBox.Show("DSR = " + signalState.ToString());
break;
case SerialPinChange.Ring:
lblRIStatus.BackColor = Color.Red;
MessageBox.Show("Ring Detected");
break;
}
}
// Since we can not garantee the order or the exact time that the event handler is called
// We will look for an event that was fired that matches the type and that bytesToRead
// is greater then the parameter
public bool Validate(SerialPinChange eventType, int bytesToRead)
{
bool retValue = false;
lock (this)
{
for (int i = 0; i < EventType.Count; i++)
{
if (eventType == (SerialPinChange)EventType[i] && bytesToRead <= (int)BytesToRead[i] && (SerialPort)Source[i] == _com)
{
EventType.RemoveAt(i);
BytesToRead.RemoveAt(i);
Source.RemoveAt(i);
NumEventsHandled--;
retValue = true;
break;
}
}
}
return(retValue);
}
internal SerialPinChangedEventArgs(SerialPinChange eventType)
{
this.eventType = eventType;
}
/// <summary>
/// Event on serial port "pin was changed"
/// </summary>
/// <param name="sender"></param>
/// <param name="pinsStatesChange"></param>
static void port_PinChanged(object sender, SerialPinChange pinsStatesChange)
{
private void IOLoop()
{
bool eofReceived = false;
// we do not care about bytes we got before - only about changes
// loop just got started which means we just got request
bool lastIsIdle = false;
int ticksWhenIdleStarted = 0;
Signals lastSignals = _pinChanged != null?Interop.Termios.TermiosGetAllSignals(_handle) : Signals.Error;
bool IsNoEventRegistered() => _dataReceived == null && _pinChanged == null;
while (IsOpen && !eofReceived && !_ioLoopFinished)
{
bool hasPendingReads = !_readQueue.IsEmpty;
bool hasPendingWrites = !_writeQueue.IsEmpty;
bool hasPendingIO = hasPendingReads || hasPendingWrites;
bool isIdle = IsNoEventRegistered() && !hasPendingIO;
if (!hasPendingIO)
{
if (isIdle)
{
if (!lastIsIdle)
{
// we've just started idling
ticksWhenIdleStarted = Environment.TickCount;
}
else if (Environment.TickCount - ticksWhenIdleStarted > IOLoopIdleTimeout)
{
// we are already idling for a while
// let's stop the loop until there is some work to do
lock (_ioLoopLock)
{
// double check we are done under lock
if (IsNoEventRegistered() && _readQueue.IsEmpty && _writeQueue.IsEmpty)
{
_ioLoop = null;
break;
}
else
{
// to make sure timer restarts
lastIsIdle = false;
continue;
}
}
}
}
Thread.Sleep(1);
}
else
{
Interop.PollEvents events = PollEvents(1,
pollReadEvents: hasPendingReads,
pollWriteEvents: hasPendingWrites,
out Interop.ErrorInfo? error);
if (error.HasValue)
{
FinishPendingIORequests(error);
break;
}
if (events.HasFlag(Interop.PollEvents.POLLNVAL) ||
events.HasFlag(Interop.PollEvents.POLLERR))
{
// bad descriptor or some other error we can't handle
FinishPendingIORequests();
break;
}
if (events.HasFlag(Interop.PollEvents.POLLIN))
{
int bytesRead = DoIORequest(_readQueue, _processReadDelegate);
_totalBytesRead += bytesRead;
}
if (events.HasFlag(Interop.PollEvents.POLLOUT))
{
DoIORequest(_writeQueue, _processWriteDelegate);
}
}
// check if there is any new data (either already read or in the driver input)
// this event is private and handled inside of SerialPort
// which then throttles it with the threshold
long totalBytesAvailable = TotalBytesAvailable;
if (totalBytesAvailable > _lastTotalBytesAvailable)
{
_lastTotalBytesAvailable = totalBytesAvailable;
RaiseDataReceivedChars();
}
if (_pinChanged != null)
{
// Checking for changes could technically speaking be done by waiting with ioctl+TIOCMIWAIT
// This would require spinning new thread and also would potentially trigger events when
// user didn't have time to respond.
// Diffing seems like a better solution.
Signals current = Interop.Termios.TermiosGetAllSignals(_handle);
// There is no really good action we can take when this errors so just ignore
// a sinle event.
if (current != Signals.Error && lastSignals != Signals.Error)
{
Signals changed = current ^ lastSignals;
if (changed != Signals.None)
{
SerialPinChange pinChanged = SignalsToPinChanges(changed);
RaisePinChanged(pinChanged);
}
}
lastSignals = current;
}
lastIsIdle = isIdle;
}
}
internal SerialPinChangedEventArgs(SerialPinChange eventCode)
{
mPinChanged = eventCode;
}
internal SerialPinChangedEventArgs(SerialPinChange eventCode){
mPinChanged = eventCode;
}
internal SerialPinChangedEventArgs(SerialPinChange eventCode)
{
EventType = eventCode;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="eventType">Event that occurred</param>
public SerialPinChangedEventArgs(SerialPinChange eventType)
{
m_EventType = eventType;
}
internal SerialPinChangedEventArgs (SerialPinChange eventType)
{
this.eventType = eventType;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="eventType">Event that occurred</param>
public SerialPinChangedEventArgs(SerialPinChange eventType)
{
m_EventType = eventType;
}
