/// <summary> /// Connect to a device. /// </summary> /// <param name="serialPortName"></param> /// <param name="baudrate"></param> /// <param name="format"></param> /// <exception cref="InvalidOperationException"> /// Thrown when a valid connection ID hasn't been allocated, or when <paramref name="baudrate"/> is invalid for the device, or when <paramref name="format"/> is invalid for the device. /// </exception> /// <exception cref="Exception"> /// Thrown when <paramref name="serialPortName"/> can't be opened for communication. /// </exception> public void Connect(string serialPortName, Baudrate baudrate = DEFAULT_BAUD_RATE, SerialDataFormat format = DEFAULT_SERIAL_FORMAT) { if (connected) { Disconnect(); } switch (TG_Connect(connectionId, serialPortName, (int)baudrate, (int)format)) { case -1: throw new InvalidOperationException($"Invalid connection ID: {connectionId.ToString(CultureInfo.CurrentCulture)}"); case -2: throw new Exception(serialPortName + " could not be opened as a serial communication port. Check that the name is a valid COM port on your system."); case -3: throw new InvalidOperationException($"{nameof(baudrate)} is not a valid TG_BAUD_* value."); case -4: throw new InvalidOperationException($"{nameof(format)} is not a valid TG_STREAM_* type."); } this.baudrate = baudrate; connected = true; }
private void SerialConnect() { InitValue(); // 시리얼포트가 열려있지 않으면 if (!SerialPort.IsOpen) { // Baudrate 데이터 전처리 Baudrate = Baudrate.Substring(8); // DataBits 데이터 전처리 switch (DataBits) { case "Five": DataBits = "5"; break; case "Six": DataBits = "6"; break; case "Seven": DataBits = "7"; break; case "Eight": DataBits = "8"; break; } SerialPort.PortName = RS232_PortNum; SerialPort.BaudRate = int.Parse(Baudrate); SerialPort.Parity = (Parity)Enum.Parse(typeof(Parity), Parity); SerialPort.DataBits = int.Parse(DataBits); // StopBits가 None일 때, 예외처리(Default값 One) try { SerialPort.StopBits = (StopBits)Enum.Parse(typeof(StopBits), StopBits); } catch { } SerialPort.Open(); //버튼 초록색으로 만든다 GlobalVariable.StateReport?.Invoke("ConnectStateBtn", true); MessageBox.Show("포트가 열렸습니다"); if (SerialPort.IsOpen) { GlobalVariable.StateReport?.Invoke("ConfigBtn", false); GlobalVariable.ReportText?.Invoke("대기중"); } } else { MessageBox.Show("포트가 열려있습니다"); } }
public void Open(Baudrate speed) { TPCANBaudrate bitrate; switch (speed) { case Baudrate.Baudrate5000: bitrate = TPCANBaudrate.PCAN_BAUD_5K; break; case Baudrate.Baudrate10000: bitrate = TPCANBaudrate.PCAN_BAUD_10K; break; case Baudrate.Baudrate20000: bitrate = TPCANBaudrate.PCAN_BAUD_20K; break; case Baudrate.Baudrate50000: bitrate = TPCANBaudrate.PCAN_BAUD_50K; break; case Baudrate.Baudrate100000: bitrate = TPCANBaudrate.PCAN_BAUD_100K; break; case Baudrate.Baudrate125000: bitrate = TPCANBaudrate.PCAN_BAUD_125K; break; case Baudrate.Baudrate250000: bitrate = TPCANBaudrate.PCAN_BAUD_250K; break; case Baudrate.Baudrate500000: bitrate = TPCANBaudrate.PCAN_BAUD_500K; break; case Baudrate.Baudrate800000: bitrate = TPCANBaudrate.PCAN_BAUD_800K; break; case Baudrate.Baudrate1000000: bitrate = TPCANBaudrate.PCAN_BAUD_1M; break; default: throw new Exception("Invalid baudrate."); } var ret = PCANBasic.Initialize(Channel, bitrate); CheckError(ret); }
/// <summary> /// Returns a hash code for this instance. /// </summary> /// <returns> /// A hash code for this instance, suitable for use in hashing algorithms and data structures /// like a hash table. /// </returns> public override int GetHashCode() { int hash = 13; hash = (hash * 7) + Baudrate.GetHashCode(); hash = (hash * 7) + Databits.GetHashCode(); hash = (hash * 7) + Stopbits.GetHashCode(); hash = (hash * 7) + Parity.GetHashCode(); hash = (hash * 7) + Handshake.GetHashCode(); hash = (hash * 7) + TxTimeoutMSec.GetHashCode(); hash = (hash * 7) + RxTimeoutMSec.GetHashCode(); return(hash); }
/// <summary> /// Open the specified portName and baudRate. /// </summary> /// <param name="portName">Port name.</param> /// <param name="baudRate">Baud rate.</param> public bool Open(string portName = null, Baudrate baudRate = Baudrate.B_9600) { if (string.IsNullOrEmpty(portName)) { // Connect to default port var ports = GetPortNames(); if (Debug.isDebugBuild) { foreach (var port in ports) { Debug.LogFormat("port : {0}", port); } if (ports.Length == 0) { Debug.LogWarning("Serial port not found"); } } if (ports.Length == 0) { return(false); } portName = ports[0]; } _messages = new Queue <string>(); _serialPort = new SerialPort(portName, (int)baudRate, Parity.None, 8, StopBits.One); // _serialPort.ReadTimeout = 10000; // _serialPort.WriteTimeout = 10000; try { _serialPort.Open(); _serialPort.DtrEnable = true; _serialPort.RtsEnable = true; } catch (IOException e) { Debug.LogError(e); _serialPort.Dispose(); return(false); } _isRunning = true; _thread = new Thread(Read); // When main thread stopped, the thread close. _thread.IsBackground = true; _thread.Start(); return(true); }
public void Setup([Implicit] ICallContext context, Baudrate baudrate, ChannelMode mode) { if (context != null && context.LoggingEnabled) { context.Logger.Log("Setup", $"( {baudrate}, {mode} )"); } m_baudrate = baudrate; m_mode = mode; if (m_open && m_receiverThread == null) { m_receiverThread = new Thread(new ThreadStart(this.ReceiveThreadHandler)); m_receiverThread.Start(); //Core.Main.ServiceManager.Get<> } }
public void Open(Baudrate speed) { Port.Open(); UsbSpeed br; switch (speed) { case Baudrate.Baudrate10000: br = UsbSpeed.Speed_10000; break; case Baudrate.Baudrate20000: br = UsbSpeed.Speed_20000; break; case Baudrate.Baudrate50000: br = UsbSpeed.Speed_50000; break; case Baudrate.Baudrate100000: br = UsbSpeed.Speed_100000; break; case Baudrate.Baudrate200000: br = UsbSpeed.Speed_200000; break; case Baudrate.Baudrate400000: br = UsbSpeed.Speed_400000; break; case Baudrate.Baudrate500000: br = UsbSpeed.Speed_500000; break; case Baudrate.Baudrate1000000: br = UsbSpeed.Speed_1000000; break; default: throw new Exception("Invalid baudrate."); } var settings = Settings(br, Mode.Normal, UsbFrameType.Standard); Port.Write(settings, 0, settings.Length); Port.ReadExisting(); Thread.Sleep(100); }
/// <summary> /// /// </summary> /// <param name="segments"></param> public void Calculate(TimeSegemnts segments) { GetCalculateDetails.Clear(); //_txtRes = new System.Resources.ResourceManager("Konvolucio.Project.Localization.TextResource", typeof(BaudrateCalculator).Assembly); if (_txtRes != null) { /*text_BaudrateSystemClock*/ /*"System Clock[PCLK]: {0:N4} MHz"*/ /*Rendszer órajel[PCLK]: {0:N4} MHz*/ GetCalculateDetails.Add(string.Format(_txtRes.GetString("text_BaudrateSystemClock"), (segments.SystemClock / 1000000))); /*text_BaudRatePrescaler*/ /*Baud Rate Prescaler[BRP]: {0}*/ /*Átviteli sebesség osztó[BRP]: {0}*/ GetCalculateDetails.Add(string.Format(_txtRes.GetString("text_BaudRatePrescaler"), segments.Brp)); } else { GetCalculateDetails.Add("System Clock[PCLK]: " + (segments.SystemClock / 1000000).ToString("N4") + " MHz"); GetCalculateDetails.Add("Baud Rate Prescaler[BRP]: " + segments.Brp.ToString() + ""); GetCalculateDetails.Add("Time Segments Before Sample[TSEG1]: " + segments.Tseg1.ToString() + " Tq"); GetCalculateDetails.Add("Time Segments After Sample[TSEG2]: " + segments.Tseg2.ToString() + " Tq"); GetCalculateDetails.Add("Max Sync Jump Width[SJW]: " + segments.Sjw.ToString() + " Tq"); } TotalNumberOfTimeQuanta = segments.Tseg1 + segments.Tseg2; GetCalculateDetails.Add("Total Number Of Time Quanta[tbit]: " + TotalNumberOfTimeQuanta.ToString()); TimeQuanta = (1 / segments.SystemClock) * segments.Brp * 1000000; /*sec -> usec*/ GetCalculateDetails.Add("Time Quanta[Tq]: " + TimeQuanta.ToString("N5") + " us"); TimeBeforeSample = segments.Tseg1 * TimeQuanta; GetCalculateDetails.Add("Time Before Sample[tseg1]: " + TimeBeforeSample.ToString("N5") + " us"); TimeAfterSample = segments.Tseg2 * TimeQuanta; GetCalculateDetails.Add("Time After Sample[tseg2]: " + TimeAfterSample.ToString("N5") + " us"); NominalBitTime = 1 * TimeQuanta + TimeBeforeSample + TimeAfterSample; /* Mindig bele kell számolni a SYNC-et! ami 1 Tq */ GetCalculateDetails.Add("Nominal Bit Time: " + NominalBitTime.ToString("N5") + " us"); Baudrate = 1 / (NominalBitTime / 1000000); /* osztva ezerrel a usec -> sec miatt*/ GetCalculateDetails.Add("Baud Rate: " + Baudrate.ToString("N") + " Buad"); SamplePoint = ((1.0 + segments.Tseg1) / (double)(segments.Tseg1 + segments.Tseg2 + 1.0)) * 100.0; GetCalculateDetails.Add("Sample Point: " + SamplePoint.ToString("N") + " %"); }
/// <summary> /// Search the serial ports for a device that conforms to the expected MindWave behaviour. /// </summary> /// <param name="baudrate"> </param> /// <param name="format"> </param> /// <param name="filterType"></param> /// <returns></returns> public static MindWaveAdapter FindAdapter(Baudrate baudrate = DEFAULT_BAUD_RATE, SerialDataFormat format = DEFAULT_SERIAL_FORMAT, FilterType filterType = DEFAULT_MAINS_FILTER) { foreach (var portName in System.IO.Ports.SerialPort.GetPortNames()) { try { return(new MindWaveAdapter(portName, baudrate, format, filterType)); } #pragma warning disable CA1031 // Do not catch general exception types catch { } #pragma warning restore CA1031 // Do not catch general exception types } return(null); }
public ISCPICommand BAUD(Baudrate baudrate) { _command += "BAUD"; switch (baudrate) { case Baudrate.BAUD115200: _command += "0"; break; case Baudrate.BAUD57600: _command += "1"; break; case Baudrate.BAUD9600: _command += "2"; break; } return(this); }
internal static TPCANBaudrate ToPCANBaudrate(Baudrate baudrate) { switch (baudrate) { case Baudrate.BR5K: return(TPCANBaudrate.PCAN_BAUD_5K); case Baudrate.BR10K: return(TPCANBaudrate.PCAN_BAUD_10K); case Baudrate.BR20K: return(TPCANBaudrate.PCAN_BAUD_20K); case Baudrate.BR33K: return(TPCANBaudrate.PCAN_BAUD_33K); case Baudrate.BR47K: return(TPCANBaudrate.PCAN_BAUD_47K); case Baudrate.BR50K: return(TPCANBaudrate.PCAN_BAUD_50K); case Baudrate.BR83K: return(TPCANBaudrate.PCAN_BAUD_83K); case Baudrate.BR95K: return(TPCANBaudrate.PCAN_BAUD_95K); case Baudrate.BR100K: return(TPCANBaudrate.PCAN_BAUD_100K); case Baudrate.BR125K: return(TPCANBaudrate.PCAN_BAUD_125K); case Baudrate.BR250K: return(TPCANBaudrate.PCAN_BAUD_250K); case Baudrate.BR500K: return(TPCANBaudrate.PCAN_BAUD_500K); case Baudrate.BR800K: return(TPCANBaudrate.PCAN_BAUD_800K); case Baudrate.BR1000K: return(TPCANBaudrate.PCAN_BAUD_1M); default: return(TPCANBaudrate.PCAN_BAUD_100K); } }
public static int TG_SetBaudrate(int connectionId, Baudrate baudrate) { return TG_SetBaudrate(connectionId, (int)baudrate); }
public static int TG_Connect(int connectionId, string serialPortName, Baudrate baudrate, SerialDataFormat format) { return TG_Connect(connectionId, serialPortName, (int)baudrate, (int)format); }
/// <summary> /// Search the serial ports for a device that conforms to the expected MindWave behaviour. /// </summary> /// <param name="baudrate"> </param> /// <param name="filterType"></param> /// <returns></returns> public static MindWaveAdapter FindAdapter(Baudrate baudrate, FilterType filterType = DEFAULT_MAINS_FILTER) { return(FindAdapter(baudrate, DEFAULT_SERIAL_FORMAT, filterType)); }
/// <summary> /// Setups up a new connection to the MindWave device. /// </summary> /// <param name="serialPortName"></param> /// <param name="baudrate"></param> /// <param name="filterType"></param> /// <exception cref="IndexOutOfRangeException"> /// Thrown when too many connections have been made to the device. /// </exception> /// <exception cref="OutOfMemoryException"> /// Thrown when there isn't enough memory on the device to allocate a new connection. /// </exception> public MindWaveAdapter(string serialPortName, Baudrate baudrate, FilterType filterType = DEFAULT_MAINS_FILTER) : this(serialPortName, baudrate, DEFAULT_SERIAL_FORMAT, filterType) { }
/// <summary> /// Setups up a new connection to the MindWave device. /// </summary> /// <param name="serialPortName"></param> /// <param name="baudrate"></param> /// <param name="format"></param> /// <param name="filterType"></param> /// <exception cref="IndexOutOfRangeException"> /// Thrown when too many connections have been made to the device. /// </exception> /// <exception cref="OutOfMemoryException"> /// Thrown when there isn't enough memory on the device to allocate a new connection. /// </exception> public MindWaveAdapter(string serialPortName, Baudrate baudrate = DEFAULT_BAUD_RATE, SerialDataFormat format = DEFAULT_SERIAL_FORMAT, FilterType filterType = DEFAULT_MAINS_FILTER) : this() { Connect(serialPortName, baudrate, format); MainsFrequency = filterType; }