Merge pull request #64 from PepperDash/feature/OccSensor-Fixes

closes #60 , closes #63 , closes #51

PepperDashEssentials/Bridges/BridgeBase.cs

@@ -136,6 +136,11 @@ namespace PepperDash.Essentials.Bridges
                             (device as GenericRelayDevice).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
                             continue;
                         }
+                        else if (device is IRSetTopBoxBase)
+                        {
+                            (device as IRSetTopBoxBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
                         else if (device is IDigitalInput)
                         {
                             (device as IDigitalInput).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);

PepperDashEssentials/Bridges/GlsOccupancySensorBaseControllerBridge.cs

@@ -31,6 +31,16 @@ namespace PepperDash.Essentials.Bridges
 
             #region Single and Dual Sensor Stuff
             occController.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            trilist.StringInput[joinMap.Name].StringValue = occController.Name;
+
+            trilist.OnlineStatusChange += new Crestron.SimplSharpPro.OnlineStatusChangeEventHandler((d, args) =>
+            {
+                if (args.DeviceOnLine)
+                {
+                    trilist.StringInput[joinMap.Name].StringValue = occController.Name;
+                }
+            }
+            );
 
             // Occupied status
             trilist.SetSigTrueAction(joinMap.ForceOccupied, new Action(() => occController.ForceOccupied()));
@@ -38,6 +48,7 @@ namespace PepperDash.Essentials.Bridges
             occController.RoomIsOccupiedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RoomOccupiedFeedback]);
             occController.RoomIsOccupiedFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.RoomVacantFeedback]);
             occController.RawOccupancyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyFeedback]);
+            trilist.SetBoolSigAction(joinMap.EnableRawStates, new Action<bool>((b) => occController.EnableRawStates(b)));
 
             // Timouts
             trilist.SetUShortSigAction(joinMap.Timeout, new Action<ushort>((u) => occController.SetRemoteTimeout(u)));

