public RTU_Client(string PortName, int BaudRate = 9600, Parity Parity = Parity.None, int DataBits = 8, StopBits StopBits = StopBits.One, int Timeout = 2500)
{
try
{
Port = new SerialPort(PortName, BaudRate, Parity, DataBits, StopBits);
}
catch (IOException ex)
{
throw new RTU_Exception("Ошибка настроек коммуникационного порта. " + ex.Message, ex);
}
ByteTimeout = 20;
MaxCount = 5;
this.Timeout = Timeout;
this.Buffer = new List<byte>(256);
ReqSendEvent += delegate { };
ByteRecievedEvent += delegate { };
try
{
Port.Open();
}
catch (Exception ex)
{
throw new RTU_Exception("Ошибка открытия коммуникационного порта. " + ex.Message, ex);
}
}
public static void initialize(string COM_port_Name, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
try
{
if (COM_port != null)
{
if (COM_port.IsOpen)
{
COM_port.Close();
}
}
COM_port = new SerialPort(COM_port_Name, baudRate, parity, dataBits, stopBits);
COM_port.DataReceived += new SerialDataReceivedEventHandler(DataReceived);
if (!COM_port.IsOpen)
{
COM_port.Open();
}
initialized = 1;
Receiver.Interval = 10;
Receiver.Elapsed += new System.Timers.ElapsedEventHandler(Receiver_time_out);
Receiver.AutoReset = false;
Synchro.Interval = 50;
Synchro.Elapsed += new System.Timers.ElapsedEventHandler(Synchro_time_out);
Synchro.AutoReset = false;
}
catch (Exception exception)
{
Error_messager.Invoke("Ошибка инициализации!\r\nRadist: \r\n" + exception.Message);
initialized = 2;
}
}
/// <summary>
///
/// </summary>
/// <param name="bardRate"></param>
/// <param name="parity"></param>
/// <param name="dataBits"></param>
/// <param name="stopBits"></param>
public SerialPortSetting(int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
this.BaudRate = baudRate;
this.Parity = parity;
this.DataBits = dataBits;
this.StopBits = stopBits;
}
public RCRadio(string id, string port = "COM1", int baudRate = 115200, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
{
Port = new SerialPort(port, baudRate, parity, dataBits, stopBits);
AutoPing = true;
PingPeriod = 3000;
DataQueue = new StringFifoQueue();
}
public void setportvalues(UInt32 BaudRate, int DataBits, StopBits StopBits, Parity Parity)
{
vBaudRate = BaudRate;
vDataBits = DataBits;
vStopBits = StopBits;
vParity = Parity;
}
public PortManager(String portName, int baudRate, Parity parity, int dataBits, StopBits stopBits, Form1 form )
{
if (this.port == null)
{
this.portName = portName;
this.baudRate = baudRate;
this.parity = parity;
this.dataBits = dataBits;
this.stopBits = stopBits;
this.port = new SerialPort(portName, baudRate, parity, dataBits, stopBits);
this.port.DtrEnable = true;
this.port.RtsEnable = true;
this.port.DataReceived += new SerialDataReceivedEventHandler(port_DataReceived);
Form = form;
}
else
{
this.port.BaudRate = baudRate;
this.port.Parity = parity;
this.port.DataBits = dataBits;
this.port.StopBits = stopBits;
}
}
public static EM406aGPS Start(string portName, int baudRate = 4800, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
{
EM406aGPS gps = new EM406aGPS(portName, baudRate, parity, dataBits, stopBits);
gps._thread = new Thread(gps.Run);
gps._thread.Start();
return gps;
}
/// <summary>
/// Default constructor of SerialPortSettings.
/// </summary>
public SerialPortSettings()
{
m_baudRate=9600;
m_dataBits=8;
Parity=Parity.None;
StopBits=StopBits.One;
}
public bool Open(string portName, int baudRate, int databits, Parity parity, StopBits stopBits)
{
//Ensure port isn't already opened:
if (!sp.IsOpen)
{
//Assign desired settings to the serial port:
sp.PortName = portName;
sp.BaudRate = baudRate;
sp.DataBits = databits;
sp.Parity = parity;
sp.StopBits = stopBits;
//These timeouts are default and cannot be editted through the class at this point:
sp.ReadTimeout = 2000;
sp.WriteTimeout = 2000;
try
{
sp.Open();
}
catch (Exception err)
{
return false;
}
return true;
}
else
{
return false;
}
}
/*
* public string ComPort = String.Empty;
public int BaudRate = 110;
public StopBits StopBits = StopBits.None;
public int DataBits = 7;
public Parity Parity = Parity.None;
* */
public BalanceReader(string comPort = "COM1", int baudRate = 9600, StopBits stopBits = StopBits.One,
int dataBits = 7, Parity parity = Parity.Even, string sicsCommand = "SI", bool rts = false)
{
_sicsCommand = sicsCommand;
if (comPort == String.Empty) comPort = "COM1";
_port = new SerialPort
{
PortName = comPort,
BaudRate = baudRate,
StopBits = stopBits,
DataBits = 7,
Parity = Parity.Even,
RtsEnable = rts
};
// from Page 39 of NewClassic Balances METTLER TOLEDO manual for MS-S / MS-L Models
//_port.Handshake = Handshake.XOnXOff;
if (_port.IsOpen == false)
{
try
{
_port.Open();
}
catch (Exception)
{
// port will not be open, therefore will become null
}
}
_port.DataReceived += _port_DataReceived;
}
public void SetOptions(int baudrate, Parity parity, int databits, StopBits stopbits)
{
this.baudrate = baudrate;
this.parity = parity;
this.databits = databits;
this.stopbits = stopbits;
}
public void Start(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
if (!GetAvailablePorts().Contains(portName))
{
throw new Exception(string.Format("Unknown serial port: {0}", portName));
}
// Start the timer to empty the receive buffer (in case data smaller than MAX_RECEIVE_BUFFER is received)
_bufferTimer = new Timer();
_bufferTimer.Interval = BUFFER_TIMER_INTERVAL;
_bufferTimer.Elapsed += _bufferTimer_Elapsed;
_bufferTimer.Start();
// Instantiate new serial port communication
_serialPort = new SerialPort(portName, baudRate, parity, dataBits, stopBits);
// Open serial port communication
_serialPort.Open();
// Check that it is actually open
if (!_serialPort.IsOpen)
{
throw new Exception(string.Format("Could not open serial port: {0}", portName));
}
_serialPort.ReadTimeout = 100; // Milliseconds
_readThread = new System.Threading.Thread(ReadThread);
_readThreadRunning = true;
_readThread.Start();
}
/// <summary>
/// 构造函数,可以自定义串口的初始化参数
/// </summary>
/// <param name="comPortName">需要操作的COM口名称</param>
/// <param name="baudRate">COM的速度</param>
/// <param name="parity">奇偶校验位</param>
/// <param name="dataBits">数据长度</param>
/// <param name="stopBits">停止位</param>
public SerialClass(string comPortName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
_serialPort = new SerialPort(comPortName, baudRate, parity, dataBits, stopBits);
_serialPort.RtsEnable = true; //自动请求
_serialPort.ReadTimeout = 3000;//超时
setSerialPort();
}
public BasicInformation(string portName, int baudRate, Parity parity, StopBits stopBits, int dataBits, Handshake handShake, string serviceCenter, bool pduMode)
{
this.Connector = new ATController(portName, baudRate, parity, stopBits, dataBits, handShake);
ServiceCenter = serviceCenter;
PDUMode = pduMode;
this.PortName = portName;
}
public ComPort(byte number, int baudrate, byte data_bits, byte parity, byte stop_bits, ushort write_timeout, ushort read_timeout, byte attemts)
{
m_name = "COM" + Convert.ToString(number);
m_baudrate = baudrate;
m_data_bits = data_bits;
m_parity = (Parity)parity;
m_stop_bits = (StopBits)stop_bits;
m_write_timeout = write_timeout;
m_read_timeout = read_timeout;
m_attemts = attemts;
try
{
m_Port = new SerialPort(m_name, m_baudrate, m_parity, m_data_bits, m_stop_bits);
/*ELF: для работы с elf108*/
m_Port.DtrEnable = true;
m_Port.RtsEnable = true;
}
catch (Exception ex)
{
#if (DEBUG)
WriteToLog("Create " + m_name + ": " + ex.Message);
#endif
}
}
private async void SaveSettingss(string port, int baud, Parity parity, Handshake handshake, int dataBits, StopBits stopBits)
{
writing = true;
XmlWriterSettings settings = new XmlWriterSettings { Indent = true, NewLineOnAttributes = true };
XmlWriter writer = XmlWriter.Create("Settings.xml", settings);
writer.WriteStartDocument();
writer.WriteStartElement("Settings");
writer.WriteElementString("Port", port);
writer.WriteElementString("Baudrate", baud.ToString());
writer.WriteElementString("Parity", parity.ToString());
writer.WriteElementString("Handshake", handshake.ToString());
writer.WriteElementString("Data_Bits", dataBits.ToString());
writer.WriteElementString("Stop_Bits", stopBits.ToString());
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
writer.Close();
writing = false;
if(!initialization)
{
MessageDialogResult result = await MessageService.ShowMessage("Gespeichert!", "Settings wurden gespeichert!", MessageDialogStyle.Affirmative).ConfigureAwait(false);
}
}
public SerialDevice(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits, string returnToken = "\n")
{
_dataReading = string.Empty;
_dataQueue = new ConcurrentQueue<string>();
_timeCounter = new Stopwatch();
_timeCounter.Start();
_COMPort = new SerialPort(portName, baudRate, parity, dataBits, stopBits);
_returnToken = returnToken;
_COMPort.NewLine = _returnToken;
_COMPort.RtsEnable = true;
_COMPort.DtrEnable = true;
_COMPort.ReadTimeout = SerialPort.InfiniteTimeout;
_COMPort.WriteTimeout = SerialPort.InfiniteTimeout;
_COMPort.Open();
if (!_COMPort.IsOpen)
_COMPort.Open();
if (!_COMPort.IsOpen)
throw new Exception("Can't connect to the COM port!");
_serialThread = new Thread(new ThreadStart(GetSerialDataContinious));
_serialThread.Priority = ThreadPriority.Normal;
_serialThread.Name = string.Format("SerialHandle{0}", _serialThread.ManagedThreadId);
_communicatyionIsActive = true;
_serialThread.Start();
}
public FrostedSerialPortStream(string portName, int baudRate, int dataBits, Parity parity, StopBits stopBits,
bool dtrEnable, bool rtsEnable, Handshake handshake, int readTimeout, int writeTimeout,
int readBufferSize, int writeBufferSize)
{
fd = open_serial(portName);
if (fd == -1) {
ThrowIOException ();
}
TryBaudRate(baudRate);
int canSetAttributes = set_attributes (fd, baudRate, parity, dataBits, stopBits, handshake);
if (canSetAttributes != 0)
{
throw new IOException(canSetAttributes.ToString()); // Probably Win32Exc for compatibility
}
read_timeout = readTimeout;
write_timeout = writeTimeout;
SetSignal(SerialSignal.Dtr, dtrEnable);
if (handshake != Handshake.RequestToSend &&
handshake != Handshake.RequestToSendXOnXOff)
SetSignal(SerialSignal.Rts, rtsEnable);
}
public bool Open(string portName, int baudRate, int databits, Parity parity, StopBits stopBits)
{
//Ensure port isn't already opened:
if (!sp.IsOpen)
{
//Assign desired settings to the serial port:
sp.PortName = portName;
sp.BaudRate = baudRate;
sp.DataBits = databits;
sp.Parity = parity;
sp.StopBits = stopBits;
//These timeouts are default and cannot be editted through the class at this point:
sp.ReadTimeout = 1000;
sp.WriteTimeout = 1000;
try
{
sp.Open();
}
catch (Exception err)
{
modbusStatus = "Error opening " + portName + ": " + err.Message;
return false;
throw err;
}
modbusStatus = portName + " opened successfully";
return true;
}
else
{
modbusStatus = portName + " already opened";
return false;
}
}
public void InitCOM(string comName, int baudRate, Parity parity, int dataBits, StopBits stopBits, int readTimeout,int writeTimeout)
{
//com = new SerialPort("COM3", 9600, Parity.Even, 7, StopBits.One);
com = new SerialPort(comName, baudRate, parity, dataBits, StopBits.One);
com.ReadTimeout = readTimeout;
com.WriteTimeout = writeTimeout;
}
public Transceiver(string portName, int baudRate = 96000, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
{
port = new SerialPort(portName, baudRate, parity, dataBits, stopBits);
port.Open();
port.DataReceived += PortOnDataReceived;
Debug.Print("Created transceiver on port " + portName);
}
public SerialTerminal(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
: base(portName, baudRate, parity, dataBits, stopBits)
{
Open();
Handshake = Handshake.XOnXOff;
OperatingMode = IBM3151.OperatingModes.Echo;
}
public SerialConfig(string cfg)
{
var parts = cfg.Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
this.initialConfig = cfg;
int index = 0;
if (!parts[index].StartsWith("COM"))
{
this.DeviceName = parts[index];
index++;
}
this.PortName = parts[index]; index++;
this.AutoConnect = Boolean.Parse(parts[index]); index++;
this.Speed = UInt32.Parse(parts[index]); index++;
this.DataBits = Byte.Parse(parts[index]); index++;
this.Parity = (Parity)Byte.Parse(parts[index]); index++;
this.StopBits = (StopBits)Byte.Parse(parts[index]); index++;
//this.PacketType = (PacketType)Byte.Parse(parts[index]); index++;
this.RxPacketType = (PacketType)Byte.Parse(parts[index]); index++;
this.TxPacketType = (PacketType)Byte.Parse(parts[index]); index++;
this.PacketType = this.RxPacketType;
if (parts.Length > index)
{
this.ReceiverCRC = Byte.Parse(parts[index]); index++;
this.TransmitterCRC = Byte.Parse(parts[index]); index++;
}
if (parts.Length > index)
{
this.DefaultDeviceAddr = Byte.Parse(parts[index]); index++;
}
}
public void SetComboBoxes(String comPortName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
try
{
cmbComPortName.Text = GetValidPortName(cmbComPortName.Text);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
cmbComPortName.Text = "NONE";
}
cmbBaudRate.Text = baudRate.ToString();
cmbParity.SelectedIndex = GetIndexOfValue(cmbParity.Items, parity.ToString());
cmbDataBits.SelectedIndex = GetIndexOfValue(cmbDataBits.Items, dataBits.ToString());
switch (stopBits)
{
case StopBits.One:
cmbStopBits.SelectedIndex = GetIndexOfValue(cmbStopBits.Items, "1");
break;
case StopBits.OnePointFive:
cmbStopBits.SelectedIndex = GetIndexOfValue(cmbStopBits.Items, "1.5");
break;
case StopBits.Two:
cmbStopBits.SelectedIndex = GetIndexOfValue(cmbStopBits.Items, "2");
break;
case StopBits.None:
cmbStopBits.SelectedIndex = GetIndexOfValue(cmbStopBits.Items, "1");
break;
default:
cmbStopBits.SelectedIndex = GetIndexOfValue(cmbStopBits.Items, "1");
break;
}
}
/// <summary>
/// Opens the serial port using the specified baud rate, parity bit, data bits, and stop bit.
/// </summary>
/// <param name="baudRate">The baud rate.</param>
/// <param name="parity">One of the Parity values.</param>
/// <param name="dataBits">The data bits value.</param>
/// <param name="stopBits">One of the StopBits values.</param>
public Windows.Foundation.IAsyncAction Open(
uint baudRate,
Parity parity,
int dataBits,
StopBits stopBits
)
{
return Task.Run(async () =>
{
this.baudRate = baudRate;
this.parity = parity;
this.dataBits = dataBits;
this.stopBits = stopBits;
if (this.cdcControl == null)
{
return;
}
// Do SetLineCoding
var len = await SetLineCoding(this.cdcControl.InterfaceNumber, this.baudRate, (byte)this.stopBits, (byte)this.parity, (byte)this.dataBits);
if (len != Constants.ExpectedResultSetLineCoding)
{
throw new System.NotSupportedException("SetLineCoding request is not supported.");
}
// Do SetControlLineState
len = await SetControlLineState(this.cdcControl.InterfaceNumber);
return;
}).AsAsyncAction();
}
public PortInitInfo(int mBaudRate,Parity mParity, int mDataBits, StopBits mStopBits)
{
this._BaudRate = mBaudRate;
this._Parity = mParity;
this._DataBits = mDataBits;
this._StopBits = mStopBits;
}
/// <summary>
/// Create a new ConnectionSettings object passed into the ELM327API to configure the serial port connections used
/// for communication between OBD Express and the ELM327 device it is connected to.
/// </summary>
/// <param name="baudRate">Baud Rate to connect with.</param>
/// <param name="dataBits">Data Bits used for communication.</param>
/// <param name="parity">Parity used for verification on communications.</param>
/// <param name="stopBits">Stop Bits used for communication.</param>
/// <param name="deviceDescription">Device Description to expect from the ELM327.</param>
public ConnectionSettings(int baudRate, int dataBits, Parity parity, StopBits stopBits, string deviceDescription)
{
_baudRate = baudRate;
_dataBits = dataBits;
_parity = parity;
_stopBits = stopBits;
_deviceDescription = deviceDescription;
}
/// <summary>
/// Construct and initialize a serial port controller object.
/// </summary>
/// <param name="PortName">The name of the serial port (i.e. COM4)</param>
/// <param name="BaudRate">The baud rate to be used by the serial port</param>
/// <param name="Parity"></param>
/// <param name="DataBits"></param>
/// <param name="StopBits"></param>
public SerialController(string PortName, int BaudRate, Parity Parity, int DataBits, StopBits StopBits)
: base(PortName, 8192)
{
this.BaudRate = BaudRate;
this.Parity = Parity;
this.DataBits = DataBits;
this.StopBits = StopBits;
}
public SerialConnection(string portname, int baudrate, Parity parity, StopBits stopbits)
: this()
{
this.portname = portname;
this.baudrate = baudrate;
this.parity = parity;
this.stopbits = stopbits;
}
public void CreateDefault()
{
comname = "Com1";
speed = 115200;
databits = 8;
parity = Parity.None;
stopbits = StopBits.One;
}
///<summary>创建串口设备</summary>
///<param name="handler">数据处理程序</param>
///<param name="baudRate">波特率</param>
///<param name="parity">奇偶校验类型</param>
///<param name="stopBits">停止位</param>
///<param name="dataBits">数据长度</param>
///<param name="simulatorDataGenerator">供串口模拟器使用的数据产生器</param>
public static SerialPortDevice Create(IDataHandler handler, int baudRate = 19200, Parity parity = Parity.Odd, StopBits stopBits = StopBits.One, int dataBits = 8, IDataGenerator <byte> simulatorDataGenerator = null)
{
return(new SerialPortDevice(handler, baudRate, parity, stopBits, dataBits, simulatorDataGenerator));
}
///<summary>创建使用默认处理程序的串口设备</summary>
///<param name="receivers">数据接收器集合</param>
///<param name="baudRate">波特率</param>
///<param name="parity">奇偶校验类型</param>
///<param name="stopBits">停止位</param>
///<param name="dataBits">数据长度</param>
public static SerialPortDevice CreateDafault(IDataReceiver[] receivers, int baudRate = 19200, Parity parity = Parity.Odd, StopBits stopBits = StopBits.One, int dataBits = 8)
{
return(new SerialPortDevice(new DefaultSerialPortDataHandler(receivers), baudRate, parity, stopBits, dataBits, new DefaultSerialPortDataGenerator()));
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="portName">COM端口名称</param>
/// <param name="baudRate">波特率</param>
/// <param name="dataBits">数据位</param>
/// <param name="stopBits">停止位</param>
/// <param name="parity">奇偶校验</param>
/// <param name="timeout">超时时间（毫秒）</param>
/// <param name="format">大小端设置</param>
public ModbusRtuClient(string portName, int baudRate, int dataBits, StopBits stopBits, Parity parity, int timeout = 1500, EndianFormat format = EndianFormat.ABCD)
: base(portName, baudRate, dataBits, stopBits, parity, timeout, format)
{
}
public override void SetParameters(int baudRate, DataBits dataBits, StopBits stopBits, Parity parity)
{
if ((_baudRate == baudRate) && (_dataBits == dataBits) && (_stopBits == stopBits) && (_parity == parity))
{
return;
}
byte[] lineRequestData = new byte[7];
lineRequestData[0] = unchecked ((byte)(baudRate & 0xff));
lineRequestData[1] = unchecked ((byte)((baudRate >> 8) & 0xff));
lineRequestData[2] = unchecked ((byte)((baudRate >> 16) & 0xff));
lineRequestData[3] = unchecked ((byte)((baudRate >> 24) & 0xff));
switch (stopBits)
{
case StopBits.One:
lineRequestData[4] = 0;
break;
case StopBits.OnePointFive:
lineRequestData[4] = 1;
break;
case StopBits.Two:
lineRequestData[4] = 2;
break;
default:
throw new ArgumentException($"Unknown stopBits value: {stopBits}");
}
switch (parity)
{
case Parity.None:
lineRequestData[5] = 0;
break;
case Parity.Odd:
lineRequestData[5] = 1;
break;
case Parity.Even:
lineRequestData[5] = 2;
break;
case Parity.Mark:
lineRequestData[5] = 3;
break;
case Parity.Space:
lineRequestData[5] = 4;
break;
default:
throw new ArgumentException($"Unknown parity value: {parity}");
}
lineRequestData[6] = (byte)dataBits;
CtrlOut(SET_LINE_REQUEST, 0, 0, lineRequestData);
ResetDevice();
_baudRate = baudRate;
_dataBits = dataBits;
_stopBits = stopBits;
_parity = parity;
}
private void connectSerial(String portName, int baudRate, int dataBits, Parity parity, StopBits stopBits, Handshake handshake)
{
this.portName = portName;
this.baudRate = baudRate;
this.dataBits = dataBits;
this.parity = parity;
this.stopBits = stopBits;
this.handshake = handshake;
Thread t = new Thread(doConnectSerial);
t.Start();
}
public Hardware(string port_name, int boundrate = 9600, Parity parity = Parity.None, int data_bits = 8, StopBits stop_bits = StopBits.One, Handshake handshake = Handshake.None)
{
_serialPort = new SerialPort();
thread = new Thread(Read);
_serialPort.PortName = port_name;
_serialPort.BaudRate = boundrate;
_serialPort.Parity = parity;
_serialPort.DataBits = data_bits;
_serialPort.StopBits = stop_bits;
_serialPort.Handshake = handshake;
_serialPort.ReadTimeout = 500;
_serialPort.WriteTimeout = 500;
_continue = false;
}
public SerialTransceiver(string portName, int baudRate, Parity parity, int portDataBits, StopBits portStopBits, Handshake portHandshake, int portReadTimeout, int portWriteTimeout)
{
serialPort.PortName = portName;
serialPort.BaudRate = baudRate;
serialPort.Parity = parity;
serialPort.DataBits = portDataBits;
serialPort.StopBits = portStopBits;
serialPort.Handshake = portHandshake;
serialPort.ReadTimeout = portReadTimeout;
serialPort.WriteTimeout = portWriteTimeout;
logger.Trace("New instance of SerialTransceiver; portName:{0}; baudRate:{1}; parity:{2}; portDataBits{3}; portStopBits{4}; portHandshake:{5}; portReadTimeout:{6}; portWriteTimeout:{7}",
portName,
baudRate,
parity,
portDataBits,
portStopBits,
portHandshake,
portReadTimeout,
portWriteTimeout);
}
internal Configuration(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
PortIndex = System.IO.Ports.SerialPortName.ConvertNameToIndex(portName);
Speed = baudRate;
Parity = parity;
DataBits = dataBits;
StopBits = stopBits;
Handshake = Handshake.None;
ReadTimeout = Timeout.Infinite;
WriteTimeout = Timeout.Infinite;
}
internal static extern int serial_getstopbits(IntPtr handle, out StopBits stopbits);
public ISerialMessagePort CreateSerialMessagePort(SerialPortName portName, byte[] prefixDelimiter, bool preserveDelimiter, int messageLength, int baudRate = 9600, int dataBits = 8, Parity parity = Parity.None, StopBits stopBits = StopBits.One, int readBufferSize = 512)
{
throw new NotImplementedException();
}
public void ModbusInit(String PortName, int BaudRate, Parity Parity, int DataBits, StopBits StopBits)
{
curSerialPort = new SerialPort();
curSerialPort.PortName = PortName;
curSerialPort.BaudRate = BaudRate;
curSerialPort.Parity = Parity;
curSerialPort.DataBits = DataBits;
curSerialPort.StopBits = StopBits;
}
private static extern int nserial_getstopbits(IntPtr handle, out StopBits stopbits);
/**
* Sets various serial port parameters.
*
* @param baudRate baud rate as an integer, for example {@code 115200}.
* @param dataBits one of {@link #DATABITS_5}, {@link #DATABITS_6},
* {@link #DATABITS_7}, or {@link #DATABITS_8}.
* @param stopBits one of {@link #STOPBITS_1}, {@link #STOPBITS_1_5}, or
* {@link #STOPBITS_2}.
* @param parity one of {@link #PARITY_NONE}, {@link #PARITY_ODD},
* {@link #PARITY_EVEN}, {@link #PARITY_MARK}, or
* {@link #PARITY_SPACE}.
* @throws IOException on error setting the port parameters
*/
public abstract void SetParameters(
int baudRate, int dataBits, StopBits stopBits, Parity parity);
/// <summary>
/// Constructor
/// </summary>
/// <param name="type">Type of serial protocol</param>
/// <param name="port">Serial port name</param>
/// <param name="baudrate">Baudrate</param>
/// <param name="databits">Data bits</param>
/// <param name="parity">Parity</param>
/// <param name="stopbits">Stop bits</param>
/// <param name="handshake">Handshake</param>
public ModbusMasterSerial(ModbusSerialType type, string port, int baudrate, int databits, Parity parity, StopBits stopbits, Handshake handshake)
{
// Set device states
switch (type)
{
case ModbusSerialType.RTU:
_connectionType = ConnectionType.SerialRTU;
break;
case ModbusSerialType.ASCII:
_connectionType = ConnectionType.SerialASCII;
break;
}
// Set serial port instance.
_serialPort = new SerialPort(port, baudrate, parity, databits, stopbits)
{
Handshake = handshake
};
// Get interframe delay.
_interframeDelay = GetInterframeDelay(_serialPort);
// Get interchar delay
_intercharDelay = GetIntercharDelay(_serialPort);
}
public SerialPort(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
m_portName = portName;
m_config = new Configuration(portName, baudRate, parity, dataBits, stopBits);
m_fDisposed = false;
m_fOpened = false;
m_evtErrorEvent = new NativeEventDispatcher("SerialPortErrorEvent", (ulong)m_config.PortIndex);
m_evtDataEvent = new NativeEventDispatcher("SerialPortDataEvent", (ulong)m_config.PortIndex);
}
public void OpenConnection(string serialPortNumber, int baudRate, Parity parity, StopBits stopBits, int dataBits, Handshake handshake, NewLine newLine, ReadMode readMode)
{
_serialConnection.Open(serialPortNumber, baudRate, parity, stopBits, dataBits, handshake, newLine, readMode);
_serialConnection.PortDataRead += DataReceived;
}
/// <summary>
/// 初始化串口参数
/// </summary>
/// <param name="portName">串口名称</param>
/// <param name="baudRate">波特率</param>
/// <param name="dataBits">数据位 多少位一个字节 默认是8</param>
/// <param name="dtrEnable">a value that enables the Data Terminal Ready (DTR) signal during serial communication</param>
/// <param name="rtsEnable">enable Request to Transmit (RTS) </param>
/// <param name="handshake">the handshaking protocol for serial port transmission of data new SerialPort()时默认是None</param>
/// <param name="encoding">传输文本时的编码，new SerialPort()时默认是 ASCIIEncoding </param>
/// <param name="parity">奇偶校验位 new SerialPort()时默认是None</param>
/// <param name="stopBits">停止位</param>
/// <param name="readWriteTimeout">读写超时时间毫秒</param>
/// <param name="receivedBytesThreshold">The number of bytes in the internal input buffer before a DataReceived event is fired. The default is 1.</param>
public void InitSerialPort(string portName, int baudRate, int dataBits = 8, bool dtrEnable = true, bool rtsEnable = true, Handshake handshake = Handshake.RequestToSend, String encoding = "utf-8", Parity parity = Parity.None, StopBits stopBits = StopBits.One, int readWriteTimeout = 5000, int receivedBytesThreshold = 1)
{
this.portName = portName;
this.baudRate = baudRate;
this.dataBits = dataBits;
this.dtrEnable = dtrEnable;
this.rtsEnable = rtsEnable;
this.handshake = handshake;
this.encoding = String.Equals("utf-8", encoding, StringComparison.InvariantCultureIgnoreCase)?Encoding.UTF8: Encoding.GetEncoding(encoding);
this.parity = parity;
this.stopBits = stopBits;
this.readWriteTimeout = readWriteTimeout;
this.receivedBytesThreshold = receivedBytesThreshold;
}
public ISerialPort CreateSerialPort(SerialPortName portName, int baudRate = 9600, int dataBits = 8, Parity parity = Parity.None, StopBits stopBits = StopBits.One, int readBufferSize = 1024)
{
throw new NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="SerialPort" /> class.
/// </summary>
/// <param name="portName">Name of the port.</param>
/// <param name="baudRate">The baud rate.</param>
/// <param name="parity">The parity.</param>
/// <param name="dataBits">The data bits.</param>
/// <param name="stopBits">The stop bits.</param>
public SerialPort(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
// TODO: Check for windows
//if (Swan.Runtime.OS == Swan.OperatingSystem.Windows)
// throw new InvalidOperationException(
// "This class is only supported by UNIX OS. Use native NET Framework class");
_portName = portName;
_baudRate = baudRate;
_dataBits = dataBits;
_stopBits = stopBits;
this._parity = parity;
}
public SerialCommunicator(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
_serial = new SerialPort(portName, baudRate, parity, dataBits, stopBits);
_serial.DataReceived += OnDataReceived;
_serial.Open();
}
private void connectButton_Click(object sender, EventArgs e)
{
if (serialPort1.IsOpen)
{
serialPort1.Close();
this.connectButton.Text = "Connect";
this.connectionProgressBar.Value = 0;
}
else
{
Form connectionDetails = new Form();
connectionDetails.Height = 300;
connectionDetails.Width = 300;
connectionDetails.Text = "Connection Details";
Label comportInputLabel = new Label()
{
Top = 20, Left = 20, Text = "Comport"
};
ComboBox comportInput = new ComboBox()
{
Top = 20, Left = 120
};
comportInput.DropDownStyle = ComboBoxStyle.DropDownList;
// Adding list items in the comportInput Drop Down
String[] availableComports = SerialPort.GetPortNames();
comportInput.Items.AddRange(availableComports);
Label baudInputLabel = new Label()
{
Top = 50, Left = 20, Text = "Baud"
};
TextBox baudInput = new TextBox()
{
Top = 50, Left = 120
};
Label parityInputLabel = new Label()
{
Top = 80, Left = 20, Text = "Parity"
};
ComboBox parityInput = new ComboBox()
{
Top = 80, Left = 120
};
parityInput.DropDownStyle = ComboBoxStyle.DropDownList;
// Adding list items in the parityInput Drop Down
String[] validParity = { "Odd", "Even", "None" };
parityInput.Items.AddRange(validParity);
Label stopBitInputLabel = new Label()
{
Top = 110, Left = 20, Text = "Stop Bit"
};
ComboBox stopBitInput = new ComboBox()
{
Top = 110, Left = 120
};
stopBitInput.DropDownStyle = ComboBoxStyle.DropDownList;
// Adding list items in the stopBitInput Drop Down
String[] validStopBits = { "None", "One", "Two" };
stopBitInput.Items.AddRange(validStopBits);
//TextBox stopBitInput = new TextBox() { Top = 110, Left = 120 };
Button promptOK = new Button()
{
Text = "OK", Top = 200, Left = 120
};
Button promptCancel = new Button()
{
Text = "Cancel", Top = 200, Left = 200
};
string comport, parity, baud, stopBit;
promptOK.Click += (sender1, e1) =>
{
comport = comportInput.Text;
parity = parityInput.Text;
baud = baudInput.Text;
stopBit = stopBitInput.Text;
int errorStatus = verifySerialCommSettingInput(comport, baud, parity, stopBit);
if (errorStatus != 100)
{
MessageBox.Show(humanReadableErrorMessage(errorStatus));
}
else
{
Parity par = Parity.None;
if (parity.Trim() == "Odd")
{
par = Parity.Odd;
}
else if (parity.Trim() == "Even")
{
par = Parity.Even;
}
else if (parity.Trim() == "None")
{
par = Parity.None;
}
StopBits stopB = StopBits.None;
if (stopBit.Trim() == "One")
{
stopB = StopBits.One;
}
else if (stopBit.Trim() == "Two")
{
stopB = StopBits.Two;
}
else if (stopBit.Trim() == "None")
{
stopB = StopBits.None;
}
serialPort1.BaudRate = Int32.Parse(baud);
serialPort1.Parity = par;
serialPort1.StopBits = stopB;
updateCommDetailMainForm();
connectionDetails.Close();
}
};
promptCancel.Click += (sender1, e1) =>
{
connectionDetails.Close();
};
connectionDetails.Controls.Add(comportInputLabel);
connectionDetails.Controls.Add(comportInput);
connectionDetails.Controls.Add(baudInput);
connectionDetails.Controls.Add(baudInputLabel);
connectionDetails.Controls.Add(parityInput);
connectionDetails.Controls.Add(parityInputLabel);
connectionDetails.Controls.Add(stopBitInputLabel);
connectionDetails.Controls.Add(stopBitInput);
connectionDetails.Controls.Add(promptOK);
connectionDetails.Controls.Add(promptCancel);
connectionDetails.ShowDialog();
}
}
public override void SetParameters(int baudRate, int dataBits, StopBits stopBits, Parity parity)
{
byte stopBitsBytes;
switch (stopBits)
{
case StopBits.One:
stopBitsBytes = 0;
break;
case StopBits.OnePointFive:
stopBitsBytes = 1;
break;
case StopBits.Two:
stopBitsBytes = 2;
break;
default:
throw new ArgumentException($"Bad value for stopBits: {stopBits}");
}
byte parityBitesBytes;
switch (parity)
{
case Parity.None:
parityBitesBytes = 0;
break;
case Parity.Odd:
parityBitesBytes = 1;
break;
case Parity.Even:
parityBitesBytes = 2;
break;
case Parity.Mark:
parityBitesBytes = 3;
break;
case Parity.Space:
parityBitesBytes = 4;
break;
default:
throw new ArgumentException($"Bad value for parity: {parity}");
}
byte[] msg =
{
(byte)(baudRate & 0xff),
(byte)((baudRate >> 8) & 0xff),
(byte)((baudRate >> 16) & 0xff),
(byte)((baudRate >> 24) & 0xff),
stopBitsBytes,
parityBitesBytes,
(byte)dataBits
};
SendAcmControlMessage(SET_LINE_CODING, 0, msg);
}
public CommMock(string portName, int baudrate = 19200, StopBits stopBits = StopBits.One, Parity parity = Parity.None)
: base(portName, baudrate, stopBits, parity)
{
}
//Add Instance Constructors for derived classes
//for setting data property values-takes input values
public ELM327Serial(string comPort, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
cPort = comPort;
bRate = baudRate;
Parity = parity;
dBits = dataBits;
StopBits = stopBits;
}
public WinSerialStream(string port_name, int baud_rate, int data_bits, Parity parity, StopBits sb,
bool dtr_enable, bool rts_enable, Handshake hs, int read_timeout, int write_timeout,
int read_buffer_size, int write_buffer_size)
{
handle = CreateFile(port_name != null && !port_name.StartsWith(@"\\.\")
? @"\\.\" + port_name : port_name,
GenericRead | GenericWrite, 0, 0, OpenExisting,
FileFlagOverlapped, 0);
if (handle == -1)
{
ReportIOError(port_name);
}
// Set port low level attributes
SetAttributes(baud_rate, parity, data_bits, sb, hs);
// Clean buffers and set sizes
if (!PurgeComm(handle, PurgeRxClear | PurgeTxClear) ||
!SetupComm(handle, read_buffer_size, write_buffer_size))
{
ReportIOError(null);
}
// Set timeouts
this.read_timeout = read_timeout;
this.write_timeout = write_timeout;
timeouts = new Timeouts(read_timeout, write_timeout);
if (!SetCommTimeouts(handle, timeouts))
{
ReportIOError(null);
}
/// Set DTR and RTS
SetSignal(SerialSignal.Dtr, dtr_enable);
if (hs != Handshake.RequestToSend &&
hs != Handshake.RequestToSendXOnXOff)
{
SetSignal(SerialSignal.Rts, rts_enable);
}
// Init overlapped structures
NativeOverlapped wo = new NativeOverlapped();
write_event = new ManualResetEvent(false);
#pragma warning disable 618
wo.EventHandle = write_event.Handle;
write_overlapped = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(NativeOverlapped)));
Marshal.StructureToPtr(wo, write_overlapped, true);
NativeOverlapped ro = new NativeOverlapped();
read_event = new ManualResetEvent(false);
ro.EventHandle = read_event.Handle;
read_overlapped = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(NativeOverlapped)));
Marshal.StructureToPtr(ro, read_overlapped, true);
#pragma warning restore 618
}
/// <summary>
/// 构造函数,可以自定义串口的初始化参数
/// </summary>
/// <param name="comPortName">需要操作的COM口名称</param>
/// <param name="baudRate">COM的速度</param>
/// <param name="parity">奇偶校验位</param>
/// <param name="dataBits">数据长度</param>
/// <param name="stopBits">停止位</param>
public SerialClass(string comPortName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
_serialPort = new SerialPort(comPortName, baudRate, parity, dataBits, stopBits);
_serialPort.RtsEnable = true; //自动请求
_serialPort.ReadTimeout = 3000; //超时
setSerialPort();
}
public void ConfigPort(string name, int baudRate, Parity parity, int dataBits, StopBits stopBits, Encoding encoding)
{
serialPort.PortName = name;
serialPort.BaudRate = baudRate;
serialPort.Parity = parity;
serialPort.DataBits = dataBits;
serialPort.StopBits = stopBits;
serialPort.Encoding = encoding;
}
/// <summary>
/// 打开串口
/// </summary>
/// <param name="portName">串口名称</param>
/// <param name="baudRate">波特率</param>
/// <param name="parity">奇偶校验</param>
/// <param name="dataBits">数据位</param>
/// <param name="stopBits">停止位</param>
public void OpenCom(string portName, int baudRate = 9600, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
{
CloseCom();
_comm = new SerialPort
{
PortName = portName,
BaudRate = baudRate,
Parity = parity,
DataBits = dataBits,
StopBits = stopBits,
};
_comm.DataReceived += SerialPortDataReceived;
try
{
_comm.Open();
IsOpen = true;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
private void BtnOpen_Click(object sender, EventArgs e)
{
btnOpen.Enabled = false;
btnClose.Enabled = true;
try
{
com.PortName = cmbPort.Text;
com.BaudRate = Int32.Parse(txtBaudRate.Text);
com.DataBits = Int32.Parse(txtBitLength.Text);
StopBits sb = StopBits.None;
String strSb = txtStopBits.Text;
if (strSb.Equals("None", StringComparison.InvariantCultureIgnoreCase))
{
sb = StopBits.None;
}
else if (strSb.Equals("1", StringComparison.InvariantCultureIgnoreCase))
{
sb = StopBits.One;
}
else if (strSb.Equals("One", StringComparison.InvariantCultureIgnoreCase))
{
sb = StopBits.One;
}
else if (strSb.Equals("OnePointFive", StringComparison.InvariantCultureIgnoreCase))
{
sb = StopBits.OnePointFive;
}
else if (strSb.Equals("Two", StringComparison.InvariantCultureIgnoreCase))
{
sb = StopBits.Two;
}
else
{
sb = StopBits.Two;
}
com.StopBits = StopBits.One;
com.DtrEnable = true;
com.RtsEnable = true;
Parity p;
String strParity = txtParity.Text;
if (strSb.Equals("Even", StringComparison.InvariantCultureIgnoreCase))
{
p = Parity.Even;
}
else if (strSb.Equals("Mark", StringComparison.InvariantCultureIgnoreCase))
{
p = Parity.Mark;
}
else if (strSb.Equals("None", StringComparison.InvariantCultureIgnoreCase))
{
p = Parity.None;
}
else if (strSb.Equals("Odd", StringComparison.InvariantCultureIgnoreCase))
{
p = Parity.Odd;
}
else if (strSb.Equals("Space", StringComparison.InvariantCultureIgnoreCase))
{
p = Parity.Space;
}
else
{
p = Parity.None;
}
com.Parity = p;
com.Open();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
com.DataReceived += new SerialDataReceivedEventHandler(com_DataReceived);
}
public CD7110Type(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
{
m_PortUtil = new PortUtil(portName, baudRate, parity, dataBits, stopBits);
}
