C#串口编程

最新推荐文章于 2024-04-28 10:21:24 发布
最新推荐文章于 2024-04-28 10:21:24 发布
阅读量4.8k 收藏 4
点赞数
分类专栏： C#.net 文章标签： c# 编程 attributes buffer callback byte

C#串口编程

   我们在移至一个MFC的串口操作，在调用win32API时，要定义一个DCB数据结构，可C#中没有位操作的功能，这下可把我难倒了，难道就用C#实现不了这样的数据结构么，结构到网上GOOGLE，看到VB的例子，原来数据结构可以不用完全一样（这也行啊～～～），最后从网上找到下面的这个例子，我将代码格式调整了一下：

/*
* Author: Marcus Lorentzon, 2001
* d98malor@dtek.chalmers.se
*
* Freeware: Please do not remove this header
*
* File: SerialStream.cs
*
* Description: Implements a Stream for asynchronous
* transfers and COMM. Stream version.
*
* Version: 2.4
*
*/

#region Using

using System;
using System.IO;
using System.Threading;
using System.Runtime.InteropServices;
using System.ComponentModel;

#endregion Using

namespace LoMaN.IO
{

public class SerialStream : Stream
{

#region Attributes

private IOCompletionCallback m_IOCompletionCallback;
private IntPtr m_hFile = IntPtr.Zero;
private string m_sPort;
private bool m_bRead;
private bool m_bWrite;

#endregion Attributes

#region Properties

 public string Port
 {
  get
  {
   return m_sPort;
  }
  set
  {
   if (m_sPort != value)
   {
    Close();
    Open(value);
   }
  }
}

 public override bool CanRead
 {
  get
  {
   return m_bRead;
  }
 }

 public override bool CanWrite
 {
  get
  {
   return m_bWrite;
  }
 }

 public override bool CanSeek
 {
  get
  {
   return false;
  }
 }

 public bool Closed
 {
  get
  {
   return m_hFile.ToInt32() 0;
  }
 }

 public bool Dsr
 {
  get
  {
   uint status;
   if (!GetCommModemStatus(m_hFile, out status))
   {
    throw new Win32Exception();
   }
   return (status & MS_DSR_ON) > 0;
  }
 }

 public bool Ring
 {
  get
  {
   uint status;
   if (!GetCommModemStatus(m_hFile, out status))
   {
    throw new Win32Exception();
   }
   return (status & MS_RING_ON) > 0;
  }
 }

 public bool Rlsd
 {
  get
  {
   uint status;
   if (!GetCommModemStatus(m_hFile, out status))
   {
    throw new Win32Exception();
   }
   return (status & MS_RLSD_ON) > 0;
  }
 }

 #endregion Properties

 #region Constructors

 public SerialStream() : this(FileAccess.ReadWrite)
 {
 }

 public SerialStream(FileAccess access)
 {
  m_bRead = ((int)access & (int)FileAccess.Read) != 0;
  m_bWrite = ((int)access & (int)FileAccess.Write) != 0;
  unsafe
  {
   m_IOCompletionCallback = new IOCompletionCallback(AsyncFSCallback);
  }
 }

 public SerialStream(string port) : this(FileAccess.ReadWrite)
 {
  Open(port);
 }

 public SerialStream(string port, FileAccess access) : this(access)
 {
  Open(port);
 }

 #endregion Constructors

 #region Methods

