public SerialPort(string portname = "COM1", int baudrate = 9600, Parity parity = Parity.None, int databits = 8, StopBits stopbits = StopBits.One,
Handshake handshake = Handshake.None, int readtimeout = System.IO.Ports.SerialPort.InfiniteTimeout,
int writetimeout = System.IO.Ports.SerialPort.InfiniteTimeout, string newline = "\n", bool isevent = false)
{
serialport = new System.IO.Ports.SerialPort(portname, baudrate, parity, databits, stopbits)
{
Handshake = handshake,
ReadTimeout = readtimeout,
WriteTimeout = writetimeout,
NewLine = newline
};
if (handshake != Handshake.None)
{
serialport.DtrEnable = true;
if (handshake != Handshake.XOnXOff)
{
serialport.RtsEnable = true;
}
}
if (isevent)
{
DataReceivedEventHandler = new SerialDataReceivedEventHandler(DataReceived);
ErrorReceivedEventHandler = new SerialErrorReceivedEventHandler(ErrorReceived);
PinChangedEventHandler = new SerialPinChangedEventHandler(PinChanged);
serialport.DataReceived += DataReceivedEventHandler;
serialport.ErrorReceived += ErrorReceivedEventHandler;
serialport.PinChanged += PinChangedEventHandler;
}
}
public frmSGMLogin()
{
InitializeComponent();
frmMsg = new frmSGMMessage();
serialDatahandler = new SerialDataReceivedEventHandler(CardReaderReceivedHandler);
RFIDReader.RegistryReaderListener(Program.ReaderPort, serialDatahandler);
}
private void myReceiveHandler(object sender, SerialDataReceivedEventArgs e)
{
//由于tbReceiveData是在主线程上创建的，所以不能直接在其他线程中访问，需要利用委托访问相应控件
if (this.tbReceivedData.InvokeRequired)
{
SerialDataReceivedEventHandler sdreh = new SerialDataReceivedEventHandler(myReceiveHandler);
this.Invoke(sdreh, new object[] { sender, e });
}
else
{
if (flag)
{
byte[] buffer = new byte[tempPort.BytesToRead];
tempPort.Read(buffer, 0, buffer.Length);
String receivedData = Utils.Bytes2String(buffer);
this.tbReceivedData.AppendText(receivedData + "\r\n");
}
else
{
byte[] buffer = new byte[comm.BytesToRead];
comm.Read(buffer, 0, buffer.Length);
String receivedData = Utils.Bytes2String(buffer);
this.tbReceivedData.AppendText(receivedData + "\r\n");
}
}
}
public MainWindow()
{
InitializeComponent();
COM3 = new SerialPort("COM3", BaudRate, ParityMode, dataBits, stopBits)
{
ReadTimeout = timeout,
WriteTimeout = timeout
};
//COM3.Open();
COM4 = new SerialPort("COM4", BaudRate, ParityMode, dataBits, stopBits)
{
ReadTimeout = timeout,
WriteTimeout = timeout
};
COM4.Open();
//COM4.NewLine = "\n";
//readThreadCOM3 = new Thread(ReadCOM3);
//readThreadCOM3.Start();
readThreadCOM4 = new Thread(ReadCOM4);
//readThreadCOM4.Start();
reev = new SerialDataReceivedEventHandler(DataReceivedHandler);
COM4.DataReceived += reev;
StopperAccurate = new System.Diagnostics.Stopwatch();
}
public NMEASerialPort(SerialPortSettings portSettings)
: base()
{
#region serialPort initialization
if (portSettings == null)
{
throw new ArgumentNullException("portSettings");
}
PortSettings = portSettings;
serialPort = new SerialPort(
PortSettings.PortName,
(int)PortSettings.PortBaudRate,
PortSettings.PortParity,
(int)PortSettings.PortDataBits,
PortSettings.PortStopBits);
serialPort.Handshake = portSettings.PortHandshake;
serialPort.Encoding = Encoding.ASCII;
serialPort.WriteTimeout = 1000;
serialPort.ReadTimeout = 1000;
serialPort.ReceivedBytesThreshold = 1;
serialErrorReceivedHandler = new SerialErrorReceivedEventHandler(serialPort_ErrorReceived);
serialDataReceivedHandler = new SerialDataReceivedEventHandler(serialPort_DataReceived);
#endregion
}
private void doOpen()
{
m_serialPort = new SerialPort(m_port, 256000, Parity.None, 8, StopBits.One);
// register for data received events
m_serialDataReceivedEventHandler = new SerialDataReceivedEventHandler(m_serialPort_DataReceived);
m_serialPort.DataReceived += m_serialDataReceivedEventHandler;
bool deviceFound = false;
for (DateTime now = DateTime.Now; DateTime.Now - now < new TimeSpan(0, 0, 5);)
{
try
{
m_serialPort.Open();
deviceFound = true;
break;
}
catch (IOException)
{
Thread.Sleep(100);
}
}
if (!deviceFound)
{
throw new BgApiException(string.Format("Cannot connect to device on port {0}", m_port));
}
m_stream = m_serialPort.BaseStream;
m_rxOffset = 0;
}
public CSerialPort(SerialPort sp, HighLevelDataHandler handler)
{
string[] ports = null;
m_SPCurrent = sp;
m_SPReceiveHandler = new SerialDataReceivedEventHandler(DataReceiverHandler);
m_SPReceiveQueue = new Queue <string>();
// common setting for serial port
m_SPCurrent.NewLine = "\n";
m_SPCurrent.DataReceived += m_SPReceiveHandler;
m_SPCurrent.Encoding = Encoding.Default;
ports = SerialPort.GetPortNames();
if (ports.Length > 0)
{
m_SPCurrent.PortName = ports[0];
}
RegisterHighLevelDataHandler(handler);
m_SPCurrent.ReadTimeout = 100;
m_SPCurrent.WriteTimeout = 100;
ReadDataScheduler = new System.Timers.Timer(IntervalBetweenReceiveAndProcessDataMs);
ReadDataScheduler.Elapsed += new System.Timers.ElapsedEventHandler(ReadDataSchedulerHandler);
}
private bool DetectRate(int baudRate, int timeout)
{
var data = new byte[]
{
192
};
this.SerialPort.BaudRate = baudRate;
this.SerialPort.DiscardInBuffer();
this.SerialPort.DiscardOutBuffer();
using (var reset = new ManualResetEvent(false))
{
var handler = new SerialDataReceivedEventHandler((sender, e) =>
{
reset.Set();
});
this.SerialPort.DataReceived += handler;
try
{
this.Write(data);
return(reset.WaitOne(timeout));
}
finally
{
this.SerialPort.DataReceived -= handler;
}
}
}
public void AddEventHandler(SerialDataReceivedEventHandler handler)
{
if (null != _serialPort)
{
_serialPort.DataReceived += handler;
}
}
private void init_serial()
{
MATHLED.port = new SerialPort();
MATHLED.port_DataReceivedHandler = new SerialDataReceivedEventHandler(port_DataReceived);
MATHLED.port.DataReceived += port_DataReceivedHandler;
//Try to find arduino and auto connect
ManagementObjectSearcher manObjSearch = new ManagementObjectSearcher("Select * from Win32_SerialPort");
ManagementObjectCollection manObjReturn = manObjSearch.Get();
foreach (ManagementObject manObj in manObjReturn)
{
if (manObj["Description"].ToString().Contains("Arduino") && port.IsOpen == false)
{
Console.WriteLine("Found Arduino on: " + manObj["Name"].ToString());
//Disable button
string commPortTarget = manObj["DeviceID"].ToString();
toggleConnectionButton.Enabled = false;
portComboBox.SelectedIndex = portComboBox.Items.IndexOf(commPortTarget);
//MATHLED.port.PortName = commPortTarget;
//MATHLED.port.BaudRate = 57600;
//MATHLED.port.Open();
connect_serial(commPortTarget);
toggleConnectionButton.Enabled = true;
toggleConnectionButton.Text = "Disconnect";
}
}
}
public classSerial(string name, int baud, SerialDataReceivedEventHandler handler)
{
port = new SerialPort(name, baud);
port.Handshake = Handshake.None;
port.ReadTimeout = 1000;
if (handler != null)
{
port.DataReceived += handler;
}
try
{
if (!port.IsOpen)
{
port.Open();
ComPortOk = true;
FixComunicationProblem();
}
}
catch (Exception ex)
{
//MessageBox.Show(ex.Message);
ComPortOk = false;
ComPortErrorMessage = string.Format("Error:{0} not exist. COM function - DP comunication." + Environment.NewLine + ex.Message, name);
}
}
public BP_RESPONSE Connect()
{
BP_RESPONSE response = BP_RESPONSE.OK;
if (!IsConnected)
{
Open();
if (handler == null)
{
handler = new SerialDataReceivedEventHandler(BPPort_DataReceived);
DataReceived += handler;
}
if ((response = SendWait("", m_prompts, 5, 1000)) == BP_RESPONSE.OK)
{
IsConnected = true;
response = Info();
}
else
{
Close();
}
}
return(response);
}
public MainWindow()
{
// Init window
InitializeComponent();
// Init Kinect
kinectDevice = KinectSensor.GetDefault();
depthFrameReader = kinectDevice.DepthFrameSource.OpenReader();
depthFrameDescription = kinectDevice.DepthFrameSource.FrameDescription;
bodyFrameReader = kinectDevice.BodyFrameSource.OpenReader();
// Init Serialport
myPort = new SerialPort();
MySerialRecv = new SerialDataReceivedEventHandler(OnDataReceived);
// Init detection
bodyParts = new Joint[5];
angles = new double[3];
angle0 = new double[filterLength];
angle1 = new double[filterLength];
angle2 = new double[filterLength];
// Init window widgets
btnClear.IsEnabled = false;
btnClosePort.IsEnabled = false;
btnOpenPort.IsEnabled = false;
btnSend.IsEnabled = false;
btnCloseCam.IsEnabled = false;
lblAng0.Content = "Angle0 = ";
lblAng1.Content = "Angle1 = ";
lblAng2.Content = "Angle2 = ";
lblRHS.Content = "State = ";
// Serialport Options Init
foreach (int bdr in baudrates)
{
cbBRate.Items.Add(bdr.ToString());
}
cbBRate.SelectedIndex = 0;
ports = SerialPort.GetPortNames();
if (ports.Length > 0)
{
cbPortNO.SelectedIndex = 0;
btnOpenPort.IsEnabled = true;
}
else
{
cbPortNO.SelectedIndex = -1;
}
Array.Sort(ports);
foreach (string s in ports)
{
cbPortNO.Items.Add(s);
}
}
public RecordForm(SerialPort p)
{
InitializeComponent();
CurrentSerialPort = p;
dataReceivedEventHandler = new SerialDataReceivedEventHandler(serialPortDataReceived);
p.DataReceived += dataReceivedEventHandler;
}
public frmSGMLogin()
{
InitializeComponent();
frmMsg = new frmSGMMessage();
serialDatahandler = new SerialDataReceivedEventHandler(CardReaderReceivedHandler);
RFIDReader.RegistryReaderListener(Program.ReaderPort, serialDatahandler);
}
private void Dispose(bool fDisposing)
{
if (!m_fDisposed)
{
try
{
if (fDisposing)
{
if (m_callbacksErrorEvent != null)
{
m_evtErrorEvent.OnInterrupt -= new NativeEventHandler(ErrorEventHandler);
m_callbacksErrorEvent = null;
m_evtErrorEvent.Dispose();
}
if (m_callbacksDataEvent != null)
{
m_evtDataEvent.OnInterrupt -= new NativeEventHandler(DataEventHandler);
m_callbacksDataEvent = null;
m_evtDataEvent.Dispose();
}
}
if (m_fOpened)
{
Close();
}
}
finally
{
m_fDisposed = true;
m_fOpened = false;
}
}
}
public void ReceiverTest()
{
Receiver = (sender, args) =>
{
Console.WriteLine("GeneralCommands");
SerialPort sp = (SerialPort)sender;
string indata = sp.ReadExisting();
string message = MessageOfNumber(indata);
if (message != null)
{
Console.WriteLine("This is my message");
Console.WriteLine(message);
string number = OnlyNumber(message);
if (number != null)
{
Console.WriteLine("Only number: ");
Console.WriteLine(number);
}
}
Console.WriteLine("Data Received->");
Console.Write(indata);
Console.WriteLine("End of data received<-");
};
}
private Boolean connectToPort(string port,
int baudRate,
Parity parity,
int databits,
StopBits stopbits,
SerialDataReceivedEventHandler sport_DataReceived,
SerialErrorReceivedEventHandler sport_ErrorReceived,
out string messageResponse)
{
Boolean response = false;
CnnPort cnnPort = new CnnPort(port,
baudRate,
parity,
databits,
stopbits,
new SerialDataReceivedEventHandler(sport_DataReceived),
new SerialErrorReceivedEventHandler(sport_ErrorReceived));
if (cnnPort.Open(out messageResponse))
{
cnnPortList.Add(port, cnnPort);
response = true;
}
return(response);
}
public void SetComPort(SerialPort port)
{
this.comPort = port;
dataReceivedSubscription = new System.IO.Ports.SerialDataReceivedEventHandler(OnDatosRecebidos);
comPort.DataReceived += dataReceivedSubscription;
this.lbPuerto.Text = this.comPort.PortName;
}
/// <summary>
/// 当通知到有数据时处理（读取，与分析）
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnSerialPortDataCome(object sender, SerialDataReceivedEventArgs e)
{
if (m_IsTryToClosePort) // 关键！！！
{
return;
}
m_IsReceiving = true; // 关键!!!
try
{
if (threadCallHandler == null)
{
threadCallHandler = new SerialDataReceivedEventHandler(OnSerialPortDataCome);
}
//read
dataSrc = serialPort.ReadExisting();//读出缓冲区所有数据
if (dataSrc != "" && this.whenGetNew != null)
{
this.whenGetNew();
}
}
finally // 放在finally里面比较好。
{
m_IsReceiving = false; // 关键!!!
}
}
public static void RegistryReaderListener(SerialPort port, SerialDataReceivedEventHandler listener)
{
if (port != null && listener != null)
{
port.DataReceived += listener;
}
}
internal void OnDataReceived(SerialDataReceivedEventArgs args)
{
SerialDataReceivedEventHandler handler =
(SerialDataReceivedEventHandler)Events [data_received];
handler?.Invoke(this, args);
}
public RecordForm(SerialPort p)
{
InitializeComponent();
CurrentSerialPort = p;
dataReceivedEventHandler = new SerialDataReceivedEventHandler(serialPortDataReceived);
p.DataReceived += dataReceivedEventHandler;
}
public classSerial(string name, int baud, SerialDataReceivedEventHandler handler)
{
port = new SerialPort(name, baud, Parity.Even, 7, StopBits.One);
port.Handshake = Handshake.None;
port.ReadTimeout = 3000;
// source port.ReadTimeout = 1000;
if (handler != null)
{
port.DataReceived += handler;
}
try
{
if (!port.IsOpen)
{
port.Open();
}
}
catch (Exception ex)
{
//throw new System.ArgumentException(ex.Message);
ComPortOk = false;
ComPortErrorMessage = string.Format("Error: {0} not exist. COM function - DELTA(PLC).", port.PortName);
}
}
public PortCOM(string _portName, int _baudrate, Wskaznik _sf)
{
this.PortName = _portName;
this.BaudRate = _baudrate;
Console.WriteLine("Param write");
PortName = _portName;
BaudRate = _baudrate;
Parity = Parity.None;
DataBits = 8;
RtsEnable = false;
DtrEnable = false;
f = _sf;
DataReceived += new SerialDataReceivedEventHandler(f);
ReadBufferSize = 8192;
Console.WriteLine("Param writed");
try
{
Open();
Console.WriteLine("Opened");
}
catch (Exception)
{
MessageBox.Show("Problem z otwarciem COMu");
}
}
/// <summary>
/// 当通知到有数据达到时处理（读取，与分析）
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnSerialPortDataCome(object sender, SerialDataReceivedEventArgs e)
{
if (m_IsTryToClosePort) // 关键！！！
{
// 如果正在尝试关闭串口就退出
return;
}
m_IsReceiving = true; // 关键！！！
try
{
if (threadCallHandler == null)
{
threadCallHandler = new SerialDataReceivedEventHandler(OnSerialPortDataCome);
}
//定义存储接收数据的数组为1
byte[] result = new byte[1];
//定义接收字符串存储的数组、启示位置、长度
serialPort.Read(result, 0, result.Length);
// ASCII码
foreach (byte basc in result)
{
dataSrc = ((char)ulong.Parse(basc.ToString(), System.Globalization.NumberStyles.HexNumber - 10)).ToString();//减10，能得出正确的结果！！！
}
if (dataSrc != "" && this.whenGetNew != null)
{
this.whenGetNew();
}
}
finally // 放在finally里面比较好。
{
m_IsReceiving = false; // 关键！！！
}
}
private void CatchReceivedEvents(object src, SerialDataReceivedEventArgs e)
{
SerialDataReceivedEventHandler dataReceived = this.DataReceived;
SerialStream internalSerialStream = this.internalSerialStream;
if ((dataReceived != null) && (internalSerialStream != null))
{
lock (internalSerialStream)
{
bool flag = false;
try
{
flag = internalSerialStream.IsOpen && ((SerialData.Eof == e.EventType) || (this.BytesToRead >= this.receivedBytesThreshold));
}
catch
{
}
finally
{
if (flag)
{
dataReceived(this, e);
}
}
}
}
}
public bool Connect(string port,
int baudRate,
Parity parity,
int dataBits,
StopBits stopBits)
{
BaudRate = baudRate;
PortName = port;
Parity = parity;
DataBits = dataBits;
StopBits = stopBits;
try
{
DataReceived += new SerialDataReceivedEventHandler(OnDataReceived);
Open();
connected_ = true;
}
catch (Exception e)
{
string err = e.ToString();
connected_ = false;
}
return(connected_);
}
public static SerialPort port = new SerialPort(); // Глобальная переменная
private void button1_Click(object sender, EventArgs e)
{
if (!port.IsOpen)
{
try
{ // настройки порта
port.PortName = comboBox1.SelectedItem.ToString();
port.BaudRate = 38400;
port.DataBits = 8;
port.Parity = Parity.None;
port.StopBits = StopBits.One;
port.ReadTimeout = 1000;
port.WriteTimeout = 1000;
port.Open();
SerialDataReceivedEventHandler SerialPort_DataReceived = null;
port.DataReceived += SerialPort_DataReceived;
label1.Text = "Порт открыт.";
}
catch (Exception ex)
{
MessageBox.Show("ERROR: невозможно открыть порт:" + ex.ToString());
return;
}
}
}
/// <summary>
/// Init, need to OpenCOM()
/// </summary>
public SLCOM()
{
FindCOM();
Port = new SerialPort();
DataReceivedEventHandler = new SerialDataReceivedEventHandler(DataReceived);
ErrorReceivedEventHandler = new SerialErrorReceivedEventHandler(ErrorReceived);
PinChangedEventHandler = new SerialPinChangedEventHandler(PinChanged);
}
/// <summary>
/// Init, need to OpenCOM()
/// </summary>
public SLCOM()
{
FindCOM();
Port = new SerialPort();
DataReceivedEventHandler = new SerialDataReceivedEventHandler(DataReceived);
ErrorReceivedEventHandler = new SerialErrorReceivedEventHandler(ErrorReceived);
PinChangedEventHandler = new SerialPinChangedEventHandler(PinChanged);
}
public SerialCommunication(string comPort, SerialDataReceivedEventHandler handler)
{
Port = new SerialPort(comPort, 9600, Parity.None, 8, StopBits.One);
Console.WriteLine("Incoming Data:");
// Attach a method to be called when there is data waiting in the port's buffer
Port.DataReceived += handler;
}
public frmSGMStore()
{
InitializeComponent();
m_service = new SGM_Service.ServiceSoapClient();
frmMsg = new frmSGMMessage();
serialDatahandler = new SerialDataReceivedEventHandler(CardReaderReceivedHandler);
RFIDReader.RegistryReaderListener(Program.ReaderPort, serialDatahandler);
}
public WeldingControlForm(SerialPort serialPort)
{
InitializeComponent();
CurrentSerialPort = serialPort;
dataReceivedEventHandler = new SerialDataReceivedEventHandler(serialPortDataReceived);
CurrentSerialPort.DataReceived += dataReceivedEventHandler;
History = History.LatestHistory();
}
public WeldingControlForm(SerialPort serialPort)
{
InitializeComponent();
CurrentSerialPort = serialPort;
dataReceivedEventHandler = new SerialDataReceivedEventHandler(serialPortDataReceived);
CurrentSerialPort.DataReceived += dataReceivedEventHandler;
History = History.LatestHistory();
}
public ESP8266SerialSetup(String portName)
{
this.portName = portName;
port = new SerialPort(portName);
port.BaudRate = 57600;
port.Open();
onReceiveHandler = new SerialDataReceivedEventHandler(OnReceive);
port.DataReceived += onReceiveHandler;
port.NewLine = "\n";
}
public SerialComPort()
{
m_selectedPort = new SerialPort();
m_SerialUtilities = new SerialUtilities();
dataReceivedHandler = new SerialDataReceivedEventHandler(SerialDataReceived);
m_selectedPort.DataReceived += dataReceivedHandler;
errorReceivedHandler = new SerialErrorReceivedEventHandler(ErrorReceivedHandler);
m_selectedPort.ErrorReceived += errorReceivedHandler;
}
public C2Flash(string portname, int baud)
: base(portname)
{
BaudRate = baud;
DataBits = 8;
Handshake = Handshake.None;
NewLine = "\r";
Parity = Parity.None;
StopBits = StopBits.One;
DataReceived += new SerialDataReceivedEventHandler(Data_Received);
Responses = new List<string>(20);
}
/// <summary>
/// Инициализирует новый экземпляр класса SerialPortProvider, используя указанное имя порта, скорость передачи в бодах, бит четности,
/// биты данных, стоп-бит и базовый обработчик события.
/// </summary>
/// <param name="portName">Порт для использования.</param>
/// <param name="baudRate">Скорость в бодах.</param>
/// <param name="parity">Одно из значений Parity.</param>
/// <param name="dataBits">Число битов данных.</param>
/// <param name="stopBits">Одно из значений StopBits.</param>
/// <param name="handler">Делегат-обработчик события - получения данных.</param>
public SerialPortProvider(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits,
SerialDataReceivedEventHandler handler)
{
_sp = new SerialPort(portName, baudRate, parity, dataBits, stopBits)
{
RtsEnable = true,
DtrEnable = true
};
//Позволяет избежать проверок на NullReferenceException, если обработчкику события присвоено null.
_sp.DataReceived += delegate { };
_sp.DataReceived += handler;
_sp.Open();
}
public frmSGMRechargeCard()
{
InitializeComponent();
m_bRecharge = false;
m_bChangeCard = false;
m_stCusID = "";
m_stCardID = "";
m_cardDTO = null;
m_iPriceGas95 = 0;
m_iPriceGas92 = 0;
m_iPriceGasDO = 0;
m_service = new SGM_Service.ServiceSoapClient();
frmMsg = new frmSGMMessage();
serialDatahandler = new SerialDataReceivedEventHandler(CardReaderReceivedHandler);
RFIDReader.RegistryReaderListener(Program.ReaderPort, serialDatahandler);
}
protected internal void OpenPort()
{
port = new SerialPort(comPort, baudRate, Parity.None, 8, StopBits.One);
port.DtrEnable = true;
port.DiscardNull = true;
port.ReadBufferSize = BUFFER_SIZE;
port.WriteBufferSize = BUFFER_SIZE;
port.ReadTimeout = TIMEOUT;
port.WriteTimeout = TIMEOUT;
port.Handshake = Handshake.RequestToSend;
port.ReceivedBytesThreshold = 1;
port.DiscardNull = true;
port.Open();
onReceiveHandler = new SerialDataReceivedEventHandler(OnReceive);
port.DataReceived += onReceiveHandler;
}
public CnnPort(string port,
int baudRate,
Parity parity,
int databits,
StopBits stopbits,
SerialDataReceivedEventHandler sport_DataReceived,
SerialErrorReceivedEventHandler sport_ErrorReceived)
{
sport = new SerialPort (port, baudRate, parity, databits, stopbits);
try {
sport.Close ();
} catch (Exception) {}
sport.DataReceived += sport_DataReceived;
sport.ErrorReceived += sport_ErrorReceived;
}
public Boolean Close(SerialDataReceivedEventHandler sport_DataReceived,
SerialErrorReceivedEventHandler sport_ErrorReceived)
{
Boolean result = false;
try
{
sport.Close();
sport.DataReceived -= sport_DataReceived;
sport.ErrorReceived -= sport_ErrorReceived;
result = true;
}
catch (Exception ex)
{
Logger logger = LogManager.GetCurrentClassLogger();
logger.Error(ex,ex.Message);
}
return result;
}
Task<byte[]> sendCmd(byte[] cmd, int n = 0)
{
var result = new TaskCompletionSource<byte[]>();
lock (_port)
{
var response = new byte[n];
SerialDataReceivedEventHandler cb = new SerialDataReceivedEventHandler((o, e) => { });
cb = new SerialDataReceivedEventHandler((o, e) =>
{
_port.DataReceived -= cb;
_port.Read(response, 0, n);
result.TrySetResult(response);
});
_port.DataReceived += cb;
_port.Write(cmd, 0, cmd.Length);
}
return result.Task;
}
static IObservable<byte> CreatePortObservable(SerialPort port)
{
return Observable.Create<byte>(obs =>
{
// Alternative Rx-driven approach on the inside
//
// var rcv = Observable.FromEvent<SerialDataReceivedEventArgs>(port, "DataReceived");
// var err = Observable.FromEvent<SerialErrorReceivedEventArgs>(port, "ErrorReceived");
var rcv = new SerialDataReceivedEventHandler((sender, e) =>
{
if (e.EventType == SerialData.Eof)
{
obs.OnCompleted();
}
else
{
var buf = new byte[port.BytesToRead];
for (int i = 0; i < port.Read(buf, 0, buf.Length); i++)
obs.OnNext(buf[i]);
}
});
port.DataReceived += rcv;
var err = new SerialErrorReceivedEventHandler((sender, e) =>
{
obs.OnError(new Exception(e.EventType.ToString()));
});
port.ErrorReceived += err;
return () =>
{
port.DataReceived -= rcv;
port.ErrorReceived -= err;
// depending on ownership of port, you could Dispose it here too
};
});
}
/// <summary>
/// Инициализирует новый экземпляр класса SerialPortProvider, используя указанное имя порта.
/// </summary>
/// <param name="portName">Имя порта.</param>
/// <param name="handler">Делегат-обработчик события - получения данных.</param>
public SerialPortProvider(string portName, SerialDataReceivedEventHandler handler)
: this(portName, 9600, Parity.None, 8, StopBits.One, handler)
{
}
public void OpenPort(String commPort, SerialDataReceivedEventHandler handler)
{
// connect via port selected
PortName = commPort;
// open connection to quadrotor bluetooth
Open();
ReadTimeout = 1000;
WriteTimeout = 1000;
// connect to device
WriteLine("C,0006666007BA");
// change color of connection status
// start reading
DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
DataReceived += handler;
new Thread(InitializeQuad);
}
private Boolean connectToPort( string port,
int baudRate,
Parity parity,
int databits,
StopBits stopbits,
SerialDataReceivedEventHandler sport_DataReceived,
SerialErrorReceivedEventHandler sport_ErrorReceived,
out string messageResponse)
{
Boolean response = false;
CnnPort cnnPort = new CnnPort ( port,
baudRate,
parity,
databits,
stopbits,
new SerialDataReceivedEventHandler(sport_DataReceived),
new SerialErrorReceivedEventHandler(sport_ErrorReceived));
if (cnnPort.Open (out messageResponse)) {
cnnPortList.Add (port, cnnPort);
response = true;
}
return response;
}
void InitializeUI()
{
dataReceivedEventHandler = new SerialDataReceivedEventHandler(serialPortDataReceived);
string portName = Properties.Settings.Default.SerialPortName;
string[] ports = SerialPort.GetPortNames();
portsBox.Items.Clear();
foreach (var port in ports)
{
portsBox.Items.Add(port);
}
if (portsBox.Items.IndexOf(portName) == -1)
{
portsBox.Text = "";
Properties.Settings.Default.SerialPortName = "";
try
{
Properties.Settings.Default.Save();
}
catch (Exception excp)
{
Console.WriteLine(excp.Message);
}
}
else
{
portsBox.Text = portName;
openPortWithName(portName);
}
UpdateTemplateLabel();
#if DEBUG
if (currentSerialPort == null)
{
return;
}
//SimulateSignal(1);
#endif
}
public void Disconnect()
{
IsConnected = false;
if (handler != null)
{
DataReceived -= handler;
handler = null;
}
if (IsOpen)
Close();
}
public BP_RESPONSE Connect()
{
BP_RESPONSE response = BP_RESPONSE.OK;
if (!IsConnected)
{
Open();
if (handler == null)
{
handler = new SerialDataReceivedEventHandler(BPPort_DataReceived);
DataReceived += handler;
}
if ((response = SendWait("", m_prompts, 5, 1000)) == BP_RESPONSE.OK)
{
IsConnected = true;
response = Info();
}
}
return response;
}
/// <summary>
/// 当通知到有数据时处理（读取，与分析）
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnSerialPortDataCome(object sender, SerialDataReceivedEventArgs e)
{
if (m_IsTryToClosePort) // 关键！！！
{
return;
}
m_IsReceiving = true; // 关键!!!
try
{
if (threadCallHandler == null)
{
threadCallHandler = new SerialDataReceivedEventHandler(OnSerialPortDataCome);
}
//read
dataSrc = serialPort.ReadExisting();//读出缓冲区所有数据
if (dataSrc != "" && this.whenGetNew != null)
{
this.whenGetNew();
}
}
finally // 放在finally里面比较好。
{
m_IsReceiving = false; // 关键!!!
}
}
private void OpenSerialPort()
{
try
{
StopSerialPorts();
inputSerial = new SerialPort();
inputSerial.BaudRate = Properties.Settings.Default.InputBaudRate;
inputSerial.DataBits = Properties.Settings.Default.InputDataBits;
inputSerial.StopBits = Properties.Settings.Default.InputStopBits;
inputSerial.Parity = Properties.Settings.Default.InputParity;
inputSerial.PortName = Properties.Settings.Default.InputPortName;
try
{
inputSerial.Open();
statusKoneksiInput.Text = "Input connected to Port : " + inputSerial.PortName;
inputDataReceivedEventHandler = new SerialDataReceivedEventHandler(InputSerialDataReceived);
inputSerial.DataReceived += inputDataReceivedEventHandler;
inputErrorReceivedEventHandler = new SerialErrorReceivedEventHandler(InputSerialErrorReceived);
inputSerial.ErrorReceived += inputErrorReceivedEventHandler;
}
catch (Exception ex)
{
statusKoneksiInput.ForeColor = Color.Red;
statusKoneksiInput.Text = "Gagal Koneksi Ke Input";
}
gateSerial = new SerialPort();
gateSerial.BaudRate = Properties.Settings.Default.GateBaudRate;
gateSerial.DataBits = Properties.Settings.Default.GateDataBits;
gateSerial.StopBits = Properties.Settings.Default.GateStopBits;
gateSerial.Parity = Properties.Settings.Default.GateParity;
gateSerial.PortName = Properties.Settings.Default.GatePortName;
try
{
gateSerial.Open();
statusKoneksiPortal.Text =
"Gate connected to Port :" + gateSerial.PortName;
gateDataReceivedEventHandler = new SerialDataReceivedEventHandler(GateSerialDataReceived);
gateSerial.DataReceived += gateDataReceivedEventHandler;
gateErrorReceivedEventHandler = new SerialErrorReceivedEventHandler(GateErrorReceived);
gateSerial.ErrorReceived += gateErrorReceivedEventHandler;
}
catch (Exception ex)
{
statusKoneksiPortal.ForeColor = Color.Red;
statusKoneksiPortal.Text = "Gagal Koneksi ke Portal";
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + ex.StackTrace);
}
}
private void frmSGMSaleGas_Load(object sender, EventArgs e)
{
SGM_WaitingIdicator.WaitingForm.waitingFrm.SetParentForm(this);
serailReaderHandler = new SerialDataReceivedEventHandler(CardReaderReceivedHandler);
RFIDReader.RegistryReaderListener(Program.ReaderPort, serailReaderHandler);
_cardDTO = null;
_rechargeDTO = null;
txtMoney.Text = _moneyBuying.ToString(MONEY_FORMAT);
lblTitle.Text = _gasStationDTO.GasStationName;
resetForm();
lblCurrentPrice.Text = SGMText.SALEGAS_CURRENT_PRICE + SGMText.GAS_92_TEXT + " : " + m_iCurrentPriceGas92 + " - " + SGMText.GAS_95_TEXT + " : " + m_iCurrentPriceGas95 + " - " + SGMText.GAS_DO_TEXT + " : " + m_iCurrentPriceGasDO;
EnableTransaction(false, true);
}
/// <summary>
/// Abrir con el SerialPort el objeto de PuertoSeleccionado.
/// Si está abierto, cierra con el SerialPort el objeto de PuertoAnterior
/// </summary>
/// <returns></returns>
public bool AbrirPuertoCom()
{
success = false;
DatoRecibidoSerialEventHandler = new SerialDataReceivedEventHandler(DatoRecibido);
ErrorRecibidoSerialEventHandler = new SerialErrorReceivedEventHandler(ErrorRecibido);
try
{
if (PuertoComExiste)
{
if (PuertoAnterior.IsOpen)
CerrarPuertoCom(PuertoAnterior);
if (!(PuertoSeleccionado.IsOpen) | PuertoCambiado)
{
PuertoSeleccionado.Open();
if (PuertoSeleccionado.IsOpen)
{
//El puerto está abierto. Setear los parametros adicionales.
//Timeouts son en milisegundos.
PuertoSeleccionado.ReadTimeout = Convert.ToInt32(TiemposEnum.CincoSegundos);
PuertoSeleccionado.WriteTimeout = Convert.ToInt32(TiemposEnum.CincoSegundos);
//Especificar las rutinas que se ejecutan cuando un evento de DatoRecibido o ErrorRecibido ocurre.
PuertoSeleccionado.DataReceived += DatoRecibidoSerialEventHandler;
PuertoSeleccionado.ErrorReceived += ErrorRecibidoSerialEventHandler;
//Enviar dato a otro modulo.
if (InterfazUsuarioDatoVista != null)
{
InterfazUsuarioDatoVista("AjustesActualesDisplay", string.Empty, Color.Black);
InterfazUsuarioDatoVista("EstadoDisplay", string.Empty, Color.Black);
}
success = true;
//El puerto está abierto con los parametros actuales.
PuertoCambiado = false;
}
}
}
}
catch (InvalidOperationException ex)
{
ParametroCambiado = true;
PuertoCambiado = true;
DisplayException(NombreModulo, ex);
}
catch (UnauthorizedAccessException ex)
{
ParametroCambiado = true;
PuertoCambiado = true;
DisplayException(NombreModulo, ex);
}
catch (System.IO.IOException ex)
{
ParametroCambiado = true;
PuertoCambiado = true;
DisplayException(NombreModulo, ex);
}
return success;
}
private void doOpen()
{
m_serialPort = new SerialPort(m_port, 256000, Parity.None, 8, StopBits.One);
// register for data received events
m_serialDataReceivedEventHandler = new SerialDataReceivedEventHandler(m_serialPort_DataReceived);
m_serialPort.DataReceived += m_serialDataReceivedEventHandler;
bool deviceFound = false;
for (DateTime now = DateTime.Now; DateTime.Now - now < new TimeSpan(0, 0, 5); )
{
try
{
m_serialPort.Open();
deviceFound = true;
break;
}
catch (IOException)
{
Thread.Sleep(100);
}
}
if (!deviceFound)
{
throw new BgApiException(string.Format("Cannot connect to device on port {0}", m_port));
}
m_stream = m_serialPort.BaseStream;
m_rxOffset = 0;
}
private void FormGSMModemEmulator_Load(object sender, EventArgs e)
{
Logger.Init("activity.log");
try
{
string[] sp = SerialPort.GetPortNames();
foreach (string port in sp)
comboCOMPort.Items.Add(port);
comboCOMPort.Sorted = true;
grpAutomatic.Enabled = true;
grpManual.Enabled = false;
mnuAutomate_Click(null, null);
for (int index = 1; index <= INBOX_CAPACITY; ++index)
Inbox[index] = new SMS(EmptySMS);
btnReload_Click(null, null);
DequeueTimer.Enabled = true;
DequeueTimer.AutoReset = true;
DequeueTimer.Elapsed += new System.Timers.ElapsedEventHandler(DequeueTimer_Elapsed);
DequeueTimer.Start();
AutomatedRXTimer.Enabled = true;
AutomatedRXTimer.AutoReset = true;
AutomatedRXTimer.Elapsed += new System.Timers.ElapsedEventHandler(AutomatedRXTimer_Elapsed);
AutomatedRXTimer.Start();
SPortEventHandler = new SerialDataReceivedEventHandler(SPort_DataReceived);
comboCOMPort.SelectedIndex = comboCOMPort.Items.IndexOf(configXML.Settings["COMPort"].Value);
comboBaud.SelectedIndex = comboBaud.Items.IndexOf(configXML.Settings["Baud"].Value);
btnConnect_Click(null, null);
}
catch
{
// Do nothing
}
}
protected override void Dispose(bool disposing)
{
if (!m_fDisposed)
{
try
{
if (disposing)
{
if (m_callbacksErrorEvent != null)
{
m_evtErrorEvent.OnInterrupt -= new NativeEventHandler(ErrorEventHandler);
m_callbacksErrorEvent = null;
m_evtErrorEvent.Dispose();
}
if (m_callbacksDataEvent != null)
{
m_evtDataEvent.OnInterrupt -= new NativeEventHandler(DataEventHandler);
m_callbacksDataEvent = null;
m_evtDataEvent.Dispose();
}
}
if (m_fOpened)
{
Close();
}
}
finally
{
m_fDisposed = true;
m_fOpened = false;
}
}
base.Dispose(disposing);
}
/// <summary>
/// Open the SerialPort object selectedPort.
/// If open, close the SerialPort object previousPort.
/// </summary>
internal bool OpenComPort()
{
var success = false;
_serialDataReceivedEventHandler1 = DataReceived;
_serialErrorReceivedEventHandler1 = ErrorReceived;
try
{
if ( ComPortExists )
{
// The system has at least one COM port.
// If the previously selected port is still open, close it.
if ( PreviousPort.IsOpen )
{
CloseComPort( PreviousPort );
}
if ( ( !( ( SelectedPort.IsOpen ) ) | PortChanged ) )
{
SelectedPort.Open();
if ( SelectedPort.IsOpen )
{
// The port is open. Set additional parameters.
// Timeouts are in milliseconds.
SelectedPort.ReadTimeout = 5000;
SelectedPort.WriteTimeout = 5000;
System.Text.Encoding iso_8859_1 = System.Text.Encoding.GetEncoding("iso-8859-1");
SelectedPort.Encoding = System.Text.Encoding.GetEncoding(28591);
//SelectedPort.Encoding = Encoding.GetEncoding("Windows-1252");
// Specify the routines that run when a DataReceived or ErrorReceived event occurs.
SelectedPort.DataReceived += _serialDataReceivedEventHandler1;
SelectedPort.ErrorReceived += _serialErrorReceivedEventHandler1;
// Send data to other modules.
if ( null != UserInterfaceData ) UserInterfaceData( "DisplayCurrentSettings", new DataModel() );
if ( null != UserInterfaceData ) UserInterfaceData( "DisplayStatus",new DataModel());
success = true;
// The port is open with the current parameters.
PortChanged = false;
}
}
}
}
catch ( InvalidOperationException ex )
{
ParameterChanged = true;
PortChanged = true;
DisplayException( ModuleName, ex );
}
catch ( UnauthorizedAccessException ex )
{
ParameterChanged = true;
PortChanged = true;
DisplayException( ModuleName, ex );
}
catch ( System.IO.IOException ex )
{
ParameterChanged = true;
PortChanged = true;
DisplayException( ModuleName, ex );
}
return success;
}
/// <summary>
/// Open the SerialPort object selectedPort.
/// If open, close the SerialPort object previousPort.
/// </summary>
internal bool OpenComPort()
{
bool success = false;
SerialDataReceivedEventHandler1 = new SerialDataReceivedEventHandler(DataReceived);
SerialErrorReceivedEventHandler1 = new SerialErrorReceivedEventHandler(ErrorReceived);
try
{
if ( comPortExists )
{
// The system has at least one COM port.
// If the previously selected port is still open, close it.
if ( PreviousPort.IsOpen )
{
CloseComPort( PreviousPort );
}
if ( ( !( ( SelectedPort.IsOpen ) ) | PortChanged ) )
{
SelectedPort.Open();
if ( SelectedPort.IsOpen )
{
// The port is open. Set additional parameters.
// Timeouts are in milliseconds.
SelectedPort.ReadTimeout = 5000;
SelectedPort.WriteTimeout = 5000;
// Specify the routines that run when a DataReceived or ErrorReceived event occurs.
SelectedPort.DataReceived += SerialDataReceivedEventHandler1;
SelectedPort.ErrorReceived += SerialErrorReceivedEventHandler1;
// Send data to other modules.
if ( null != UserInterfaceData ) UserInterfaceData( "DisplayCurrentSettings", "", Color.Black );
if ( null != UserInterfaceData ) UserInterfaceData( "DisplayStatus", "", Color.Black );
success = true;
// The port is open with the current parameters.
PortChanged = false;
}
}
}
}
catch ( InvalidOperationException ex )
{
ParameterChanged = true;
PortChanged = true;
DisplayException( ModuleName, ex );
}
catch ( UnauthorizedAccessException ex )
{
ParameterChanged = true;
PortChanged = true;
DisplayException( ModuleName, ex );
}
catch ( System.IO.IOException ex )
{
ParameterChanged = true;
PortChanged = true;
DisplayException( ModuleName, ex );
}
return success;
}