PepperDashEssentials/Bridges/IRSetTopBoxBaseBridge.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Devices.Common;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class IRSetTopBoxBaseApiExtensions
+    {
+        public static void LinkToApi(this PepperDash.Essentials.Devices.Common.IRSetTopBoxBase stbDevice, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            SetTopBoxControllerJoinMap joinMap = new SetTopBoxControllerJoinMap();
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<SetTopBoxControllerJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+            Debug.Console(0, "Linking to Display: {0}", stbDevice.Name);
+
+            trilist.StringInput[joinMap.Name].StringValue = stbDevice.Name;
+
+            var stbBase = stbDevice as ISetTopBoxControls;
+            if (stbBase != null)
+            {
+                trilist.BooleanInput[joinMap.HasDpad].BoolValue = stbBase.HasDpad;
+                trilist.BooleanInput[joinMap.HasNumeric].BoolValue = stbBase.HasNumeric;
+                trilist.BooleanInput[joinMap.HasDvr].BoolValue = stbBase.HasDvr;
+                trilist.BooleanInput[joinMap.HasPresets].BoolValue = stbBase.HasPresets;
+
+                trilist.SetBoolSigAction(joinMap.DvrList, (b) => stbBase.DvrList(b));
+                trilist.SetBoolSigAction(joinMap.Replay, (b) => stbBase.Replay(b));
+
+                trilist.SetStringSigAction(joinMap.LoadPresets, (s) => stbBase.LoadPresets(s));
+            }
+
+            var stbPower = stbDevice as IPower;
+            if (stbPower != null)
+            {
+                trilist.SetSigTrueAction(joinMap.PowerOn, () => stbPower.PowerOn());
+                trilist.SetSigTrueAction(joinMap.PowerOff, () => stbPower.PowerOff());
+                trilist.SetSigTrueAction(joinMap.PowerToggle, () => stbPower.PowerToggle());
+
+            }
+
+            var stbDPad = stbDevice as IDPad;
+            if (stbDPad != null)
+            {
+                trilist.SetBoolSigAction(joinMap.Up, (b) => stbDPad.Up(b));
+                trilist.SetBoolSigAction(joinMap.Down, (b) => stbDPad.Down(b));
+                trilist.SetBoolSigAction(joinMap.Left, (b) => stbDPad.Left(b));
+                trilist.SetBoolSigAction(joinMap.Right, (b) => stbDPad.Right(b));
+                trilist.SetBoolSigAction(joinMap.Select, (b) => stbDPad.Select(b));
+                trilist.SetBoolSigAction(joinMap.Menu, (b) => stbDPad.Menu(b));
+                trilist.SetBoolSigAction(joinMap.Exit, (b) => stbDPad.Exit(b));
+            }
+
+            var stbChannel = stbDevice as IChannel;
+            if (stbChannel != null)
+            {
+                trilist.SetBoolSigAction(joinMap.ChannelUp, (b) => stbChannel.ChannelUp(b));
+                trilist.SetBoolSigAction(joinMap.ChannelDown, (b) => stbChannel.ChannelDown(b));
+                trilist.SetBoolSigAction(joinMap.LastChannel, (b) => stbChannel.LastChannel(b));
+                trilist.SetBoolSigAction(joinMap.Guide, (b) => stbChannel.Guide(b));
+                trilist.SetBoolSigAction(joinMap.Info, (b) => stbChannel.Info(b));
+                trilist.SetBoolSigAction(joinMap.Exit, (b) => stbChannel.Exit(b));
+            }
+
+            var stbColor = stbDevice as IColor;
+            if (stbColor != null)
+            {
+                trilist.SetBoolSigAction(joinMap.Red, (b) => stbColor.Red(b));
+                trilist.SetBoolSigAction(joinMap.Green, (b) => stbColor.Green(b));
+                trilist.SetBoolSigAction(joinMap.Yellow, (b) => stbColor.Yellow(b));
+                trilist.SetBoolSigAction(joinMap.Blue, (b) => stbColor.Blue(b));
+            }
+
+            var stbKeypad = stbDevice as ISetTopBoxNumericKeypad;
+            if (stbKeypad != null)
+            {
+                trilist.StringInput[joinMap.KeypadAccessoryButton1Label].StringValue = stbKeypad.KeypadAccessoryButton1Label;
+                trilist.StringInput[joinMap.KeypadAccessoryButton2Label].StringValue = stbKeypad.KeypadAccessoryButton2Label;
+
+                trilist.BooleanInput[joinMap.HasKeypadAccessoryButton1].BoolValue = stbKeypad.HasKeypadAccessoryButton1;
+                trilist.BooleanInput[joinMap.HasKeypadAccessoryButton2].BoolValue = stbKeypad.HasKeypadAccessoryButton2;
+
+                trilist.SetBoolSigAction(joinMap.Digit0, (b) => stbKeypad.Digit0(b));
+                trilist.SetBoolSigAction(joinMap.Digit1, (b) => stbKeypad.Digit1(b));
+                trilist.SetBoolSigAction(joinMap.Digit2, (b) => stbKeypad.Digit2(b));
+                trilist.SetBoolSigAction(joinMap.Digit3, (b) => stbKeypad.Digit3(b));
+                trilist.SetBoolSigAction(joinMap.Digit4, (b) => stbKeypad.Digit4(b));
+                trilist.SetBoolSigAction(joinMap.Digit5, (b) => stbKeypad.Digit5(b));
+                trilist.SetBoolSigAction(joinMap.Digit6, (b) => stbKeypad.Digit6(b));
+                trilist.SetBoolSigAction(joinMap.Digit7, (b) => stbKeypad.Digit7(b));
+                trilist.SetBoolSigAction(joinMap.Digit8, (b) => stbKeypad.Digit8(b));
+                trilist.SetBoolSigAction(joinMap.Digit9, (b) => stbKeypad.Digit9(b));
+                trilist.SetBoolSigAction(joinMap.KeypadAccessoryButton1Press, (b) => stbKeypad.KeypadAccessoryButton1(b));
+                trilist.SetBoolSigAction(joinMap.KeypadAccessoryButton2Press, (b) => stbKeypad.KeypadAccessoryButton1(b));
+                trilist.SetBoolSigAction(joinMap.Dash, (b) => stbKeypad.Dash(b));
+                trilist.SetBoolSigAction(joinMap.KeypadEnter, (b) => stbKeypad.KeypadEnter(b));
+            }
+
+            var stbTransport = stbDevice as ITransport;
+            if (stbTransport != null)
+            {
+                trilist.SetBoolSigAction(joinMap.Play, (b) => stbTransport.Play(b));
+                trilist.SetBoolSigAction(joinMap.Pause, (b) => stbTransport.Pause(b));
+                trilist.SetBoolSigAction(joinMap.Rewind, (b) => stbTransport.Rewind(b));
+                trilist.SetBoolSigAction(joinMap.FFwd, (b) => stbTransport.FFwd(b));
+                trilist.SetBoolSigAction(joinMap.ChapMinus, (b) => stbTransport.ChapMinus(b));
+                trilist.SetBoolSigAction(joinMap.ChapPlus, (b) => stbTransport.ChapPlus(b));
+                trilist.SetBoolSigAction(joinMap.Stop, (b) => stbTransport.Stop(b));
+                trilist.SetBoolSigAction(joinMap.Record, (b) => stbTransport.Record(b));
+
+            }
+
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/GlsOccupancySensorBaseJoinMap.cs

@@ -137,6 +137,10 @@ namespace PepperDash.Essentials.Bridges
         public uint PirSensitivityInVacantState { get; set; }
         #endregion
 
+        #region Serial
+        public uint Name { get; set; }
+        #endregion
+
         public GlsOccupancySensorBaseJoinMap()
         {
             IsOnline = 1;
@@ -178,6 +182,9 @@ namespace PepperDash.Essentials.Bridges
             UsSensitivityInVacantState = 6;
             PirSensitivityInOccupiedState = 7;
             PirSensitivityInVacantState = 8;
+
+            Name = 1;
+            
         }
 
         public override void OffsetJoinNumbers(uint joinStart)
@@ -206,7 +213,6 @@ namespace PepperDash.Essentials.Bridges
             DisableUsB =                        DisableUsB + joinOffset; 
             EnablePir =                         EnablePir + joinOffset; 
             DisablePir =                        DisablePir + joinOffset; 
-            DisablePir =                        DisablePir + joinOffset; 
             IncrementUsInOccupiedState =        IncrementUsInOccupiedState + joinOffset; 
             DecrementUsInOccupiedState =        DecrementUsInOccupiedState + joinOffset; 
             IncrementUsInVacantState =          IncrementUsInVacantState + joinOffset; 
@@ -224,6 +230,8 @@ namespace PepperDash.Essentials.Bridges
             UsSensitivityInVacantState =        UsSensitivityInVacantState + joinOffset; 
             PirSensitivityInOccupiedState =     PirSensitivityInOccupiedState + joinOffset;
             PirSensitivityInVacantState =       PirSensitivityInVacantState + joinOffset;
+
+            Name =                              Name + joinOffset;
         }
     }    
          

