/// <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;
}
