Merge branch 'development' into feature/room-combining

Update Occupancy Aggregator to be real device

PepperDashEssentials/PepperDashEssentials.csproj

@@ -149,7 +149,8 @@
     <Compile Include="Room\Types\EssentialsNDisplayRoomBase.cs" />
     <Compile Include="Room\Config\EssentialsRoomConfig.cs" />
     <Compile Include="Room\Types\EssentialsTechRoom.cs" />
-    <Compile Include="Room\Types\IEssentialsHuddleSpaceRoom.cs" />
+    <Compile Include="Room\Types\Interfaces\IEssentialsHuddleSpaceRoom.cs" />
+    <Compile Include="Room\Types\Interfaces\IEssentialsHuddleVtc1Room.cs" />
     <Compile Include="UIDrivers\Environment Drivers\EssentialsEnvironmentDriver.cs" />
     <Compile Include="UIDrivers\Environment Drivers\EssentialsLightingDriver.cs" />
     <Compile Include="UIDrivers\Environment Drivers\EssentialsShadeDriver.cs" />

PepperDashEssentials/Room/Types/IEssentialsHuddleSpaceRoom.cs

@@ -1,48 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.DeviceTypeInterfaces;
-using PepperDash.Essentials.Room.Config;
-using PepperDash.Essentials.Core.Devices;
-using PepperDash.Essentials.Devices.Common.Codec;
-using PepperDash.Essentials.Devices.Common.VideoCodec;
-using PepperDash.Essentials.Devices.Common.AudioCodec;
-
-
-using PepperDash.Core;
-
-namespace PepperDash.Essentials
-{
-    public interface IEssentialsHuddleSpaceRoom : IEssentialsRoom, IHasCurrentSourceInfoChange, IRunRouteAction, IRunDefaultPresentRoute, IHasDefaultDisplay
-    {
-        bool ExcludeFromGlobalFunctions { get; }
-
-        void RunRouteAction(string routeKey);
-
-        EssentialsHuddleRoomPropertiesConfig PropertiesConfig { get; }
-
-        IBasicVolumeControls CurrentVolumeControls { get; }
-
-        event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
-    }
-
-    public interface IEssentialsHuddleVtc1Room : IEssentialsRoom, IHasCurrentSourceInfoChange,
-        IPrivacy, IHasCurrentVolumeControls, IRunRouteAction, IRunDefaultCallRoute, IHasVideoCodec, IHasAudioCodec, IHasDefaultDisplay, IHasInCallFeedback
-    {
-        EssentialsHuddleVtc1PropertiesConfig PropertiesConfig { get; }
-
-        void RunRouteAction(string routeKey);
-
-        IHasScheduleAwareness ScheduleSource { get; }
-
-        BoolFeedback InCallFeedback { get; }
-
-        BoolFeedback PrivacyModeIsOnFeedback { get; }
-
-        string DefaultCodecRouteString { get; }
-    }
-}

PepperDashEssentials/Room/Types/Interfaces/IEssentialsHuddleSpaceRoom.cs

@@ -0,0 +1,24 @@
+using System;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Room.Config;
+
+
+
+namespace PepperDash.Essentials
+{
+    public interface IEssentialsHuddleSpaceRoom : IEssentialsRoom, IHasCurrentSourceInfoChange, IRunRouteAction, IRunDefaultPresentRoute, IHasDefaultDisplay
+    {
+        bool ExcludeFromGlobalFunctions { get; }
+
+        void RunRouteAction(string routeKey);
+
+        EssentialsHuddleRoomPropertiesConfig PropertiesConfig { get; }
+
+        IBasicVolumeControls CurrentVolumeControls { get; }
+
+        event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
+    }
+
+ 
+}

PepperDashEssentials/Room/Types/Interfaces/IEssentialsHuddleVtc1Room.cs

@@ -0,0 +1,25 @@
+
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Room.Config;
+using PepperDash.Essentials.Devices.Common.Codec;
+using PepperDash.Essentials.Devices.Common.VideoCodec;
+using PepperDash.Essentials.Devices.Common.AudioCodec;
+
+namespace PepperDash.Essentials
+{
+    public interface IEssentialsHuddleVtc1Room : IEssentialsRoom, IHasCurrentSourceInfoChange,
+         IPrivacy, IHasCurrentVolumeControls, IRunRouteAction, IRunDefaultCallRoute, IHasVideoCodec, IHasAudioCodec, IHasDefaultDisplay, IHasInCallFeedback
+    {
+        EssentialsHuddleVtc1PropertiesConfig PropertiesConfig { get; }
+
+        void RunRouteAction(string routeKey);
+
+        IHasScheduleAwareness ScheduleSource { get; }
+
+        new BoolFeedback InCallFeedback { get; }
+
+        new BoolFeedback PrivacyModeIsOnFeedback { get; }
+
+        string DefaultCodecRouteString { get; }
+    }
+}

PepperDashEssentials/UIDrivers/EssentialsHuddle/EssentialsHuddleTechPageDriver.cs

@@ -1,326 +1,326 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro.DeviceSupport;
-
-using PepperDash.Core;
-using PepperDash.Essentials;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials;
 using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Core.SmartObjects;