PepperDashEssentials/Bridges/JoinMaps/SetTopBoxControllerJoinMap.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+using Crestron.SimplSharp.Reflection;
+
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class SetTopBoxControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        public uint DvrList { get; set; } //
+        public uint Replay { get; set; }
+        public uint Up { get; set; } //
+        public uint Down { get; set; } //
+        public uint Left { get; set; } //
+        public uint Right { get; set; } //
+        public uint Select { get; set; } //
+        public uint Menu { get; set; } //
+        public uint Exit { get; set; } //
+        public uint Digit0 { get; set; } //
+        public uint Digit1 { get; set; } // 
+        public uint Digit2 { get; set; } //
+        public uint Digit3 { get; set; } //
+        public uint Digit4 { get; set; } // 
+        public uint Digit5 { get; set; } //
+        public uint Digit6 { get; set; } //
+        public uint Digit7 { get; set; } //
+        public uint Digit8 { get; set; } //
+        public uint Digit9 { get; set; } //
+        public uint Dash { get; set; } //
+        public uint KeypadEnter { get; set; } //
+        public uint ChannelUp { get; set; } //
+        public uint ChannelDown { get; set; } //
+        public uint LastChannel { get; set; } //
+        public uint Guide { get; set; } //
+        public uint Info { get; set; } //
+        public uint Red { get; set; } //
+        public uint Green { get; set; } //
+        public uint Yellow { get; set; } //
+        public uint Blue { get; set; } //
+        public uint ChapMinus { get; set; }
+        public uint ChapPlus { get; set; }
+        public uint FFwd { get; set; } //
+        public uint Pause { get; set; } //
+        public uint Play { get; set; } //
+        public uint Record { get; set; }
+        public uint Rewind { get; set; } //
+        public uint Stop { get; set; } //
+
+        public uint PowerOn { get; set; } //
+        public uint PowerOff { get; set; } //
+        public uint PowerToggle { get; set; } //
+
+        public uint HasKeypadAccessoryButton1 { get; set; }
+        public uint HasKeypadAccessoryButton2 { get; set; }
+
+        public uint KeypadAccessoryButton1Press { get; set; }
+        public uint KeypadAccessoryButton2Press { get; set; }
+
+
+        public uint HasDvr { get; set; }
+        public uint HasPresets { get; set; }
+        public uint HasNumeric { get; set; }
+        public uint HasDpad { get; set; }
+
+
+        #endregion
+
+        #region Analogs
+
+        #endregion
+
+        #region Strings
+        public uint Name { get; set; }
+        public uint LoadPresets { get; set; }
+        public uint KeypadAccessoryButton1Label { get; set; }
+        public uint KeypadAccessoryButton2Label { get; set; }
+
+        #endregion
+
+        public SetTopBoxControllerJoinMap()
+        {
+            PowerOn = 1;
+            PowerOff = 2;
+            PowerToggle = 3;
+
+            HasDpad = 4;
+            Up = 4;
+            Down = 5;
+            Left = 6;
+            Right = 7;
+            Select = 8;
+            Menu = 9;
+            Exit = 10;
+
+            HasNumeric = 11;
+            Digit0 = 11;
+            Digit1 = 12;
+            Digit2 = 13;
+            Digit3 = 14;
+            Digit4 = 15;
+            Digit5 = 16;
+            Digit6 = 17;
+            Digit7 = 18;
+            Digit8 = 19;
+            Digit9 = 20;
+            Dash = 21;
+            KeypadEnter = 22;
+            ChannelUp = 23;
+            ChannelDown = 24;
+            LastChannel = 25;
+
+            Guide = 26;
+            Info = 27;
+            Red = 28;
+            Green = 29;
+            Yellow = 30;
+            Blue = 31;
+
+            HasDvr = 32;
+            DvrList = 32;
+            Play = 33;
+            Pause = 34;
+            Stop = 35;
+            FFwd = 36;
+            Rewind = 37;
+            ChapPlus = 38;
+            ChapMinus = 39;
+            Replay = 40;
+            Record = 41;
+            HasKeypadAccessoryButton1 = 42;
+            KeypadAccessoryButton1Press = 42;
+            HasKeypadAccessoryButton2 = 43;
+            KeypadAccessoryButton2Press = 43;
+
+            Name = 1;
+            KeypadAccessoryButton1Label = 42;
+            KeypadAccessoryButton2Label = 43;
+
+            LoadPresets = 50;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            PowerOn += joinOffset;
+            PowerOff += joinOffset;
+            PowerToggle += joinOffset;
+
+            HasDpad += joinOffset;
+            Up += joinOffset;
+            Down += joinOffset;
+            Left += joinOffset;
+            Right += joinOffset;
+            Select += joinOffset;
+            Menu += joinOffset;
+            Exit += joinOffset;
+
+            HasNumeric += joinOffset;
+            Digit0 += joinOffset;
+            Digit1 += joinOffset;
+            Digit2 += joinOffset;
+            Digit3 += joinOffset;
+            Digit4 += joinOffset;
+            Digit5 += joinOffset;
+            Digit6 += joinOffset;
+            Digit7 += joinOffset;
+            Digit8 += joinOffset;
+            Digit9 += joinOffset;
+            Dash += joinOffset;
+            KeypadEnter += joinOffset;
+            ChannelUp += joinOffset;
+            ChannelDown += joinOffset;
+            LastChannel += joinOffset;
+
+            Guide += joinOffset;
+            Info += joinOffset;
+            Red += joinOffset;
+            Green += joinOffset;
+            Yellow += joinOffset;
+            Blue += joinOffset;
+
+            HasDvr += joinOffset;
+            DvrList += joinOffset;
+            Play += joinOffset;
+            Pause += joinOffset;
+            Stop += joinOffset;
+            FFwd += joinOffset;
+            Rewind += joinOffset;
+            ChapPlus += joinOffset;
+            ChapMinus += joinOffset;
+            Replay += joinOffset;
+            Record += joinOffset;
+            HasKeypadAccessoryButton1 += joinOffset;
+            KeypadAccessoryButton1Press += joinOffset;
+            HasKeypadAccessoryButton2 += joinOffset;
+            KeypadAccessoryButton2Press += joinOffset;
+
+            Name += joinOffset;
+            KeypadAccessoryButton1Label += joinOffset;
+            KeypadAccessoryButton2Label += joinOffset;
+
+            LoadPresets += joinOffset;
+        }
+
+    }
+}

