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