-using PepperDash.Essentials.Core.Touchpanels.Keyboards;
-using PepperDash.Essentials.Devices.Displays;
-using PepperDash.Essentials.Room.Config;
-
-namespace PepperDash.Essentials.UIDrivers
-{
-    public class EssentialsHuddleTechPageDriver : PanelDriverBase
-    {
-        /// <summary>
-        /// 
-        /// </summary>
-        SmartObjectDynamicList MenuList;
-        /// <summary>
-        /// 
-        /// </summary>
-        SubpageReferenceList StatusList;
-        /// <summary>
-        /// The list of display controls
-        /// </summary>
-        SubpageReferenceList DisplayList;
-        /// <summary>
-        /// References lines in the list against device instances
-        /// </summary>
-        Dictionary<ICommunicationMonitor, uint> StatusListDeviceIndexes;
-        /// <summary>
-        /// 
-        /// </summary>
-        JoinedSigInterlock PagesInterlock;
-
-        /// <summary>
-        /// 1
-        /// </summary>
-        public const uint JoinText = 1;
-
-        CTimer PinAuthorizedTimer;
-
-		EssentialsRoomTechConfig Config;
-
-        StringBuilder PinEntryBuilder = new StringBuilder(4);
-
-        bool IsAuthorized;
-
-        SmartObjectNumeric PinKeypad;
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="trilist"></param>
-        /// <param name="parent"></param>
-        public EssentialsHuddleTechPageDriver(BasicTriListWithSmartObject trilist, EssentialsRoomTechConfig config)
-            : base(trilist)
-        {
-			Config = config;
-
-            PagesInterlock = new JoinedSigInterlock(trilist);
-            PagesInterlock.SetButDontShow(UIBoolJoin.TechSystemStatusVisible);
-
-            trilist.SetSigFalseAction(UIBoolJoin.TechExitButton, Hide);
-
-            MenuList = new SmartObjectDynamicList(trilist.SmartObjects[UISmartObjectJoin.TechMenuList], 
-                true, 3100);
-
-            MenuList.SetFeedback(1, true); // initial fb
-			ushort count = 0;
-
-            MenuList.SetItemMainText(1, "System Status");
-            MenuList.SetItemButtonAction(1, b => { 
-                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechSystemStatusVisible); 
-                MenuList.SetFeedback(1, true);
-            });
-
-            MenuList.SetItemMainText(2, "Display Controls");
-            MenuList.SetItemButtonAction(2, b => { 
-                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechDisplayControlsVisible); 
-                MenuList.SetFeedback(2, true);
-            });
-
-			count = 2;
-
-			// Don't show panel setup on iPad or xpanel
-			if (TriList is Crestron.SimplSharpPro.DeviceSupport.TswFt5Button)
-			{
-				count++;
-				MenuList.SetItemMainText(count, "Panel Setup");
-				MenuList.SetItemButtonAction(count, b =>
-				{
-					if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechPanelSetupVisible);
-					MenuList.SetFeedback(count, true);
-				});
-			}
-
-            MenuList.Count = count;
-            BuildStatusList();
-            BuildDisplayList();
-            SetupPinModal();
-        }
-        
-        /// <summary>
-        /// 
-        /// </summary>
-        public override void Show()
-        {
-            // divert to PIN if we need auth
-            if (IsAuthorized)
-            {
-                // Cancel the auth timer so we don't deauth after coming back in
-                if (PinAuthorizedTimer != null)
-                    PinAuthorizedTimer.Stop();
-
-                TriList.SetBool(UIBoolJoin.TechCommonItemsVisbible, true);
-                PagesInterlock.Show();
-                base.Show();
-            }
-            else
-            {
-                TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, true);
-            }
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        public override void Hide()
-        {
-            // Leave it authorized for 60 seconds.
-            if (IsAuthorized)
-                PinAuthorizedTimer = new CTimer(o => { 
-                    IsAuthorized = false;
-                    PinAuthorizedTimer = null;
-                }, 60000);
-            TriList.SetBool(UIBoolJoin.TechCommonItemsVisbible, false);
-            PagesInterlock.Hide();
-            base.Hide();
-        }
-
-        /// <summary>
-        /// Wire up the keypad and buttons
-        /// </summary>
-        void SetupPinModal()
-        {
-            TriList.SetSigFalseAction(UIBoolJoin.PinDialogCancelPress, CancelPinDialog);
-            PinKeypad = new SmartObjectNumeric(TriList.SmartObjects[UISmartObjectJoin.TechPinDialogKeypad], true);
-            PinKeypad.Digit0.UserObject = new Action<bool>(b => { if (b)DialPinDigit('0'); });
-            PinKeypad.Digit1.UserObject = new Action<bool>(b => { if (b)DialPinDigit('1'); });
-            PinKeypad.Digit2.UserObject = new Action<bool>(b => { if (b)DialPinDigit('2'); });
-            PinKeypad.Digit3.UserObject = new Action<bool>(b => { if (b)DialPinDigit('3'); });
-            PinKeypad.Digit4.UserObject = new Action<bool>(b => { if (b)DialPinDigit('4'); });
-            PinKeypad.Digit5.UserObject = new Action<bool>(b => { if (b)DialPinDigit('5'); });
-            PinKeypad.Digit6.UserObject = new Action<bool>(b => { if (b)DialPinDigit('6'); });
-            PinKeypad.Digit7.UserObject = new Action<bool>(b => { if (b)DialPinDigit('7'); });
-            PinKeypad.Digit8.UserObject = new Action<bool>(b => { if (b)DialPinDigit('8'); });
-            PinKeypad.Digit9.UserObject = new Action<bool>(b => { if (b)DialPinDigit('9'); });
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="d"></param>
-        void DialPinDigit(char d)
-        {
-            PinEntryBuilder.Append(d);
-            var len = PinEntryBuilder.Length;
-            SetPinDotsFeedback(len);
-
-            // check it!
-            if (len == 4)
-            {
-                if (Config.Password == PinEntryBuilder.ToString())
-                {
-                    IsAuthorized = true;
-                    SetPinDotsFeedback(0);
-                    TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, false);
-                    Show();
-                }
-                else
-                {
-                    SetPinDotsFeedback(0);
-                    TriList.SetBool(UIBoolJoin.PinDialogErrorVisible, true);
-                    new CTimer(o => 
-                        {
-                            TriList.SetBool(UIBoolJoin.PinDialogErrorVisible, false);
-                        }, 1500);
-                }
-
-                PinEntryBuilder.Remove(0, len); // clear it either way
-            }
-        }
-
-        /// <summary>
-        /// Draws the dots as pin is entered
-        /// </summary>
-        /// <param name="len"></param>
-        void SetPinDotsFeedback(int len)
-        {
-            TriList.SetBool(UIBoolJoin.PinDialogDot1, len >= 1);
-            TriList.SetBool(UIBoolJoin.PinDialogDot2, len >= 2);
-            TriList.SetBool(UIBoolJoin.PinDialogDot3, len >= 3);
-            TriList.SetBool(UIBoolJoin.PinDialogDot4, len == 4);
-
-        }
-
-        /// <summary>
-        /// Does what it says
-        /// </summary>
-        void CancelPinDialog()
-        {
-            PinEntryBuilder.Remove(0, PinEntryBuilder.Length);
-            TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, false);
-        }
-
-
-        /// <summary>
-        /// 
-        /// </summary>
-        void BuildStatusList()
-        {
-            StatusList = new SubpageReferenceList(TriList, UISmartObjectJoin.TechStatusList, 3, 3, 3);
-            StatusListDeviceIndexes = new Dictionary<ICommunicationMonitor, uint>();
-            uint i = 0;
-            foreach (var d in DeviceManager.AllDevices)
-            {
-                // make sure it is both ICommunicationMonitor and a Device
-                var sd = d as ICommunicationMonitor;
-                if (sd == null)
-                    continue;
-                var dd = sd as Device;
-                if(dd == null)
-                    continue;
-                i++;
-                StatusList.StringInputSig(i, 1).StringValue = dd.Name;
-                StatusList.UShortInputSig(i, 1).UShortValue = (ushort)sd.CommunicationMonitor.Status;
-                StatusListDeviceIndexes.Add(sd, i);
-                sd.CommunicationMonitor.StatusChange += CommunicationMonitor_StatusChange ;
-            }
-            StatusList.Count = (ushort)i;
-        }
-
-        /// <summary>
-        /// Builds the list of display controls
-        /// </summary>
-        void BuildDisplayList()
-        {
-            DisplayList = new SubpageReferenceList(TriList, UISmartObjectJoin.TechDisplayControlsList, 10, 3, 3);
-
-            var devKeys = ConfigReader.ConfigObject.Devices.Where(d =>
-                d.Group.Equals("display", StringComparison.OrdinalIgnoreCase)
-                || d.Group.Equals("projector", StringComparison.OrdinalIgnoreCase))
-                .Select(dd => dd.Key);
-            var disps = DeviceManager.AllDevices.Where(d =>
-                devKeys.Contains(d.Key));
-            ushort i = 0;
-            foreach (var disp in disps)
-            {
-                var display = disp as DisplayBase;
-                if (display != null)
-                {
-                    i++;
-                    DisplayList.StringInputSig(i, 1).StringValue = display.Name;
-                    DisplayList.GetBoolFeedbackSig(i, 1).SetSigFalseAction(display.PowerOn);      
-                    DisplayList.GetBoolFeedbackSig(i, 2).SetSigFalseAction(display.PowerOff);
-                    if (display is TwoWayDisplayBase)
-                    {
-                        var powerOnSig = DisplayList.BoolInputSig(i, 1);
-                        (display as TwoWayDisplayBase).PowerIsOnFeedback.LinkInputSig(powerOnSig);
-
-                        var powerOffSig = DisplayList.BoolInputSig(1, 2);
-                        (display as TwoWayDisplayBase).PowerIsOnFeedback.LinkComplementInputSig(powerOffSig);
-                    } 
-                    DisplayList.GetBoolFeedbackSig(i, 3).SetSigFalseAction(() =>
-                        { if (display is IInputHdmi1) (display as IInputHdmi1).InputHdmi1(); });
-                    DisplayList.GetBoolFeedbackSig(i, 4).SetSigFalseAction(() =>
-                        { if (display is IInputHdmi2) (display as IInputHdmi2).InputHdmi2(); });
-                    DisplayList.GetBoolFeedbackSig(i, 5).SetSigFalseAction(() =>
-                        { if (display is IInputHdmi3) (display as IInputHdmi3).InputHdmi3(); });
-                    //DisplayList.GetBoolFeedbackSig(i, 6).SetSigFalseAction(() =>
-                    //{ if (display is IInputHdmi4) (display as IInputHdmi4).InputHdmi4(); });
-                    DisplayList.GetBoolFeedbackSig(i, 6).SetSigFalseAction(() =>
-                        { if (display is IInputDisplayPort1) (display as IInputDisplayPort1).InputDisplayPort1(); });
-
-                
-                    // Figure out some way to provide current input feedback
-                    if (display is TwoWayDisplayBase)
-                    {
-                        (display as TwoWayDisplayBase).CurrentInputFeedback.OutputChange += CurrentInputFeedback_OutputChange;
-                    }
-                }
-
-                
-            }
-
-            DisplayList.Count = i;
-        }
-
-
-        void CurrentInputFeedback_OutputChange(object sender, EventArgs e)
-        {
-            
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        void CommunicationMonitor_StatusChange(object sender, MonitorStatusChangeEventArgs e)
-        {
-            var c = sender as ICommunicationMonitor;
-            if (StatusListDeviceIndexes.ContainsKey(c))
-            {
-                var i = StatusListDeviceIndexes[c];
-                StatusList.UShortInputSig(i, 1).UShortValue = (ushort)e.Status;
-            }
-        }
-    }
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.SmartObjects;
+using PepperDash.Essentials.Core.Touchpanels.Keyboards;
+using PepperDash.Essentials.Devices.Displays;
+using PepperDash.Essentials.Room.Config;
+
+namespace PepperDash.Essentials.UIDrivers
+{
+    public class EssentialsHuddleTechPageDriver : PanelDriverBase
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        SmartObjectDynamicList MenuList;
+        /// <summary>
+        /// 
+        /// </summary>
+        SubpageReferenceList StatusList;
+        /// <summary>
+        /// The list of display controls
+        /// </summary>
+        SubpageReferenceList DisplayList;
+        /// <summary>
+        /// References lines in the list against device instances
+        /// </summary>
+        Dictionary<ICommunicationMonitor, uint> StatusListDeviceIndexes;
+        /// <summary>
+        /// 
+        /// </summary>
+        JoinedSigInterlock PagesInterlock;
+
+        /// <summary>
+        /// 1
+        /// </summary>
+        public const uint JoinText = 1;
+
+        CTimer PinAuthorizedTimer;
+
+		EssentialsRoomTechConfig Config;
+
+        StringBuilder PinEntryBuilder = new StringBuilder(4);
+
+        bool IsAuthorized;
+
+        SmartObjectNumeric PinKeypad;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="trilist"></param>
+        /// <param name="parent"></param>
+        public EssentialsHuddleTechPageDriver(BasicTriListWithSmartObject trilist, EssentialsRoomTechConfig config)
+            : base(trilist)
+        {
+			Config = config;
+
+            PagesInterlock = new JoinedSigInterlock(trilist);
+            PagesInterlock.SetButDontShow(UIBoolJoin.TechSystemStatusVisible);
+
+            trilist.SetSigFalseAction(UIBoolJoin.TechExitButton, Hide);
+
+            MenuList = new SmartObjectDynamicList(trilist.SmartObjects[UISmartObjectJoin.TechMenuList], 
+                true, 3100);
+
+            MenuList.SetFeedback(1, true); // initial fb
+			ushort count = 0;
+
+            MenuList.SetItemMainText(1, "System Status");
+            MenuList.SetItemButtonAction(1, b => { 
+                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechSystemStatusVisible); 
+                MenuList.SetFeedback(1, true);
+            });
+
+            MenuList.SetItemMainText(2, "Display Controls");
+            MenuList.SetItemButtonAction(2, b => { 
+                if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechDisplayControlsVisible); 
+                MenuList.SetFeedback(2, true);
+            });
+
+			count = 2;
+
+			// Don't show panel setup on iPad or xpanel
+			if (TriList is Crestron.SimplSharpPro.DeviceSupport.TswFt5Button)
+			{
+				count++;
+				MenuList.SetItemMainText(count, "Panel Setup");
+				MenuList.SetItemButtonAction(count, b =>
+				{
+					if (b) PagesInterlock.ShowInterlocked(UIBoolJoin.TechPanelSetupVisible);
+					MenuList.SetFeedback(count, true);
+				});
+			}
+
+            MenuList.Count = count;
+            BuildStatusList();
+            BuildDisplayList();
+            SetupPinModal();
+        }
+        
+        /// <summary>
+        /// 
+        /// </summary>
+        public override void Show()
+        {
+            // divert to PIN if we need auth
+            if (IsAuthorized)
+            {
+                // Cancel the auth timer so we don't deauth after coming back in
+                if (PinAuthorizedTimer != null)
+                    PinAuthorizedTimer.Stop();
+
+                TriList.SetBool(UIBoolJoin.TechCommonItemsVisbible, true);
+                PagesInterlock.Show();
+                base.Show();
+            }
+            else
+            {
+                TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, true);
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public override void Hide()
+        {
+            // Leave it authorized for 60 seconds.
+            if (IsAuthorized)
+                PinAuthorizedTimer = new CTimer(o => { 
+                    IsAuthorized = false;
+                    PinAuthorizedTimer = null;
+                }, 60000);
+            TriList.SetBool(UIBoolJoin.TechCommonItemsVisbible, false);
+            PagesInterlock.Hide();
+            base.Hide();
+        }
+
+        /// <summary>
+        /// Wire up the keypad and buttons
+        /// </summary>
+        void SetupPinModal()
+        {
+            TriList.SetSigFalseAction(UIBoolJoin.PinDialogCancelPress, CancelPinDialog);
+            PinKeypad = new SmartObjectNumeric(TriList.SmartObjects[UISmartObjectJoin.TechPinDialogKeypad], true);
+            PinKeypad.Digit0.UserObject = new Action<bool>(b => { if (b)DialPinDigit('0'); });
+            PinKeypad.Digit1.UserObject = new Action<bool>(b => { if (b)DialPinDigit('1'); });
+            PinKeypad.Digit2.UserObject = new Action<bool>(b => { if (b)DialPinDigit('2'); });
+            PinKeypad.Digit3.UserObject = new Action<bool>(b => { if (b)DialPinDigit('3'); });
+            PinKeypad.Digit4.UserObject = new Action<bool>(b => { if (b)DialPinDigit('4'); });
+            PinKeypad.Digit5.UserObject = new Action<bool>(b => { if (b)DialPinDigit('5'); });
+            PinKeypad.Digit6.UserObject = new Action<bool>(b => { if (b)DialPinDigit('6'); });
+            PinKeypad.Digit7.UserObject = new Action<bool>(b => { if (b)DialPinDigit('7'); });
+            PinKeypad.Digit8.UserObject = new Action<bool>(b => { if (b)DialPinDigit('8'); });
+            PinKeypad.Digit9.UserObject = new Action<bool>(b => { if (b)DialPinDigit('9'); });
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="d"></param>
+        void DialPinDigit(char d)
+        {
+            PinEntryBuilder.Append(d);
+            var len = PinEntryBuilder.Length;
+            SetPinDotsFeedback(len);
+
+            // check it!
+            if (len == 4)
+            {
+                if (Config.Password == PinEntryBuilder.ToString())
+                {
+                    IsAuthorized = true;
+                    SetPinDotsFeedback(0);
+                    TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, false);
+                    Show();
+                }
+                else
+                {
+                    SetPinDotsFeedback(0);
+                    TriList.SetBool(UIBoolJoin.PinDialogErrorVisible, true);
+                    new CTimer(o => 
+                        {
+                            TriList.SetBool(UIBoolJoin.PinDialogErrorVisible, false);
+                        }, 1500);
+                }
+
+                PinEntryBuilder.Remove(0, len); // clear it either way
+            }
+        }
+
+        /// <summary>
+        /// Draws the dots as pin is entered
+        /// </summary>
+        /// <param name="len"></param>
+        void SetPinDotsFeedback(int len)
+        {
+            TriList.SetBool(UIBoolJoin.PinDialogDot1, len >= 1);
+            TriList.SetBool(UIBoolJoin.PinDialogDot2, len >= 2);
+            TriList.SetBool(UIBoolJoin.PinDialogDot3, len >= 3);
+            TriList.SetBool(UIBoolJoin.PinDialogDot4, len == 4);
+
+        }
+
+        /// <summary>
+        /// Does what it says
+        /// </summary>
+        void CancelPinDialog()
+        {
+            PinEntryBuilder.Remove(0, PinEntryBuilder.Length);
+            TriList.SetBool(UIBoolJoin.PinDialog4DigitVisible, false);
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void BuildStatusList()
+        {
+            StatusList = new SubpageReferenceList(TriList, UISmartObjectJoin.TechStatusList, 3, 3, 3);
+            StatusListDeviceIndexes = new Dictionary<ICommunicationMonitor, uint>();
+            uint i = 0;
+            foreach (var d in DeviceManager.AllDevices)
+            {
+                // make sure it is both ICommunicationMonitor and a Device
+                var sd = d as ICommunicationMonitor;
+                if (sd == null)
+                    continue;
+                var dd = sd as Device;
+                if(dd == null)
+                    continue;
+                i++;
+                StatusList.StringInputSig(i, 1).StringValue = dd.Name;
+                StatusList.UShortInputSig(i, 1).UShortValue = (ushort)sd.CommunicationMonitor.Status;
+                StatusListDeviceIndexes.Add(sd, i);
+                sd.CommunicationMonitor.StatusChange += CommunicationMonitor_StatusChange ;
+            }
+            StatusList.Count = (ushort)i;
+        }
+
+        /// <summary>
+        /// Builds the list of display controls
+        /// </summary>
+        void BuildDisplayList()
+        {
+            DisplayList = new SubpageReferenceList(TriList, UISmartObjectJoin.TechDisplayControlsList, 10, 3, 3);
+
+            var devKeys = ConfigReader.ConfigObject.Devices.Where(d =>
+                d.Group.Equals("display", StringComparison.OrdinalIgnoreCase)
+                || d.Group.Equals("projector", StringComparison.OrdinalIgnoreCase))
+                .Select(dd => dd.Key);
+            var disps = DeviceManager.AllDevices.Where(d =>
+                devKeys.Contains(d.Key));
+            ushort i = 0;
+            foreach (var disp in disps)
+            {
+                var display = disp as DisplayBase;
+                if (display != null)
+                {
+                    i++;
+                    DisplayList.StringInputSig(i, 1).StringValue = display.Name;
+                    DisplayList.GetBoolFeedbackSig(i, 1).SetSigFalseAction(display.PowerOn);      
+                    DisplayList.GetBoolFeedbackSig(i, 2).SetSigFalseAction(display.PowerOff);
+                    if (display is TwoWayDisplayBase)
+                    {
+                        var powerOnSig = DisplayList.BoolInputSig(i, 1);
+                        (display as TwoWayDisplayBase).PowerIsOnFeedback.LinkInputSig(powerOnSig);
+
+                        var powerOffSig = DisplayList.BoolInputSig(1, 2);
+                        (display as TwoWayDisplayBase).PowerIsOnFeedback.LinkComplementInputSig(powerOffSig);
+                    } 
+                    DisplayList.GetBoolFeedbackSig(i, 3).SetSigFalseAction(() =>
+                        { if (display is IInputHdmi1) (display as IInputHdmi1).InputHdmi1(); });
+                    DisplayList.GetBoolFeedbackSig(i, 4).SetSigFalseAction(() =>
+                        { if (display is IInputHdmi2) (display as IInputHdmi2).InputHdmi2(); });
+                    DisplayList.GetBoolFeedbackSig(i, 5).SetSigFalseAction(() =>
+                        { if (display is IInputHdmi3) (display as IInputHdmi3).InputHdmi3(); });
+                    //DisplayList.GetBoolFeedbackSig(i, 6).SetSigFalseAction(() =>
+                    //{ if (display is IInputHdmi4) (display as IInputHdmi4).InputHdmi4(); });
+                    DisplayList.GetBoolFeedbackSig(i, 6).SetSigFalseAction(() =>
+                        { if (display is IInputDisplayPort1) (display as IInputDisplayPort1).InputDisplayPort1(); });
+
+                
+                    // Figure out some way to provide current input feedback
+                    if (display is TwoWayDisplayBase)
+                    {
+                        (display as TwoWayDisplayBase).CurrentInputFeedback.OutputChange += CurrentInputFeedback_OutputChange;
+                    }
+                }
+
+                
+            }
+
+            DisplayList.Count = i;
+        }
+
+
+        void CurrentInputFeedback_OutputChange(object sender, EventArgs e)
+        {
+            
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void CommunicationMonitor_StatusChange(object sender, MonitorStatusChangeEventArgs e)
+        {
+            var c = sender as ICommunicationMonitor;
+            if (StatusListDeviceIndexes.ContainsKey(c))
+            {
+                var i = StatusListDeviceIndexes[c];
+                StatusList.UShortInputSig(i, 1).UShortValue = (ushort)e.Status;
+            }
+        }
+    }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/C2nIo/C2nIoController.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    public class C2NIoController:CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IRelayPorts
+    {
+        private C2nIo _device;
+
+        public C2NIoController(string key, Func<DeviceConfig, C2nIo> preActivationFunc, DeviceConfig config):base(key, config.Name)
+        {
+            AddPreActivationAction(() =>
+            {
+                _device = preActivationFunc(config);
+
+                RegisterCrestronGenericBase(_device);
+            });
+        }
+
+        #region Implementation of IComPorts
+
+        public CrestronCollection<ComPort> ComPorts
+        {
+            get { return _device.ComPorts; }
+        }
+
+        public int NumberOfComPorts
+        {
+            get { return _device.NumberOfComPorts; }
+        }
+
+        #endregion
+
+        #region Implementation of IIROutputPorts
+
+        public CrestronCollection<IROutputPort> IROutputPorts
+        {
+            get { return _device.IROutputPorts; }
+        }
+
+        public int NumberOfIROutputPorts
+        {
+            get { return _device.NumberOfIROutputPorts; }
+        }
+
+        #endregion
+
+        #region Implementation of IRelayPorts
+
+        public CrestronCollection<Relay> RelayPorts
+        {
+            get { return _device.RelayPorts; }
+        }
+
+        public int NumberOfRelayPorts
+        {
+            get { return _device.NumberOfRelayPorts; }
+        }
+
+        #endregion
+    }
+
+    public class C2NIoControllerFactory : EssentialsDeviceFactory<C2nRthsController>
+    {
+        public C2NIoControllerFactory()
+        {
+            TypeNames = new List<string>() { "c2nio" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new C2N-IO Device");
+
+            return new C2NIoController(dc.Key, GetC2NIoDevice, dc);
+        }
+
+        static C2nIo GetC2NIoDevice(DeviceConfig dc)
+        {
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+            var cresnetId = control.CresnetIdInt;
+            var branchId = control.ControlPortNumber;
+            var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
+
+            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new C2nIo", parentKey);
+                return new C2nIo(cresnetId, Global.ControlSystem);
+            }
+            var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as IHasCresnetBranches;
+
+            if (cresnetBridge != null)
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new C2nIo", parentKey);
+                return new C2nIo(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/BoolFeedback.cs

@@ -62,6 +62,11 @@ namespace PepperDash.Essentials.Core
             ValueFunc = valueFunc;
         }
 
+        public void SetValueFunc(Func<bool> newFunc)
+        {
+            ValueFunc = newFunc;
+        }
+
         public override void FireUpdate()
         {
             bool newValue = InTestMode ? TestValue : ValueFunc.Invoke();

essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/BoolOutputLogicals.cs

@@ -23,7 +23,7 @@ namespace PepperDash.Essentials.Core
 
 		protected bool ComputedValue;
 
-		public BoolFeedbackLogic()
+	    protected BoolFeedbackLogic()
 		{
 			Output = new BoolFeedback(() => ComputedValue);
 		}	
@@ -40,21 +40,18 @@ namespace PepperDash.Essentials.Core
 
 		public void AddOutputsIn(List<BoolFeedback> outputs)
 		{
-			foreach (var o in outputs)
-			{
-				// skip existing
-				if (OutputsIn.Contains(o)) continue;
-			
-				OutputsIn.Add(o);
-				o.OutputChange += AnyInput_OutputChange;
-			}
-			Evaluate();
+		    foreach (var o in outputs.Where(o => !OutputsIn.Contains(o)))
+		    {
+		        OutputsIn.Add(o);
+		        o.OutputChange += AnyInput_OutputChange;
+		    }
+		    Evaluate();
 		}
 
-		public void RemoveOutputIn(BoolFeedback output)
+	    public void RemoveOutputIn(BoolFeedback output)
 		{
 			// Don't double up outputs
-			if (OutputsIn.Contains(output)) return;
+			if (!OutputsIn.Contains(output)) return;
 
 			OutputsIn.Remove(output);
 			output.OutputChange -= AnyInput_OutputChange;
@@ -71,6 +68,12 @@ namespace PepperDash.Essentials.Core
 			Evaluate();
 		}
 
+	    public void ClearOutputs()
+	    {
+	        OutputsIn.Clear();
+            Evaluate();
+	    }
+
 		void AnyInput_OutputChange(object sender, EventArgs e)
 		{
 			Evaluate();
@@ -85,11 +88,12 @@ namespace PepperDash.Essentials.Core
 		{
 			var prevValue = ComputedValue;
 			var newValue = OutputsIn.All(o => o.BoolValue);
-			if (newValue != prevValue)
-			{
-				ComputedValue = newValue;
-				Output.FireUpdate();
-			}
+		    if (newValue == prevValue)
+		    {
+		        return;
+		    }
+		    ComputedValue = newValue;
+		    Output.FireUpdate();
 		}
 	}
 
@@ -99,33 +103,35 @@ namespace PepperDash.Essentials.Core
 		{
 			var prevValue = ComputedValue;
 			var newValue = OutputsIn.Any(o => o.BoolValue);
-			if (newValue != prevValue)
-			{
-				ComputedValue = newValue;
-				Output.FireUpdate();
-			}
+		    if (newValue == prevValue)
+		    {
+		        return;
+		    }
+		    ComputedValue = newValue;
+		    Output.FireUpdate();
 		}
 	}
 
 	public class BoolFeedbackLinq : BoolFeedbackLogic
 	{
-		Func<IEnumerable<BoolFeedback>, bool> Predicate;
+	    readonly Func<IEnumerable<BoolFeedback>, bool> _predicate;
 
 		public BoolFeedbackLinq(Func<IEnumerable<BoolFeedback>, bool> predicate)
 			: base()
 		{
-			Predicate = predicate;
+			_predicate = predicate;
 		}
 
 		protected override void Evaluate()
 		{
 			var prevValue = ComputedValue;
-			var newValue = Predicate(OutputsIn);
-			if (newValue != prevValue)
-			{
-				ComputedValue = newValue;
-				Output.FireUpdate();
-			}
+			var newValue = _predicate(OutputsIn);
+		    if (newValue == prevValue)
+		    {
+		        return;
+		    }
+		    ComputedValue = newValue;
+		    Output.FireUpdate();
 		} 
 	}
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/IntFeedback.cs

@@ -51,6 +51,12 @@ namespace PepperDash.Essentials.Core
             ValueFunc = valueFunc;
         }
 
+        public void SetValueFunc(Func<int> newFunc)
+        {
+            ValueFunc = newFunc;
+        }
+
+
         public override void FireUpdate()
         {
             var newValue = InTestMode ? TestValue : ValueFunc.Invoke();

essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/StringFeedback.cs

@@ -52,7 +52,10 @@ namespace PepperDash.Essentials.Core
             ValueFunc = valueFunc;
         }
 
-
+        public void SetValueFunc(Func<string> newFunc)
+        {
+            ValueFunc = newFunc;
+        }
 
         public override void FireUpdate()
         {

essentials-framework/Essentials Core/PepperDashEssentialsBase/Occupancy/IOccupancyStatusProviderAggregator.cs

@@ -2,17 +2,18 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Crestron.SimplSharp;
-
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.GeneralIO;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
 
 namespace PepperDash.Essentials.Core
 {
     /// <summary>
     /// Aggregates the RoomIsOccupied feedbacks of one or more IOccupancyStatusProvider objects
     /// </summary>
-    public class IOccupancyStatusProviderAggregator : Device, IOccupancyStatusProvider
+    public class IOccupancyStatusProviderAggregator : EssentialsDevice, IOccupancyStatusProvider
     {
         /// <summary>
         /// Aggregated feedback of all linked IOccupancyStatusProvider devices
@@ -21,16 +22,51 @@ namespace PepperDash.Essentials.Core
         {
             get
             {
-                return AggregatedOccupancyStatus.Output;
+                return _aggregatedOccupancyStatus.Output;
             }
         }
 
-        private BoolFeedbackOr AggregatedOccupancyStatus;
+        private readonly BoolFeedbackOr _aggregatedOccupancyStatus;
 
         public IOccupancyStatusProviderAggregator(string key, string name) 
             : base(key, name)
         {
-            AggregatedOccupancyStatus = new BoolFeedbackOr();
+            _aggregatedOccupancyStatus = new BoolFeedbackOr();
+        }
+
+        public IOccupancyStatusProviderAggregator(string key, string name, OccupancyAggregatorConfig config)
+            : this(key, name)
+        {
+            AddPostActivationAction(() =>
+            {
+                if (config.DeviceKeys.Count == 0)
+                {
+                    return;
+                }
+
+                foreach (var deviceKey in config.DeviceKeys)
+                {
+                    var device = DeviceManager.GetDeviceForKey(deviceKey);
+
+                    if (device == null)
+                    {
+                        Debug.Console(0, this, Debug.ErrorLogLevel.Notice,
+                            "Unable to retrieve Occupancy provider with key {0}", deviceKey);
+                        continue;
+                    }
+
+                    var provider = device as IOccupancyStatusProvider;
+
+                    if (provider == null)
+                    {
+                        Debug.Console(0, this, Debug.ErrorLogLevel.Notice,
+                            "Device with key {0} does NOT implement IOccupancyStatusProvider. Please check configuration.");
+                        continue;
+                    }
+
+                    AddOccupancyStatusProvider(provider);
+                }
+            });
         }
 
         /// <summary>
@@ -39,7 +75,35 @@ namespace PepperDash.Essentials.Core
         /// <param name="statusProvider"></param>
         public void AddOccupancyStatusProvider(IOccupancyStatusProvider statusProvider)
         {
-            AggregatedOccupancyStatus.AddOutputIn(statusProvider.RoomIsOccupiedFeedback);
+            _aggregatedOccupancyStatus.AddOutputIn(statusProvider.RoomIsOccupiedFeedback);
+        }
+
+        public void RemoveOccupancyStatusProvider(IOccupancyStatusProvider statusProvider)
+        {
+            _aggregatedOccupancyStatus.RemoveOutputIn(statusProvider.RoomIsOccupiedFeedback);
+        }
+
+        public void ClearOccupancyStatusProviders()
+        {
+            _aggregatedOccupancyStatus.ClearOutputs();
         }
+    }
+
+    public class OccupancyAggregatorFactory : EssentialsDeviceFactory<IOccupancyStatusProviderAggregator>
+    {
+        public OccupancyAggregatorFactory()
+        {
+            TypeNames = new List<string> { "occupancyAggregator", "occAggregate" };
+        }
+
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
+
+            var config = dc.Properties.ToObject<OccupancyAggregatorConfig>();
+                
+            return new IOccupancyStatusProviderAggregator(dc.Key, dc.Name, config);
+        }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Occupancy/OccupancyAggregatorConfig.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core
+{
+    public class OccupancyAggregatorConfig
+    {
+        [JsonProperty("deviceKeys")] public List<string> DeviceKeys { get; set; }
+
+        public OccupancyAggregatorConfig()
+        {
+            DeviceKeys = new List<string>();
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/PartitionSensor/EssentialsPartitionController.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Represents an abstract controller device for a partition dividing rooms that are combinable
+    /// 
+    /// In Auto mode, it can use a partition sensor to automatically determine whether the partition is present.
+    /// 
+    /// In Manual mode it accepts user input to tell it whether the partition is present.
+    /// </summary>
+    public class EssentialsPartitionController : IPartitionController
+    {
+        private IPartitionStateProvider _partitionSensor;
+
+        private bool isInAutoMode;
+
+        private bool partitionPresent;
+
+        public EssentialsPartitionController(string key, string name, IPartitionStateProvider sensor, bool defaultToManualMode, List<string> adjacentRoomKeys)
+        {
+            Key = key;
+
+            Name = name;
+
+            AdjacentRoomKeys = adjacentRoomKeys;
+
+            if (sensor != null)
+            {
+                _partitionSensor = sensor;
+
+                if (!defaultToManualMode)
+                {
+                    SetAutoMode();
+                }
+                else
+                {
+                    SetManualMode();
+                }
+            }
+            else
+            {
+                SetManualMode();
+            }
+
+            PartitionPresentFeedback.FireUpdate();
+        }
+
+        void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
+        {
+            if (isInAutoMode)
+            {
+                PartitionPresentFeedback.FireUpdate();
+            }
+        }
+
+        #region IPartitionController Members
+
+        public List<string> AdjacentRoomKeys { get; private set; }
+
+        public void SetAutoMode()
+        {
+            isInAutoMode = true;
+            if (PartitionPresentFeedback != null)
+            {
+                PartitionPresentFeedback.SetValueFunc(() => _partitionSensor.PartitionPresentFeedback.BoolValue);
+            }
+            else
+            {
+                PartitionPresentFeedback = new BoolFeedback(() => _partitionSensor.PartitionPresentFeedback.BoolValue);
+            }
+
+            if (_partitionSensor != null)
+            {
+                _partitionSensor.PartitionPresentFeedback.OutputChange += PartitionPresentFeedback_OutputChange;
+            }
+        }
+
+        public void SetManualMode()
+        {
+            isInAutoMode = false;
+            if (PartitionPresentFeedback != null)
+            {
+                PartitionPresentFeedback.SetValueFunc(() => partitionPresent);
+            }
+            else
+            {
+                PartitionPresentFeedback = new BoolFeedback(() => partitionPresent);
+            }
+
+            if (_partitionSensor != null)
+            {
+                _partitionSensor.PartitionPresentFeedback.OutputChange -= PartitionPresentFeedback_OutputChange;
+            }
+        }
+
+
+        public void SetPartitionStatePresent()
+        {
+            if (!isInAutoMode)
+            {
+                partitionPresent = true;
+                PartitionPresentFeedback.FireUpdate();
+            }
+        }
+
+        public void SetPartitionStateNotPresent()
+        {
+            if (!isInAutoMode)
+            {
+                partitionPresent = false;
+                PartitionPresentFeedback.FireUpdate();
+            }
+        }
+
+        public void ToggglePartitionState()
+        {
+            if (!isInAutoMode)
+            {
+                partitionPresent = !partitionPresent;
+                PartitionPresentFeedback.FireUpdate();
+            }
+        }
+
+        #endregion
+
+        #region IPartitionStateProvider Members
+
+        public BoolFeedback PartitionPresentFeedback { get; private set; }
+
+        #endregion
+
+        #region IKeyName Members
+
+        public string Name { get; private set; }
+
+        #endregion
+
+        #region IKeyed Members
+
+        public string Key { get; private set; }
+
+        #endregion
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/PartitionSensor/GlsPartitionSensorController.cs

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.Core
 
 		public StringFeedback NameFeedback { get; private set; }
 		public BoolFeedback EnableFeedback { get; private set; }
-		public BoolFeedback PartitionSensedFeedback { get; private set; }
+		public BoolFeedback PartitionPresentFeedback { get; private set; }
 		public BoolFeedback PartitionNotSensedFeedback { get; private set; }
 		public IntFeedback SensitivityFeedback { get; private set; }
 
@@ -40,7 +40,7 @@ namespace PepperDash.Essentials.Core
 
                 NameFeedback = new StringFeedback(() => Name);
                 EnableFeedback = new BoolFeedback(() => _partitionSensor.EnableFeedback.BoolValue);
-                PartitionSensedFeedback = new BoolFeedback(() => _partitionSensor.PartitionSensedFeedback.BoolValue);
+                PartitionPresentFeedback = new BoolFeedback(() => _partitionSensor.PartitionSensedFeedback.BoolValue);
                 PartitionNotSensedFeedback = new BoolFeedback(() => _partitionSensor.PartitionNotSensedFeedback.BoolValue);
                 SensitivityFeedback = new IntFeedback(() => _partitionSensor.SensitivityFeedback.UShortValue);
 
@@ -61,7 +61,7 @@ namespace PepperDash.Essentials.Core
 					}
 				case (GlsPartCn.PartitionSensedFeedbackEventId):
 					{
-						PartitionSensedFeedback.FireUpdate();
+						PartitionPresentFeedback.FireUpdate();
 						break;
 					}
 				case (GlsPartCn.PartitionNotSensedFeedbackEventId):
@@ -186,7 +186,7 @@ namespace PepperDash.Essentials.Core
 			// link output to simpl
 			IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
 			EnableFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Enable.JoinNumber]);
-			PartitionSensedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionSensed.JoinNumber]);
+			PartitionPresentFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionSensed.JoinNumber]);
 			PartitionNotSensedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionNotSensed.JoinNumber]);
 			SensitivityFeedback.LinkInputSig(trilist.UShortInput[joinMap.Sensitivity.JoinNumber]);
 