PepperDashEssentials/PepperDashEssentials.csproj

@@ -123,6 +123,7 @@
     <Compile Include="Bridges\CameraControllerBridge.cs" />
     <Compile Include="Bridges\AirMediaControllerBridge.cs" />
     <Compile Include="Bridges\DmBladeChassisControllerBridge.cs" />
+    <Compile Include="Bridges\IRSetTopBoxBaseBridge.cs" />
     <Compile Include="Bridges\JoinMaps\C2nRthsControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\DmBladeChassisControllerJoinMap.cs" />
     <Compile Include="Bridges\DmpsAudioOutputControllerBridge.cs" />
@@ -155,6 +156,7 @@
     <Compile Include="Bridges\JoinMaps\IBasicCommunicationJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\IDigitalInputJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\GlsOccupancySensorBaseJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\SetTopBoxControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\StatusSignControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\SystemMonitorJoinMap.cs" />
     <Compile Include="Bridges\StatusSignControllerBridge.cs" />

essentials-framework/Essentials Core/PepperDashEssentialsBase/Timers/CountdownTimer.cs

@@ -50,7 +50,18 @@ namespace PepperDash.Essentials.Core
                     if (StartTime == null || FinishTime == null)
                         return "";
                     var timeSpan = FinishTime - DateTime.Now;
