public void FindSerialConnection_Serial()
{
using (var arduinoConnection = SerialConnection.Find("Hello?", "Arduino!"))
{
Assert.IsNotNull(arduinoConnection);
}
}
protected override Task <IObservable <LocalisationData> > InitializeCore()
{
return(Task.Run(
() =>
{
IObservable <byte[]> packets;
switch (this.ConnectionType)
{
case ConnectionType.Serial:
packets = ToNcomPacket(SerialConnection.CreateByteListener(this.SerialPortName, this.SerialBaudRate, Parity.None, 8, StopBits.One));
break;
case ConnectionType.Udp:
packets = UdpConnection.CreateListener(this.RemoteAddress, this.UdpListenerPort).Select(udpResult => udpResult.Buffer);
break;
default:
throw new NotSupportedException(string.Format("Connection type '{0}' is not supported.", this.ConnectionType));
}
return (
from geoData in ToGeoData(packets)
select new LocalisationData {
RawData = geoData,
GpsStatus = (IsInitializing(geoData) ? GpsStatus.Initializing : geoData.PositionData.Longitude == 0 && geoData.PositionData.Latitude == 0 ? GpsStatus.SignalLost : GpsStatus.Reliable)
}).Publish().RefCount();
}));
}
private void buttonConnection_Click(object sender, EventArgs e)
{
ConnectionForm form = new ConnectionForm(portName_, baudRate_);
if (form.ShowDialog() != DialogResult.OK)
{
return;
}
portName_ = form.PortName;
baudRate_ = form.BaudRate;
CloseConnection();
if (portName_ != null)
{
try
{
connection_ = new SerialConnection(portName_, baudRate_);
}
catch (Exception)
{
}
if (connection_ != null)
{
SendCommand('c', 1, this.ReceiveCapabilities);
SendCommand('t', 8, this.ReceiveMotorLastAngles);
SendCommand('h', 4, this.ReceiveAltAzmResolutionFirstTime);
}
}
UpdateUI(false);
}
public static void Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("Parameter ComPort needed.");
return;
}
string comPort = args[0];
using (SerialConnection connection = new SerialConnection(comPort))
using (ELM327 dev = new ELM327(connection, new OBDConsoleLogger(OBDLogLevel.Debug)))
{
dev.SubscribeDataReceived <EngineRPM>((sender, data) => Console.WriteLine("EngineRPM: " + data.Data.Rpm));
dev.SubscribeDataReceived <VehicleSpeed>((sender, data) => Console.WriteLine("VehicleSpeed: " + data.Data.Speed));
dev.SubscribeDataReceived <IOBDData>((sender, data) => Console.WriteLine($"PID {data.Data.PID.ToHexString()}: {data.Data}"));
dev.Initialize();
dev.RequestData <FuelType>();
for (int i = 0; i < 5; i++)
{
dev.RequestData <EngineRPM>();
dev.RequestData <VehicleSpeed>();
Thread.Sleep(1000);
}
}
Console.ReadLine();
//Async example
//MainAsync(comPort).Wait();
//Console.ReadLine();
}
private static void AutoOpenTest()
{
for (int x = 0; x < 1; x++)
{
var a = SerialConnection.FindSerialConnection();
}
}
// Connect to the serial port
private void btn_Connect_Click(object sender, EventArgs e)
{
if (port == null)
{
// Port is closed
int baudrate = -1;
try {
baudrate = int.Parse(cmb_baudRate.Text);
} catch { }
if (baudrate < 0)
{
btn_Connect.BackColor = colorClosed;
Program.errors.Add("Faulty baud rate.");
}
else
{
btn_Connect.BackColor = colorOpen;
port = new SerialConnection(cmb_port.Text, baudrate, this);
port.Open();
timerbuffer.Start();
}
}
else
{
// Port is open
btn_Connect.BackColor = colorClosed;
if (port.IsOpen())
{
port.Close();
}
timerbuffer.Stop();
}
}
private void WindowStatus_Load(object sender, EventArgs e)
{
indexSettings = new IndexSettings(panel_IndexSettings);
indexStats = new IndexStats(indexSettings, panel_IndexStats, btn_EditMode);
joystickSettings = new JoystickSettings();
//add all available com port elements to com port combobox
cmb_comport.Items.AddRange(SerialConnection.GetPortList());
try { cmb_comport.SelectedIndex = 1; } catch { } //load index 1 (COM5) as default
//temp, initialize status[0]
st.status[0] = 1;
// Load all settings
graphicsCreator = new GraphicsCreator(pan_graphicsCreator);
graphicToolbox = new GraphicToolbox(pan_graphicsCreator, pan_graphicToolbox, rightclickMenu);
ProgramSaverLoader.Load();
// Start the st_register send timer
tim_SendCommandsDelay.Tick += ST_Register.SendCommands;
//load local IP address into communication tabs ethernet server settings
txt_comm_serverip.Text = GetLocalIPAddress();
txt_comm_serverport.Text = "80";
}
public static async Task Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("Parameter ComPort needed.");
return;
}
string comPort = args[0];
Console.CancelKeyPress += ConsoleOnCancelKeyPress;
using SerialConnection connection = new SerialConnection(comPort);
using ELM327 dev = new ELM327(connection, new OBDConsoleLogger(OBDLogLevel.Debug));
dev.SubscribeDataReceived <EngineRPM>((sender, data) => Console.WriteLine("EngineRPM: " + data.Data.Rpm));
dev.SubscribeDataReceived <VehicleSpeed>((sender, data) => Console.WriteLine("VehicleSpeed: " + data.Data.Speed));
dev.SubscribeDataReceived <IOBDData>((sender, data) => Console.WriteLine($"PID {((byte)data.Data.PID).ToHexString()}: {data.Data}"));
dev.Initialize();
dev.RequestData <FuelType>();
while (_requestData)
{
dev.RequestData <EngineRPM>();
dev.RequestData <VehicleSpeed>();
await Task.Delay(1000);
}
}
private void SendCommand(SerialConnection connection, byte[] cmd, int receiveCnt, ReceiveDelegate receiveDelegate)
{
if (connection_ != null)
{
connection_.SendReceiveRequest(cmd, receiveCnt, new BaseConnectionHandler(this, receiveDelegate, connection));
}
}
public void FindSerialConnection_FirmataEnabled()
{
using (var arduinoConnection = SerialConnection.Find())
{
Assert.IsNotNull(arduinoConnection);
}
}
/// <summary>
/// Autodetect monochromator controller in connected devices
/// </summary>
/// <returns>Controller's device name</returns>
/// <exception cref="ControllerDetectionException"></exception>
public string Autodetect()
{
// Get connected controllers
var controllers = Controllers();
foreach (var controller in controllers)
{
try {
// Open connection
using var conn = new SerialConnection(controller, 1000);
conn.Open();
// Check connection
if (IsMonochromator(conn))
{
Logger.Info($"Autodection has chosen: {controller}");
return(controller);
}
} catch (Exception e) {
Logger.Error(e);
}
}
throw new ControllerDetectionException(controllers);
}
private void SendCommand(SerialConnection connection, char cmd, int receiveCnt, ReceiveDelegate receiveDelegate)
{
if (connection != null)
{
connection.SendReceiveRequest(new byte[] { (byte)cmd }, receiveCnt, new BaseConnectionHandler(this, receiveDelegate, connection));
}
}
public MainViewModel()
{
var connection = new SerialConnection("COM3", SerialBaudRate.Bps_115200);
var session = new ArduinoSession(connection);
session.CreateReceivedStringMonitor().Subscribe(this);
}
public void OpenSerialConnection(string portName, int baudRate, int dataBits, StopBits stopBits, Parity parity)
{
spManager = new SerialConnection(portName, baudRate, dataBits, stopBits, parity);
spManager.OnTelemetry += SerialPort_OnTelemetry;
spManager.OnError += SerialPort_OnError;
spManager.Open();
}
public void CheckOpenConnectionBadPortName()
{
_serialParameters.PortName = "JUNK";
SerialConnection sc = new SerialConnection(_serialParameters);
sc.Open();
}
public static SerialConnection OpenConnection()
{
if (connection == null)
{
connection = new SerialConnection();
string portname, baudrate, parity, databits, stopbits, handshake;
portname = settings.Read("SERIAL PORT PROPERTIES", "PORT_NAME");
baudrate = settings.Read("SERIAL PORT PROPERTIES", "BAUD_RATE");
parity = settings.Read("SERIAL PORT PROPERTIES", "PARITY");
databits = settings.Read("SERIAL PORT PROPERTIES", "DATA_BITS");
stopbits = settings.Read("SERIAL PORT PROPERTIES", "STOP_BITS");
handshake = settings.Read("SERIAL PORT PROPERTIES", "HANDSHAKE");
connection.SerialPort = new SerialPort(); //error here
connection.SerialPort.PortName = portname;
connection.SerialPort.BaudRate = int.Parse(baudrate);
connection.SerialPort.Parity = (Parity)Enum.Parse(typeof(Parity), parity, true);
connection.SerialPort.DataBits = int.Parse(databits);
connection.SerialPort.StopBits = (StopBits)Enum.Parse(typeof(StopBits), stopbits, true);
connection.SerialPort.Handshake = (Handshake)Enum.Parse(typeof(Handshake), handshake, true);
connection.SerialPort.Open();
connection.SerialPort.ReadTimeout = 200;
connection.SerialPort.DataReceived += new SerialDataReceivedEventHandler(connection.serialPort1_DataReceived);
}
static void Main(string[] args)
{
try
{
var connection = new SerialConnection("COM5", SerialBaudRate.Bps_57600);
var session = new ArduinoSession(connection, timeOut: 250);
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e)
{
e.Cancel = true;
running = false;
};
IFirmataProtocol firmata = (IFirmataProtocol)session;
int led1 = 12;
int led2 = 11;
int led3 = 10;
firmata.SetDigitalPinMode(led1, PinMode.DigitalOutput);
firmata.SetDigitalPinMode(led2, PinMode.DigitalOutput);
firmata.SetDigitalPinMode(led3, PinMode.DigitalOutput);
while (running)
{
// led 1
Console.WriteLine("Turn on LED 1");
firmata.SetDigitalPin(led1, true);
firmata.SetDigitalPin(led2, false);
firmata.SetDigitalPin(led3, false);
Thread.Sleep(1000); // sleep
// led 2
Console.WriteLine("Turn on LED 2");
firmata.SetDigitalPin(led1, false);
firmata.SetDigitalPin(led2, true);
firmata.SetDigitalPin(led3, false);
Thread.Sleep(1000);
// led 3
Console.WriteLine("Turn on LED 3");
firmata.SetDigitalPin(led1, false);
firmata.SetDigitalPin(led2, false);
firmata.SetDigitalPin(led3, true);
Thread.Sleep(1000);
}
// turn off LEDs
firmata.SetDigitalPin(led1, false);
firmata.SetDigitalPin(led2, false);
firmata.SetDigitalPin(led3, false);
connection.Close();
}
catch (Exception err)
{
Console.WriteLine(err);
}
Console.WriteLine("Program exit. Press ENTER to close.");
Console.ReadLine();
}
public ConnectionViewModel(ILogger logger)
{
DisplayName = "Connection";
Connections = new List <IConnection>();
_serial = new SerialConnection();
if (_serial.AvailablePorts.Any(x => x.Equals(Settings.Default.SerialPort, StringComparison.InvariantCultureIgnoreCase)))
{
_serial.Portname = Settings.Default.SerialPort;
}
_serial.Baudrate = Settings.Default.Baudrate;
Connections.Add(_serial);
_udp = new UdpConnection(logger);
_udp.TerminalIp = Settings.Default.TerminalIp;
_udp.Port = Settings.Default.NetworkPort;
Connections.Add(_udp);
if (Settings.Default.UseSerialPort)
{
IsSerialConnection = true;
}
else
{
IsNetworkConnection = true;
}
}
public void EnhancedSerialConnection_OpenAndClose()
{
var connection = new SerialConnection();
connection.Open();
connection.Close();
}
private void btnExecute_Click(object sender, EventArgs e)
{
try
{
var connection = new SerialConnection("COM5", SerialBaudRate.Bps_57600);
var session = new ArduinoSession(connection, timeOut: 250);
IFirmataProtocol firmata = (IFirmataProtocol)session;
int redPin = 9;
int greenPin = 10;
int bluePin = 11;
firmata.SetDigitalPinMode(redPin, PinMode.PwmOutput);
firmata.SetDigitalPinMode(greenPin, PinMode.PwmOutput);
firmata.SetDigitalPinMode(bluePin, PinMode.PwmOutput);
firmata.SetDigitalPin(redPin, redVal);
firmata.SetDigitalPin(greenPin, greenVal);
firmata.SetDigitalPin(bluePin, blueVal);
connection.Close();
}
catch (Exception err)
{
MessageBox.Show(err.Message);
}
}
// Start is called before the first frame update
void Start()
{
// コントローラに必要なので追加
serial = gameObject.AddComponent <SerialConnection>();
serial.SetSize(sizeof(float) * (int)Shoulder.Max);
data = new float[(int)Shoulder.Max];
DontDestroyOnLoad(gameObject);
}
private void SerialSend(SerialConnection conn, string command)
{
try{
conn.WriteLine(command);
} catch (System.NullReferenceException) {
MessageBox.Show("Serial connection not established");
}
}
public void SerialConnection_OpenAndDoubleClose()
{
var connection = new SerialConnection();
connection.Open();
connection.Close();
connection.Close();
}
public void EnhancedSerialConnection_Constructor_WithParameters()
{
var connection = new SerialConnection("COM1", SerialBaudRate.Bps_115200);
//Assert.AreEqual(100, connection.ReadTimeout);
//Assert.AreEqual(100, connection.WriteTimeout);
Assert.AreEqual(115200, connection.BaudRate);
}
public void SerialConnection_Constructor_WithoutParameters()
{
var connection = new SerialConnection();
//Assert.AreEqual(100, connection.ReadTimeout);
//Assert.AreEqual(100, connection.WriteTimeout);
Assert.AreEqual(115200, connection.BaudRate);
}
static void Main(string[] args)
{
bool error = false;
if (args.Length != 2) {
Console.WriteLine("Syntax: program.exe <port> <baudrate>");
Console.WriteLine("port - can be in form of /dev/ttyS0 or com2 or /udp/ipaddress/port");
Console.WriteLine("baudrate - any baudrate like 19200 (for udp baudrate could be any number)");
Console.WriteLine("");
Console.WriteLine("example: program.exe /dev/ttyUSB0 19200");
Console.WriteLine("example: program.exe /udp/192.168.0.10/1100 0");
error = true;
return;
}
if (!error) {
//Console.WriteLine("arg0: " + args[0] + "\n");
argPort = args[0];
argBaud = Int32.Parse(args[1]);
}
if (!error) {
if (DEBUG_LEVEL>0) {
Console.WriteLine("canDaemon");
Console.WriteLine("Commands:");
//Console.WriteLine("reset - reset communication.");
Console.WriteLine("exit - exit program");
Console.WriteLine("");
Thread.Sleep(1000);
}
sc = new SerialConnection();
try {
sc.setConfiguration(argBaud, System.IO.Ports.Parity.None, argPort, System.IO.Ports.StopBits.One, 8, false);
}
catch (Exception e) { Console.WriteLine("Error: " + e.Message); }
if (!sc.open()) {
Console.WriteLine("Error opening port to target");
//... här ska man testa om igen...
} else {
d = new Daemon(sc);
tcps = new TcpServer(1200);
d.addServer(tcps);
Thread t = new Thread(d.thread);
t.Start();
string instr;
do {
//Console.Write("> ");
instr = Console.ReadLine().ToLower();
} while (parseInput(instr));
d.stop();
}
}
}
private void frmAddInventoryTransItem3_Load(object sender, EventArgs e)
{
txtQty.Text = 1.ToString();
txtWeight.Text = 0.ToString("N3");
this.ActiveControl = txtPLU;
sc = SerialConnection.OpenConnection();
sc.WeightReceived += new SerialDataReceivedEventHandler(WeightReceived);
}
private void CloseConnection()
{
if (connection_ != null)
{
connection_.Close();
connection_.Dispose();
connection_ = null;
}
}
public void SetUp()
{
_serialParameters = new SerialParameters();
_serialParameters.PortName = "COM3";
_serialConnection = new SerialConnection(_serialParameters);
//TODO what I really want to do above is have a config file w/ test settings which will vary by developement environment
// e.g. SerialParameters sp = new SerialParameters(props.TestPortName, props.TestBaudRate, ...
}
public void SetUp()
{
_serialParameters = new SerialParameters();
_serialParameters.PortName = "COM3";
_serialConnection = new SerialConnection(_serialParameters);
//TODO what I really want to do above is have a config file w/ test settings which will vary by developement environment
// e.g. SerialParameters sp = new SerialParameters(props.TestPortName, props.TestBaudRate, ...
}
/// <summary>
/// Test whether the given connection is a link with monochromator controller
/// </summary>
/// <param name="connection">Connection</param>
/// <returns>true if connection is a link with monochromator controller, false otherwise</returns>
private static bool IsMonochromator(SerialConnection connection)
{
// Ping controller
connection.Send((uint)PacketHeader.Ping);
// Parse response
var responseAsBytes = connection.Read(sizeof(PacketHeader));
var response = BitConverter.ToUInt32(responseAsBytes);
return(response == PingResponse);
}
public static void Main(string[] args)
{
//if (args.Length < 1)
//{
// Console.WriteLine("Parameter ComPort needed.");
// return;
//}
//string comPort = "COM6";
//using (SerialConnection connection = new SerialConnection(comPort))
//using (ELM327 dev = new ELM327(connection, new OBDConsoleLogger(OBDLogLevel.Debug)))
//{
// //Realtime
// dev.SubscribeDataReceived<EngineRPM>((sender, data) => Console.WriteLine("EngineRPM: " + data.Data.Rpm));
// dev.SubscribeDataReceived<VehicleSpeed>((sender, data) => Console.WriteLine("VehicleSpeed: " + data.Data.Speed));
// dev.SubscribeDataReceived<EngineCoolantTemperature>((sender, data) => Console.WriteLine("Coolant Temperature: " + data.Data.Temperature));
// dev.SubscribeDataReceived<EngineOilTemperature>((sender, data) => Console.WriteLine("Engine Oil Temperature: " + data.Data.Temperature));
// dev.SubscribeDataReceived<FuelTankLevelInput>((sender, data) => Console.WriteLine("Coolant Temperature: " + data.Data.Level));
// //dev.SubscribeDataReceived<IOBDData>((sender, data) => Console.WriteLine($"PID {data.Data.PID.ToHexString()}: {data.Data}"));
// //Analytics
// //Calculate Hard Braking, Hard Acceleration, Frequent stoppages, RPM Vs Speed.
// //Error Codes
// dev.SubscribeDataReceived<EGRError>((sender, data) => Console.WriteLine("EngineRPM: " + data.Data));
// dev.Initialize();
// dev.RequestData<FuelType>();
// for (int i = 0; i < 5; i++)
// {
// dev.RequestData<EngineRPM>();
// dev.RequestData<VehicleSpeed>();
// Thread.Sleep(1000);
// }
//}
//Console.ReadLine();
//Async example
connection = new SerialConnection("COM2");
//MainAsync("COM6").Wait();
ContinuousPush(3000, () => true);
Console.ReadKey();
//Console.ReadLine();
}
public Daemon(SerialConnection sc)
{
this.sc = sc;
running = true;
}
public void CheckOpenConnectionBadPortName()
{
_serialParameters.PortName = "JUNK";
SerialConnection sc = new SerialConnection(_serialParameters);
sc.Open();
}
public void CreateSerialConnectionDefaultParameters()
{
SerialConnection sc = new SerialConnection(new SerialParameters());
Assert.IsNotNull(sc);
}
private static void Main(string[] args)
{
var consoleListener = new TextWriterTraceListener(Console.Out);
Trace.Listeners.Add(consoleListener);
var portName = args.Length > 1 ? args[1] : GetPortName();
using(var conn = new SerialConnection(portName))
{
conn.Open();
//conn.WritePriorityMessage("Hello World!");
conn.SetDateTime(DateTime.Now);
//conn.Send(Clear());
//Thread.Sleep(10000);
//conn.Send(DemoPicture());
//DemoWriteTextCommands(conn);
}
Console.ReadLine();
}