@@ -216,7 +216,7 @@ namespace PepperDash.Essentials.Core
 			IsOnline.FireUpdate();
 			NameFeedback.FireUpdate();
 			EnableFeedback.FireUpdate();
-			PartitionSensedFeedback.FireUpdate();
+			PartitionPresentFeedback.FireUpdate();
 			PartitionNotSensedFeedback.FireUpdate();
 			SensitivityFeedback.FireUpdate();
 		}
@@ -257,7 +257,7 @@ namespace PepperDash.Essentials.Core
 
             public override EssentialsDevice BuildDevice(DeviceConfig dc)
             {
-                Debug.Console(1, "Factory Attempting to create new C2N-RTHS Device");
+                Debug.Console(1, "Factory Attempting to create new GlsPartitionSensorController Device");
 
                 return new GlsPartitionSensorController(dc.Key, GetGlsPartCnDevice, dc);
             }

essentials-framework/Essentials Core/PepperDashEssentialsBase/PartitionSensor/IPartitionStateProvider.cs

@@ -13,15 +13,24 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public interface IPartitionStateProvider : IKeyName
     {
-        BoolFeedback PartitionSensedFeedback { get; }
+        BoolFeedback PartitionPresentFeedback { get; }
     }
 
-    public interface IManualPartitionSensor : IPartitionStateProvider
+    /// <summary>
+    /// Describes the functionality of a device that can provide partition state either manually via user input or optionally via a sensor state
+    /// </summary>
+    public interface IPartitionController : IPartitionStateProvider
     {
+        List<string> AdjacentRoomKeys { get; }
+
         void SetPartitionStatePresent();
 
         void SetPartitionStateNotPresent();
 
         void ToggglePartitionState();
+
+        void SetManualMode();
+
+        void SetAutoMode();
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj

@@ -162,6 +162,7 @@
     <Compile Include="Config\Essentials\ConfigWriter.cs" />
     <Compile Include="Config\Essentials\EssentialsConfig.cs" />
     <Compile Include="Config\SourceDevicePropertiesConfigBase.cs" />
+    <Compile Include="Crestron IO\C2nIo\C2nIoController.cs" />
     <Compile Include="Crestron IO\C2nRts\C2nRthsController.cs" />
     <Compile Include="Crestron IO\Cards\C3CardControllerBase.cs" />
     <Compile Include="Crestron IO\Cards\C3Com3Controller.cs" />
@@ -233,7 +234,9 @@
     <Compile Include="Interfaces\ILogStringsWithLevel.cs" />
     <Compile Include="Occupancy\GlsOccupancySensorPropertiesConfig.cs" />
     <Compile Include="Occupancy\GlsOirOccupancySensorController.cs" />
+    <Compile Include="PartitionSensor\EssentialsPartitionController.cs" />
     <Compile Include="PartitionSensor\IPartitionStateProvider.cs" />
+    <Compile Include="Occupancy\OccupancyAggregatorConfig.cs" />
     <Compile Include="Queues\ComsMessage.cs" />
     <Compile Include="Queues\ProcessStringMessage.cs" />
     <Compile Include="Queues\GenericQueue.cs" />
@@ -288,6 +291,7 @@
     <Compile Include="Remotes\CrestronRemotePropertiesConfig.cs" />
     <Compile Include="Remotes\Hrxx0WirelessRemoteController.cs" />
     <Compile Include="Room\Behaviours\RoomOnToDefaultSourceWhenOccupied.cs" />
+    <Compile Include="Room\Combining\EssentialsRoomCombiner.cs" />
     <Compile Include="Room\Combining\EssentialsRoomCombinerPropertiesConfig.cs" />
     <Compile Include="Room\Combining\IEssentialsRoomCombiner.cs" />
     <Compile Include="Room\Combining\RoomCombinationScenario.cs" />

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Combining/EssentialsRoomCombiner.cs

@@ -0,0 +1,266 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    public class EssentialsRoomCombiner : EssentialsDevice, IEssentialsRoomCombiner
+    {
+        private EssentialsRoomCombinerPropertiesConfig _propertiesConfig;
+
+        private IRoomCombinationScenario _currentScenario;
+
+        private List<IEssentialsRoom> _rooms;
+
+        private bool isInAutoMode;
+
+        private CTimer _scenarioChangeDebounceTimer;
+
+        private int _scenarioChangeDebounceTimeSeconds = 10; // default to 10s
+
+        public EssentialsRoomCombiner(string key, EssentialsRoomCombinerPropertiesConfig props)
+            : base(key)
+        {
+            _propertiesConfig = props;
+
+            if (_propertiesConfig.ScenarioChangeDebounceTimeSeconds > 0)
+            {
+                _scenarioChangeDebounceTimeSeconds = _propertiesConfig.ScenarioChangeDebounceTimeSeconds;
+            }
+
+            IsInAutoModeFeedback = new BoolFeedback(() => isInAutoMode);
+
+            // default to auto mode
+            isInAutoMode = true;
+
+            if (_propertiesConfig.defaultToManualMode)
+            {
+                isInAutoMode = false;
+            }
+
+            IsInAutoModeFeedback.FireUpdate();
+
+            CreateScenarios();
+
+            AddPostActivationAction(() =>
+            {
+                SetupPartitionStateProviders();
+
+                SetRooms();
+            });
+        }
+
+        void CreateScenarios()
+        {
+            RoomCombinationScenarios = new List<IRoomCombinationScenario>();
+
+            foreach (var scenarioConfig in _propertiesConfig.Scenarios)
+            {
+                var scenario = new RoomCombinationScenario(scenarioConfig);
+                RoomCombinationScenarios.Add(scenario);
+            }
+        }
+
+        void SetRooms()
+        {
+            _rooms = new List<IEssentialsRoom>();
+
+            foreach (var roomKey in _propertiesConfig.RoomKeys)
+            {
+                var room = DeviceManager.GetDeviceForKey(roomKey) as IEssentialsRoom;
+                if (room != null)
+                {
+                    _rooms.Add(room);
+                }
+            }
+        }
+
+        void SetupPartitionStateProviders()
+        {
+            foreach (var pConfig in _propertiesConfig.Partitions)
+            {
+                var sensor = DeviceManager.GetDeviceForKey(pConfig.DeviceKey) as IPartitionStateProvider;
+
+                var partition = new EssentialsPartitionController(pConfig.Key, pConfig.Name, sensor, _propertiesConfig.defaultToManualMode, pConfig.AdjacentRoomKeys);
+
+                partition.PartitionPresentFeedback.OutputChange += PartitionPresentFeedback_OutputChange;
+
+                Partitions.Add(partition);
+            }
+        }
+
+        void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
+        {
+            StartDebounceTimer();
+        }
+
+        void StartDebounceTimer()
+        {
+            var time = _scenarioChangeDebounceTimeSeconds * 1000;
+
+            if (_scenarioChangeDebounceTimer == null)
+            {
+                _scenarioChangeDebounceTimer = new CTimer((o) => DetermineRoomCombinationScenario(), time);
+            }
+            else
+            {
+                _scenarioChangeDebounceTimer.Reset(time);
+            }
+        }
+
+        /// <summary>
+        /// Determines the current room combination scenario based on the state of the partition sensors
+        /// </summary>
+        void DetermineRoomCombinationScenario()
+        {
+            if (_scenarioChangeDebounceTimer != null)
+            {
+                _scenarioChangeDebounceTimer.Dispose();
+                _scenarioChangeDebounceTimer = null;
+            }
+
+            var currentScenario = RoomCombinationScenarios.FirstOrDefault((s) =>
+            {
+                // iterate the partition states
+                foreach (var partitionState in s.PartitionStates)
+                {
+                    // get the partition by key
+                    var partition = Partitions.FirstOrDefault((p) => p.Key.Equals(partitionState.PartitionKey));
+
+                    if (partition != null && partitionState.PartitionPresent != partition.PartitionPresentFeedback.BoolValue)
+                    {
+                        // the partition can't be found or the state doesn't match
+                        return false;
+                    }
+                    else
+                    {
+                        // check the next partition state
+                        continue;
+                    }
+                }
+                // if it hasn't returned false by now we have the matching scenario
+                return true;
+            });
+
+            if (currentScenario != null)
+            {
+                CurrentScenario = currentScenario;
+            }
+        }
+
+        #region IEssentialsRoomCombiner Members
+
+        public event EventHandler<EventArgs> RoomCombinationScenarioChanged;
+
+        public IRoomCombinationScenario CurrentScenario
+        {
+            get
+            {
+                return _currentScenario;
+            }
+            set
+            {
+                if (value != _currentScenario)
+                {
+                    _currentScenario = value;
+                    Debug.Console(1, this, "Current Scenario: {0}", _currentScenario.Name);
+                    var handler = RoomCombinationScenarioChanged;
+                    if (handler != null)
+                    {
+                        handler(this, new EventArgs());
+                    }
+                }
+            }
+        }
+
+        public BoolFeedback IsInAutoModeFeedback { get; private set; }
+
+        public void SetAutoMode()
+        {
+            isInAutoMode = true;
+            IsInAutoModeFeedback.FireUpdate();
+        }
+
+        public void SetManualMode()
+        {
+            isInAutoMode = false;
+            IsInAutoModeFeedback.FireUpdate();
+        }
+
+        public void ToggleMode()
+        {
+            isInAutoMode = !isInAutoMode;
+            IsInAutoModeFeedback.FireUpdate();
+        }
+
+        public List<IRoomCombinationScenario> RoomCombinationScenarios { get; private set; }
+
+        public List<IPartitionController> Partitions { get; private set; }
+
+        public void TogglePartitionState(string partitionKey)
+        {
+            var partition = Partitions.FirstOrDefault((p) => p.Key.Equals(partitionKey)) as IPartitionController;
+
+            if (partition != null)
+            {
+                partition.ToggglePartitionState();
+            }
+        }
+
+        public void SetRoomCombinationScenario(string scenarioKey)
+        {
+            if (isInAutoMode)
+            {
+                Debug.Console(0, this, "Cannot set room combination scenario when in auto mode.  Set to auto mode first.");
+                return;
+            }
+
+            // Get the scenario
+            var scenario = RoomCombinationScenarios.FirstOrDefault((s) => s.Key.Equals(scenarioKey));
+
+            // Set the parition states from the scenario manually
+            if (scenario != null)
+            {
+                foreach (var partitionState in scenario.PartitionStates)
+                {
+                    var partition = Partitions.FirstOrDefault((p) => p.Key.Equals(partitionState.PartitionKey));
+
+                    if (partition != null)
+                    {
+                        if (partitionState.PartitionPresent)
+                        {
+                            partition.SetPartitionStatePresent();
+                        }
+                        else
+                        {
+                            partition.SetPartitionStateNotPresent();
+                        }
+                    }
+                }
+            }
+        }
+
+        #endregion
+    }
+
+    public class EssentialsRoomCombinerFactory : EssentialsDeviceFactory<EssentialsRoomCombiner>
+    {
+        public EssentialsRoomCombinerFactory()
+        {
+            TypeNames = new List<string> { "essentialsroomcombiner" };
+        }
+
+        public override EssentialsDevice BuildDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new EssentialsRoomCombiner Device");
+
+            var props = dc.Properties.ToObject<EssentialsRoomCombinerPropertiesConfig>();
+
+            return new EssentialsRoomCombiner(dc.Key, props);
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Combining/EssentialsRoomCombinerPropertiesConfig.cs

@@ -28,10 +28,25 @@ namespace PepperDash.Essentials.Core
         public List<RoomCombinationScenarioConfig> Scenarios { get; set; }
 
         /// <summary>
-        /// The list of rooms that can be combined
+        /// The list of rooms keys that can be combined
         /// </summary>
         [JsonProperty("roomMap")]
-        public Dictionary<string, string> RoomMap {get; set;}
+        public List<string> RoomKeys {get; set;}
+
+        /// <summary>
+        /// Set to true to default to manual mode
+        /// </summary>
+        [JsonProperty("defaultToManualMode")]
+        public bool defaultToManualMode { get; set; }
+
+        /// <summary>
+        /// The key of the scenario to default to at system startup if in manual mode
+        /// </summary>
+        [JsonProperty("defaultScenarioKey")]
+        public string defaultScenarioKey { get; set; }
+
+        [JsonProperty("scenarioChangeDebounceTimeSeconds")]
+        public int ScenarioChangeDebounceTimeSeconds { get; set; }
     }
 
     /// <summary>
@@ -54,8 +69,8 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Keys of the rooms that this partion would be located between
         /// </summary>
-        [JsonProperty("roomKeys")]
-        public List<string> RoomKeys { get; set; }
+        [JsonProperty("adjacentRoomKeys")]
+        public List<string> AdjacentRoomKeys { get; set; }
     }
 
     /// <summary>
