public static void Main() { SerialPort serialPort = new SerialPort("COM1", 115200, Parity.None); serialPort.ReadTimeout = 5000; // milliseconds serialPort.Open(); byte[] outBuffer = Encoding.UTF8.GetBytes("All right?\r\n"); byte[] inBuffer = new byte[2]; while (true) { Debug.Print("Request data"); serialPort.Write(outBuffer, 0, outBuffer.Length); int count = serialPort.Read(inBuffer, 0, 2); if (count == 2) { Debug.Print("Received expected two bytes!"); } else { if (count == 0) Debug.Print("No response!"); if (count == 1) Debug.Print("Not enough bytes received!"); } Debug.Print(string.Empty); } }
static void Main(string[] args) { SerialPort ser = new SerialPort( "COM1", (int)BaudRate.Baudrate115200 ); byte[] buf = new byte[26]; byte[] ret = new byte[26]; ser.Handshake = Handshake.XOnXOff; ser.DataReceived += new SerialDataReceivedEventHandler(ser_DataReceived); ser.Open(); Debug.Print("Initializing Serial Test"); for (int i = 0;i < buf.Length;i++) { buf[i] = (byte)('a' + i); } ser.Write(buf, 0, buf.Length); ser.Flush(); Thread.Sleep(1000); ser.DataReceived -= new SerialDataReceivedEventHandler(ser_DataReceived); ser.Write(buf, 0, buf.Length); Thread.Sleep(1000); ser.DataReceived += new SerialDataReceivedEventHandler(ser_DataReceived); ser.ErrorReceived += new SerialErrorReceivedEventHandler(ser_ErrorReceived); ser.Write(buf, 0, buf.Length); Thread.Sleep(3000); ser.Read(ret, 0, ret.Length); Thread.Sleep(10000); }
public void Read(SerialPort _serialPort, int commNum, string portName, Connection connection) { while (_continue) { try { int bytes = _serialPort.BytesToRead; //Console.WriteLine(bytes); if (bytes > 0) { watch.Start(); byte[] buffer = new byte[bytes]; _serialPort.Read(buffer, 0, bytes); decHand.readInput(buffer, commNum, decHand); freq += buffer.Length; if (watch.ElapsedMilliseconds > 5000) { watch.Stop(); Console.WriteLine("Sensor Node " + commNum + " Data Frequency (Bytes per Second): " + (freq / watch.Elapsed.Seconds));// 2 = freq/watch / 12 * 6 freq = 0; watch.Reset(); } } } catch (Exception exception) { Console.WriteLine("Read: " + exception.Message); Console.WriteLine(portName + " disconnected :" + commNum); DetectPortThread.connContainer.Remove(commNum); DetectPortThread.portList.Remove(portName); connection.disconnect(false); } }//end while }
private void DataReceived(object sender, SerialDataReceivedEventArgs e) { lock (NM) { try { Thread.Sleep(100); if (serialPort.IsOpen && serialPort.BytesToRead > 0) { int n = serialPort.BytesToRead; //先记录下来,避免某种原因,人为的原因,操作几次之间时间长,缓存不一致 ; byte[] buf = new byte[n]; //声明一个临时字节数组存储当前来的串口数据 received_count += n; //增加接收计数 serialPort.Read(buf, 0, n); //读取缓冲数据 // string eee= COMM.ReadLine(); for (int i = 0; i < buf.Length; i++) { DataReceivedstr_STR = System.Text.Encoding.Default.GetString(buf); DataReceivedstr = System.Text.Encoding.Default.GetString(buf); } } } catch (Exception) { } string dd = DataReceivedstr; } }
/// <summary> /// Функция посылает запрос в порт, потом отсчитывает время readTimeout и проверяет буфер порта на чтение. /// Таким образом обеспечивается одинаковый промежуток времени между запросами в порт. /// </summary> public async Task <byte[]> RequestAndRespawnConstPeriodAsync(byte[] writeBuffer, int nBytesRead, int readTimeout, CancellationToken ct) { if (!_port.IsOpen) { return(await Task <byte[]> .Factory.StartNew(() => null, ct)); } //очистили буферы порта _port.DiscardInBuffer(); _port.DiscardOutBuffer(); //отправили данные в порт _port.WriteTimeout = 500; _port.Write(writeBuffer, 0, writeBuffer.Length); //ждем ответа.... await Task.Delay(readTimeout, ct); //проверяем ответ var buffer = new byte[nBytesRead]; if (_port.BytesToRead >= nBytesRead) { _port.Read(buffer, 0, nBytesRead); return(buffer); } Debug.WriteLine($"Время на ожидание ответа вышло {_port.BytesToRead} >= {nBytesRead}"); throw new TimeoutException("Время на ожидание ответа вышло"); }
private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e) { while (m_SerialPort.BytesToRead > 0) { SerialPort sp = (SerialPort)sender; m_ReadCount += m_SerialPort.Read(m_ReceiveBuffer, m_ReadCount, 1024 - m_ReadCount); } }
private void btnMove_Click(object sender, EventArgs e) { string err = "Error: Please Enter valid Hex-Code!"; string pos = comPositions.Text; byte[] bit = new byte[6]; if (pos == "Position 1") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x1, 0x0, 0xBA }; } else if (pos == "Position 2") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x2, 0x0, 0xBB }; } else if (pos == "Position 3") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x3, 0x0, 0xBC }; } else if (pos == "Position 4") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x4, 0x0, 0xBD }; } else if (pos == "Position 5") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x5, 0x0, 0xBE }; } else if (pos == "Position 6") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x6, 0x0, 0xBF }; } else if (pos == "Position 7") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x7, 0x0, 0xC0 }; } else if (pos == "Position 8") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x8, 0x0, 0xC1 }; } else if (pos == "Position 9") { bit = new byte[] { 0xA5, 0x3, 0x11, 0x9, 0x0, 0xC2 }; } else if (pos == "Position 10") { bit = new byte[] { 0xA5, 0x3, 0x11, 0xA, 0x0, 0xC3 }; } else { txtError.Text = err; } sport.Write(bit, 0, 6); Thread.Sleep(200); byte[] move = new byte[sport.BytesToRead]; sport.Read(move, 0, sport.BytesToRead); }
public byte[] ReadBuffer() { byte[] Buffer_Get = null; Thread.Sleep(1000); int N = SP.BytesToRead; Buffer_Get = new byte[N]; SP.Read(Buffer_Get, 0, N); return(Buffer_Get); }
public void Poket_Read() { try { #region чтение из АЦП ReadBytes = port.Read(priem_nedoch, 0, 2007); #endregion } catch { } }
private string findUID(SerialPort port, int position, string bufferString) { char[] buffer = new char[1]; while(!bufferString.Contains("Card UID: ")){ port.Read(buffer, position, 1); bufferString += new string(buffer); return findUID(port, position++, bufferString); } char[] uid = new char[11]; port.Read(uid, position, 11); return new string(uid); }
public static void Main() { // A program to set the baud rate on a new HC-06 to // 115200 // SerialPort blueComms = new SerialPort(SerialPorts.COM1, 9600, Parity.None, 8, StopBits.One); blueComms.Open(); // // Rename the device // byte[] outBuffer = System.Text.Encoding.UTF8.GetBytes("AT+NAMEHC_A"); blueComms.Write(outBuffer, 0, outBuffer.Length); Thread.Sleep(2000); while (blueComms.BytesToRead > 0) { byte[] a = new byte[1] { 0 }; blueComms.Read(a, 0, 1); char[] cc = System.Text.Encoding.UTF8.GetChars(a, 0, a.Length); Debug.Print(cc.ToString()); Thread.Sleep(10); } // // Set the baud rate. // outBuffer = System.Text.Encoding.UTF8.GetBytes("AT+BAUD8"); blueComms.Write(outBuffer, 0, outBuffer.Length); Thread.Sleep(2000); blueComms.Close(); SerialPort blueFast = new SerialPort(SerialPorts.COM1, 115200, Parity.None, 8, StopBits.One); blueFast.Open(); outBuffer = System.Text.Encoding.UTF8.GetBytes("AT"); blueComms.Write(outBuffer, 0, outBuffer.Length); Debug.Print("After Baud rate set"); while (blueComms.BytesToRead > 0) { byte[] a = new byte[1] { 0 }; blueComms.Read(a, 0, 1); char[] cc = System.Text.Encoding.UTF8.GetChars(a, 0, a.Length); Debug.Print(cc.ToString()); Thread.Sleep(10); } }
/// <summary> /// Read the specified number of bytes. /// </summary> /// <param name='numBytes'> /// Number bytes. /// </param> public int Read(int numBytes, out string result) { int numRead = -1; try { numRead = m_serial.Read(m_receiveBuffer, 0, numBytes); result = System.Text.ASCIIEncoding.ASCII.GetString(m_receiveBuffer, 0, Mathf.Min(numBytes, numRead)); } catch (System.Exception e) { m_error = e.Message; result = ""; } return(result.Length); }
private void GetSerialData(object sender, SerialDataReceivedEventArgs e) { if ((fIsConnected) && (fComPort.BytesToRead > 0)) { try { byte[] buf; int read = 0; lock (fComPort) { read = fComPort.BytesToRead; buf = new byte[read]; read = fComPort.Read(buf, 0, read); } fBuffer.Put(buf, read); int cmdlen = 0; do { cmdlen = fBuffer.ExtractCommand(168, 13, 10, ref buf); if (cmdlen > 0) { ParseCommand(buf, cmdlen); } } while (cmdlen > 0); } catch (TimeoutException) { } } }
public String ReadData() { try { int n = _spPon1.BytesToRead; byte[] buf = new byte[n + 1]; // received_count += n; _spPon1.Read(buf, 0, n); String SerialIn = System.Text.Encoding.ASCII.GetString(buf, 0, n); return(SerialIn); //builder.Clear(); //this.Invoke((EventHandler)(delegate //{ // //直接按ASCII规则转换成字符串 // builder.Append(Encoding.ASCII.GetString(buf)); // //} // //追加的形式添加到文本框末端,并滚动到最后。 // tB1.AppendText(builder.ToString()); // series.Points.AddY(builder.ToString()); // //修改接收计数 // //label1.Text = "Get:" + received_count.ToString(); //})); } catch (Exception e) { MessageBox.Show(e.Message); return(""); } }
//! \brief read data from serial port public Boolean ReadDevice(ref Byte[] tData) { if (null == m_SerialPort) { return(false); } try { if (!m_SerialPort.IsOpen) { return(false); } else if (m_SerialPort.BytesToRead <= 0) { return(false); } tData = new Byte[m_SerialPort.BytesToRead]; if (m_SerialPort.Read(tData, 0, tData.Length) > 0) { return(true); } return(false); } catch (Exception Err) { m_ErrorInfo = Err.ToString(); return(false); } }
private void PortReceiveData(object sender, SerialDataReceivedEventArgs e) { byte[] receiveData = new byte[serialPort.BytesToRead]; try { int len = serialPort.Read(receiveData, 0, receiveData.Length); if (len > 0) { StringBuilder sb = new StringBuilder(); sb.Append(Encoding.Default.GetString(receiveData, 0, len)); string str = sb.ToString().Trim(); str = str.Trim("\n\r".ToCharArray()); ReceiveMsgEventArgs msg = new ReceiveMsgEventArgs(str); ReceiveDataEvent?.Invoke(this, msg); } } catch (Exception ex) { CommonModules.Notifier.NotifyHelper.Notify(CommonModules.Notifier.NotifyLevel.ERROR, $"串口{serialPort.PortName}接收数据出错,错误信息:{ex.Message}。"); } finally { serialPort.DiscardInBuffer(); } }
/// <summary> /// Determines whether [is device connected]. /// </summary> public static bool IsDeviceConnected(string portName) { using (var sp = new System.IO.Ports.SerialPort(portName, baudRates, parity, dataBits, stopBits)) { sp.Open(); sp.WriteLine(SendAcknoledge); int byteToRead = sp.BytesToRead; var inputData = new byte[byteToRead]; sp.Read(inputData, 0, byteToRead); var readData = System.Text.Encoding.Default.GetString(inputData); Console.WriteLine(string.Format(PortFoundMessage, sp.PortName)); Console.WriteLine(readData); var result = readData.StartsWith(ReceivedAcknoledge); if (result) { SetupDevice(sp, SetupMode.OneData); } sp.Close(); return(result); } }
public static void Main() { int count = 0; SerialPort SPort = new SerialPort(SerialPorts.COM2, 9600, Parity.None,8,StopBits.One); SPort.ReadTimeout = 1000; SPort.WriteTimeout = 1000; byte[] buf = new byte[5]; string CardId = ""; SPort.Open(); byte[] readCommand = { 0x21, 0x52, 0x57, 0x01, 0x03 }; int numCodes = 0; while (true) { //SPort.Write(new byte[] { 0xFF, 0xFF, 0X39, 0x44 }, 0, 4); SPort.Write(readCommand, 0, 5); SPort.Flush(); int readcnt = SPort.Read(buf, 0, SPort.BytesToRead); SPort.Flush(); string s = ""; if (buf[0] == 0x01 && numCodes < 10) { foreach (byte b in buf) { s = s + b.ToString() + ","; } if (s[0] == '1') { count++; Debug.Print(count.ToString() + ":" + s + "\n"); numCodes++; } } } }
/// <summary> /// serial port receive data packet /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void serialPortMode_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e) { try { if (TimeOut > 0) { System.Threading.Thread.Sleep(TimeOut); } DataLength = serialPortMode.BytesToRead; if (DataLength > 0) { if (DataLength > RtBuff.Length) { DataLength = RtBuff.Length; } serialPortMode.Read(RtBuff, 0, DataLength); b_SerialReceiveReady = true; } } catch { } }
private void sport_DataReceived(object sender, SerialDataReceivedEventArgs e) { DateTime dt = DateTime.Now; String dtn = dt.ToShortTimeString(); sport.DtrEnable = true; sport.RtsEnable = true; int bytes = sport.BytesToRead; byte[] buffer = new byte[bytes]; byte[] buffer1 = new byte[bytes]; sport.Read(buffer, 0, bytes); if (bytes >= 22) { //Buffer.BlockCopy(buffer, 1, buffer1, 0, 11); string g = System.Text.Encoding.ASCII.GetString(buffer); txtReceive.AppendText("[" + dtn + "] " + "Received: " + g + "\n"); } TextBox.CheckForIllegalCrossThreadCalls = false; //txtReceive.AppendText("[" + dtn + "] " + "Received: " + g + "\n"); }
static void Main(string[] args) { // initialize the sensor port, mine was registered as COM8, you may check yours // through the hardware devices from control panel SerialPort sensor = new SerialPort("COM4", 9600, Parity.None, 8, StopBits.One); int bytesToRead = 0; string message; sensor.Open(); try { while (true) { // check if there are bytes incoming bytesToRead = sensor.BytesToRead; if (bytesToRead > 0) { byte[] input = new byte[bytesToRead]; // read the Xbee's input sensor.Read(input, 0, bytesToRead); // convert the bytes into string message = System.Text.Encoding.UTF8.GetString(input); Console.WriteLine(message); } } } finally { // again always close the serial ports! sensor.Close(); } }
/// <summary> /// Check the serial port for data. If data is available, data is read and parsed. /// This is a loop the keeps running until the port is closed. /// </summary> private void Read() { int MilliSecondsWait = 10; string strData = ""; this.Open(); while (com.IsOpen) { int nBytes = com.BytesToRead; byte[] BufBytes; BufBytes = new byte[nBytes]; com.Read(BufBytes, 0, nBytes); strData += Encoding.GetEncoding("ASCII").GetString(BufBytes, 0, nBytes); string temp = ""; while (strData != temp) { temp = strData; strData = GetNmeaString(strData); } Thread.Sleep(MilliSecondsWait); if (DateTime.Now.Ticks - TimeSinceLastEvent > 10000000 * _TimeOut && !HasTimedOut) { HasTimedOut = true; FireEvent(GPSEventType.TimeOut, ""); } } }
private void serialPort_DataReceived(object sender, SerialDataReceivedEventArgs e) { System.IO.Ports.SerialPort sp = (System.IO.Ports.SerialPort)sender; if (sp.BytesToRead > 0 && sp.IsOpen) { try { int count = sp.BytesToRead; if (count > 0) { //Console.WriteLine("Recv线程id=" + System.Threading.Thread.CurrentThread.ManagedThreadId); byte[] buffer = new byte[count]; sp.Read(buffer, 0, count); _sendCount += buffer.Length; if (tcpServer != null && tcpServer.IsRunning && currClientState != null) { tcpServer.SyncSend(currClientState, buffer); if (sendCountChanged != null) { sendCountChanged(this, new CommDataCountEventArgs(_sendCount)); } } } } catch (Exception ex) { Console.WriteLine(ex.Message); } } }
/// <summary> /// 接收数据 /// </summary> public bool ReadData() { try { //comportIsReading = true; if (ComPort_2.BytesToRead > 0) { int read_buffer_length = ComPort_2.BytesToRead; Read_Buffer = new byte[read_buffer_length]; ComPort_2.Read(Read_Buffer, 0, read_buffer_length); List <byte> buffer = Read_Buffer.ToList(); All_Content_byte.AddRange(buffer.ToList()); //All_Content += Encoding.Default.GetString(buffer.ToArray()); return(true); } else { return(false); } //comportIsReading = false; } catch (Exception) { ComPort_2.DiscardInBuffer(); return(false); } }
private void ReadResponseBytes() { while (readContinue) { try { byte[] bytes = new byte[256]; var readLength = serialPort.Read(bytes, 0, bytes.Length); if (readLength > 0) { byte[] readBytes = new byte[readLength]; Array.Copy(bytes, 0, readBytes, 0, readLength); ResponseBytesHandler(readBytes); #if DEBUG Console.WriteLine($"DEVICE-READ: {BitConverter.ToString(readBytes)}"); System.Diagnostics.Debug.WriteLine($"READ: {BitConverter.ToString(readBytes)}"); #endif } } catch (TimeoutException) { } catch (Exception) { } } }
private byte[] ReadByteInPort() { //Thread.Sleep(1000); byte[] r = new byte[_serialPort.BytesToRead]; try { _serialPort.Read(r, 0, _serialPort.BytesToRead); } catch (Exception ex) { Debug.WriteLine("Exception read byte in port: " + ex.ToString()); } finally { if (_serialPort.BytesToRead != 0) { _serialPort.DiscardInBuffer(); } Debug.WriteLine("Read byte in port finally"); } return(r); }
public string ReadMsg() { serialPort1.Open(); string rd = "null "; #region 读数据老方法 ////------------mothed1---- //int i = serialPort1.ReadBufferSize; // byte[] data = Convert.FromBase64String(serialPort1.ReadLine()); // rd = Encoding.Unicode.GetString(data); // // mothed2 //int DataLength = serialPort1.BytesToRead; //int i = 0; //StringBuilder sb = new StringBuilder(); //while (i < DataLength) //{ // byte[] ds = new byte[1024]; // int len = serialPort1.Read(ds, 0, 1024); // // sb.Append(Encoding.ASCII.GetString(ds, 0, len)); // sb.Append(ByteToString(ds)); // i += len; //} // // mothed2 //byte[] data= new byte[serialPort1.BytesToRead]; //int i = serialPort1.Read(data, 0, serialPort1.BytesToRead); //rd = ByteToString(data); #endregion // mothed3 byte[] data = new byte[serialPort1.BytesToRead]; int i = serialPort1.Read(data, 0, serialPort1.BytesToRead); rd = ByteToString(data); return(rd); }
private void serialPort_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e) { try { System.IO.Ports.SerialPort sp = (System.IO.Ports.SerialPort)sender; byte[] buffer = new byte[8]; if (sp.BytesToRead == 8) { sp.Read(buffer, 0, 8); _BufferSB.Clear(); } else { _BufferSB.Append(sp.ReadExisting()); if (_BufferSB.Length == 8) { Utilite.StrToMas(_BufferSB.ToString(), buffer); _BufferSB.Clear(); } else if (_BufferSB.Length > 8) { int pieces = (_BufferSB.Length / 8); int piecesSum = pieces * 8; if (piecesSum == _BufferSB.Length) { Utilite.StrToMas(_BufferSB.ToString().Substring(_BufferSB.Length - 8, 8), buffer); _BufferSB.Clear(); } else { int ix = _BufferSB.Length - piecesSum; string piece = _BufferSB.ToString().Substring(_BufferSB.Length - ix, ix); _BufferSB.Clear(); _BufferSB.Append(piece); } } } // Валидация if ((buffer[6] != 0) || (buffer[7] != 0)) { int CR = 0; for (int i = 0; i < 6; i++) { CR += buffer[i]; } string strCR = BitConverter.ToString(buffer, 6, 2).Replace("-", ""); if (CR == Utilite.HexToBase(strCR)) { buffer.CopyTo(_Response, 0); } } } catch (Exception ex) { _ExceptionMessage = ex.Message; _BufferSB.Clear(); } }
static public int GetWeight() { try { int W = 0; if (iniFile.ScaleType == 1) { port.DiscardInBuffer(); port.DiscardOutBuffer(); byte[] com = HexStringToByteArray("45"); port.Write(com, 0, 1); int k = (port.Read(com, 0, 1)); BitArray Ba = new BitArray(com); int k2 = (port.Read(com, 0, 1)); BitArray Ba2 = new BitArray(com); BitArray ba3 = new BitArray(16); for (int i = 0; i < 16; i++) { if (i < 8) { ba3.Set(i, Ba[i]); } else { ba3.Set(i, Ba2[i - 8]); } } W = getIntFromBitArray(ba3); } else if (iniFile.ScaleType == 2) { W = ScaleCasAD.GetWeight(); } return(W); } catch (Exception e) { Utils.ToCardLog("[Error] GetWeight " + e.Message); return(-1); } }
private void port_DataReceived(object sender, SerialDataReceivedEventArgs e) {//zxy // This method will be called when there is data waiting in the port's buffer // Read all the data waiting in the buffer and pasrse it /* http://forums.microsoft.com/MSDN/ShowPost.aspx?PageIndex=2&SiteID=1&PostID=293187 * You would need to use Control.Invoke() to update the GUI controls * because unlike Windows Forms events like Button.Click which are processed * in the GUI thread, SerialPort events are processed in a non-GUI thread * (more precisely a ThreadPool thread). */ if (bClosing)//如果要关闭串口,则此时不再处理串口数据 { return; } //如果正在关闭,忽略操作,直接返回,完成串口监听线程的一次循环 try { //设置标记,说明我已经开始处理数据, 一会儿要使用系统UI的。 int n = comport.BytesToRead; //先记录下来,避免某种原因,人为的原因,操作几次之间时间长,缓存不一致 byte[] buf = new byte[n]; //声明一个临时数组存储当前来的串口数据 received_count += n; //增加接收计数 comport.Read(buf, 0, n); //读取缓冲数据 //判断是否是显示为16进制 if (checkBoxHexView.Checked) { //依次的拼接出16进制字符串 foreach (byte b in buf) { builder.Append(b.ToString("X2") + " "); } } else { //直接按ASCII规则转换成字符串 builder.Append(Encoding.ASCII.GetString(buf)); } //追加的形式添加到文本框末端,并滚动到最后。 //this.txt_showinfo.Text = builder.ToString() + this.txt_showinfo.Text; HandleShowInfoText(builder.ToString()); builder.Remove(0, builder.Length); HandleReceivedCountText(received_count.ToString()); //this.lblReceivedCount.Text = received_count.ToString(); } catch (Exception ex) { MessageBox.Show(ex.Message); } //this.Invoke(new EventHandler(HandleSerialData)); }
/// <summary> /// 接收数据 /// </summary> public void ReadData() { Read_Buffer = new byte[2048]; if (Read_Flag) { Read_Flag = false; ComPort_3.Read(Read_Buffer, 0, 2048); } }
//读取一个字存储单元的数据 //public static bool ReadWord(int Address, Enums.StorageType storageType, out byte[] WordValue, int plcAdd) public static PPIReadWritePara ReadWord(PPIReadWritePara para) { int i = 0; byte fcs; if (!serialPort1.IsOpen) { serialPort1.Open(); } para.ByteAddress = para.ByteAddress * 8; PPIAddress ppiAddress = new PPIAddress(); ppiAddress.DAddress = Convert.ToByte(para.PlcAddress); byte[] Rbyte = ppiAddress.Rbyte; Rbyte[22] = 0x04; //Byte 22 为读取数据的长度,01: 1 Bit 02: 1 Byte 04: 1 Word 06: Double Word Rbyte[24] = 0x01; //一次读取的个数 if (para.StorageType == Enums.StorageType.V) { Rbyte[26] = 0x01; } else { Rbyte[26] = 0x00; } Rbyte[27] = (byte)para.StorageType; Rbyte[28] = Convert.ToByte(para.ByteAddress / 0x10000); Rbyte[29] = Convert.ToByte((para.ByteAddress / 0x100) & 0xff); //0x100 ->256; Rbyte[30] = Convert.ToByte(para.ByteAddress & 0xff); //低位,如320H,结果为20; for (i = 4, fcs = 0; i < 31; i++) { fcs += Rbyte[i]; } int tt = Convert.ToInt32(fcs) % 256;//添加的代码 mod 256 Rbyte[31] = Convert.ToByte(tt); byte[] Receives = ReceiveReadByte(serialPort1, Rbyte, ppiAddress); if (Receives != null) { receiveByte = ByteHelper.ByteToString(Receives); para.ReadValue = new byte[2]; serialPort1.Read(Receives, 0, 30); para.ReadValue[0] = Receives[25]; para.ReadValue[1] = Receives[26]; receiveByte = ByteHelper.ByteToString(Receives); para.IsSuceess = true; } return(para); }
static void Main(string[] args) { SerialPort device = new SerialPort("COM8", 9600); device.Open(); while (true) { string command = "0"; try { switch (Console.ReadKey().Key) { case ConsoleKey.LeftArrow: { command = "4"; break; } case ConsoleKey.RightArrow: { command = "3"; break; } case ConsoleKey.UpArrow: { command = "1"; break; } case ConsoleKey.DownArrow: { command = "2"; break; } default: { command = "0"; break; } } } catch (Exception ex) { break; } device.Write(command); char[] buffer = {'a'}; device.Read(buffer, 0, 1); Console.WriteLine(buffer); } device.Close(); }
// Event Data Receive private void ComPort_DataReceived(object sender, SerialDataReceivedEventArgs e) { bool isEndReceive = false; // Obtain the number of bytes waiting in the port's buffer int bytes = ComPort.BytesToRead; // Create a byte array buffer to hold the incoming data byte[] buffer = new byte[bytes]; // Read the data from the port and store it in our buffer ComPort.Read(buffer, 0, bytes); if (bytes > 250) { return; } // Character Timeout 50 ms CurrentTime = GetTimeInMilliseconds(); if (CountByte == 0) { PastTime = CurrentTime; } else { if (CurrentTime - PastTime > 50) { CountByte = 0; } } // копируем принятые данные в BufferPort for (int i = 0; i < bytes; i++) { BufferPort[CountByte + i] = buffer[i]; } CountByte += bytes; if (CountByte >= 4) { isEndReceive = true; } // if have finished receive if (isEndReceive) { // создаем строку sbReceive длиной CountByte*3 StringBuilder sbReceive = new StringBuilder(CountByte * 3); // выводим принятые данные в строку sbReceive for (int i = 0; i < CountByte; i++) { sbReceive.Append(Convert.ToString(BufferPort[i], 16).PadLeft(2, '0').PadRight(3, ' ')); } // сохроняем принятую строку strDataRecive = sbReceive.ToString(); CountByte = 0; } }
static byte[] ReadBytes(SerialPort serialPort, CancellationToken token) { var buffer = new byte[_sampleCount]; WaitForBytesReady(serialPort, buffer.Length, token); var count = serialPort.Read(buffer, 0, buffer.Length); Debug.Assert(count == buffer.Length); return buffer; }
public void FlushBuffer() { if (BytesWaiting > 0) { int bytes = port.BytesToRead; byte[] buffer = new byte[bytes]; port.Read(buffer, 0, bytes); ReceiveData(buffer); } }
public byte[] ReadBackBytes() { //byte[] bytes = new byte[10]; int counter = ComPort.BytesToRead; byte[] bytes = new byte[counter]; ComPort.Read(bytes, 0, counter); return(bytes); }
//TODO Desctructor to set off buzzer private void KeyUp() { while (true) { if (serialPort.BytesToRead == 0) { if (stack.Count == 0) { System.Threading.Thread.Sleep(50); continue; } } else { byte [] buffer = new byte[3]; serialPort.Read(buffer, 0, 3); String s = ""; foreach (byte b in buffer) { if (b < 48) { s = b.ToString(); break; } } stack.AddRange(s.Split(' ')); } try { String input = ReadNext(); if (input.Length == 0) { continue; } try { PosKey key = KeyMap.Get(input); ConsumeKey(this, new ConsumeKeyEventArgs(key)); } catch { continue; } } catch (TimeoutException) { Display.Log.Error("Timeout exception on serial keyboard"); } catch (Exception e) { Display.Log.Error(e); } } }
void OnSerialPortDataReceived(object sender, SerialDataReceivedEventArgs e) { if (e.EventType == SerialData.Chars) { byte[] readBuffer; lock (dataReadLock) { int numBytesToRead = serialPort.BytesToRead; readBuffer = new byte[numBytesToRead]; serialPort.Read(readBuffer, 0, numBytesToRead); } var handler = DataReceived; if (handler != null) { handler(this, new DeviceDataReceivedEventArgs(readBuffer)); } } }
static void Main(string[] args) { // initialize the sensor port, mine was registered as COM8, you may check yours // through the hardware devices from control panel SerialPort sensor = new SerialPort("COM8", 9600, Parity.None, 8, StopBits.One); int bytesToRead = 0; bool isPlaying = false; string message; sensor.Open(); try { while (true) { // check if there are bytes incoming bytesToRead = sensor.BytesToRead; if (bytesToRead > 0) { byte[] input = new byte[bytesToRead]; // read the Xbee's input sensor.Read(input, 0, bytesToRead); // convert the bytes into string message = System.Text.Encoding.UTF8.GetString(input); // in our case "MOVE" is what we will expect if ("MOVE".Equals(message)) { if (!isPlaying) { // this is where the wmplayer through process.start System.Diagnostics.Process pr; System.Diagnostics.ProcessStartInfo ps; // this is much like doing Start > Run > wmplayer <file> command ps = new System.Diagnostics.ProcessStartInfo("wmplayer", "\"C:\\Alarm.mp3\""); pr = new System.Diagnostics.Process(); pr.StartInfo = ps; pr.Start(); // start it finally isPlaying = true; // will not open another wmplayer anymore } // write something to the console Console.WriteLine("Something moved!"); } } } } finally { // again always close the serial ports! sensor.Close(); } }
public Program(string port) { serial = new SerialPort(port, 9600, Parity.None, 8, StopBits.One) { Handshake = Handshake.RequestToSend, NewLine = "\r", }; serial.DataReceived +=(o,e)=> { var num = serial.BytesToRead; if (num == 0) return; var data = new byte[num]; serial.Read(data, 0, num); foreach (var b in data) { switch (phase) { case 0: if (b == 0x0A) phase = 1; else message.Append((char) b); break; case 1: phase = (b == 0x30) ? 2 : 0; break; case 2: phase = (b == 0x30) ? 3 : 0; break; case 3: if (b == 0x0D) { if (message.Length > 0 && verbose) Console.WriteLine(message); lastMessage = message.ToString(); message.Clear(); syncEvent.Set(); } phase = 0; break; } } }; serial.Open(); //serial.RtsEnable = true; serial.DiscardOutBuffer(); serial.DiscardInBuffer(); }
public SerialPortThread(ToEcuBuffer toEcu, FromEcuBuffer fromEcu, SerialPort port) { _port = port; _toEcu = toEcu; _fromEcu = fromEcu; _port.DataReceived += (object sender, SerialDataReceivedEventArgs e) => { try { int count = _port.BytesToRead; while (count != 0) { count = Math.Min(count, _readBuff.Length); _port.Read(_readBuff, 0, count); _fromEcu.Write(_readBuff, 0, count); count = _port.BytesToRead; } } catch { } }; _writeTask = Task.Factory.StartNew(() => { while (_port.IsOpen) { try { int count = _toEcu.BytesToRead; while (count != 0) { count = Math.Min(count, _writeBuff.Length); _toEcu.Read(_writeBuff, 0, count); _port.Write(_writeBuff, 0, count); count = _toEcu.BytesToRead; } Thread.Sleep(1); Thread.Yield(); } catch { } } }); }
public static void Main() { // initialize the serial port which Xbee will use // COM1 is what i always use, it just works hehe SerialPort serialPort = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One); serialPort.ReadTimneout = 0; serialPort.Open(); try { while (true) { // check for incoming bytes int bytesToRead = serialPort.BytesToRead; // dim the LED pin13.Write(false); if (bytesToRead > 0) { // get the waiting data byte[] buffer = new byte[bytesToRead]; // READ any data received, this is necessary to consume the buffer // why? the Xbee buffer will be filled up and something weird will happen to Xbee serialPort.Read(buffer, 0, buffer.Length); // we can ignore the message anyway } // if there is motion detected if (pin8.Read()) { // then we will prepare sending the message byte[] buffer = new byte[MOVEMESSAGE.Length]; // convert the string to bytes buffer = System.Text.Encoding.UTF8.GetBytes(MOVEMESSAGE); // write it to Xbee through serial serialPort.Write(buffer, 0, buffer.Length); // turn the LED on pin13.Write(true); } // wait 500 seconds Thread.Sleep(500); } } finally { // always close the serial ports! serialPort.Close(); } }
public static void Main() { SerialPort serialPort = new SerialPort("COM1", 115200, Parity.None); serialPort.ReadTimeout = 0; serialPort.Open(); byte[] inBuffer = new byte[32]; while (true) { int count = serialPort.Read(inBuffer, 0, inBuffer.Length); if (count > 0) // Minimum one byte read { char[] chars = Encoding.UTF8.GetChars(inBuffer); string str = new string(chars, 0, count); Debug.Print(str); } Thread.Sleep(25); // Give device time to sleep } }
void Connect() { string[] names = SerialPort.GetPortNames(); List<string> Ports = new List<string>(); foreach (string name in names) { if (name != "COM1" && name != "COM2" && name != "COM3" && name != "COM4") Ports.Add(name); } for (int i = 0; i < Ports.Count && connected == false; i++) { port = new SerialPort(Ports[i], 115200, Parity.None, 8, StopBits.One); port.Open(); System.Threading.Thread.Sleep(50); int bytesAvail = port.BytesToRead; if (bytesAvail > 0) { while (bytesAvail > 0) { int toRead = Math.Min(bytesAvail, rxBuf.Length); int bytesRead = port.Read(rxBuf, 0, toRead ); if (bytesRead == 0) { bytesAvail = 0; break; } for (int j = 0; j < bytesRead; j++) { if (rxBuf[j] == '$') { connected = true; bytesAvail = 0; break; } } } } } }
static void Main(string[] args) { if (args.Length != 1) { Console.WriteLine("Usage: reconnect port"); return; } var serial = new SerialPort(args[0], 576000); var startCommand = new byte[] { 0xAA, 0xAA }; var stopCommand = new byte[] { 0xBB, 0xBB }; var getVerCommand = new byte[] { 0xCC, 0xCC }; var version = new byte[3]; while (true) { try { if (!serial.IsOpen) { serial.Open(); } else { serial.Write(getVerCommand, 0, 2); // *** Comment out/Uncomment this line, and see how the behaviour of // this program changes. //Thread.Sleep(200); if (serial.Read(version, 0, 3) == 3 && version[0] == 0x50) { Console.WriteLine("{0:x} {1:x} {2:x}", version[0], version[1], version[2]); } } } catch { Console.WriteLine("Oops!"); } Thread.Sleep(200); } }
static void Main(string[] args) { String port="COM9"; if (args.Length>0) port=args[0]; if (args.Length > 1) Process.Start(args[1]); try { com = new SerialPort(port, 57600, Parity.None, 8, StopBits.One); } catch (Exception e) { Console.WriteLine(e.Message); Console.ReadKey(false); return; } com.Open(); while (true) { byte[] buf = new byte[10]; com.ReadTimeout = Timeout.Infinite; int n=com.Read(buf,0,10); //FUNC.Sleep(1000); //int n = 10; Write("recv: "+FUNC.BytesToString(buf,0,n)); byte c = FUNC.CRC8(buf, 0, n - 1); if ((n == 10) && (c == buf[9])) { WriteLine(" [OK]"); ExcuteCmd(buf[3], buf[4]); } else { WriteLine(" [Failed]"); } FUNC.Sleep(30); } }
public static void Main() { SerialPort serial = new SerialPort(SerialPorts.COM1, 115200, Parity.None, 8, StopBits.One); serial.Open(); string Shadow = "Program Start!\r\n"; byte[] TxBuff; TxBuff = System.Text.Encoding.UTF8.GetBytes(Shadow); serial.Write(TxBuff, 0, TxBuff.Length); TxBuff = new byte[5];//clear data while (true) { while (serial.BytesToRead>=1) { serial.Read(TxBuff, 0, 1); serial.Write(TxBuff, 0, 1); } } }
public static void Main() { // initialize the serial port for COM1 (using D0 & D1) serial = new SerialPort("COM1", 115200, Parity.None, 8, StopBits.One); // open the serial-port, so we can send & receive data serial.Open(); // add an event-handler for handling incoming data //serial.DataReceived += new SerialDataReceivedEventHandler(serial_DataReceived); led.Write(false); int counter = 0; while (true) { // create a string string counter_string = "Count: " + counter.ToString() + "\r\n"; // create a single byte array byte[] bytes = new byte[1]; // as long as there is data waiting to be read while (serial.BytesToRead > 0) { // read a single byte serial.Read(bytes, 0, bytes.Length); // send the same byte back serial.Write(bytes, 0, bytes.Length); led.Write(!led.Read()); } // convert the string to bytes byte[] buffer = Encoding.UTF8.GetBytes(counter_string); // send the bytes on the serial port serial.Write(buffer, 0, buffer.Length); // increment the counter; counter++; Debug.Print(counter.ToString()); //wait... Thread.Sleep(500); } }
/// <summary> /// Get a byte[] from the serial port. /// Will keep reading until the port returns a 0. 0 bytes were read on the port /// </summary> /// <returns>The byte[] that has been sent by the other application</returns> protected byte[] GetBytes(SerialPort port) { byte[] bigBuffer = null; while (true) { //new up a buffer to read the available bytes byte[] buffer = new byte[port.BytesToRead]; //read all of the available bytes, only read the buffer length int count = port.Read(buffer, 0, buffer.Length); //combine what we had before with the new data bigBuffer = CombineArrays(buffer, bigBuffer); if (count <= 0) { var result = _channel.ConvertTo(bigBuffer); if (OnReceived != null) OnReceived(result, _port, _channel, DateTime.Now); } } return bigBuffer; }
public static void Main() { SerialPort SPort = new SerialPort(SerialPorts.COM2, 9600, Parity.None, 8, StopBits.One); SPort.ReadTimeout = 1000; SPort.WriteTimeout = 1000; byte[] buf = new byte[5]; string CardId = ""; SPort.Open(); byte[] writeCommand = { 0x21, 0x52, 0x57, 0x02, 0x03, 0x10, 0x20, 0x10, 0x21}; while (true) { SPort.Write(writeCommand, 0, 9); int readcnt = SPort.Read(buf, 0, SPort.BytesToRead); string s = ""; if (buf[0] == 0x01) { Debug.Print("Success"); } } }
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 }; }); }
public static void Run() { var serialPort = new SerialPort(); serialPort.PortName = "Test Name"; serialPort.BaudRate = 115200; serialPort.Parity = Parity.None; serialPort.DataBits = 1; serialPort.StopBits = StopBits.None; serialPort.Handshake = Handshake.None; serialPort.ReadTimeout = 500; serialPort.WriteTimeout = 500; serialPort.ReadBufferSize = 64; serialPort.WriteBufferSize = 64; serialPort.DataReceived += new SerialDataReceivedEventHandler(serialPort_DataReceived); serialPort.Open(); var bytes = new List<byte>(); serialPort.Write(bytes.ToArray(), 0, bytes.Count); serialPort.Read(bytes.ToArray(), 0, bytes.Count); serialPort.Close(); }
public override bool Initialize() { bool isValid = true; SerialPort spc = new SerialPort(); Thread.Sleep(1000); spc.BaudRate=BAUD_RATE; spc.PortName = "COM" + this.portNumber; if (this._Parity) spc.Parity = Parity.Odd; else spc.Parity = Parity.None; if (this._StopBit) spc.StopBits = StopBits.One; else spc.StopBits = StopBits.None; try { spc.Open(); } catch (Exception) { isValid = false; } if (isValid) { isValid = false; byte[] someData = new byte[4000]; int startTime = Environment.TickCount; // Loop for 1 second and wait for a DD while ((Environment.TickCount - startTime) < 1000) { int j = spc.Read(someData,0,someData.Length); //Console.WriteLine ("Data: " + someData.Length); if (j > 1) for (int i = 0; i < j - 1; i++) if ((someData[i] == (int)68) && (someData[i + 1] == (int)68)) isValid = true; Thread.Sleep(100); } } if (isValid) { this.spc = spc; //this._Running = true; this._Status = ReceiverStatus.Connected; } return isValid; }
private int ReadBytesInBackground(SerialPort serialPort, byte[] buffer) { bool timedOut = false; int result = 0; try { _BusyReading.Reset(); do { try { timedOut = false; while(!_Closing && serialPort.BytesToRead == 0) Thread.Sleep(1); // give up the rest of our time slice before trying again if(!_Closing) result = serialPort.Read(buffer, 0, buffer.Length); } catch(TimeoutException) { result = -1; timedOut = true; } } while(!_Closing && (timedOut || result == 0)); } finally { _BusyReading.Set(); } return result; }
static double get_com_distant(ref SerialPort sensor) { char[] buff = new char[1]; string s_distant = ""; // read port until '\n' try { for (sensor.Read(buff, 0, 1); buff[0] != '\n'; sensor.Read(buff, 0, 1)) s_distant += buff[0]; } catch (IOException) { } string[] split = s_distant.Split('c', 'm', '\n'); return Convert.ToDouble(split[0]); }
private void OpenSerialPort(string portName) { _serialPort = new SerialPort(portName); _serialPort.Encoding = System.Text.Encoding.ASCII; _serialPort.BaudRate = 115200; _serialPort.Parity = Parity.None; _serialPort.StopBits = StopBits.One; _serialPort.DataBits = 8; _serialPort.Handshake = Handshake.None; if (!_serialPort.IsOpen) { _serialPort.Open(); } _serialPortReader = new Thread(() => { try { while (true) { var bytesToRead = _serialPort.BytesToRead; if (bytesToRead > 0) { int bytesRead = _serialPort.Read(_serialPortBuffer, 0, Math.Min(_serialPortBuffer.Length, bytesToRead)); _parser.HandleData(_serialPortBuffer, bytesRead); } else { Thread.Sleep(1); } } } catch (ThreadAbortException) { } catch (Exception e) { Dispatcher.BeginInvoke((Action)(() => { Title = e.Message; })); } }); _serialPortReader.Start(); }
public static void Main() { Radio = new SerialPort("COM1", 9600); Radio.Open(); // Radio.DataReceived += new SerialDataReceivedEventHandler(UART_DataReceived); uint i = 0; while (true) { if (leftPwr != 0) leftMotor.SetPulse(100000, (uint)(((double)leftPwr / 100) * 90000.0)); else leftMotor.SetPulse(100000, 0); if (rightPwr != 0) rightMotor.SetPulse(100000, (uint)(((double)rightPwr / 100) * 90000.0)); else rightMotor.SetPulse(100000, 0); //leftMotor.SetPulse(100000, 90000); Thread.Sleep(1); string input = ""; // read the data try { read_count = Radio.Read(rx_data, 0, Radio.BytesToRead); if (read_count > 0) { for (int k = 0; k < read_count; k++ ) { if (rx_data[k] == '$') i = 0; else if (rx_data[k] == '*') { Radio.Flush(); for(int j = 0; j < i; j++) { input += (char)str[j]; } ParseCommand(input); i = 0; read_count = 0; } else { str[i] = rx_data[k]; i++; if (i > str.Length) i = 0; } } } } catch { } } }
public virtual bool Receive(SerialPort serialPort) { if (serialPort == null) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs("Invalid serial port. (null)"); OnError(this, e); } return false; } if (SlaveAddress == 0) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(String.Format("Invalid slave address. ({0})", SlaveAddress)); OnError(this, e); } return false; } if (CommandCode == 0) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(String.Format("Invalid command code. (0x{0x2})", CommandCode)); OnError(this, e); } return false; } if (!serialPort.IsOpen) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs("Serial port is not open."); OnError(this, e); } return false; } byte[] buf = new byte[1]; try { if (serialPort.Read(buf, 0, 1) < 1) return false; } catch (Exception ex) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(ex); OnError(this, e); } return false; } if (OnReceive != null) { LogEventArgs e = new LogEventArgs(buf, 1); OnReceive(this, e); } if (buf[0] != SlaveAddress) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(String.Format("Invalid slave address received. ({0})", buf[0])); OnError(this, e); } return false; } try { if (serialPort.Read(buf, 0, 1) < 1) return false; } catch (Exception ex) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(ex); OnError(this, e); } return false; } if (OnReceive != null) { LogEventArgs e = new LogEventArgs(buf, 1); OnReceive(this, e); } if (buf[0] != _commandCode + 1) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(String.Format("Invalid command code received. (0x{0x2})", buf[0])); OnError(this, e); } return false; } try { if (serialPort.Read(buf, 0, 1) < 1) return false; } catch (Exception ex) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(ex); OnError(this, e); } return false; } if (OnReceive != null) { LogEventArgs e = new LogEventArgs(buf, 1); OnReceive(this, e); } byte length = buf[0]; if (length < 4) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(String.Format("Invalid length received. ({0})", length)); OnError(this, e); } return false; } Length = length; _buffer[0] = SlaveAddress; _buffer[1] = (byte)(_commandCode + 1); _buffer[2] = length; int dataLen = 0; try { dataLen = serialPort.Read(_buffer, 3, Length - 3); } catch (Exception ex) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs(ex); OnError(this, e); } } if (OnReceive != null) { LogEventArgs e = new LogEventArgs(_buffer, 3, dataLen); OnReceive(this, e); } if (dataLen != Length) return false; if (_buffer[Length - 1] != Crc8(_buffer, Length - 1)) { if (OnError != null) { ErrorEventArgs e = new ErrorEventArgs("Receive CRC error."); OnError(this, e); } return false; } return true; }
public int runCheck() { SerialPort serialPort = new SerialPort(optSerialPort); byte[] buffer = new byte[1024]; int readBytes = 0; string s; int c = 0, i = 0; int retval = 0; switch(optParityIndex) { case 0: serialPort.Parity = Parity.None; break; case 1: serialPort.Parity = Parity.Odd; break; case 2: serialPort.Parity = Parity.Even; break; case 3: serialPort.Parity = Parity.Mark; break; case 4: serialPort.Parity = Parity.Space; break; default: return -1; } switch (optStopBitsIndex) { case 0: serialPort.StopBits = StopBits.One; break; case 1: serialPort.StopBits = StopBits.OnePointFive; break; case 2: serialPort.StopBits = StopBits.Two; break; case 3: serialPort.StopBits = StopBits.None; break; default: return -1; } serialPort.DataBits = optDataBitIndex+5; serialPort.BaudRate = optBaudrate; switch (optHandshakeIndex) { case 0: serialPort.Handshake = Handshake.None; break; case 1: serialPort.Handshake = Handshake.XOnXOff; break; case 2: serialPort.Handshake = Handshake.RequestToSend; break; default: return -1; } serialPort.ReadTimeout = optReadTimeout; try { serialPort.Open(); } catch { return -1; } for (i=0, c=0; i < optStrSendBeforeCheck.Length; i++) { if (optStrSendBeforeCheck[i] == '$') { i++; if (optStrSendBeforeCheck[i] == '$') buffer[c++] = (byte)'$'; else { string str = optStrSendBeforeCheck.Substring(i, 2); i++; buffer[c++] = (byte) Convert.ToByte(str, 16); } } else buffer[c++] = (byte) optStrSendBeforeCheck[i]; } serialPort.Write(buffer, 0, c); i = 0; buffer[0] = 0; try { do { readBytes = serialPort.Read(buffer, i, 1); if (readBytes > 0) { i += readBytes; } } while (i<1024); } catch (TimeoutException) { if (i == 0) { addTextCB("Timeout while waiting for answer\r\n"); serialPort.Close(); return 2; } } s = System.Text.Encoding.ASCII.GetString(buffer, 0, i); if (s.Contains(optStrCheck)) { addTextCB("expected string returned\r\n"); retval = 0; } else { addTextCB("unexpected string returned: " + s + "\r\n"); retval = 1; } serialPort.Close(); return retval; }