public void SerialPortSettingsToStringException()
{
SerialPortSettings s = new SerialPortSettings(BaudRate.BR_57600,
Parity.Even, StopBits.One, 0xA0, 0xA1);
Console.WriteLine(s.ToString("F", null));
}
public static void Begin(string portName, SerialPortSettings settings)
{
s_ReceivingThread = new Thread(Read);
s_SerialPort = new SerialPort();
s_Settings = settings;
s_SerialPort.PortName = portName;
s_SerialPort.BaudRate = s_Settings.BaudRate;
s_SerialPort.Parity = s_Settings.Parity;
s_SerialPort.DataBits = s_Settings.DataBitSize;
s_SerialPort.StopBits = s_Settings.StopBitCount;
s_SerialPort.Handshake = s_Settings.HandshakeMode;
//s_SerialPort.RtsEnable = true;//*
//s_SerialPort.DtrEnable = true;//*
//s_SerialPort.ReceivedBytesThreshold = Marshal.SizeOf(typeof(SonarData));//*
s_SerialPort.ReadTimeout = s_Settings.ReadTimeout;
s_SerialPort.WriteTimeout = s_Settings.WriteTimeout;
//s_SerialPort.DataReceived += new SerialDataReceivedEventHandler(OnDataReceived);//*
s_IsActive = true;
s_SerialPort.Open();
s_ReceivingThread.Start();//*
}
public Serial(SerialPortSettings serialPortSettings, IDisk disk, ILogger log, CancellationTokenSource cancelTokenSource, bool compressionIsEnabled)
{
_localDisk = disk;
_logger = log;
_listenTokenSource = cancelTokenSource;
_compressionIsEnabled = compressionIsEnabled;
_isRLERun = false;
try
{
_serialPort = InitializeSerialPort(serialPortSettings);
_serialPort.Open();
_serialPort.DiscardOutBuffer();
_serialPort.DiscardInBuffer();
}
catch (Exception portException) when(portException is IOException || portException is UnauthorizedAccessException)
{
_logger.LogException(portException, $"Error opening serial port {serialPortSettings.PortName}");
throw;
}
_state = ReceiverState.ReceiveStartMagic;
StartListening();
}
public void UpdateXElement()
{
SerialPortSettings serialPortSettings = new SerialPortSettings(BaudRate.BR_57600,
Parity.Odd, StopBits.One, 0xAA, 0xA5);
string xElementSerialPortSettings =
"<serialPortSettings>" + "\r\n " +
"<baudrate>9600</baudrate>" + "\r\n " +
"<parity>1</parity>" + "\r\n " +
"<stopbit>2</stopbit>" + "\r\n " +
"<headerTx>0x8A</headerTx>" + "\r\n " +
"<headerRx>0x85</headerRx>" + "\r\n" +
"</serialPortSettings>";
XElement xElement = XElement.Parse(xElementSerialPortSettings);
xElement.UpdateXElement(serialPortSettings, XNamespace.None);
string xExpectedElementSerialPortSettings =
"<serialPortSettings>" + "\r\n " +
"<baudrate>57600</baudrate>" + "\r\n " +
"<parity>1</parity>" + "\r\n " +
"<stopbit>1</stopbit>" + "\r\n " +
"<headerTx>0xAA</headerTx>" + "\r\n " +
"<headerRx>0xA5</headerRx>" + "\r\n" +
"</serialPortSettings>";
Assert.AreEqual(xExpectedElementSerialPortSettings, xElement.ToString());
}
/// <summary>
/// Initializes the SPD reader/writer device
/// </summary>
/// <param name="portSettings">Serial port settings</param>
/// <param name="portName">Serial port name</param>
/// <param name="i2cAddress">EEPROM address on the device's i2c bus</param>
/// <param name="spdSize">Total EEPROM size</param>
public Device(SerialPortSettings portSettings, string portName, UInt8 i2cAddress, SpdSize spdSize)
{
PortSettings = portSettings;
PortName = portName;
I2CAddress = i2cAddress;
SpdSize = spdSize;
}
public void UpdateXElement()
{
SerialPortSettings serialPortSettings = new SerialPortSettings(BaudRate.BR_57600,
Parity.Odd, StopBits.One, 0xAA, 0xA5);
string xElementSerialPortSettings =
"<serialPortSettings>" + "\r\n " +
"<baudrate>9600</baudrate>" + "\r\n " +
"<parity>1</parity>" + "\r\n " +
"<stopbit>2</stopbit>" + "\r\n " +
"<headerTx>0x8A</headerTx>" + "\r\n " +
"<headerRx>0x85</headerRx>" + "\r\n" +
"</serialPortSettings>";
XElement xElement = XElement.Parse(xElementSerialPortSettings);
xElement.UpdateXElement(serialPortSettings, XNamespace.None);
string xExpectedElementSerialPortSettings =
"<serialPortSettings>" + "\r\n " +
"<baudrate>57600</baudrate>" + "\r\n " +
"<parity>1</parity>" + "\r\n " +
"<stopbit>1</stopbit>" + "\r\n " +
"<headerTx>0xAA</headerTx>" + "\r\n " +
"<headerRx>0xA5</headerRx>" + "\r\n" +
"</serialPortSettings>";
Assert.AreEqual(xExpectedElementSerialPortSettings, xElement.ToString());
}
/// <summary>
/// 构造函数。
/// </summary>
/// <param name="spSetting">本地串口配置。</param>
/// <param name="localType">本地节点类型。</param>
/// <param name="localCode">本地节点编号。</param>
protected One2OneSerialPort(SerialPortSettings spSetting,
NodeType localType, uint localCode)
: base(localType)
{
this.LocalCode = localCode;
_spSetting = spSetting;
}
public static void Begin(string portName, SerialPortSettings settings, int updateInterval = 0)
{
if (SerialPort != null && SerialPort.IsOpen)
{
return;
}
ReceivingThread = new Thread(Poll);
SerialPort = new SerialPort();
Settings = settings;
SerialPort.PortName = portName;
SerialPort.BaudRate = Settings.BaudRate;
SerialPort.Parity = Settings.Parity;
SerialPort.DataBits = Settings.DataBits;
SerialPort.StopBits = Settings.StopBits;
SerialPort.Handshake = Settings.Handshake;
SerialPort.RtsEnable = Settings.RTSEnable;
SerialPort.DtrEnable = Settings.DTREnable;
//SerialPort.ReceivedBytesThreshold = Settings.ReceiveThreshold;//*
SerialPort.ReadTimeout = Settings.ReadTimeout;
SerialPort.WriteTimeout = Settings.WriteTimeout;
//SerialPort.DataReceived += new SerialDataReceivedEventHandler(OnDataReceived);//*
UpdateInterval = updateInterval;
SerialPort.Open();
IsActive = true;
}
public ErasePageWorkerSlave(string port, SerialPortSettings serialPortSettings, ILoggerFacade logger,
MemoryType memoryType, IMemory memory) :
base(port, serialPortSettings, logger)
{
this.memoryType = memoryType;
this.memory = memory;
}
public RedNavPort()
{
portSettings = new SerialPortSettings("COM1", BaudRate.baudRate115200, Parity.None, DataBits.dataBits8, StopBits.One, Handshake.None);
#region timers
timer = new PrecisionTimer();
timer.Mode = Mode.Periodic;
timer.Period = 5000;
timer.Tick += new EventHandler(timer_Tick);
#endregion
#region Handlers
port_NewNMEAMessage_Handler = new EventHandler <NewNMEAMessageEventArgs>(port_NewNMEAMessage);
port_PortError_Handler = new EventHandler <SerialErrorReceivedEventArgs>(port_PortError);
#endregion
#region NMEA
NMEAInit();
#endregion
}
public void SerialPortSettingsToStringException()
{
SerialPortSettings s = new SerialPortSettings(BaudRate.BR_57600,
Parity.Even, StopBits.One, 0xA0, 0xA1);
Console.WriteLine(s.ToString("F", null));
}
private void StartCycleRequest(byte AddressCommand, int RequestType)
{
try
{
SerialPortSettings.OpenSerialPortConnection(serialPort1);
ThreadPool.QueueUserWorkItem(new WaitCallback((obj) =>
{
while (IsCurrentVoltageRequestCyclical && !Data.IsRequestSingle)
{
if (AddressCommand == AddressCurrentVoltageCommand)
{
OutputResponceData(AddressCommand, RequestType);
}
else
{
OutputResponceData(AddressCommand, RequestType);
AddressCommand = AddressCurrentVoltageCommand;
}
}
}));
}
catch (Exception ex)
{
Logger.Log.Error(ex.Message);
MessageBox.Show(ex.Message, "Ошибка!");
}
}
public BaseViewModel(string portName, SerialPortSettings serialPortSettings, ILoggerFacade logger)
{
StartCommand = new DelegateCommand(OnStart, CanExecuteStart);
StopCommand = new DelegateCommand(OnStop, CanExecuteStop);
this.portName = portName;
this.serialPortSettings = serialPortSettings;
this.logger = logger;
}
internal static void UpdateXElement(this XElement element, SerialPortSettings serialPortSettings, XNamespace ns)
{
element.Element(ns + "baudrate").Value = ((int)Enum.Parse(typeof(BaudRate), serialPortSettings.BaudRate.ToString())).ToString();
element.Element(ns + "parity").Value = ((int)Enum.Parse(typeof(Parity), serialPortSettings.Parity.ToString())).ToString();
element.Element(ns + "stopbit").Value = ((int)Enum.Parse(typeof(StopBits), serialPortSettings.StopBits.ToString())).ToString();
element.Element(ns + "headerTx").Value = "0x" + serialPortSettings.HeaderTX.ToString("X2");
element.Element(ns + "headerRx").Value = "0x" + serialPortSettings.HeaderRX.ToString("X2");
}
public ReadPageWorkerMaster(string port, SerialPortSettings serialPortSettings, ILoggerFacade logger,
MemoryType memoryType, Processor processor, List <int> numberOfPages)
: base(port, serialPortSettings, logger)
{
this.numberOfPages = numberOfPages;
this.memoryType = memoryType;
this.processor = processor;
}
internal static void UpdateXElement(this XElement element, SerialPortSettings serialPortSettings, XNamespace ns)
{
element.Element(ns + "baudrate").Value = ((int)Enum.Parse(typeof(BaudRate), serialPortSettings.BaudRate.ToString())).ToString();
element.Element(ns + "parity").Value = ((int)Enum.Parse(typeof(Parity), serialPortSettings.Parity.ToString())).ToString();
element.Element(ns + "stopbit").Value = ((int)Enum.Parse(typeof(StopBits), serialPortSettings.StopBits.ToString())).ToString();
element.Element(ns + "headerTx").Value = "0x" + serialPortSettings.HeaderTX.ToString("X2");
element.Element(ns + "headerRx").Value = "0x" + serialPortSettings.HeaderRX.ToString("X2");
}
private void OpenPort_OnExecuted(object sender, ExecutedRoutedEventArgs e)
{
_comService = new CommunicateService(MessageParserFactory.GetParserByProtocal(TransponderType.Robitronic));
var portSetting = new SerialPortSettings(38400, System.IO.Ports.StopBits.One, System.IO.Ports.Parity.None, 8);
_comService.StartService(ComSelection.Text, portSetting);
}
public WritePageWorkerMaster(string port, SerialPortSettings serialPortSettings, ILoggerFacade logger,
MemoryType memoryType, Processor processor, IMemory memory)
: base(port, serialPortSettings, logger)
{
this.memory = memory;
this.memoryType = memoryType;
this.processor = processor;
}
internal static XElement ToXElement(this SerialPortSettings serialPortSettings, XNamespace ns)
{
return(new XElement(ns + "serialPortSettings",
new XElement(ns + "baudrate", (int)Enum.Parse(typeof(BaudRate), serialPortSettings.BaudRate.ToString())),
new XElement(ns + "parity", (int)Enum.Parse(typeof(Parity), serialPortSettings.Parity.ToString())),
new XElement(ns + "stopbit", (int)Enum.Parse(typeof(StopBits), serialPortSettings.StopBits.ToString())),
new XElement(ns + "headerTx", "0x" + serialPortSettings.HeaderTX.ToString("X2")),
new XElement(ns + "headerRx", "0x" + serialPortSettings.HeaderRX.ToString("X2"))));
}
public void OpenPort(SerialPortSettings portSettings)
{
PortName = portSettings.PortName;
BaudRate = portSettings.BaudRate;
DataBits = portSettings.DataBits;
Parity = portSettings.Parity;
StopBits = portSettings.StopBits;
OpenPort();
}
public void AddChannel(ScalesDescriptor sd, DbScalesMeasureData lastMeaure = null)
{
IScales scales = SetupSource(sd);
ScalesChannel channel = null;
if (sd.StreamType == "serial")
{
SerialPortSettings settings = JsonConvert.DeserializeObject <SerialPortSettings>(sd.Settings);
channel = new ScalesChannel
{
Id = sd.Id,
Code = sd.Code,
Name = string.Format("{0} ({1})", sd.Name, settings.PortName),
Active = scales != null ? sd.Active : false,
Description = sd.Description,
Exposure = TimeSpan.FromMilliseconds(sd.Exposure),
Timeout = TimeSpan.FromMilliseconds(sd.Timeout),
TriggerEmpty = sd.TriggerEmpty,
TriggerLoading = sd.TriggerLoading,
ChannelSettings = settings,
owner = Program.mainForm
};
}
if (sd.StreamType == "tcp")
{
TcpChannelSettings settings = JsonConvert.DeserializeObject <TcpChannelSettings>(sd.Settings);
channel = new ScalesChannel
{
Id = sd.Id,
Code = sd.Code,
Name = string.Format("{0} ({1})", "TCP", settings.Address),
Active = scales != null ? sd.Active : false,
Description = sd.Description,
Exposure = TimeSpan.FromMilliseconds(sd.Exposure),
Timeout = TimeSpan.FromMilliseconds(sd.Timeout),
TriggerEmpty = sd.TriggerEmpty,
TriggerLoading = sd.TriggerLoading,
ChannelSettings = settings,
owner = Program.mainForm
};
}
if (lastMeaure != null)
{
channel.AcceptedTime = lastMeaure.Time;
channel.AcceptedValue = lastMeaure.Value;
}
Program.MeasuringChannels.Add(channel);
channel.EventSource = scales;
}
public virtual SettingsInfo GetNewSettingsInfo()
{
var processor = ListOfProcessors.ElementAt(IndexOfTheSelectedProcessor);
var serialPortSettings = new SerialPortSettings(ListOfBaudRates.ElementAt(IndexOfTheSelectedBaudRate),
ListOfParities.ElementAt(IndexOfTheSelectedParity), ListOfStopBits.ElementAt(IndexOfTheSelectedStopBits),
ListOfAllowableHeaders.ElementAt(IndexOfTheSelectedHeaderTx), ListOfAllowableHeaders.ElementAt(IndexOfTheSelectedHeaderRx));
var s = new SettingsInfo(0, string.Empty, processor, serialPortSettings);
return(s);
}
public void InitOutputPort(SerialPortSettings portSettings)
{
portDescrByHash.Add(portSettings.PortName.GetHashCode(), "OUT");
portNameByHash.Add(portSettings.PortName.GetHashCode(), portSettings.PortName);
outPort = new SerialPort(portSettings.PortName, (int)portSettings.PortBaudRate,
portSettings.PortParity, (int)portSettings.PortDataBits, portSettings.PortStopBits);
outPort.ErrorReceived += (o, e) => InfoEventHandler.Rise(o,
new LogEventArgs(LogLineType.ERROR,
string.Format("{0} ({1}) >> {2}", outPort.PortName, portDescrByHash[outPort.PortName.GetHashCode()], e.EventType.ToString())));
}
private void Start()
{
// 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200
SerialPortSettings settings = SerialPortSettings.Default;
settings.BaudRate = m_BaudRate;
settings.LoopDelay = 50;
//SonarSerialReceiver.OnUpdate += UpdateDataRevolving;
SonarSerialReceiver.OnUpdate += UpdateDataOscillating;
SonarSerialReceiver.Begin(m_COMPortName, settings);
}
public void InitOutputPort(SerialPortSettings outPortSettings)
{
if (outPort == null)
{
outPort = new SerialPort(outPortSettings.PortName, (int)outPortSettings.PortBaudRate);
OutPortUsed = true;
}
else
{
throw new InvalidOperationException("Output port has been already initialized");
}
}
public MainWindowViewModel()
{
Settings = new SerialPortSettings();
DataReceiver = new DataReceiver(new SerialPortByteSource(Settings));
Car = new CarModel()
{
Make = "Vauxhall", Model = "Corsa", Year = 2001
};
InitCommands();
}
public ConnectionViewModel(string portName, SerialPortSettings serialPortSettings, ILoggerFacade logger, int version, DateTime date)
: base(portName, serialPortSettings, logger)
{
Text = "Connection";
taskm = new TaskManager <bool>((taskManager) =>
{
return(new ConnectionWorkerSlave(portName, serialPortSettings, logger, version, date).Run(taskManager));
});
taskm.Canceled += taskm_Canceled;
taskm.Completed += taskm_Completed;
taskm.Faulted += taskm_Faulted;
taskm.Started += taskm_Started;
}
public ConnectionViewModel(string portName, SerialPortSettings serialPortSettings, ILoggerFacade logger, int version, DateTime date)
: base(portName, serialPortSettings, logger)
{
Text = "Connection";
taskm = new TaskManager<bool>((taskManager) =>
{
return (new ConnectionWorkerSlave(portName, serialPortSettings, logger, version, date).Run(taskManager));
});
taskm.Canceled += taskm_Canceled;
taskm.Completed += taskm_Completed;
taskm.Faulted += taskm_Faulted;
taskm.Started += taskm_Started;
}
public EraseViewModel(string portName, SerialPortSettings serialPortSettings, ILoggerFacade logger, MemoryType type, IMemory memory)
: base(portName, serialPortSettings, logger)
{
Text = "Erase " + ((type == MemoryType.FLASH) ? "FLASH" : "EEPROM");
taskm = new TaskManager <bool>((taskManager) =>
{
return(new ErasePageWorkerSlave(portName, serialPortSettings, logger, type, memory).Run(taskManager));
});
taskm.Canceled += taskm_Canceled;
taskm.Completed += taskm_Completed;
taskm.Faulted += taskm_Faulted;
taskm.Started += taskm_Started;
}
public EraseViewModel(string portName, SerialPortSettings serialPortSettings, ILoggerFacade logger, MemoryType type, IMemory memory)
: base(portName, serialPortSettings, logger)
{
Text = "Erase " + ((type == MemoryType.FLASH) ? "FLASH" : "EEPROM");
taskm = new TaskManager<bool>((taskManager) =>
{
return (new ErasePageWorkerSlave(portName, serialPortSettings, logger, type, memory).Run(taskManager));
});
taskm.Canceled += taskm_Canceled;
taskm.Completed += taskm_Completed;
taskm.Faulted += taskm_Faulted;
taskm.Started += taskm_Started;
}
public ResetViewModel(string portName, SerialPortSettings serialPortSettings, ILoggerFacade logger)
: base(portName, serialPortSettings, logger)
{
Text = "Reset";
taskm = new TaskManager <bool>((taskManager) =>
{
return(new ResetWorkerSlave(portName, serialPortSettings, logger).Run(taskManager));
});
taskm.Canceled += taskm_Canceled;
taskm.Completed += taskm_Completed;
taskm.Faulted += taskm_Faulted;
taskm.Started += taskm_Started;
}
public ReadLockViewModel(string portName, SerialPortSettings serialPortSettings, ILoggerFacade logger, byte locks)
: base(portName, serialPortSettings, logger)
{
Text = "Read Lock";
taskm = new TaskManager<bool>((taskManager) =>
{
return (new ReadLockWorkerSlave(portName, serialPortSettings, logger, locks).Run(taskManager));
});
taskm.Canceled += taskm_Canceled;
taskm.Completed += taskm_Completed;
taskm.Faulted += taskm_Faulted;
taskm.Started += taskm_Started;
}
public DeviceHandlerContextTests(ITestOutputHelper output)
{
Output = output;
ICommunicationDeviceSettings settings = new SerialPortSettings()
{
BaudRate = /*19200*/ 921600,
Encoding = 20127,
PortNumber = 4,
WriteTimeout = -1,
DataBits = 8,
Parity = Parity.None,
StopBits = StopBits.One,
ReadTimeout = -1,
};
var dataSplitter = new StandardDataStreamSplitter('#');
var v1 = new OnlyAlphanumericAllowedValidator();
var v2 = AllwaysGoodValidatorSingleton.Instance;
var v3 = AllwaysBadValidatorSingleton.Instance;
var a1 = idfac = new PartFactoryAutofacAdapter((data, validator) => new IDPart(data, validator), v3);
var a2 = hostidfac = new PartFactoryAutofacAdapter((data, validator) => new HostIDPart(data, validator), v3);
var a3 = targetfac = new PartFactoryAutofacAdapter((data, validator) => new TargetPart(data, validator), v3);
var a4 = orderfac = new PartFactoryAutofacAdapter((data, validator) => new OrderPart(data, validator), v3);
var a5 = datafac = new PartFactoryAutofacAdapter((data, validator) => new DataPart(data, validator), v3);
var a6 = emptyfac = new PartFactoryAutofacAdapter((data, validator) => new EmptyPart(validator), v2);
var partFactory = new PrecisePartFactory(new Dictionary <PartType, PartFactoryAutofacAdapter>()
{
[PartType.ID] = a1,
[PartType.HostID] = a2,
[PartType.Target] = a3,
[PartType.Order] = a4,
[PartType.Data] = a5,
[PartType.Empty] = a6
});
var comfacadap = new CommandFactoryAutoFacAdapter((id, hostid, target, order, data, Timestamp) => new Command(id, hostid, target, order, data, TimestampFactory.Timestamp));
var Factory = new CommandFactory('*', partFactory, comfacadap);
var ConfirmationFactory = new ConfirmationFactory();
var Translator = new CommandTranslator(Factory, new RawCommandFactory('#', '*'));
ICommunicationDeviceAsync com = new Shield.COMDevice.SerialPortAdapter(settings);
DHC = new DeviceHandlerContext(com, dataSplitter, Translator);
}
public void Load(ScalesDescriptor sd)
{
if (sd.StreamType == "serial")
{
SerialPortSettings settings = JsonConvert.DeserializeObject <SerialPortSettings>(sd.Settings);
Id = sd.Id;
Code = sd.Code;
Name = sd.Name;
Decoder = sd.Decoder;
Active = sd.Active;
Description = sd.Description;
Exposure = TimeSpan.FromMilliseconds(sd.Exposure);
Timeout = TimeSpan.FromMilliseconds(sd.Timeout);
TriggerLoading = sd.TriggerLoading;
TriggerEmpty = sd.TriggerEmpty;
SettingsType = settings.SettingsType;
PortName = settings.PortName;
Address = "";
BaudRate = settings.BaudRate;
DataBits = settings.DataBits;
Parity = settings.Parity;
StopBits = settings.StopBits;
}
if (sd.StreamType == "tcp")
{
TcpChannelSettings settings = JsonConvert.DeserializeObject <TcpChannelSettings>(sd.Settings);
Id = sd.Id;
Code = sd.Code;
Name = sd.Name;
Decoder = sd.Decoder;
Active = sd.Active;
Description = sd.Description;
Exposure = TimeSpan.FromMilliseconds(sd.Exposure);
Timeout = TimeSpan.FromMilliseconds(sd.Timeout);
TriggerLoading = sd.TriggerLoading;
TriggerEmpty = sd.TriggerEmpty;
SettingsType = settings.SettingsType;
PortName = "";
Address = settings.Address;
BaudRate = 0;
DataBits = 0;
Parity = 0;
StopBits = 0;
}
}
public void Create()
{
SerialPortSettings s1 = new SerialPortSettings(BaudRate.BR_57600,
Parity.Even, StopBits.One, 0xA0, 0xA5);
SerialPortSettings s2 = new SerialPortSettings(BaudRate.BR_57600,
Parity.Even, StopBits.One, 0xA0, 0xA5);
Assert.IsTrue(s1.Equals(s2));
foreach (var h in SerialPortSettings.AllowableHeadersList)
{
if (h % 0x10 == 0 && h != SerialPortSettings.MinAllowableHeaderValue)
Console.WriteLine();
Console.Write("0x{0:X2} ", h);
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public SerialPortSettings GetSettings()
{
if (cbxComName.SelectedIndex == -1)
{
throw new ArgumentException("无可用的串口。");
}
SerialPortSettings result = new SerialPortSettings(cbxComName.Text);
result.BaudRate = Convert.ToInt32(cbxBaudRate.Text);
result.Parity = (Parity)(cbxParity.SelectedIndex);
result.Stopbits = (StopBits)(cbxStopBits.SelectedIndex + 1);
result.Databits = Convert.ToInt32(cbxDatabits.Text);
return(result);
}
public CalibrationSettings()
{
RFID = new RFIDPortSettings();
_rfidPortSettings = new SerialPortSettings();
_safetyControllerPortSettings = new SerialPortSettings();
Vision = new VisionSettings();
MeasurementTest = new MeasurementTestSettings();
SafetyController = new SafetyControllerPortSettings();
//HgaProducts = new HGAProductSetting();
//HgaProducts = new HGAProductSetting();
//HgaProduct = new HGAProductInfo();
Load();
}
public void ToSerialPortSettings()
{
string xElementSerialPortSettings =
"<serialPortSettings>" + "\r\n " +
"<baudrate>57600</baudrate>" + "\r\n " +
"<parity>1</parity>" + "\r\n " +
"<stopbit>1</stopbit>" + "\r\n " +
"<headerTx>0xAA</headerTx>" + "\r\n" +
"<headerRx>0xA5</headerRx>" + "\r\n" +
"</serialPortSettings>";
XElement xElement = XElement.Parse(xElementSerialPortSettings);
SerialPortSettings serialPortSettings = xElement.ToSerialPortSettings(XNamespace.None);
SerialPortSettings expectedSerialPortSettings = new SerialPortSettings(BaudRate.BR_57600,
Parity.Odd, StopBits.One, 0xAA, 0xA5);
Assert.IsTrue(expectedSerialPortSettings.Equals(serialPortSettings));
}
public void ToXElement()
{
SerialPortSettings serialPortSettings = new SerialPortSettings(BaudRate.BR_57600,
Parity.Odd, StopBits.One, 0xAA, 0xA5);
XElement xElement = serialPortSettings.ToXElement("namespace");
string xElementSerialPortSettings =
"<serialPortSettings xmlns=\"namespace\">" + "\r\n " +
"<baudrate>57600</baudrate>" + "\r\n " +
"<parity>1</parity>" + "\r\n " +
"<stopbit>1</stopbit>" + "\r\n " +
"<headerTx>0xAA</headerTx>" + "\r\n " +
"<headerRx>0xA5</headerRx>" + "\r\n" +
"</serialPortSettings>";
Assert.AreEqual(xElementSerialPortSettings, xElement.ToString());
}
private void LoadSettings()
{
Text = @"Bliksem Control Center (2016)" + (Settings.Default.WindowCaption != "" ? " - " + Settings.Default.WindowCaption : "");
using (FileStream reader = new FileStream(_dataFile, FileMode.Open, FileAccess.Read))
{
DataContractSerializer ser = new DataContractSerializer(typeof(List<Channels>));
_outputs = (List<Channels>)ser.ReadObject(reader);
}
if (File.Exists(_scheduleFile))
{
using (FileStream reader = new FileStream(_scheduleFile, FileMode.Open, FileAccess.Read))
{
DataContractSerializer ser = new DataContractSerializer(typeof(List<Schedule>));
_schedules = (List<Schedule>)ser.ReadObject(reader);
}
}
if (!File.Exists(_serialportFile)) return;
using (FileStream reader = new FileStream(_serialportFile, FileMode.Open, FileAccess.Read))
{
DataContractSerializer ser = new DataContractSerializer(typeof(SerialPortSettings));
_portSettings = (SerialPortSettings)ser.ReadObject(reader);
}
_port.PortName = _portSettings.PortName ?? _port.PortName;
_port.BaudRate = _portSettings.BaudRate == 0 ? 9600 : _portSettings.BaudRate;
_port.Parity = _portSettings.Parity;
_port.DataBits = _portSettings.DataBits == 0 ? 8 : _portSettings.DataBits;
_port.StopBits = _portSettings.StopBits == StopBits.None ? StopBits.One : _portSettings.StopBits;
}
public IOWorkerBase(string portName, SerialPortSettings serialPortSettings, ILoggerFacade logger)
{
this.portName = portName;
this.serialPortSettings = serialPortSettings;
this.logger = logger;
}
public virtual SettingsInfo GetNewSettingsInfo()
{
var processor = ListOfProcessors.ElementAt(IndexOfTheSelectedProcessor);
var serialPortSettings = new SerialPortSettings(ListOfBaudRates.ElementAt(IndexOfTheSelectedBaudRate),
ListOfParities.ElementAt(IndexOfTheSelectedParity), ListOfStopBits.ElementAt(IndexOfTheSelectedStopBits),
ListOfAllowableHeaders.ElementAt(IndexOfTheSelectedHeaderTx), ListOfAllowableHeaders.ElementAt(IndexOfTheSelectedHeaderRx));
var s = new SettingsInfo(0, string.Empty, processor, serialPortSettings);
return s;
}
public void CreateHeaderTXException()
{
SerialPortSettings s = new SerialPortSettings(BaudRate.BR_57600,
Parity.Even, StopBits.One, 0x7F, 0xA5);
}
