private void UpdateCode(ValidPassCode pw, bool highlighted, ISerialConnection terminal) { for(var i = 0; i < pw.Code.Length; i++) { var pos = pw.Position + i; var row = (pos / _cols) % _rows + 6; var col = ((pos % _cols) + 8) + ((pos / bytesPerColumn) * 22); terminal.Write(IBM3151.Commands.SetBufferPosition(row, col)); terminal.Write(pw.Code[i].ToString()); pw.Highlighted = highlighted; } }
private async Task ConnectDisconnect(string currentState) { if (currentState.Equals("Connect")) { serialConnection = new BluetoothSerialConnection("SPP"); dev = new ELM327(serialConnection, new OBDConsoleLogger(OBDLogLevel.Debug)); while (!serialConnection.IsOpen) { try { await dev.InitializeAsync(); } catch (Exception) { } } connectionBtn.Content = "Disconnect"; } else { serialConnection.Dispose(); dev.Dispose(); connectionBtn.Content = "Connect"; } }
private void InitWeightScale() { _logger.Information($"Initiate connection to weight scale"); Color color = Color.Green; if (_isWeightScaleTestMode) { _scaleSerialConnection = new SerialConnectionScaleTest(); color = Color.DarkOrange; } else { _scaleSerialConnection = new SerialConnection(); } try { _handlerRs232WeigthScale = new HandlerRs232WeigthScale(_scaleSerialConnection); _handlerRs232WeigthScale.OpenConnection(_weightScaleConfig.ComPort, _weightScaleConfig.BaudRate, _weightScaleConfig.Parity, _weightScaleConfig.StopBits, _weightScaleConfig.DataBits, _weightScaleConfig.Handshake, _weightScaleConfig.NewLine, _weightScaleConfig.ReadMode); _logger.Information($"Opened port to Scale"); _handlerRs232WeigthScale.OnDataRead += DisplayWeight; UpdateLabel(label_weight, $"Vekt tilkobling, {_weightScaleConfig.ComPort}", color); } catch (Exception e) { _handlerRs232WeigthScale = null; _logger.Error($"Exception InitPowerSupply: {e.Message}"); } }
private IStringProtocol CreateSerialSession(ISerialConnection connection, int timeout = -1) { var session = new ArduinoSession(connection); session.TimeOut = timeout; session.MessageReceived += (o, e) => { Assert.Fail("MessageReceived event triggered"); }; session.AnalogStateReceived += (o, e) => { Assert.Fail("AnalogStateReceived event triggered"); }; session.DigitalStateReceived += (o, e) => { Assert.Fail("DigitalStateReceived event triggered"); }; session.I2CReplyReceived += (o, e) => { Assert.Fail("I2CReplyReceived event triggered"); }; session.StringReceived += (o, e) => { Console.WriteLine("Received: '{0}'", e.Text); }; return(session); }
public ArduinoDriver() { connection_handler: try { this._connection = getArduinoConnection(); } catch (Exception e) { Console.WriteLine("Error Message : " + e.Message); this._session = null; } if (this._connection != null) { this._session = new ArduinoSession(this._connection); Console.WriteLine("New arduino session started successfully ... !!!"); Console.WriteLine("Performing board compatibility tests ..."); this.compatibilityTest(); Console.WriteLine("arduino is ready to receive commands ..."); } else { Console.WriteLine("No connection found..."); Console.WriteLine("Press any to try again."); Console.ReadKey(true); goto connection_handler; } }
public HandlerRs232PowerSupply(ISerialConnection serialConnection) { _serialConnection = serialConnection; _voltageOff = Convert.ToDouble(ConfigurationManager.AppSettings["app:voltageTurnOff"], CultureInfo.InvariantCulture); _voltageOn = Convert.ToDouble(ConfigurationManager.AppSettings["app:voltageTurnOn"], CultureInfo.InvariantCulture); }
/// <summary> /// Initializes a new instance of the <see cref="SerialDevice"/> class. /// </summary> /// <param name="connection">connection.</param> /// <param name="terminator">terminator used for terminating the command message</param> /// <param name="logger">logger instance</param> protected SerialDevice(ISerialConnection connection, char terminator = '\r', IOBDLogger logger = null) { Connection = connection; Terminator = terminator; Logger = logger; connection.DataReceived += OnDataReceived; }
public static async Task Push(ISerialConnection connection, RealTimePayload realTimePayLoad) { HttpClient httpClient = new HttpClient(); httpClient.MaxResponseContentBufferSize = 256000; var serviceUri = new Uri(@"http://obdmicroservice20180827101800.azurewebsites.net/api/realtimepayloads"); StringContent realTimePayLoadContent = new StringContent(JsonConvert.SerializeObject(realTimePayLoad), System.Text.Encoding.UTF8, "application/json"); HttpResponseMessage response = await httpClient.PostAsync(serviceUri, realTimePayLoadContent); }
public void Dispose() { if (this.connection != null) { this.connection.Dispose(); this.connection = null; this.session = null; SetState("disconnected"); } }
/// <summary> /// Initializes a new instance of the <see cref="ArduinoSession"/> class. /// </summary> /// <param name="connection">The serial port connection</param> /// <param name="timeOut">The response time out in milliseconds</param> /// <exception cref="System.ArgumentNullException">connection</exception> /// <exception cref="System.ArgumentOutOfRangeException">timeOut</exception> public ArduinoSession(ISerialConnection connection, int timeOut) : this(connection) { if (timeOut < SerialPort.InfiniteTimeout) { throw new ArgumentOutOfRangeException(nameof(timeOut)); } _messageTimeout = timeOut; }
public V300(ISerialConnection serial) { _serial = serial; _parser = new V300Parser(); _parser.HaltRestartMaint += HandleParserHaltRestartMaint; _parser.HaltRestartNormal += HandleParserHaltRestartNormal; _parser.SetFileProtection += HandleParserSetFileProtection; _parser.RunDebugAccounts += HandleParserRunDebugAccounts; _parser.LogonAdmin += Handle_parserLogonAdmin; _serial.Restart += HandleSerialRestart; }
private IFirmataProtocol CreateFirmataSession(ISerialConnection connection, int timeout = -1) { var session = new ArduinoSession(connection); session.TimeOut = timeout; session.MessageReceived += (o, e) => { _messagesReceived.Enqueue(e.Value); }; return(session); }
/// <summary> /// Initializes a new instance of the <see cref="ArduinoSession"/> class. /// </summary> /// <param name="connection">The serial port connection</param> /// <exception cref="System.ArgumentNullException">connection</exception> public ArduinoSession(ISerialConnection connection) { _connection = connection ?? throw new ArgumentNullException(nameof(connection)); _gotOpenConnection = connection.IsOpen; if (!connection.IsOpen) { connection.Open(); } _connection.DataReceived += SerialDataReceived; }
private ISerialConnection getArduinoConnection() { Console.WriteLine("Searching for arduino ..."); ISerialConnection _connection = EnhancedSerialConnection.Find(); if (_connection == null) { Console.WriteLine("Arduino not found .... :("); return(null); } Console.WriteLine($"Arduino found in : {_connection.PortName} at {_connection.BaudRate} baud rate."); return(_connection); }
static void Main(string[] args) { ISerialConnection connection = GetConnection(); if (connection != null) { using (var session = new ArduinoSession(connection)) PerformBasicTest(session); } Console.WriteLine("Press a key"); Console.ReadKey(true); }
/// <inheritdoc cref="ISerialConnection.Write(string)" /> /// <inheritdoc cref="ISerialConnection.Write(byte[],int,int)" /> /// <summary> /// Finds a serial connection to a device supporting the Firmata protocol. /// </summary> /// <returns>A <see cref="ISerialConnection"/> instance or <c>null</c> if no connection is found</returns> /// <remarks> /// <para> /// This method searches all available serial ports until it finds a working serial connection. /// For every available serial port an attempt is made to open a connection at a range of common baudrates. /// The connection is tested by issueing an <see cref="IFirmataProtocol.GetFirmware()"/> command. /// (I.e. a Firmata SysEx Firmware query (0xF0 0x79 0xF7).) /// </para> /// <para> /// The connected device is expected to respond by sending the version number of the supported protocol. /// When a major version of 2 or higher is received, the connection is regarded to be valid. /// </para> /// </remarks> /// <seealso cref="IFirmataProtocol"/> /// <seealso href="http://www.firmata.org/wiki/Protocol#Query_Firmware_Name_and_Version">Query Firmware Name and Version</seealso> public static ISerialConnection Find() { Func <ArduinoSession, bool> isAvailableFunc = session => { Firmware firmware = session.GetFirmware(); return(firmware.MajorVersion >= 2); }; string[] portNames = GetPortNames(); ISerialConnection connection = FindConnection(isAvailableFunc, portNames, PopularBaudRates); return(connection ?? FindConnection(isAvailableFunc, portNames, OtherBaudRates)); }
private void MainWindowLoaded(object sender, RoutedEventArgs e) { var sensorStatus = new KinectSensorChooser(); sensorStatus.KinectChanged += KinectSensorChooserKinectChanged; kinectChooser.KinectSensorChooser = sensorStatus; sensorStatus.Start(); connection = GetConnection(); if (connection != null) { session = new ArduinoSession(connection); } }
private static ISerialConnection GetConnection() { Console.WriteLine("Searching Arduino connection..."); ISerialConnection connection = EnhancedSerialConnection.Find(); if (connection == null) { Console.WriteLine("No connection found. Make shure your Arduino board is attached to a USB port."); } else { Console.WriteLine($"Connected to port {connection.PortName} at {connection.BaudRate} baud."); } return(connection); }
public static async Task Push(ISerialConnection connection, RealTimePayload realTimePayLoad) { HttpClient httpClient = new HttpClient(); httpClient.MaxResponseContentBufferSize = 256000; var serviceUri = new Uri(@"http://obdmicroservice20180827101800.azurewebsites.net/api/realtimepayloads"); StringContent realTimePayLoadContent = new StringContent(JsonConvert.SerializeObject(realTimePayLoad), Encoding.UTF8, "application/json"); HttpResponseMessage response = await httpClient.PostAsync(serviceUri, realTimePayLoadContent); if (response.IsSuccessStatusCode) { Console.WriteLine($"Speed: {realTimePayLoad.Speed} : RPM: {realTimePayLoad.Rpm} : Fuel Level: {realTimePayLoad.FuelLevel}"); } else { Console.WriteLine("FAILED"); } }
public IFirmataProtocol EstablishConnection(string port) { print("Searching for Arduino connection..."); if (port == "auto") { connection = EnhancedSerialConnection.Find(); connection.BaudRate = 9600; if (connection == null) { print(NoConnect); } else { print(System.String.Format("Connected to port {0} at {1} baud rate.", connection.PortName, connection.BaudRate)); session = new ArduinoSession(connection) { TimeOut = 3000 }; protocol = session; } } else { connection = new EnhancedSerialConnection(port, SerialBaudRate.Bps_9600); if (connection == null) { print(NoConnect); } else { print(System.String.Format("Connected to port {0} at {1} baud rate.", connection.PortName, connection.BaudRate)); session = new ArduinoSession(connection) { TimeOut = 3000 }; protocol = session; } } return(protocol); }
private void SetConnection() { try { _connection = EnhancedSerialConnection.Find(); if (_connection == null) { _comOK = false; } else { _comOK = true; } } catch { _comOK = false; _connection.Close(); } }
private void DoTurnLight(bool on) { if (this.session == null) { this.connection = EnhancedSerialConnection.Find(); if (this.connection != null) { this.session = new ArduinoSession(this.connection); session.SetDigitalPinMode(PWM_PIN, PinMode.PwmOutput); session.SetDigitalPinMode(LED_PIN, PinMode.DigitalOutput); SetState($"Firmata on {connection.PortName} (PWM pin {PWM_PIN})"); } } if (this.session != null) { int pwmWidthByte = ((LangLedMain.BrightnessPercentage * 255) / 100); session.SetDigitalPin(PWM_PIN, on ? pwmWidthByte : 0); session.SetDigitalPin(LED_PIN, on); } }
private void findArduino() // Try finding the arduino { ISerialConnection connection = EnhancedSerialConnection.Find(); if (connection != null) { session = new ArduinoSession(connection); lblConnection.Text = "Arduino found!"; session.SetDigitalPinMode(redPin, PinMode.PwmOutput); session.SetDigitalPinMode(greenPin, PinMode.PwmOutput); session.SetDigitalPinMode(bluePin, PinMode.PwmOutput); session.SetDigitalPin(redPin, btnColor.BackColor.R); session.SetDigitalPin(greenPin, btnColor.BackColor.G); session.SetDigitalPin(bluePin, btnColor.BackColor.B); btnRetry.Hide(); } else { lblConnection.Text = "The arduino was not found..."; btnRetry.Show(); } }
/// <summary> /// Finds a serial connection to a device supporting plain serial communications. /// </summary> /// <param name="query">The query text used to inquire the connection</param> /// <param name="expectedReply">The reply text the connected device is expected to respond with</param> /// <returns>A <see cref="ISerialConnection"/> instance or <c>null</c> if no connection is found</returns> /// <remarks> /// <para> /// This method searches all available serial ports until it finds a working serial connection. /// For every available serial port an attempt is made to open a connection at a range of common baudrates. /// The connection is tested by sending the query string passed to this method. /// </para> /// <para> /// The connected device is expected to respond by sending the reply string passed to this method. /// When the string received is equal to the expected reply string, the connection is regarded to be valid. /// </para> /// </remarks> /// <example> /// The Arduino sketch below can be used to demonstrate this method. /// Upload the sketch to your Arduino device. /// <code lang="Arduino Sketch"> /// char query[] = "Hello?"; /// char reply[] = "Arduino!"; /// /// void setup() /// { /// Serial.begin(9600); /// while (!Serial) {} /// } /// /// void loop() /// { /// if (Serial.find(query)) /// { /// Serial.println(reply); /// } /// else /// { /// Serial.println("Listening..."); /// Serial.flush(); /// } /// /// delay(25); /// } /// </code> /// </example> /// <seealso cref="IStringProtocol"/> public static ISerialConnection Find(string query, string expectedReply) { if (string.IsNullOrEmpty(query)) { throw new ArgumentException(Messages.ArgumentEx_NotNullOrEmpty, "query"); } if (string.IsNullOrEmpty(expectedReply)) { throw new ArgumentException(Messages.ArgumentEx_NotNullOrEmpty, "expectedReply"); } Func <ArduinoSession, bool> isAvailableFunc = session => { session.Write(query); return(session.Read(expectedReply.Length) == expectedReply); }; string[] portNames = GetPortNames(); ISerialConnection connection = FindConnection(isAvailableFunc, portNames, PopularBaudRates); return(connection ?? FindConnection(isAvailableFunc, portNames, OtherBaudRates)); }
private void InitPowerSupply() { _logger.Information($"Initiate connection to power supply for Silo"); Color color = Color.Green; if (_isPowerSupplyTestMode) { _psSerialConnection = new SerialConnectionPsTest(); color = Color.DarkOrange; } else { _psSerialConnection = new SerialConnection(); } try { _handlerRs232PowerSupply = new HandlerRs232PowerSupply(_psSerialConnection); _handlerRs232PowerSupply.OpenConnection(_powerSupplyConfig.ComPort, _powerSupplyConfig.BaudRate, _powerSupplyConfig.Parity, _powerSupplyConfig.StopBits, _powerSupplyConfig.DataBits, _powerSupplyConfig.Handshake, _powerSupplyConfig.NewLine, _powerSupplyConfig.ReadMode); _logger.Information($"Opened port to Silo"); _handlerRs232PowerSupply.OnDataRead += ReadVoltageSetting; UpdateLabel(label_powerSupply, $"Silo tilkobling, {_powerSupplyConfig.ComPort}", color); } catch (Exception e) { _handlerRs232PowerSupply = null; _logger.Error($"Exception InitPowerSupply: {e.Message}"); } }
private static ISerialConnection GetConnection() { ISerialConnection connection = null; Console.WriteLine("Searching for serial ports"); var ports = SerialPort.GetPortNames(); foreach (var port in ports.Where(p => p != "COM3" && p != "COM1")) { try { connection = new EnhancedSerialConnection(port, SerialBaudRate.Bps_57600); Console.WriteLine($"Connected to port {connection.PortName} at {connection.BaudRate} baud."); break; } catch (Exception e) { Console.WriteLine("Failed to connect serial port: " + e); connection = null; } } return(connection); }
public ArduinoOne(ISerialConnection connection) : this(new ArduinoSession(connection)) { }
private II2CProtocol CreateFirmataSession(ISerialConnection connection, int timeout = -1) { var session = new ArduinoSession(connection); session.TimeOut = timeout; session.MessageReceived += (o, e) => { _messagesReceived.Enqueue(e.Value); }; return session; }
/// <summary> /// Initializes a new instance of the <see cref="ArduinoSession"/> class. /// </summary> /// <param name="connection">The serial port connection</param> /// <exception cref="System.ArgumentNullException">connection</exception> public ArduinoSession(ISerialConnection connection) { if (connection == null) throw new ArgumentNullException("connection"); _connection = connection; _gotOpenConnection = connection.IsOpen; if (!connection.IsOpen) connection.Open(); _connection.DataReceived += SerialDataReceived; }
/// <summary> /// Initializes a new instance of the <see cref="ArduinoWS281XDeviceDefinition"/> class. /// </summary> /// <param name="serialConnection">The serial connection used for the device.</param> public ArduinoWS281XDeviceDefinition(ISerialConnection serialConnection) { this.SerialConnection = serialConnection; }
public ELM327(ISerialConnection connection, IOBDLogger logger = null) : base(connection, logger: logger) { }
/// <inheritdoc /> /// <summary> /// Initializes a new instance of the <see cref="SerialConnectionUpdateQueue{TData}"/> class. /// </summary> /// <param name="updateTrigger">The update trigger used by this queue.</param> /// <param name="portName">The name of the serial-port to connect to.</param> /// <param name="baudRate">The baud-rate used by the serial-connection.</param> internal SerialConnectionUpdateQueue(IDeviceUpdateTrigger updateTrigger, ISerialConnection serialConnection) : base(updateTrigger) { SerialConnection = serialConnection; }
/// <inheritdoc /> /// <summary> /// Initializes a new instance of the <see cref="T:RGB.NET.Devices.WS281X.Bitwizard.BitwizardWS2812USBUpdateQueue" /> class. /// </summary> /// <param name="updateTrigger">The update trigger used by this queue.</param> /// <param name="portName">The name of the serial-port to connect to.</param> /// <param name="baudRate">The baud-rate used by the serial-connection.</param> public BitwizardWS2812USBUpdateQueue(IDeviceUpdateTrigger updateTrigger, ISerialConnection serialConnection) : base(updateTrigger, serialConnection) { }
private IStringProtocol CreateSerialSession(ISerialConnection connection, int timeout = -1) { var session = new ArduinoSession(connection); session.TimeOut = timeout; session.MessageReceived += (o, e) => { Assert.Fail("MessageReceived event triggered"); }; session.AnalogStateReceived += (o, e) => { Assert.Fail("AnalogStateReceived event triggered"); }; session.DigitalStateReceived += (o, e) => { Assert.Fail("DigitalStateReceived event triggered"); }; session.I2CReplyReceived += (o, e) => { Assert.Fail("I2CReplyReceived event triggered"); }; session.StringReceived += (o, e) => { Console.WriteLine("Received: '{0}'", e.Text); }; return session; }
public void HighlightPossible(string guess, ISerialConnection terminal) { terminal.Write(IBM3151.Commands.SetCharacterAttribute(IBM3151.CharacterAttributes.Intense)); foreach(var pw in _passwords.Where(x => x.Highlighted)) UpdateCode(pw, false, terminal); if(guess != string.Empty) { terminal.Write(IBM3151.Commands.SetCharacterAttribute(IBM3151.CharacterAttributes.Intense | IBM3151.CharacterAttributes.Reverse)); foreach(var pw in _passwords.Where(x => x.Code.StartsWith(guess, StringComparison.CurrentCultureIgnoreCase))) UpdateCode(pw, true, terminal); } terminal.Write(IBM3151.Commands.SetCharacterAttribute(IBM3151.CharacterAttributes.None)); terminal.Write(IBM3151.Commands.ResetBufferAddressMode); }
private static async void StartServer() { _connection = GetConnection(); if (_connection == null) { return; } _deviceConnected = true; using (var session = new OttoSession(_connection)) { await session.TestConnectionAsync(); var listener = new HttpListener(); listener.Prefixes.Add("http://+:12345/"); //listener.Prefixes.Add("http://127.0.0.1:12345/"); listener.AuthenticationSchemes = AuthenticationSchemes.Anonymous; listener.Start(); Console.WriteLine("HttpListener started"); while (true) { var context = await listener.GetContextAsync(); Console.WriteLine($"Request: {context.Request.HttpMethod} {context.Request.RawUrl}"); context.Response.AppendHeader("Access-Control-Allow-Origin", "*"); if (context.Request.HttpMethod == HttpMethod.Post.Method) { ParseUrl(context.Request.RawUrl, out var resource, out var value); switch (resource) { case "commands": var result = await session.SendStringCommandAsync(value); context.Response.StatusCode = result ? 201 : 400; context.Response.Close(); continue; default: context.Response.StatusCode = 404; context.Response.Close(); continue; } } if (context.Request.HttpMethod == HttpMethod.Get.Method) { ParseUrl(context.Request.RawUrl, out var resource, out var value); switch (resource) { case "connection": await WriteTextAsync(context, _deviceConnected.ToString()); continue; case "distance": var distance = await session.GetStringDataAsync(resource); await WriteTextAsync(context, distance); continue; } } context.Response.StatusCode = 404; context.Response.Close(); } } }
/// <summary> /// Initializes a new instance of the <see cref="ArduinoWS2812USBUpdateQueue"/> class. /// </summary> /// <param name="updateTrigger">The update trigger used by this queue.</param> /// <param name="portName">The name of the serial-port to connect to.</param> /// <param name="baudRate">The baud-rate used by the serial-connection.</param> public ArduinoWS2812USBUpdateQueue(IDeviceUpdateTrigger updateTrigger, ISerialConnection serialConnection) : base(updateTrigger, serialConnection) { }
/// <summary> /// Initializes a new instance of the <see cref="ArduinoSession"/> class. /// </summary> /// <param name="connection">The serial port connection</param> /// <param name="timeOut">The response time out in milliseconds</param> /// <exception cref="System.ArgumentNullException">connection</exception> /// <exception cref="System.ArgumentOutOfRangeException">timeOut</exception> public ArduinoSession(ISerialConnection connection, int timeOut) : this(connection) { if (timeOut < SerialPort.InfiniteTimeout) throw new ArgumentOutOfRangeException("timeOut"); _messageTimeout = timeOut; }