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

closes #60 , closes #63 , closes #51
2026-02-16 13:15:03 +00:00 · 2020-03-16 09:34:42 -06:00
parent b5251651af c25901f8c9
commit b1573e99de
12 changed files with 1060 additions and 637 deletions
--- a/PepperDashEssentials/Bridges/BridgeBase.cs
+++ b/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);
--- a/PepperDashEssentials/Bridges/GlsOccupancySensorBaseControllerBridge.cs
+++ b/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)));
--- a/PepperDashEssentials/Bridges/IRSetTopBoxBaseBridge.cs
+++ b/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));
+
+            }
+
+        }
+    }
+}
--- a/PepperDashEssentials/Bridges/JoinMaps/GlsOccupancySensorBaseJoinMap.cs
+++ 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;
        }
    }    
         
--- a/PepperDashEssentials/Bridges/JoinMaps/SetTopBoxControllerJoinMap.cs
+++ b/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;
+        }
+
+    }
+}
--- a/PepperDashEssentials/PepperDashEssentials.csproj
+++ b/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" />
--- a/Core/PepperDashEssentialsBase/Timers/CountdownTimer.cs
+++ b/Core/PepperDashEssentialsBase/Timers/CountdownTimer.cs
@@ -50,7 +50,18 @@ namespace PepperDash.Essentials.Core
                    if (StartTime == null || FinishTime == null)
                        return "";
                    var timeSpan = FinishTime - DateTime.Now;
-                    return Math.Round(timeSpan.TotalSeconds).ToString();
+
+                    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(() =>
--- a/DM/Essentials_DM/AirMedia/AirMediaController.cs
+++ b/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));

--- a/DM/Essentials_DM/Config/DeviceFactory.cs
+++ b/DM/Essentials_DM/Config/DeviceFactory.cs
@@ -30,14 +30,17 @@ namespace PepperDash.Essentials.DM

            if (typeName.StartsWith("am"))
            {
-                var props = JsonConvert.DeserializeObject<AirMediaPropertiesConfig>(properties.ToString());
-                AmX00 amDevice = null;
-                if (typeName == "am200")
-                    amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am200(props.Control.IpIdInt, Global.ControlSystem);
-                else if(typeName == "am300")
-                    amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am300(props.Control.IpIdInt, Global.ControlSystem);
+                if (typeName == "am200" || typeName == "am300")
+                {
+                    var props = JsonConvert.DeserializeObject<AirMediaPropertiesConfig>(properties.ToString());
+                    AmX00 amDevice = null;
+                    if (typeName == "am200")
+                        amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am200(props.Control.IpIdInt, Global.ControlSystem);
+                    else if (typeName == "am300")
+                        amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am300(props.Control.IpIdInt, Global.ControlSystem);

-                return new AirMediaController(key, name, amDevice, dc, props);
+                    return new AirMediaController(key, name, amDevice, dc, props);
+                }
            }
 			else if (typeName.StartsWith("dmmd8x") || typeName.StartsWith("dmmd16x") || typeName.StartsWith("dmmd32x"))
 			{
--- a/Common/Occupancy/GlsOccupancySensorBaseController.cs
+++ b/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;
--- a/Common/Occupancy/GlsOdtOccupancySensorController.cs
+++ b/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>
--- a/Common/SetTopBox/IRSetTopBoxBase.cs
+++ b/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
+    }
 }