Esempio n. 1
0
 private Task TestBulb(LampStateEnum currentState)
 {
     return(Task.Run(() =>
     {
         if (CurrentSensor.GetState().Result != CurrentSensorStateEnum.Flowing)
         {
             var badBulb = Bulbs.FirstOrDefault(b => b.GetState().Result == BulbStateEnum.On);
             badBulb?.MarkInOp(true);
         }
         else
         {
             var badBulb = Bulbs.FirstOrDefault(b => b.GetState().Result == BulbStateEnum.InOperable);
             if (badBulb == null)
             {
                 return;
             }
             if (badBulb.BulbType == BulbTypeEnum.Green && currentState == LampStateEnum.Go ||
                 badBulb.BulbType == BulbTypeEnum.Yellow && currentState == LampStateEnum.Caution ||
                 badBulb.BulbType == BulbTypeEnum.Red && currentState == LampStateEnum.Stop)
             {
                 badBulb.MarkInOp(false);
             }
         }
     }));
 }
Esempio n. 2
0
 protected virtual void OnStateChanged(LampStateEnum oldState, LampStateEnum newState)
 {
     StateChanged?.Invoke(this, new StateChangedEventArgs
     {
         SourceId        = Id,
         OldState        = (int)oldState,
         NewState        = (int)newState,
         SourceTimestamp = DateTime.UtcNow
     });
 }
Esempio n. 3
0
 public void TurnOff()
 {
     this._LampState = LampStateEnum.Off;
 }
Esempio n. 4
0
 public void TurnOn()
 {
     this._LampState = LampStateEnum.On;
 }
Esempio n. 5
0
 public Lamp()
 {
     this._LampState = LampStateEnum.Off;
 }
Esempio n. 6
0
        public async Task <bool> TransitionToState(LampStateEnum requestedState)
        {
            var ret = true;

            //Is this a valid request?
            if (requestedState != LampStateEnum.Go && requestedState != LampStateEnum.Caution && requestedState != LampStateEnum.Stop)
            {
                throw new Exception("You can only request transitions to Go, Caution and Stop");
            }

            var oldState = await GetState();

            //If it was transitioning, lets wait a little bit
            var i = 0;

            while (i++ < 10 && oldState == LampStateEnum.Transitioning)
            {
                await Task.Delay(TimeSpan.FromMilliseconds(100));

                oldState = await GetState();
            }

            //Are we in a valid state to start a transition?
            if (oldState == LampStateEnum.CriticalMalfunction || oldState == LampStateEnum.Transitioning)
            {
                ret = false;
            }

            //We have to go through caution before we go from green to red
            if (oldState == LampStateEnum.Go && requestedState != LampStateEnum.Caution)
            {
                ret = false;
            }

            _iAmTransitioning = true;

            //Lat's restrict to proper transitions. InOperable is likely the bad bulb bubbling up. Try requested transition.
            if (ret && (oldState == LampStateEnum.Go || oldState == LampStateEnum.InOperable) && requestedState == LampStateEnum.Caution)
            {
                ret = await DoTransitionToCaution();
            }
            else if (ret && (oldState == LampStateEnum.Caution || oldState == LampStateEnum.InOperable) && requestedState == LampStateEnum.Stop)
            {
                ret = await DoTransitionToStop();
            }
            else if (ret && (oldState == LampStateEnum.Stop || oldState == LampStateEnum.InOperable) && requestedState == LampStateEnum.Go)
            {
                ret = await DoTransitionToGo();
            }
            else
            {
                ret = false;
            }

            //Let's clean up. finish the transition and raise state change if necessary
            _iAmTransitioning = false;

            var newState = await GetState();

            TestBulb(requestedState);

            if (oldState != newState)
            {
                OnStateChanged(oldState, newState);
            }

            return(ret);
        }