+
+                    if (timeSpan.TotalSeconds < 60)
+                    {
                         return Math.Round(timeSpan.TotalSeconds).ToString();
+                    }
+                    else
+                    {
+                        Debug.Console(2, this, "timeSpan.Minutes == {0}, timeSpan.Seconds == {1}", timeSpan.Minutes, timeSpan.Seconds);
+                        return String.Format("{0:D2}:{1:D2}",
+                            timeSpan.Minutes,
+                            timeSpan.Seconds);
+                    }
                 });
 
             PercentFeedback = new IntFeedback(() =>

essentials-framework/Essentials DM/Essentials_DM/AirMedia/AirMediaController.cs

@@ -46,6 +46,9 @@ namespace PepperDash.Essentials.DM.AirMedia
 
             PropertiesConfig = props;
 
+            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+
             InputPorts.Add(new RoutingInputPort(DmPortName.Osd, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                 eRoutingPortConnectionType.None, new Action(SelectPinPointUxLandingPage), this));
 

essentials-framework/Essentials DM/Essentials_DM/Config/DeviceFactory.cs

@@ -29,6 +29,8 @@ namespace PepperDash.Essentials.DM
 			var typeName = dc.Type.ToLower();
 
             if (typeName.StartsWith("am"))
+            {
+                if (typeName == "am200" || typeName == "am300")
                 {
                     var props = JsonConvert.DeserializeObject<AirMediaPropertiesConfig>(properties.ToString());
                     AmX00 amDevice = null;
@@ -38,6 +40,7 @@ namespace PepperDash.Essentials.DM
                         amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am300(props.Control.IpIdInt, Global.ControlSystem);
 
                     return new AirMediaController(key, name, amDevice, dc, props);
+                }
             }
 			else if (typeName.StartsWith("dmmd8x") || typeName.StartsWith("dmmd16x") || typeName.StartsWith("dmmd32x"))
 			{

essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/GlsOccupancySensorBaseController.cs

@@ -103,6 +103,18 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
                 PirSensitivityInOccupiedStateFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.PirSensitivityInVacantStateFeedbackEventId)
                 PirSensitivityInVacantStateFeedback.FireUpdate();
+        }
+
+        protected virtual void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+        {
+            Debug.Console(2, this, "GlsOccupancySensorChange  EventId: {0}", args.EventId);
+
+            if (args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId 
+                || args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId)
+            {
+                Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
+                RoomIsOccupiedFeedback.FireUpdate();
+            }
             else if (args.EventId == GlsOccupancySensorBase.TimeoutFeedbackEventId)
                 CurrentTimeoutFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.TimeoutLocalFeedbackEventId)
