private void SelectNextState(IRouteState route) { if (lastSensor != null) { lastSensor.Active.Actual = false; } if (state == States.Initial) { var sensor = route.Sensors.FirstOrDefault(x => route.IsEnteringDestinationSensor(x, loc)); if (sensor != null) { sensor.Active.Actual = true; lastSensor = sensor; state = States.Enter; return; } } // Activate reached sensor { var sensor = route.Sensors.FirstOrDefault(x => route.IsReachedDestinationSensor(x, loc)); if (sensor != null) { sensor.Active.Actual = true; lastSensor = sensor; state = States.Initial; } } }
/// <summary> /// Default ctor /// </summary> public SensorItem(ISensor entity, ISensorState state, ItemContext context, bool interactive) : base(entity, false, context) { this.state = state; if (interactive) { MouseHandler = new EntityClickHandler(null, state); } }
/// <summary> /// Try to get the behavior for the given sensor. /// </summary> public bool TryGetBehavior(ISensorState sensor, out IRouteEventBehaviorState behavior) { if (behaviors.TryGetValue(sensor, out behavior)) { behaviors.Remove(sensor); // Avoid listening to the sensor twice return(true); } return(false); }
public DeviceResources(IFactory factory, IHMDDevice handle) { if (factory == null || handle == null) throw new ArgumentNullException(); Info = handle.Info; Device = handle; Sensor = Device.GetSensorState(0.0); if (Info == null) throw new ArgumentNullException(); if (Device == null) throw new ArgumentNullException(); if (Sensor == null) System.Diagnostics.Trace.TraceWarning("Unable to create Sensor"); if (Sensor != null) Key = new DeviceKey(Device.SensorInfo); }
/// <summary> /// Handle a ghost sensor event /// </summary> private void HandleGhost(ISensorState sensor) { log.Trace("HandleGhost {0}", sensor); // Notify about it if (UnexpectedSensorActivated != null) { var args = new UnexpectedSensorActivatedEventArgs(sensor); UnexpectedSensorActivated(this, args); if (args.Handled) { return; } } else { // Not handled, power off log.Warn("Ghost activation in sensor {0}, global power down.", sensor); railwayState.Power.Requested = false; } }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { sensor = RailwayState.SensorStates[Entity.Sensor]; return(sensor != null); }
/// <summary> /// Does this route contains the given sensor (either as entering or reached) /// </summary> public bool Contains(ISensorState sensorState) { return(events.Any(x => x.Sensor == sensorState)); }
/// <summary> /// Is the given sensor listed as one of the "entering destination" sensors of this route? /// </summary> public bool IsReachedDestinationSensor(ISensorState sensor, ILocState loc) { return(events.Any(x => (x.Sensor == sensor) && x.Behaviors.Any(b => b.AppliesTo(loc) && (b.StateBehavior == RouteStateBehavior.Reached)))); }
/// <summary> /// Does this route contain an event for the given sensor for my loc? /// </summary> public bool Contains(ISensorState sensor) { return(behaviors.ContainsKey(sensor)); }
/// <summary> /// Gets advanced info for the given sensor /// </summary> internal bool TryGetLoc(ISensorState sensorState, out FeedbackModule feedbackModule) { return(sensorIds.TryGetValue(sensorState, out feedbackModule)); }
/// <summary> /// Active state of given sensor has changed. /// </summary> private void OnSensorActiveChanged(ISensorState sensor) { if (!sensor.Active.Actual) { // Sensor became inactive return; } log.Trace("OnSensorActive {0}", sensor); var locsWithRoutes = autoLocs.Where(x => x.CurrentRoute.Actual != null).ToList(); var locsWithSensor = locsWithRoutes.Where(x => x.CurrentRoute.Actual.Contains(sensor)); var ghost = true; // Update state of all locs foreach (var loc in locsWithSensor) { IRouteEventBehaviorState behavior; var route = loc.CurrentRoute.Actual; if (!route.TryGetBehavior(sensor, out behavior)) { continue; } // Save in loc loc.LastEventBehavior = behavior; // Update state var autoLocState = loc.AutomaticState.Actual; ghost = false; switch (behavior.StateBehavior) { case RouteStateBehavior.NoChange: // No change break; case RouteStateBehavior.Enter: if (autoLocState == AutoLocState.Running) { loc.AutomaticState.Actual = AutoLocState.EnterSensorActivated; RequestUpdate(); } break; case RouteStateBehavior.Reached: if ((autoLocState == AutoLocState.Running) || (autoLocState == AutoLocState.EnterSensorActivated) || (autoLocState == AutoLocState.EnteringDestination)) { loc.AutomaticState.Actual = AutoLocState.ReachedSensorActivated; RequestUpdate(); } break; } // Update speed switch (behavior.SpeedBehavior) { case LocSpeedBehavior.NoChange: // No change break; case LocSpeedBehavior.Default: // This is handled in the applicable states break; case LocSpeedBehavior.Maximum: loc.Speed.Requested = loc.GetMaximumSpeed(route.Route); break; case LocSpeedBehavior.Medium: loc.Speed.Requested = loc.GetMediumSpeed(route.Route); break; case LocSpeedBehavior.Minimum: loc.Speed.Requested = loc.SlowSpeed; break; } } // Handle ghost events if (ghost) { // Is the sensor connected to any route, other then the routes that are active? var destinationBlocks = sensor.DestinationBlocks; var activeRoutes = locsWithRoutes.Select(x => x.CurrentRoute.Actual).ToList(); if (destinationBlocks.Any(x => !activeRoutes.Any(r => r.Route.Contains(x)))) { // Yes, now consider it a ghost event HandleGhost(sensor); } } }