 public void Open(string port)
 {
  if (m_hFile != IntPtr.Zero)
  {
   throw new IOException("Stream already opened.");
  }
  m_sPort = port;
  m_hFile = CreateFile(port, (uint)((m_bRead?GENERIC_READ:0)|(m_bWrite?GENERIC_WRITE:0)), 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
  if (m_hFile.ToInt32() == INVALID_HANDLE_VALUE)
  {
   m_hFile = IntPtr.Zero;
   throw new FileNotFoundException("Unable to open " + port);
  }

  ThreadPool.BindHandle(m_hFile);

  SetTimeouts(0, 0, 0, 0, 0);
 }

 public override void Close()
 {
  CloseHandle(m_hFile);
  m_hFile = IntPtr.Zero;
  m_sPort = null;
 }

 public IAsyncResult BeginRead(byte[] buffer)
 {
  return BeginRead(buffer, 0, buffer.Length, null, null);
 }

 public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
 {
  GCHandle gchBuffer = GCHandle.Alloc(buffer, GCHandleType.Pinned);
  SerialAsyncResult sar = new SerialAsyncResult(this, state, callback, true, gchBuffer);
  Overlapped ov = new Overlapped(0, 0, sar.AsyncWaitHandle.Handle.ToInt32(), sar);
  unsafe
  {
   NativeOverlapped* nov = ov.Pack(m_IOCompletionCallback);
   byte* data = (byte*)((int)gchBuffer.AddrOfPinnedObject() + offset);

   uint read = 0;
   if (ReadFile(m_hFile, data, (uint)count, out read, nov))
   {
    sar.m_bCompletedSynchronously = true;
    return sar;
   }
   else if (GetLastError() == ERROR_IO_PENDING)
   {
    return sar;
   }
   else
    throw new Exception("Unable to initialize read. Errorcode: " + GetLastError().ToString());
  }
 }

 public IAsyncResult BeginWrite(byte[] buffer)
 {
  return BeginWrite(buffer, 0, buffer.Length, null, null);
 }

 public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
 {
  GCHandle gchBuffer = GCHandle.Alloc(buffer, GCHandleType.Pinned);
  SerialAsyncResult sar = new SerialAsyncResult(this, state, callback, false, gchBuffer);
  Overlapped ov = new Overlapped(0, 0, sar.AsyncWaitHandle.Handle.ToInt32(), sar);
  unsafe
  {
   NativeOverlapped* nov = ov.Pack(m_IOCompletionCallback);
   byte* data = (byte*)((int)gchBuffer.AddrOfPinnedObject() + offset);

   uint written = 0;
   if (WriteFile(m_hFile, data, (uint)count, out written, nov))
   {
    sar.m_bCompletedSynchronously = true;
    return sar;
   }
   else if (GetLastError() == ERROR_IO_PENDING)
   {
    return sar;
   }
   else
    throw new Exception("Unable to initialize write. Errorcode: " + GetLastError().ToString());
  }
 }

 private int EndOperation(IAsyncResult asyncResult, bool isRead)
 {
  SerialAsyncResult sar = (SerialAsyncResult)asyncResult;
  if (sar.m_bIsRead != isRead)
   throw new IOException("Invalid parameter: IAsyncResult is not from a " + (isRead ? "read" : "write"));
  if (sar.EndOperationCalled)
  {
   throw new IOException("End" + (isRead ? "Read" : "Write") + " called twice for the same operation.");
  }
  else
  {
   sar.m_bEndOperationCalled = true;
  }

  while (!sar.m_bCompleted)
  {
   sar.AsyncWaitHandle.WaitOne();
  }

  sar.Dispose();

  if (sar.m_nErrorCode != ERROR_SUCCESS && sar.m_nErrorCode != ERROR_OPERATION_ABORTED)
  {
   throw new IOException("Operation finished with errorcode: " + sar.m_nErrorCode);
  }

  return sar.m_nReadWritten;
 }

 public override int EndRead(IAsyncResult asyncResult)
 {
  return EndOperation(asyncResult, true);
 }

 public override void EndWrite(IAsyncResult asyncResult)
 {
  EndOperation(asyncResult, false);
 }

 public int EndWriteEx(IAsyncResult asyncResult)
 {
  return EndOperation(asyncResult, false);
 }

 public override int Read(byte[] buffer, int offset, int count)
 {
  return EndRead(BeginRead(buffer, offset, count, null, null));
 }

 public override void Write(byte[] buffer, int offset, int count)
 {
  EndWrite(BeginWrite(buffer, offset, count, null, null));
 }

 public int WriteEx(byte[] buffer, int offset, int count)
 {
  return EndWriteEx(BeginWrite(buffer, offset, count, null, null));
 }

 public int Read(byte[] buffer)
 {
  return EndRead(BeginRead(buffer, 0, buffer.Length, null, null));
 }

 public int Write(byte[] buffer)
 {
  return EndOperation(BeginWrite(buffer, 0, buffer.Length, null, null), false);
 }

 public override void Flush()
 {
  FlushFileBuffers(m_hFile);
 }

 public bool PurgeRead()
 {
  return PurgeComm(m_hFile, PURGE_RXCLEAR);
 }

 public bool PurgeWrite()
 {
  return PurgeComm(m_hFile, PURGE_TXCLEAR);
 }

 public bool Purge()
 {
  return PurgeRead() && PurgeWrite();
 }

 public bool CancelRead()
 {
  return PurgeComm(m_hFile, PURGE_RXABORT);
 }

 public bool CancelWrite()
 {
  return PurgeComm(m_hFile, PURGE_TXABORT);
 }

 public bool CancelAll()
 {
  return CancelRead() && CancelWrite();
 }

 public override void SetLength(long nLength)
 {
  throw new NotSupportedException("SetLength isn't supported on serial ports.");
 }

 public override long Seek(long offset, SeekOrigin origin)
 {
  throw new NotSupportedException("Seek isn't supported on serial ports.");
 }

 public void SetTimeouts(int ReadIntervalTimeout,
  int ReadTotalTimeoutMultiplier,
  int ReadTotalTimeoutConstant,
  int WriteTotalTimeoutMultiplier,
  int WriteTotalTimeoutConstant)
 {
  SerialTimeouts Timeouts = new SerialTimeouts(ReadIntervalTimeout,
   ReadTotalTimeoutMultiplier,
   ReadTotalTimeoutConstant,
   WriteTotalTimeoutMultiplier,
   WriteTotalTimeoutConstant);
  unsafe
  {
   SetCommTimeouts(m_hFile, ref Timeouts);
  }
 }

 public bool SetPortSettings(uint baudrate)
 {
  return SetPortSettings(baudrate, FlowControl.Hardware);
 }

 public bool SetPortSettings(uint baudrate, FlowControl flowControl)
 {
  return SetPortSettings(baudrate, flowControl, Parity.None);
 }

 public bool SetPortSettings(uint baudrate, FlowControl flowControl, Parity parity)
 {
  return SetPortSettings(baudrate, flowControl, parity, 8, StopBits.One);
 }

 public bool SetPortSettings(uint baudrate, FlowControl flowControl, Parity parity, byte databits, StopBits stopbits)
 {
  unsafe
  {
   DCB dcb = new DCB();
   dcb.DCBlength = sizeof(DCB);
   dcb.BaudRate = baudrate;
   dcb.ByteSize = databits;
   dcb.StopBits = (byte)stopbits;
   dcb.Parity = (byte)parity;
   dcb.fParity = (parity > 0)? 1U : 0U;
   dcb.fBinary = dcb.fDtrControl = dcb.fTXContinueOnXoff = 1;
   dcb.fOutxCtsFlow = dcb.fAbortOnError = (flowControl == FlowControl.Hardware)? 1U : 0U;
   dcb.fOutX = dcb.fInX = (flowControl == FlowControl.XOnXOff)? 1U : 0U;
   dcb.fRtsControl = (flowControl == FlowControl.Hardware)? 2U : 1U;
   dcb.XonLim = 2048;
   dcb.XoffLim = 512;
   dcb.XonChar = 0x11; // Ctrl-Q
   dcb.XoffChar = 0x13; // Ctrl-S
   return SetCommState(m_hFile, ref dcb);
  }
 }

 public bool SetPortSettings(DCB dcb)
 {
  return SetCommState(m_hFile, ref dcb);
 }

 public bool GetPortSettings(out DCB dcb)
 {
  unsafe
  {
   DCB dcb2 = new DCB();
   dcb2.DCBlength = sizeof(DCB);
   bool ret = GetCommState(m_hFile, ref dcb2);
   dcb = dcb2;
   return ret;
  }
 }

 public bool SetXOn()
 {
  return EscapeCommFunction(m_hFile, SETXON);
 }

 public bool SetXOff()
 {
  return EscapeCommFunction(m_hFile, SETXOFF);
 }

 private unsafe void AsyncFSCallback(uint errorCode, uint numBytes, NativeOverlapped* pOverlapped)
 {
  SerialAsyncResult sar = (SerialAsyncResult)Overlapped.Unpack(pOverlapped).AsyncResult;

  sar.m_nErrorCode = errorCode;
  sar.m_nReadWritten = (int)numBytes;
  sar.m_bCompleted = true;

  if (sar.Callback != null)
   sar.Callback.Invoke(sar);

  Overlapped.Free(pOverlapped);
 }

 #endregion Methods

 #region Constants

 private const uint PURGE_TXABORT = 0x0001; // Kill the pending/current writes to the comm port.
 private const uint PURGE_RXABORT = 0x0002; // Kill the pending/current reads to the comm port.
 private const uint PURGE_TXCLEAR = 0x0004; // Kill the transmit queue if there.
 private const uint PURGE_RXCLEAR = 0x0008; // Kill the typeahead buffer if there.

 private const uint SETXOFF = 1; // Simulate XOFF received
 private const uint SETXON = 2; // Simulate XON received
 private const uint SETRTS = 3; // Set RTS high
 private const uint CLRRTS = 4; // Set RTS low
 private const uint SETDTR = 5; // Set DTR high
 private const uint CLRDTR = 6; // Set DTR low
 private const uint SETBREAK = 8; // Set the device break line.
 private const uint CLRBREAK = 9; // Clear the device break line.

 private const uint MS_CTS_ON = 0x0010;
 private const uint MS_DSR_ON = 0x0020;
 private const uint MS_RING_ON = 0x0040;
 private const uint MS_RLSD_ON = 0x0080;

 private const uint FILE_FLAG_OVERLAPPED = 0x40000000;

 private const uint OPEN_EXISTING = 3;

 private const int INVALID_HANDLE_VALUE = -1;

 private const uint GENERIC_READ = 0x80000000;
 private const uint GENERIC_WRITE = 0x40000000;

 private const uint ERROR_SUCCESS = 0;
 private const uint ERROR_OPERATION_ABORTED = 995;
 private const uint ERROR_IO_PENDING = 997;

 #endregion Constants

 #region Enums

 public enum Parity
 {
  None,
  Odd,
  Even,
  Mark,
  Space
 };
 public enum StopBits
 {
  One,
  OneAndHalf,
  Two
 };
 public enum FlowControl
 {
  None,
  XOnXOff,
  Hardware
 };

 #endregion Enums

 #region Classes

 [StructLayout(LayoutKind.Sequential)]
  public struct DCB
 {

  #region Attributes

  public int DCBlength;
  public uint BaudRate;
  public uint Flags;
  public ushort wReserved;
  public ushort XonLim;
  public ushort XoffLim;
  public byte ByteSize;
  public byte Parity;
  public byte StopBits;
  public sbyte XonChar;
  public sbyte XoffChar;
  public sbyte ErrorChar;
  public sbyte EofChar;
  public sbyte EvtChar;
  public ushort wReserved1;

  #endregion Attributes

#region Properties

     internal uint binary
   {
    get
    {
     return flags&0x0001;
    }
    set
    {
     flags = flags & ~1U | value;
    }
   }
   internal uint bitParity
   {
    set
    {
     flags = (flags & ~(1U << 1)) | ((value & 1U) << 1);
    }
   }
   internal uint outxCtsFlow
   {
    set
    {
     flags = (flags & ~(1U << 2)) | ((value & 1U) << 2);
    }
   }
   internal uint outxDsrFlow
   {
    set
    {
     flags = (flags & ~(1U << 3)) | ((value & 1U) << 3);
    }    
   }
   internal uint dtrControl
   {
    set
    {
     flags = (flags & ~(1U << 4)) | ((value & 1U) << 4);
    }
   }
   internal uint dsrSensitivity
   {
    set
    {
     flags = (flags & ~(3U << 1)) | ((value & 3U) << 5);
    }
   }
   internal uint continueOnXoff
   {
    set
    {
     flags = (flags & ~(1U << 7)) | ((value & 1U) << 7);
    }
   }
   internal uint outX
   {
    set
    {
     flags = (flags & ~(1U << 8)) | ((value & 1U) << 8);
    }
   }
   internal uint inX
   {
    set
    {
     flags = (flags & ~(1U << 9)) | ((value & 1U) << 9);
    }
   }
   internal uint biterrorChar
   {
    set
    {
     flags = (flags & ~(1U << 10)) | ((value & 1U) << 10);
    }
   }
   internal uint nullFlag
   {
    set
    {
     flags = (flags & ~(1U << 11)) | ((value & 1U) << 11);
    }
   }
   internal uint rtsControl
   {
    set
    {
     flags = (flags & ~(1U << 12)) | ((value & 1U) << 12);
    }
   }
   internal uint abortOnError
   {
    set
    {
     flags = (flags & ~(1U << 13)) | ((value & 1U) << 13);
    }
   }
   internal uint dummy2
   {
    set
    {
     flags = flags & ~(131072U << 14) | (value << 14);
    }
   }

#endregion Properties

#region Methods

public override string ToString()
{
return "DCBlength: " + DCBlength + "/r/n" +
  "BaudRate: " + BaudRate + "/r/n" +
  "fBinary: " + fBinary + "/r/n" +
  "fParity: " + fParity + "/r/n" +
  "fOutxCtsFlow: " + fOutxCtsFlow + "/r/n" +
  "fOutxDsrFlow: " + fOutxDsrFlow + "/r/n" +
  "fDtrControl: " + fDtrControl + "/r/n" +
  "fDsrSensitivity: " + fDsrSensitivity + "/r/n" +
  "fTXContinueOnXoff: " + fTXContinueOnXoff + "/r/n" +
  "fOutX: " + fOutX + "/r/n" +
  "fInX: " + fInX + "/r/n" +
  "fErrorChar: " + fErrorChar + "/r/n" +
  "fNull: " + fNull + "/r/n" +
  "fRtsControl: " + fRtsControl + "/r/n" +
  "fAbortOnError: " + fAbortOnError + "/r/n" +
  "XonLim: " + XonLim + "/r/n" +
  "XoffLim: " + XoffLim + "/r/n" +
  "ByteSize: " + ByteSize + "/r/n" +
  "Parity: " + Parity + "/r/n" +
  "StopBits: " + StopBits + "/r/n" +
  "XonChar: " + XonChar + "/r/n" +
  "XoffChar: " + XoffChar + "/r/n" +
  "EofChar: " + EofChar + "/r/n" +
  "EvtChar: " + EvtChar + "/r/n";
}

#endregion Methods
}

private class SerialAsyncResult : IAsyncResult, IDisposable
{

#region Attributes

internal bool m_bEndOperationCalled = false;
internal bool m_bIsRead;
internal int m_nReadWritten = 0;
internal bool m_bCompleted = false;
internal bool m_bCompletedSynchronously = false;
internal uint m_nErrorCode = ERROR_SUCCESS;

private object m_AsyncObject;
private object m_StateObject;
private ManualResetEvent m_WaitHandle = new ManualResetEvent(false);
private AsyncCallback m_Callback;
private GCHandle m_gchBuffer;

#endregion Attributes

#region Properties

internal bool EndOperationCalled
{
get
 {
return m_bEndOperationCalled;
 }
}

public bool IsCompleted
{
get
{
return m_bCompleted;
}
}

public bool CompletedSynchronously
 {
get
 {
return m_bCompletedSynchronously;
 }
}

public object AsyncObject
{
get
{
return m_AsyncObject;
}
}

public object AsyncState
{
 get
{
return m_StateObject;
}
}

public WaitHandle AsyncWaitHandle
{
get
 {
return m_WaitHandle;
}
}
internal ManualResetEvent WaitHandle
{
get
 {
return m_WaitHandle;
}
 }

public AsyncCallback Callback
{
get
 {
return m_Callback;
}
}

#endregion Properties

#region Constructors

public SerialAsyncResult(object asyncObject,
  object stateObject,
  AsyncCallback callback,
  bool bIsRead,
  GCHandle gchBuffer)
{

m_AsyncObject = asyncObject;
m_StateObject = stateObject;
m_Callback = callback;
m_bIsRead = bIsRead;
m_gchBuffer = gchBuffer;
}

#endregion Constructors

#region Methods

public void Dispose()
{
m_WaitHandle.Close();
m_gchBuffer.Free();
}

#endregion Methods
}

#endregion Classes

#region Imports

[DllImport("kernel32.dll", EntryPoint="CreateFileW", SetLastError=true,
CharSet=CharSet.Unicode, ExactSpelling=true)]
static extern IntPtr CreateFile(string filename, uint access, uint sharemode, uint security_attributes, uint creation, uint flags, uint template);

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool CloseHandle(IntPtr handle);

[DllImport("kernel32.dll", SetLastError=true)]
static extern unsafe bool ReadFile(IntPtr hFile, byte* lpBuffer, uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead, NativeOverlapped* lpOverlapped);

[DllImport("kernel32.dll", SetLastError=true)]
static extern unsafe bool WriteFile(IntPtr hFile, byte* lpBuffer, uint nNumberOfBytesToWrite, out uint lpNumberOfBytesWritten, NativeOverlapped* lpOverlapped);

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool SetCommTimeouts(IntPtr hFile, ref SerialTimeouts lpCommTimeouts);

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool SetCommState(IntPtr hFile, ref DCB lpDCB);

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool GetCommState(IntPtr hFile, ref DCB lpDCB);

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool BuildCommDCB(string def, ref DCB lpDCB);

[DllImport("kernel32.dll", SetLastError=true)]
static extern int GetLastError();

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool FlushFileBuffers(IntPtr hFile);

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool PurgeComm(IntPtr hFile, uint dwFlags);

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool EscapeCommFunction(IntPtr hFile, uint dwFunc);

[DllImport("kernel32.dll", SetLastError=true)]
static extern bool GetCommModemStatus(IntPtr hFile, out uint modemStat);

#endregion Imports
}

[StructLayout(LayoutKind.Sequential)]
public struct SerialTimeouts
{

#region Attributes

public int ReadIntervalTimeout;
public int ReadTotalTimeoutMultiplier;
public int ReadTotalTimeoutConstant;
public int WriteTotalTimeoutMultiplier;
public int WriteTotalTimeoutConstant;

#endregion Attributes

#region Constructors

public SerialTimeouts(int r1, int r2, int r3, int w1, int w2)
{
ReadIntervalTimeout = r1;
ReadTotalTimeoutMultiplier = r2;
ReadTotalTimeoutConstant = r3;
WriteTotalTimeoutMultiplier = w1;
WriteTotalTimeoutConstant = w2;
}

#endregion Constructors

#region Methods

public override string ToString()
{
return "ReadIntervalTimeout: " + ReadIntervalTimeout + "/r/n" +
"ReadTotalTimeoutMultiplier: " + ReadTotalTimeoutMultiplier + "/r/n" +
"ReadTotalTimeoutConstant: " + ReadTotalTimeoutConstant + "/r/n" +
"WriteTotalTimeoutMultiplier: " + WriteTotalTimeoutMultiplier + "/r/n" +
"WriteTotalTimeoutConstant: " + WriteTotalTimeoutConstant + "/r/n";
}

#endregion Methods
}
}

 

using System;
using System.IO;
using System.Threading;

using LoMaN.IO;

namespace SerialStreamReader
{

class App
{

// The main serial stream
static SerialStream ss;

[STAThread]
static void Main(string[] args)
{

// Create a serial port
ss = new SerialStream();
try
{
ss.Open("COM4"); /
}
catch (Exception e)
 {
Console.WriteLine("Error: " + e.Message);
return;
}

// Set port settings
ss.SetPortSettings(9600);

// Set timeout so read ends after 20ms of silence after a response
ss.SetTimeouts(20, 0, 0, 0, 0);

// Create the StreamWriter used to send commands
StreamWriter sw = new StreamWriter(ss, System.Text.Encoding.ASCII);

// Create the Thread used to read responses
Thread responseReaderThread = new Thread(new ThreadStart(ReadResponseThread));
responseReaderThread.Start();

// Read all returned lines
for (;;) {
// Read command from console
string command = Console.ReadLine();

// Check for exit command
if (command.Trim().ToLower() == "exit")
{
responseReaderThread.Abort();
break;
}

// Write command to modem
sw.WriteLine(command);
sw.Flush();
}
}

// Main loop for reading responses
static void ReadResponseThread()
{
StreamReader sr = new StreamReader(ss, System.Text.Encoding.ASCII);
try
{
for (;;)
{
// Read response from modem
string response = sr.ReadLine();
Console.WriteLine("Response: " + response);
}
}
catch (ThreadAbortException) {
}
}
}
}
 

lyl_98
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C#串口编程基础入门实例
08-05
**C#串口编程基础入门实例** 在C#编程中，串口通信是连接硬件设备、进行数据交换的重要手段。本实例将引导你逐步了解如何使用C#进行串口编程，实现向端口发送数据的基本功能。串口编程通常涉及COM端口，这些端口在...
C#调用API操作串口(ZT)
zdf73的专栏
12-18 1072
本文主要是讲述如何通过C# .net1.1平台调用API操作串口，.net2.0已经内置串口操作类！ 通常，在C#中实现串口通信，我们有四种方法： 第一：通过MSCOMM控件这是最简单的，最方便的方法。可功能上很难做到控制自如，同时这个控件并不是系统本身所带，所以还得注册。可以访问 http://www.devhood.com/tutorials/tutorial_details.aspx?tut
Visual Studio 2019 C# 上位机入门(2)：写一个简单的串口助手
a只如初见的博客
04-21 9758
本文记录一下用Visual Studio 2019 C# 写一个简单的串口助手的过程，由于没有先从小处学习，而是直接找相关资料就开始做，免不了很多奇怪的问题花了一些时间，基于此情况，我将尽可能整理出更多细节，尤其是我遇到的坑，以便和我一样的新手小白上手。后续我还准备单独分析Visual Studio上提供的一些控件的使用方法，以加深理解。话不多说，正文开始。
手把手教你学会C#串口编程
最新发布
Admans的专栏
04-28 89
在单片机项目开发中，上位机也是一个很重要的部分，主要用于数据显示（波形、温度等）、用户控制（LED，继电器等），下位机（单片机）与 上位机之间要进行数据通信的两种方式都是基于串口的：　　　 在Windows上，最早用VB语言开发，后来由于C++的发展，采用MFC开发，近几年，微软发布了基于.NET框架的面向对象语言C#，更加稳定安全，再配合微软强大的VS进行开发，效率奇高；　　　 另外，如果想要在Linux上跨平台运行，可以选用Qt；如果想要更加丰富好看的数据显示界面，可以选用Labview开发；　　　　
C#开发串口通信实例及串口基础
fangyuan621的专栏
11-22 904
串行接口（串口）是一种可以将接受来自CPU的并行数据字符转换为连续的串行数据流发送出去，同时可将接受的串行数据流转换为并行的数据字符供给CPU的器件。一般完成这种功能的电路，我们称为串行接口电路。串口通信（Serial Communications）的概念非常简单，串口按位（bit）发送和接收字节。尽管比按字节（byte）的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。串口通信最重要的参数是波特率、数据位、停止位和奇偶校验。对于两个进行通信的端口，这些参数必须匹配。
C#与串口通信简单例子，实现与串口通信的容易上手方法 c#实现发送和接收串口数据，获取工业扫码枪扫码数据
weijia3624的专栏
11-01 6805
目前在工业互联网环境有非常多的接口还是使用串口通信，以下是通过c#简单实现实用的功能，并且提供下载源码地址。请查看通信实际图片内容。
C#串口编程实例代码
09-01
这个C#串口编程实例代码提供了一个基础的串口通信框架，可以根据实际需求进行扩展和修改，比如增加错误处理、添加数据校验机制或者实现更复杂的通信协议。在实际应用中，还需要根据硬件设备的文档调整串口参数，确保...
C# 串口编程
09-09
用WPF开发的完整的串口编码实例。 支持字符传输与16进制的数字传输。
C#串口编程案例
01-22
C#串口编程案例，对实际串口编程有很大的帮助
C#学习记录——C#编写串口程序
做有价值的事，积累有价值的笔记！
09-19 4528
因为电气自动化专业出差太多，考虑学点其他的看能不能实现转行，也没太清晰的路线，看网上好多推荐电气自动化转C#上位机开发的，也抽时间学习了解下C#，因为非软件专业，对计算机软件不算太熟悉，只能从网上搜罗资料，看到一个用C#写串口程序的例子，拿来练习一下，边练习边记录，方便回顾总结，有兴趣的也可以一起探讨。这样就可以显示多行了。1、在窗体上添加三个“GroupBox”控件，分别将窗体分为“串口设置”、“数据接收”以及“数据发送”三部分。6、“清空数据”则可以清除“数据接收”栏以及“收据发送”栏中的所有数据；
记一次 .NET 某流媒体独角兽 API 句柄泄漏分析
一线码农的专栏
08-30 485
一：背景 1. 讲故事 上上周有位朋友找到我，说他的程序CPU和句柄都在不断的增长，无回头趋势，查了好些天也没什么进展，特加wx寻求帮助，截图如下： 看的出来这位朋友也是非常郁闷，出问题还出两个，气人哈，关于 cpu 爆高的问题我准备单独用一篇文章去侦读，这篇就先聊聊 句柄泄漏 的问题，毕竟写了20多篇，也是第一次聊到 handle 泄露，有点意思哈。 2. 什么是句柄 我个人理解的句柄：就是在托管层持有了一个对非托管层资源的引用，有了这个引用，我们就可以强制回收非托管资源，那什么是非托管资源？ 我个人
C#-串口编程
cxu123321的博客
06-07 1615
c#串口编程（转） 在单片机项目开发中，上位机也是一个很重要的部分，主要用于数据显示（波形、温度等）、用户控制（LED，继电器等），下位机（单片机）与 上位机之间要进行数据通信的两种方式都是基于串口的： USB转串口 —— 上位机和下位机通过USB转串口连接线直接相连进行数据交互； 串口转WIFI（ESP8266） —— 上位机和下位机基于TCP/IP协议通过WIFI传输数据； 串口转蓝...
串口流控制（flow control）
匆匆那年
06-06 2561
我们在串行通讯处理中,常常看到RTS/CTS和XON/XOFF这两个选项,这就是两个流控制的选项,目前流控制主要应用于调制解调器的数据通讯中,但对普通RS232编程,了解一点这方面的知识是有好处的。那么,流控制在串行通讯中有何作用,在编制串行通讯程序怎样应用呢？这里我们就来谈谈这个问题。    1.流控制在串行通讯中的作用    这里讲到的“流”,当然指的是数据流。数据在两个串口之间传输时
STM32F4 HAL库开发 -- 串口
不积跬步，无以至千里
06-30 4146
一、串口介绍 串口设置包含：开启串口时钟、设置响应的IO口模式、设置波特率、数据位长度、奇偶校验位、DMA等信息。 具体参看：STM32开发 – 串口详解 二、函数 1、串口参数初始化，并使能串口。 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); 该函数只有一个入口参数 huart，为UART_HandleTypeDef 结构体指针类型，我们俗称其为串口句柄，它的使用会贯穿整个串口程序。一般情况下，我们会定义一个UART_Handl
串行通信（二）：串口流控
既有随处可栖的江湖，也有追风逐梦的骁勇！
03-01 2787
引脚编号名称含义I/OCD载波检测IRXD接收数据ITXD发送数据ODTR数据终端就绪OGND系统接地DSR数据设备就绪IRTS请求发送OCTS。
在C#中使用SerialPort类实现串口通信（陆续更新）
热门推荐
08-23 11万+
 在.NET Framework 2.0中提供了SerialPort类，该类主要实现串口数据通信等。本文章将本人在学习过程中从网络上搜集到的相关信息写出来供大家参考。下面主要介绍该类的主要属性（表1）和方法（表.2）。如果需要了解更多的信息请登录http://msdn.microsoft.com/zh-cn/library/system.io.ports.serialport(VS.80)
c#串口编程控件wpf
01-12
C是计算机科学中的一种常见的编程语言。它是由贝尔实验室的丹尼斯·里奇和肯·汤普逊在20世纪70年代初开发的。C语言具有高效简洁、功能强大和广泛适用的特点，因此成为了广泛应用于系统级编程和应用软件开发领域的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值