@@ -117,18 +129,6 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
                 ExternalPhotoSensorValue.FireUpdate();
         }
 
-        void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
-        {
-            Debug.Console(2, this, "GlsOccupancySensorChange  EventId: {0}", args.EventId);
-
-            if (args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId 
-                || args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId)
-            {
-                Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
-                RoomIsOccupiedFeedback.FireUpdate();
-            }
-        }
-
         public void SetTestMode(bool mode)
         {
             InTestMode = mode;

essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/GlsOdtOccupancySensorController.cs

@@ -69,10 +69,6 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
                 UltrasonicAEnabledFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.UsBEnabledFeedbackEventId)
                 UltrasonicBEnabledFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyPirFeedbackEventId)
-                RawOccupancyPirFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId)
-                RawOccupancyUsFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInOccupiedStateFeedbackEventId)
                 UltrasonicSensitivityInOccupiedStateFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInVacantStateFeedbackEventId)
@@ -81,6 +77,22 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
             base.OccSensor_GlsOccupancySensorChange(device, args);
         }
 
+        /// <summary>
+        /// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
+        /// Then calls the base delegate method to ensure any common event IDs are captured.
+        /// </summary>
+        /// <param name="device"></param>
+        /// <param name="args"></param>
+        protected override void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+        {
+             if (args.EventId == GlsOccupancySensorBase.RawOccupancyPirFeedbackEventId)
+                RawOccupancyPirFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId)
+                RawOccupancyUsFeedback.FireUpdate();
+
+            base.OccSensor_BaseEvent(device, args);
+        }
+
         /// <summary>
         /// Sets the OrWhenVacated state
         /// </summary>

essentials-framework/Essentials Devices Common/Essentials Devices Common/SetTopBox/IRSetTopBoxBase.cs

@@ -12,7 +12,7 @@ using PepperDash.Essentials.Core.Routing;
 
 namespace PepperDash.Essentials.Devices.Common
 {
-	public class IRSetTopBoxBase : Device, ISetTopBoxControls, IUiDisplayInfo, IRoutingOutputs, IUsageTracking
+	public class IRSetTopBoxBase : Device, ISetTopBoxControls, IUiDisplayInfo, IRoutingOutputs, IUsageTracking, IPower
 	{
 		public IrOutputPortController IrPort { get; private set; }
 
@@ -339,5 +339,33 @@ namespace PepperDash.Essentials.Devices.Common
         public UsageTracking UsageTracker { get; set; }
 
         #endregion
+
+        #region IPower Members
+
+        public void PowerOn()
+        {
+            IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_ON, true);
+            IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_ON, false);
+
+        }
+
+        public void PowerOff()
+        {
+            IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_OFF, true);
+            IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_OFF, false);
+
+        }
+
+        public void PowerToggle()
+        {
+            throw new NotImplementedException(); 
+        }
+
+        public BoolFeedback PowerIsOnFeedback
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        #endregion
     }
 }