@@ -72,11 +87,14 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("partitionStates")]
         public List<PartitionState> PartitionStates { get; set; }
 
-        [JsonProperty("enabledRoomKeys")]
-        public List<string> EnabledRoomKeys { get; set; }
+        [JsonProperty("uiMap")]
+        public Dictionary<string, string> UiMap { get; set; }
 
-        [JsonProperty("actions")]
-        public List<DeviceActionWrapper> Actions { get; set; }    
+        [JsonProperty("activationActions")]
+        public List<DeviceActionWrapper> ActivationActions { get; set; }
+
+        [JsonProperty("deactivationActions")]
+        public List<DeviceActionWrapper> DeactivationActions { get; set; }    
     }
 
     /// <summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Combining/IEssentialsRoomCombiner.cs

@@ -11,31 +11,82 @@ namespace PepperDash.Essentials.Core
     /// <summary>
     /// Describes the functionality for an EssentailsRoomCombiner device
     /// </summary>
-    public interface IEssentialsRoomCombiner
+    public interface IEssentialsRoomCombiner : IKeyed
     {
-        // TODO: Update the EventArgs class as needed to specify scenario change
+        /// <summary>
+        /// Indicates that the room combination scenario has changed
+        /// </summary>
         event EventHandler<EventArgs> RoomCombinationScenarioChanged;
 
+        /// <summary>
+        /// The current room combination scenario
+        /// </summary>
+        IRoomCombinationScenario CurrentScenario { get; }
+
+        /// <summary>
+        /// When true, indicates the current mode is auto mode
+        /// </summary>
         BoolFeedback IsInAutoModeFeedback {get;}
 
+        /// <summary>
+        /// Sets auto mode
+        /// </summary>
         void SetAutoMode();
 
+        /// <summary>
+        /// Sets manual mode
+        /// </summary>
         void SetManualMode();
 
+        /// <summary>
+        /// Toggles the current mode between auto and manual
+        /// </summary>
         void ToggleMode();
 
-        List<IRoomCombinationScenario> Scenarios { get; }
+        /// <summary>
+        /// The available room combinatino scenarios
+        /// </summary>
+        List<IRoomCombinationScenario> RoomCombinationScenarios { get; }
 
-        List<IPartitionStateProvider> Partitions { get; }
+        /// <summary>
+        /// The partition
+        /// </summary>
+        List<IPartitionController> Partitions { get; }
 
+        /// <summary>
+        /// Toggles the state of a manual partition sensor
+        /// </summary>
+        /// <param name="partitionKey"></param>
         void TogglePartitionState(string partitionKey);
+
+        /// <summary>
+        /// Sets the room combination scenario (if in manual mode)
+        /// </summary>
+        /// <param name="scenarioKey"></param>
+        void SetRoomCombinationScenario(string scenarioKey);
     }
 
     public interface IRoomCombinationScenario : IKeyName
     {
-        BoolFeedback IsActive { get; }
+        /// <summary>
+        /// When true, indicates that this room combination scenario is active
+        /// </summary>
+        BoolFeedback IsActiveFeedback { get; }
 
+        /// <summary>
+        /// Activates this room combination scenario
+        /// </summary>
         void Activate();
+
+        /// <summary>
+        /// The state of the partitions that would activate this scenario
+        /// </summary>
+        List<PartitionState> PartitionStates { get; }
+
+        /// <summary>
+        /// The mapping of UIs by key to rooms by key
+        /// </summary>
+        Dictionary<string, string> UiMap { get; set; }
     }
 
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Combining/RoomCombinationScenario.cs

