public object GetConnector <T>(object instance, PortConfiguration portConfiguration) { var importer = (RemoteImporter)instance; var streamName = (string)portConfiguration.Index; return(importer.Importer.OpenStream <T>(streamName)); }
/// <summary> /// Creates an initialized instance of the device configured with fusion and the default settings. /// </summary> public static NavioPositionDevice Initialize() { // Create device var device = new NavioPositionDevice(); // Initialize message polling device.StartPolling(); // Initialize port configuration var portConfig = new PortConfiguration(); portConfig.IsInUbx = true; portConfig.IsOutUbx = true; portConfig.Mode[9] = true; portConfig.Mode[12] = true; portConfig.Mode[13] = true; var portResponse = device.WriteMessage(portConfig); // Read current software/hardware version from receiver device.ReadVersion(); // Initialize polling for messages device.SetPollingRate(0x01, 0x02, 0x01); // Return initialized device return(device); }
private static string AssignIndexer(PortDescription desc, PortConfiguration config) { if (desc.IsList || desc.IsDictionary) { return(config is null || config.Indexer is null ? string.Empty : config.Indexer); } return(null); }
internal void ConfigureCOMPort(PortConfiguration portConfiguration) { try { myport.BaudRate = portConfiguration.BaudRate; myport.Parity = portConfiguration.Parity; myport.PortName = portConfiguration.PortName; myport.StopBits = portConfiguration.StopBits; myport.ReadTimeout = portConfiguration.ReadTimeout; myport.WriteTimeout = portConfiguration.WriteTimeout; myport.DataBits = portConfiguration.DataBits; myport.RtsEnable = portConfiguration.Rts; } catch (Exception) { } }
/// <summary> /// Open the serial port. /// </summary> Task IPort.OpenAsync(PortConfiguration configuration) { // Clean up the existing SerialPort object, if we have one. if (this.port != null) { this.port.Dispose(); } SerialPortConfiguration config = configuration as SerialPortConfiguration; this.port = new SerialPort(this.name); this.port.BaudRate = config.BaudRate; this.port.DataBits = 8; this.port.Parity = Parity.None; this.port.StopBits = StopBits.One; if (config.Timeout == 0) { config.Timeout = 1000; // default to 1 second but allow override. } this.port.ReadTimeout = config.Timeout; if (this.port.IsOpen == true) { this.port.Close(); } /* if (config.DataReceived != null) * { * this.dataReceivedCallback = config.DataReceived; * this.port.DataReceived += this.DataReceived; * } */ this.port.Open(); // This line must come AFTER the call to port.Open(). // Attempting to use the BaseStream member will throw an exception otherwise. // // However, even after setting the BaseStream.ReadTimout property, calls to // BaseStream.ReadAsync will hang indefinitely. It turns out that you have // to implement the timeout yourself if you use the async approach. this.port.BaseStream.ReadTimeout = this.port.ReadTimeout; return(Task.CompletedTask); }
public object GetConnector <T>(object instance, PortConfiguration portConfiguration) => throw new InvalidOperationException();
/// <summary> /// Pretend to open a port. /// </summary> Task IPort.OpenAsync(PortConfiguration configuration) { return(Task.CompletedTask); }
partial void OnPortConfigChanging(PortConfiguration value);
/// <summary> /// Open the J2534 device. /// </summary> Task IPort.OpenAsync(PortConfiguration configuration) { throw new NotImplementedException(); }
public object GetConnector <T>(object instance, PortConfiguration portConfiguration) { Debug.Assert(Equals(this.OutputPorts().Single().Identifier, portConfiguration.Identifier)); Debug.Assert(instance != null && typeof(IProducer <T>).IsAssignableFrom(instance.GetType())); return(instance); }
/// <summary> /// Process Brick State /// </summary> /// <param name="brickState"></param> private IEnumerator<ITask> ProcessBrickState(brick.NxtBrickState brickState) { foreach (string key in brickState.Runtime.Devices.Keys) { brick.AttachRequest device = brickState.Runtime.Devices[key]; if (device.Registration.DeviceType != LegoDeviceType.AnalogSensor && device.Registration.DeviceType != LegoDeviceType.DigitalSensor) { continue; } PortSet<DsspDefaultLookup, DsspDefaultGet> lookupPort = ServiceForwarder<PortSet<DsspDefaultLookup, DsspDefaultGet>>(device.Registration.ServiceUri); DsspDefaultLookup lu = new DsspDefaultLookup(); lookupPort.Post(lu); yield return Arbiter.Choice(lu.ResponsePort, delegate(LookupResponse luResponse) { foreach(PartnerType pt in luResponse.PartnerList) { // See if this service supports the analog sensor contract if (pt.Contract == analog.Contract.Identifier) { // Check if we have already processed this one. if (_sensorList.ContainsKey(pt.Service)) break; string name = device.Registration.Name; string model = device.Registration.DeviceModel; int hardwareIdentifier = NxtCommon.HardwareIdentifier(device.Registration.Connection.Port); LogVerbose(LogGroups.Console, string.Format("Configuring {0}:{1} on {2} with analog service at {3}", model, name, hardwareIdentifier, pt.Service)); analog.AnalogSensorOperations sensorPort = ServiceForwarder<analog.AnalogSensorOperations>(pt.Service); Activate(Arbiter.Choice(sensorPort.Subscribe(_analogSensorNotificationsPort), delegate(SubscribeResponseType response) { // Keep track of the subscription manager response // so that we can unsubscribe later. _sensorList.Add(pt.Service, response); }, delegate(Fault fault) { LogError(LogGroups.Console, string.Format("Failure subscribing to {0} on port {1}.", model, hardwareIdentifier)); })); foreach (SensorConfiguration cfg in _state.SensorConfiguration) { if (cfg.DeviceModel != model) continue; SensorRange range = new SensorRange(hardwareIdentifier, model, name, cfg.RangeName); PortConfiguration portConfig = new PortConfiguration(hardwareIdentifier, range.ContactSensorName, cfg.SuccessRangeMin, cfg.SuccessRangeMax); portConfig.AnalogSensorServiceUri = pt.Service; if (portConfig != null) _state.RuntimeConfiguration.Add(range, portConfig); } break; } } }, delegate(Fault f) { }); } }
/// <summary> /// Generate a Port Configuration for the specified device. /// </summary> /// <param name="model"></param> /// <param name="name"></param> /// <param name="hardwareIdentifier"></param> /// <param name="serviceUri"></param> /// <returns></returns> private PortConfiguration GeneratePortConfiguration(string model, string name, int hardwareIdentifier, string serviceUri) { PortConfiguration sensorConfig = new PortConfiguration(hardwareIdentifier, name, 0.0, 0.0); bool found = false; foreach (SensorConfiguration config in _state.SensorConfiguration) { if (config.DeviceModel != model) continue; found = true; sensorConfig.SuccessRangeMin = config.SuccessRangeMin; sensorConfig.SuccessRangeMax = config.SuccessRangeMax; sensorConfig.AnalogSensorServiceUri = serviceUri; // If we found a name override, we are done. if (!string.IsNullOrEmpty(config.DeviceName) && config.DeviceName == name) break; // otherwise, keep looking for an override. } if (!found) return null; return sensorConfig; }