| public Read ( byte buffer, int offset, int count ) : int | ||
| buffer | byte | |
| offset | int | |
| count | int | |
| return | int | |
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;
}