@@ -13,17 +13,69 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public class RoomCombinationScenario: IRoomCombinationScenario
     {
-        [JsonProperty("key")]
+        private RoomCombinationScenarioConfig _config;
+
         public string Key { get; set; }
 
-        [JsonProperty("name")]
         public string Name { get; set; }
 
-        public BoolFeedback IsActive { get; private set; }
+        public List<PartitionState> PartitionStates { get; private set; }
+
+        public Dictionary<string, string> UiMap { get; set; }
+
+        private bool _isActive;
+
+        public BoolFeedback IsActiveFeedback { get; private set; }
+
+        List<DeviceActionWrapper> activationActions;
+
+        List<DeviceActionWrapper> deactivationActions;
+
+        public RoomCombinationScenario(RoomCombinationScenarioConfig config)
+        {
+            Key = config.Key;
+
+            Name = config.Name;
+
+            PartitionStates = config.PartitionStates;
+
+            UiMap = config.UiMap;
+
+            activationActions = config.ActivationActions;
+
+            deactivationActions = config.DeactivationActions;
+
+            _config = config;
+
+            IsActiveFeedback = new BoolFeedback(() => _isActive);
+        }
 
         public void Activate()
         {
+            if (activationActions != null)
+            {
+                foreach (var action in activationActions)
+                {
+                    DeviceJsonApi.DoDeviceAction(action);
+                }
+            }
 
+            _isActive = true;
+            IsActiveFeedback.FireUpdate();
+        }
+
+        public void Deactivate()
+        {
+            if (deactivationActions != null)
+            {
+                foreach (var action in deactivationActions)
+                {
+                    DeviceJsonApi.DoDeviceAction(action);
+                }
+            }
+
+            _isActive = false;
+            IsActiveFeedback.FireUpdate();
         }
 
     }