Merge pull request #304 from PepperDash/feature/minor-updates

Add bulk device add method and update Eisc

PepperDashEssentials/Bridges/EiscBridge.cs

@@ -151,12 +151,12 @@ namespace PepperDash.Essentials.Bridges
             try
             {
                 if (Debug.Level >= 1)
-                    Debug.Console(1, this, "EiscApi change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
+                    Debug.Console(2, this, "EiscApi change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
                 var uo = args.Sig.UserObject;
 
                 if (uo == null) return;
 
-                Debug.Console(1, this, "Executing Action: {0}", uo.ToString());
+                Debug.Console(2, this, "Executing Action: {0}", uo.ToString());
                 if (uo is Action<bool>)
                     (uo as Action<bool>)(args.Sig.BoolValue);
                 else if (uo is Action<ushort>)

PepperDashEssentials/Fusion/EssentialsHuddleVtc1FusionController.cs

@@ -1,23 +1,15 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.CrestronIO;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DeviceSupport;
+using System;
+using System.Linq;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.Fusion;
 
 
-using PepperDash.Core;
-using PepperDash.Essentials;
+using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Core.Fusion;
-using PepperDash.Essentials.Devices.Common;
-using PepperDash.Essentials.Devices.Common.Occupancy;
-
+using PepperDash.Essentials.Core.Fusion;
+
 namespace PepperDash.Essentials.Fusion
 {
     public class EssentialsHuddleVtc1FusionController : EssentialsHuddleSpaceFusionSystemControllerBase

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/BridgeBase.cs

@@ -190,11 +190,11 @@ namespace PepperDash.Essentials.Core.Bridges
                             var uo = Eisc.BooleanOutput[join].UserObject as Action<bool>;
                             if (uo != null)
                             {
-                                Debug.Console(1, this, "Executing Action: {0}", uo.ToString());
+                                Debug.Console(2, this, "Executing Action: {0}", uo.ToString());
                                 uo(Convert.ToBoolean(state));
                             }
                             else
-                                Debug.Console(1, this, "User Action is null.  Nothing to Execute");
+                                Debug.Console(2, this, "User Action is null.  Nothing to Execute");
                             break;
                         }
                     case "analog":
@@ -202,27 +202,27 @@ namespace PepperDash.Essentials.Core.Bridges
                             var uo = Eisc.BooleanOutput[join].UserObject as Action<ushort>;
                             if (uo != null)
                             {
-                                Debug.Console(1, this, "Executing Action: {0}", uo.ToString());
+                                Debug.Console(2, this, "Executing Action: {0}", uo.ToString());
                                 uo(Convert.ToUInt16(state));
                             }
                             else
-                                Debug.Console(1, this, "User Action is null.  Nothing to Execute"); break;
+                                Debug.Console(2, this, "User Action is null.  Nothing to Execute"); break;
                         }
                     case "serial":
                         {
                             var uo = Eisc.BooleanOutput[join].UserObject as Action<string>;
                             if (uo != null)
                             {
-                                Debug.Console(1, this, "Executing Action: {0}", uo.ToString());
+                                Debug.Console(2, this, "Executing Action: {0}", uo.ToString());
                                 uo(Convert.ToString(state));
                             }
                             else
-                                Debug.Console(1, this, "User Action is null.  Nothing to Execute");
+                                Debug.Console(2, this, "User Action is null.  Nothing to Execute");
                             break;
                         }
                     default:
                         {
-                            Debug.Console(1, "Unknown join type.  Use digital/serial/analog");
+                            Debug.Console(2, "Unknown join type.  Use digital/serial/analog");
                             break;
                         }
                 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/C2nRts/C2nRthsController.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.GeneralIO;
@@ -13,21 +14,30 @@ namespace PepperDash.Essentials.Core.CrestronIO
     [Description("Wrapper class for the C2N-RTHS sensor")]
     public class C2nRthsController : CrestronGenericBridgeableBaseDevice
     {
-        private readonly C2nRths _device;
+        private C2nRths _device;
 
         public IntFeedback TemperatureFeedback { get; private set; }
         public IntFeedback HumidityFeedback { get; private set; }
 
-        public C2nRthsController(string key, string name, GenericBase hardware) : base(key, name, hardware)
+        public C2nRthsController(string key, Func<DeviceConfig, C2nRths> preActivationFunc,
+            DeviceConfig config)
+            : base(key, config.Name)
         {
-            _device = hardware as C2nRths;
 
-            TemperatureFeedback = new IntFeedback(() => _device.TemperatureFeedback.UShortValue);
-            HumidityFeedback = new IntFeedback(() => _device.HumidityFeedback.UShortValue);
+            AddPreActivationAction(() =>
+            {
+                _device = preActivationFunc(config);
 
-            if (_device != null) _device.BaseEvent += DeviceOnBaseEvent;
+                RegisterCrestronGenericBase(_device);
+
+                TemperatureFeedback = new IntFeedback(() => _device.TemperatureFeedback.UShortValue);
+                HumidityFeedback = new IntFeedback(() => _device.HumidityFeedback.UShortValue);
+
+                if (_device != null) _device.BaseEvent += DeviceOnBaseEvent;
+            });
         }
 
+
         private void DeviceOnBaseEvent(GenericBase device, BaseEventArgs args)
         {
             switch (args.EventId)
@@ -76,24 +86,63 @@ namespace PepperDash.Essentials.Core.CrestronIO
             HumidityFeedback.LinkInputSig(trilist.UShortInput[joinMap.Humidity.JoinNumber]);
 
             trilist.StringInput[joinMap.Name.JoinNumber].StringValue = Name;
-        }
-    }
 
-    public class C2nRthsControllerFactory : EssentialsDeviceFactory<C2nRthsController>
-    {
-        public C2nRthsControllerFactory()
-        {
-            TypeNames = new List<string>() { "c2nrths" };
+            trilist.OnlineStatusChange += (d, args) =>
+            {
+                if (!args.DeviceOnLine) return;
+
+                UpdateFeedbacksWhenOnline();
+
+                trilist.StringInput[joinMap.Name.JoinNumber].StringValue = Name;
+            };
         }
 
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        private void UpdateFeedbacksWhenOnline()
         {
-            Debug.Console(1, "Factory Attempting to create new C2N-RTHS Device");
+            IsOnline.FireUpdate();
+            TemperatureFeedback.FireUpdate();
+            HumidityFeedback.FireUpdate();
+        }
 
+        #region PreActivation
+
+        private static C2nRths GetC2nRthsDevice(DeviceConfig dc)
+        {
             var control = CommFactory.GetControlPropertiesConfig(dc);
             var cresnetId = control.CresnetIdInt;
+            var branchId = control.ControlPortNumber;
+            var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
 
-            return new C2nRthsController(dc.Key, dc.Name, new C2nRths(cresnetId, Global.ControlSystem));
+            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new C2nRths", parentKey);
+                return new C2nRths(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 C2nRths", parentKey);
+                return new C2nRths(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+        #endregion
+
+        public class C2nRthsControllerFactory : EssentialsDeviceFactory<C2nRthsController>
+        {
+            public C2nRthsControllerFactory()
+            {
+                TypeNames = new List<string>() { "c2nrths" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new C2N-RTHS Device");
+
+                return new C2nRthsController(dc.Key, GetC2nRthsDevice, dc);
+            }
         }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/DinCenCn/DinCenCnController.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+
+namespace PepperDash.Essentials.Core
+{
+    public class DinCenCn2Controller : CrestronGenericBaseDevice, IHasCresnetBranches
+    {
+        private readonly DinCenCn2 _device;
+
+        public CrestronCollection<CresnetBranch> CresnetBranches
+        {
+            get {
+                return _device != null ? _device.Branches : null;
+            }
+        }
+
+        public DinCenCn2Controller(string key, string name, DinCenCn2 device, DeviceConfig config)
+            : base(key, name, device)
+        {
+            _device = device;
+        }
+
+        public class DinCenCn2ControllerFactory : EssentialsDeviceFactory<DinCenCn2Controller>
+        {
+            public DinCenCn2ControllerFactory()
+            {
+                TypeNames = new List<string>() { "dincencn2", "dincencn2poe", "din-cencn2", "din-cencn2-poe" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new C2N-RTHS Device");
+
+                var control = CommFactory.GetControlPropertiesConfig(dc);
+                var ipid = control.IpIdInt;
+
+                if (dc.Type.ToLower().Contains("poe"))
+                {
+                    return new DinCenCn2Controller(dc.Key, dc.Name, new DinCenCn2Poe(ipid, Global.ControlSystem), dc);
+                }
+
+                return new DinCenCn2Controller(dc.Key, dc.Name, new DinCenCn2(ipid, Global.ControlSystem), dc);
+            }
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/DinCenCn/IHasCresnetBranches.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+namespace PepperDash.Essentials.Core
+{
+    public interface IHasCresnetBranches
+    {
+        CrestronCollection<CresnetBranch> CresnetBranches { get; }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Relay/GenericRelayDevice.cs

@@ -31,13 +31,14 @@ namespace PepperDash.Essentials.Core.CrestronIO
             RelayOutput = relay;
             RelayOutput.Register();
 
-            RelayOutput.StateChange += new RelayEventHandler(RelayOutput_StateChange);
+            RelayOutput.StateChange += RelayOutput_StateChange;
         }
 
         public GenericRelayDevice(string key, string name, Func<IOPortConfig, Relay> postActivationFunc,
             IOPortConfig config)
             : base(key, name)
         {
+            OutputIsOnFeedback = new BoolFeedback(() => RelayOutput.State);
 
             AddPostActivationAction(() =>
             {
@@ -46,7 +47,6 @@ namespace PepperDash.Essentials.Core.CrestronIO
                 RelayOutput.Register();
 
                 RelayOutput.StateChange += RelayOutput_StateChange;
-
             });
         }
 

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/StatusSign/StatusSignController.cs

@@ -13,7 +13,7 @@ namespace PepperDash.Essentials.Core.CrestronIO
     [Description("Wrapper class for the Crestron StatusSign device")]
     public class StatusSignController : CrestronGenericBridgeableBaseDevice
     {
-        private readonly StatusSign _device;
+        private StatusSign _device;
 
         public BoolFeedback RedLedEnabledFeedback { get; private set; }
         public BoolFeedback GreenLedEnabledFeedback { get; private set; }
@@ -23,34 +23,40 @@ namespace PepperDash.Essentials.Core.CrestronIO
         public IntFeedback GreenLedBrightnessFeedback { get; private set; }
         public IntFeedback BlueLedBrightnessFeedback { get; private set; }
 
-        public StatusSignController(string key, string name, GenericBase hardware) : base(key, name, hardware)
+        public StatusSignController(string key, Func<DeviceConfig, StatusSign> preActivationFunc, DeviceConfig config) : base(key, config.Name)
         {
-            _device = hardware as StatusSign;
+            AddPreActivationAction(() =>
+            {
+                _device = preActivationFunc(config);
 
-            RedLedEnabledFeedback =
+                RegisterCrestronGenericBase(_device);
+
+                RedLedEnabledFeedback =
                 new BoolFeedback(
                     () =>
-                        _device.Leds[(uint) StatusSign.Led.eLedColor.Red]
-                            .ControlFeedback.BoolValue);
-            GreenLedEnabledFeedback =
-                new BoolFeedback(
-                    () =>
-                        _device.Leds[(uint) StatusSign.Led.eLedColor.Green]
-                            .ControlFeedback.BoolValue);
-            BlueLedEnabledFeedback =
-                new BoolFeedback(
-                    () =>
-                        _device.Leds[(uint) StatusSign.Led.eLedColor.Blue]
+                        _device.Leds[(uint)StatusSign.Led.eLedColor.Red]
                             .ControlFeedback.BoolValue);
+                GreenLedEnabledFeedback =
+                    new BoolFeedback(
+                        () =>
+                            _device.Leds[(uint)StatusSign.Led.eLedColor.Green]
+                                .ControlFeedback.BoolValue);
+                BlueLedEnabledFeedback =
+                    new BoolFeedback(
+                        () =>
+                            _device.Leds[(uint)StatusSign.Led.eLedColor.Blue]
+                                .ControlFeedback.BoolValue);
 
-            RedLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Red].BrightnessFeedback);
-            GreenLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Green].BrightnessFeedback);
-            BlueLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Blue].BrightnessFeedback);
+                RedLedBrightnessFeedback =
+                    new IntFeedback(() => (int)_device.Leds[(uint)StatusSign.Led.eLedColor.Red].BrightnessFeedback);
+                GreenLedBrightnessFeedback =
+                    new IntFeedback(() => (int)_device.Leds[(uint)StatusSign.Led.eLedColor.Green].BrightnessFeedback);
+                BlueLedBrightnessFeedback =
+                    new IntFeedback(() => (int)_device.Leds[(uint)StatusSign.Led.eLedColor.Blue].BrightnessFeedback);
 
-            if (_device != null) _device.BaseEvent += _device_BaseEvent;
+                if (_device != null) _device.BaseEvent += _device_BaseEvent;
+
+            });
         }
 
         void _device_BaseEvent(GenericBase device, BaseEventArgs args)
@@ -167,23 +173,51 @@ namespace PepperDash.Essentials.Core.CrestronIO
 
             device.SetColor(redBrightness, greenBrightness, blueBrightness);
         }
-    }
 
-    public class StatusSignControllerFactory : EssentialsDeviceFactory<StatusSignController>
-    {
-        public StatusSignControllerFactory()
+        #region PreActivation
+
+        private static StatusSign GetStatusSignDevice(DeviceConfig dc)
         {
-            TypeNames = new List<string>() { "statussign" };
-        }
-
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
-        {
-            Debug.Console(1, "Factory Attempting to create new StatusSign Device");
-
             var control = CommFactory.GetControlPropertiesConfig(dc);
             var cresnetId = control.CresnetIdInt;
+            var branchId = control.ControlPortNumber;
+            var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
 
-            return new StatusSignController(dc.Key, dc.Name, new StatusSign(cresnetId, Global.ControlSystem));
+            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new StatusSign", parentKey);
+                return new StatusSign(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 StatusSign", parentKey);
+                return new StatusSign(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+        #endregion
+
+        public class StatusSignControllerFactory : EssentialsDeviceFactory<StatusSignController>
+        {
+            public StatusSignControllerFactory()
+            {
+                TypeNames = new List<string>() { "statussign" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new StatusSign Device");
+
+                var control = CommFactory.GetControlPropertiesConfig(dc);
+                var cresnetId = control.CresnetIdInt;
+
+                return new StatusSignController(dc.Key, GetStatusSignDevice, dc);
+            }
         }
     }
+
+    
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron/CrestronGenericBaseDevice.cs

@@ -1,7 +1,9 @@
-using System.Linq;
+using System;
+using System.Linq;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
 using PepperDash.Core;
+using PepperDash.Core.JsonStandardObjects;
 using PepperDash.Essentials.Core.Bridges;
 
 namespace PepperDash.Essentials.Core
@@ -11,7 +13,7 @@ namespace PepperDash.Essentials.Core
 	/// </summary>
 	public abstract class CrestronGenericBaseDevice : EssentialsDevice, IOnline, IHasFeedback, ICommunicationMonitor, IUsageTracking
 	{
-		public virtual GenericBase Hardware { get; protected set; }
+	    protected GenericBase Hardware;
 
         /// <summary>
         /// Returns a list containing the Outputs that we want to expose.
@@ -42,6 +44,24 @@ namespace PepperDash.Essentials.Core
             CommunicationMonitor = new CrestronGenericBaseCommunicationMonitor(this, hardware, 120000, 300000);
         }
 
+        protected CrestronGenericBaseDevice(string key, string name)
+            : base(key, name)
+        {
+            Feedbacks = new FeedbackCollection<Feedback>();
+
+        }
+
+	    protected void RegisterCrestronGenericBase(GenericBase hardware)
+	    {
+            Hardware = hardware;
+            IsOnline = new BoolFeedback("IsOnlineFeedback", () => Hardware.IsOnline);
+            IsRegistered = new BoolFeedback("IsRegistered", () => Hardware.Registered);
+            IpConnectionsText = new StringFeedback("IpConnectionsText", () => Hardware.ConnectedIpList != null ? string.Join(",", Hardware.ConnectedIpList.Select(cip => cip.DeviceIpAddress).ToArray()) : string.Empty);
+            AddToFeedbackList(IsOnline, IpConnectionsText);
+
+            CommunicationMonitor = new CrestronGenericBaseCommunicationMonitor(this, hardware, 120000, 300000);
+	    }
+
 		/// <summary>
 		/// Make sure that overriding classes call this!
 		/// Registers the Crestron device, connects up to the base events, starts communication monitor
@@ -135,6 +155,11 @@ namespace PepperDash.Essentials.Core
         {
         }
 
+        protected CrestronGenericBridgeableBaseDevice(string key, string name)
+            : base(key, name)
+        {
+        }
+
 
         public abstract void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge);
     }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/DeviceManager.cs

@@ -238,6 +238,42 @@ namespace PepperDash.Essentials.Core
 		    }
 		}
 
+	    public static void AddDevice(IEnumerable<IKeyed> devicesToAdd)
+	    {
+	        try
+	        {
+	            if (!DeviceCriticalSection.TryEnter())
+	            {
+	                Debug.Console(0, Debug.ErrorLogLevel.Error,
+	                    "Currently unable to add devices to Device Manager. Please try again");
+	                return;
+	            }
+	            if (!AddDeviceEnabled)
+	            {
+	                Debug.Console(0, Debug.ErrorLogLevel.Error,
+	                    "All devices have been activated. Adding new devices is not allowed.");
+	                return;
+	            }
+
+	            foreach (var dev in devicesToAdd)
+	            {
+	                try
+	                {
+	                    Devices.Add(dev.Key, dev);
+	                }
+	                catch (ArgumentException ex)
+	                {
+	                    Debug.Console(0, "Error adding device with key {0} to Device Manager: {1}\r\nStack Trace: {2}",
+	                        dev.Key, ex.Message, ex.StackTrace);
+	                }
+	            }
+	        }
+	        finally
+	        {
+	            DeviceCriticalSection.Leave();
+	        }
+	    }
+
 		public static void RemoveDevice(IKeyed newDev)
 		{
 		    try

essentials-framework/Essentials Core/PepperDashEssentialsBase/Factory/ReadyEventArgs.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash_Essentials_Core
+{
+    public class IsReadyEventArgs : EventArgs
+    {
+        public bool IsReady { get; set; }
+
+        public IsReadyEventArgs(bool data)
+        {
+            IsReady = data;
+        }
+    }
+
+    public interface IHasReady
+    {
+        event EventHandler<IsReadyEventArgs> IsReadyEvent;
+        bool IsReady { get; }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Gateways/CenRfgwController.cs

@@ -6,134 +6,192 @@ using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.Gateways;
 using Newtonsoft.Json;
+using Crestron.SimplSharpPro.DeviceSupport;
 
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
+using PepperDash_Essentials_Core;
 
 
-namespace PepperDash.Essentials.Core
+namespace PepperDash.Essentials.Core
 {
-    [Description("Wrapper class for Crestron Infinet-EX Gateways")]
-	public class CenRfgwController : CrestronGenericBaseDevice
-	{
-        private GatewayBase _Gateway;
-        public GatewayBase GateWay { get { return _Gateway; } }
-
-		/// <summary>
-		/// Constructor for the on-board gateway
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
-		public CenRfgwController(string key, string name, GatewayBase gateway) :
-			base(key, name, gateway)
-		{
-            _Gateway = gateway;
-		}
-
-		public static CenRfgwController GetNewExGatewayController(string key, string name, ushort ipId, ushort cresnetId,  string gatewayType)
-		{
-			eExGatewayType type = (eExGatewayType)Enum.Parse(typeof(eExGatewayType), gatewayType, true);
-			try
-			{
-				var cs = Global.ControlSystem;
-
-				GatewayBase gw = null;
-				switch (type)
-				{
-					case eExGatewayType.Ethernet:
-                        gw = new CenRfgwEx(ipId, cs);
-						break;
-					case eExGatewayType.EthernetShared:
-                        gw = new CenRfgwExEthernetSharable(ipId, cs);
-						break;
-					case eExGatewayType.Cresnet:
-                        gw = new CenRfgwExCresnet(cresnetId, cs);
-						break;
-				}
-				return new CenRfgwController(key, name, gw);
-			}
-			catch (Exception)
-			{
-                Debug.Console(0, "ERROR: Cannot create EX Gateway, id {0}, type {1}", type == eExGatewayType.Cresnet ? cresnetId : ipId, gatewayType);
-				return null;
-			}
-		}
-		public static CenRfgwController GetNewErGatewayController(string key, string name, ushort ipId, ushort cresnetId, string gatewayType)
-		{
-			eExGatewayType type = (eExGatewayType)Enum.Parse(typeof(eExGatewayType), gatewayType, true);
-			try
-			{
-				var cs = Global.ControlSystem;
-
-				GatewayBase gw = null;
-				switch (type)
-				{
-					case eExGatewayType.Ethernet:
-						gw = new CenErfgwPoe(ipId, cs);
-						break;
-					case eExGatewayType.EthernetShared:
-                        gw = new CenErfgwPoeEthernetSharable(ipId, cs);
-						break;
-					case eExGatewayType.Cresnet:
-                        gw = new CenErfgwPoeCresnet(cresnetId, cs);
-						break;
-				}
-				return new CenRfgwController(key, name, gw);
-			}
-			catch (Exception)
-			{
-                Debug.Console(0, "ERROR: Cannot create ER Gateway, id {0}, type {1}", type== eExGatewayType.Cresnet ? cresnetId : ipId, gatewayType);
-				return null;
-			}
-		}
-
-	}
-
-
-
-	public enum eExGatewayType
-	{
-		Ethernet, EthernetShared, Cresnet
-    }
+    [Description("Wrapper class for Crestron Infinet-EX Gateways")]
+    public class CenRfgwController : CrestronGenericBaseDevice, IHasReady
+    {
+        public event EventHandler<IsReadyEventArgs> IsReadyEvent;
 
+        public bool IsReady { get; private set; }
 
-    #region Factory
-    public class CenRfgwControllerFactory : EssentialsDeviceFactory<CenRfgwController>
-    {
-        public CenRfgwControllerFactory()
-        {
-            TypeNames = new List<string>() { "cenrfgwex", "cenerfgwpoe" };
-        }
+        private GatewayBase _gateway;
 
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        public GatewayBase GateWay
         {
-
-            Debug.Console(1, "Factory Attempting to create new CEN-GWEXER Device");
-
-            var props = JsonConvert.DeserializeObject<EssentialsRfGatewayConfig>(dc.Properties.ToString());
-
-            var type = dc.Type.ToLower();
-            var control = props.Control;
-            var ipid = control.IpIdInt;
-            var cresnetId = control.CresnetIdInt;
-            var gatewayType = props.GatewayType;
-
-            switch (type)
-            {
-                case ("cenrfgwex"):
-                    return CenRfgwController.GetNewExGatewayController(dc.Key, dc.Name,
-                        (ushort)ipid, (ushort)cresnetId, gatewayType);
-                case ("cenerfgwpoe"):
-                    return CenRfgwController.GetNewErGatewayController(dc.Key, dc.Name,
-                        (ushort)ipid, (ushort)cresnetId, gatewayType);
-                default:
-                    return null;
-            }
+            get { return _gateway; }
         }
+
+        /// <summary>
+        /// Constructor for the on-board gateway
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="gateway"></param>
+        public CenRfgwController(string key, string name, GatewayBase gateway) :
+            base(key, name, gateway)
+        {
+            _gateway = gateway;
+            IsReady = true;
+            FireIsReadyEvent(IsReady);
+        }
+
+        public CenRfgwController(string key, Func<DeviceConfig, GatewayBase> preActivationFunc, DeviceConfig config) :
+            base(key, config.Name)
+        {
+            IsReady = false;
+            FireIsReadyEvent(IsReady);
+            AddPreActivationAction(() =>
+            {
+                _gateway = preActivationFunc(config);
+
+                IsReady = true;
+                RegisterCrestronGenericBase(_gateway);
+                FireIsReadyEvent(IsReady);
+
+            });
+        }
+
+        public static GatewayBase GetNewIpRfGateway(DeviceConfig dc)
+        {
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+            var type = dc.Type;
+            var ipId = control.IpIdInt;
+
+            if (type.Equals("cenrfgwex", StringComparison.InvariantCultureIgnoreCase))
+            {
+                return new CenRfgwEx(ipId, Global.ControlSystem);
+            }
+            if (type.Equals("cenerfgwpoe", StringComparison.InvariantCultureIgnoreCase))
+            {
+                return new CenErfgwPoe(ipId, Global.ControlSystem);
+            }
+            return null;
+        }
+
+        private void FireIsReadyEvent(bool data)
+        {
+            var handler = IsReadyEvent;
+            if (handler == null) return;
+
+            handler(this, new IsReadyEventArgs(data));
+
+        }
+
+        public static GatewayBase GetNewSharedIpRfGateway(DeviceConfig dc)
+        {
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+            var ipId = control.IpIdInt;
+
+            if (dc.Type.Equals("cenrfgwex", StringComparison.InvariantCultureIgnoreCase))
+            {
+                return new CenRfgwExEthernetSharable(ipId, Global.ControlSystem);
+            }
+            if (dc.Type.Equals("cenerfgwpoe", StringComparison.InvariantCultureIgnoreCase))
+            {
+                return new CenErfgwPoeEthernetSharable(ipId, Global.ControlSystem);
+            }
+            return null;
+        }
+
+        public static GatewayBase GetCenRfgwCresnetController(DeviceConfig dc)
+        {
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+            var type = dc.Type;
+            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 CenRfgw", parentKey);
+                if (type.Equals("cenerfgwpoe", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return new CenErfgwPoeCresnet(cresnetId, Global.ControlSystem);
+                }
+                if (type.Equals("cenrfgwex", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return new CenRfgwExCresnet(cresnetId, Global.ControlSystem);
+                }
+            }
+            var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as ICresnetBridge;
+
+            if (cresnetBridge != null)
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new CenRfgw", parentKey);
+
+                if (type.Equals("cenerfgwpoe", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return new CenErfgwPoeCresnet(cresnetId, cresnetBridge.Branches[branchId]);
+                }
+                if (type.Equals("cenrfgwex", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return new CenRfgwExCresnet(cresnetId, cresnetBridge.Branches[branchId]);
+                }
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+
+
+
+
+
+
+
+        public enum EExGatewayType
+        {
+            Ethernet,
+            EthernetShared,
+            Cresnet
+        }
+
+
+        #region Factory
+
+        public class CenRfgwControllerFactory : EssentialsDeviceFactory<CenRfgwController>
+        {
+            public CenRfgwControllerFactory()
+            {
+                TypeNames = new List<string> {"cenrfgwex", "cenerfgwpoe"};
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+
+                Debug.Console(1, "Factory Attempting to create new CEN-GWEXER Device");
+
+                var props = JsonConvert.DeserializeObject<EssentialsRfGatewayConfig>(dc.Properties.ToString());
+
+                EExGatewayType gatewayType =
+                    (EExGatewayType) Enum.Parse(typeof (EExGatewayType), props.GatewayType, true);
+
+                switch (gatewayType)
+                {
+                    case (EExGatewayType.Ethernet):
+                        return new CenRfgwController(dc.Key, dc.Name, GetNewIpRfGateway(dc));
+                    case (EExGatewayType.EthernetShared):
+                        return new CenRfgwController(dc.Key, dc.Name, GetNewSharedIpRfGateway(dc));
+                    case (EExGatewayType.Cresnet):
+                        return new CenRfgwController(dc.Key, GetCenRfgwCresnetController, dc);
+                }
+                return null;
+            }
+        }
+
+        #endregion
     }
-    #endregion
+
+    
+}
 
 
-}

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

@@ -11,7 +11,7 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Bridges;
 
-namespace PepperDash.Essentials.Devices.Common.Occupancy
+namespace PepperDash.Essentials.Core
 {
     [Description("Wrapper class for CEN-ODT-C-POE")]
     public class CenOdtOccupancySensorBaseController : CrestronGenericBridgeableBaseDevice, IOccupancyStatusProvider

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

@@ -11,7 +11,7 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Bridges;
 
-namespace PepperDash.Essentials.Devices.Common.Occupancy
+namespace PepperDash.Essentials.Core
 {
     [Description("Wrapper class for Single Technology GLS Occupancy Sensors")]
     public class GlsOccupancySensorBaseController : CrestronGenericBridgeableBaseDevice, IOccupancyStatusProvider
@@ -55,11 +55,29 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
             }
         }
 
-        public GlsOccupancySensorBaseController(string key, string name, GlsOccupancySensorBase sensor)
-            : base(key, name, sensor)
+        public GlsOccupancySensorBaseController(string key, Func<DeviceConfig, GlsOccupancySensorBase> preActivationFunc,
+            DeviceConfig config)
+            : base(key, config.Name)
         {
-            OccSensor = sensor;
-            
+
+
+            AddPreActivationAction(() =>
+            {
+                OccSensor = preActivationFunc(config);
+
+                RegisterCrestronGenericBase(OccSensor);
+
+                RegisterGlsOdtSensorBaseController(OccSensor);
+
+            });
+        }
+
+        public GlsOccupancySensorBaseController(string key, string name) : base(key, name) {}
+
+        protected void RegisterGlsOdtSensorBaseController(GlsOccupancySensorBase occSensor)
+        {
+            OccSensor = occSensor;
+
             RoomIsOccupiedFeedback = new BoolFeedback(RoomIsOccupiedFeedbackFunc);
 
             PirSensorEnabledFeedback = new BoolFeedback(() => OccSensor.PirEnabledFeedback.BoolValue);
@@ -68,15 +86,18 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
 
             ShortTimeoutEnabledFeedback = new BoolFeedback(() => OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
 
-            PirSensitivityInVacantStateFeedback = new IntFeedback(() => OccSensor.PirSensitivityInVacantStateFeedback.UShortValue);
+            PirSensitivityInVacantStateFeedback =
+                new IntFeedback(() => OccSensor.PirSensitivityInVacantStateFeedback.UShortValue);
 
-            PirSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.PirSensitivityInOccupiedStateFeedback.UShortValue);
+            PirSensitivityInOccupiedStateFeedback =
+                new IntFeedback(() => OccSensor.PirSensitivityInOccupiedStateFeedback.UShortValue);
 
             CurrentTimeoutFeedback = new IntFeedback(() => OccSensor.CurrentTimeoutFeedback.UShortValue);
 
             LocalTimoutFeedback = new IntFeedback(() => OccSensor.LocalTimeoutFeedback.UShortValue);
 
-            GraceOccupancyDetectedFeedback = new BoolFeedback(() => OccSensor.GraceOccupancyDetectedFeedback.BoolValue);
+            GraceOccupancyDetectedFeedback =
+                new BoolFeedback(() => OccSensor.GraceOccupancyDetectedFeedback.BoolValue);
 
             RawOccupancyFeedback = new BoolFeedback(() => OccSensor.RawOccupancyFeedback.BoolValue);
 
@@ -84,9 +105,9 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
 
             ExternalPhotoSensorValue = new IntFeedback(() => OccSensor.ExternalPhotoSensorValueFeedback.UShortValue);
 
-            OccSensor.BaseEvent += new Crestron.SimplSharpPro.BaseEventHandler(OccSensor_BaseEvent);
+            OccSensor.BaseEvent += OccSensor_BaseEvent;
 
-            OccSensor.GlsOccupancySensorChange += new GlsOccupancySensorChangeEventHandler(OccSensor_GlsOccupancySensorChange);
+            OccSensor.GlsOccupancySensorChange += OccSensor_GlsOccupancySensorChange;
         }
 
 
@@ -97,40 +118,56 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
         /// <param name="args"></param>
         protected virtual void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
         {
-            if (args.EventId == GlsOccupancySensorBase.PirEnabledFeedbackEventId)
-                PirSensorEnabledFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.LedFlashEnabledFeedbackEventId)
-                LedFlashEnabledFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.ShortTimeoutEnabledFeedbackEventId)
-                ShortTimeoutEnabledFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.PirSensitivityInOccupiedStateFeedbackEventId)
-                PirSensitivityInOccupiedStateFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.PirSensitivityInVacantStateFeedbackEventId)
-                PirSensitivityInVacantStateFeedback.FireUpdate();
+            switch (args.EventId)
+            {
+                case GlsOccupancySensorBase.PirEnabledFeedbackEventId:
+                    PirSensorEnabledFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.LedFlashEnabledFeedbackEventId:
+                    LedFlashEnabledFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.ShortTimeoutEnabledFeedbackEventId:
+                    ShortTimeoutEnabledFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.PirSensitivityInOccupiedStateFeedbackEventId:
+                    PirSensitivityInOccupiedStateFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.PirSensitivityInVacantStateFeedbackEventId:
+                    PirSensitivityInVacantStateFeedback.FireUpdate();
+                    break;
+            }
         }
 
         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)
+            switch (args.EventId)
             {
-                Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
-                RoomIsOccupiedFeedback.FireUpdate();
+                case Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId:
+                case Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId:
+                    Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
+                    RoomIsOccupiedFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.TimeoutFeedbackEventId:
+                    CurrentTimeoutFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.TimeoutLocalFeedbackEventId:
+                    LocalTimoutFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.GraceOccupancyDetectedFeedbackEventId:
+                    GraceOccupancyDetectedFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.RawOccupancyFeedbackEventId:
+                    RawOccupancyFeedback.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.InternalPhotoSensorValueFeedbackEventId:
+                    InternalPhotoSensorValue.FireUpdate();
+                    break;
+                case GlsOccupancySensorBase.ExternalPhotoSensorValueFeedbackEventId:
+                    ExternalPhotoSensorValue.FireUpdate();
+                    break;
             }
-            else if (args.EventId == GlsOccupancySensorBase.TimeoutFeedbackEventId)
-                CurrentTimeoutFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.TimeoutLocalFeedbackEventId)
-                LocalTimoutFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.GraceOccupancyDetectedFeedbackEventId)
-                GraceOccupancyDetectedFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyFeedbackEventId)
-                RawOccupancyFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.InternalPhotoSensorValueFeedbackEventId)
-                InternalPhotoSensorValue.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.ExternalPhotoSensorValueFeedbackEventId)
-                ExternalPhotoSensorValue.FireUpdate();
         }
 
         public void SetTestMode(bool mode)
@@ -373,27 +410,51 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
         {
             LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
         }
-    }
 
-    public class GlsOccupancySensorBaseControllerFactory : EssentialsDeviceFactory<GlsOccupancySensorBaseController>
-    {
-        public GlsOccupancySensorBaseControllerFactory()
+        #region PreActivation
+
+        private static GlsOirCCn GetGlsOirCCn(DeviceConfig dc)
         {
-            TypeNames = new List<string>() { "glsoirccn" };
+            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 GlsOirCCn", parentKey);
+                return new GlsOirCCn(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 GlsOirCCn", parentKey);
+                return new GlsOirCCn(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
         }
+        #endregion
 
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        public class GlsOccupancySensorBaseControllerFactory : EssentialsDeviceFactory<GlsOccupancySensorBaseController>
         {
-            Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
+            public GlsOccupancySensorBaseControllerFactory()
+            {
+                TypeNames = new List<string>() { "glsoirccn" };
+            }
 
-            var key = dc.Key;
-            var name = dc.Name;
-            var comm = CommFactory.GetControlPropertiesConfig(dc);
 
-            GlsOccupancySensorBase occSensor = new GlsOirCCn(comm.CresnetIdInt, Global.ControlSystem);
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
+
+                return new GlsOccupancySensorBaseController(dc.Key, GetGlsOirCCn, dc);
+            }
 
-            return new GlsOccupancySensorBaseController(key, name, occSensor);
         }
     }
 
+    
+
 }

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

@@ -11,7 +11,7 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Bridges;
 
-namespace PepperDash.Essentials.Devices.Common.Occupancy
+namespace PepperDash.Essentials.Core
 {
     [Description("Wrapper class for Dual Technology GLS Occupancy Sensors")]
     public class GlsOdtOccupancySensorController : GlsOccupancySensorBaseController
@@ -35,26 +35,35 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
         public BoolFeedback RawOccupancyUsFeedback { get; private set; }
 
 
-        public GlsOdtOccupancySensorController(string key, string name, GlsOdtCCn sensor)
-            : base(key, name, sensor)
+        public GlsOdtOccupancySensorController(string key, Func<DeviceConfig, GlsOdtCCn> preActivationFunc,
+            DeviceConfig config)
+            : base(key, config.Name)
         {
-            OccSensor = sensor;
+            AddPreActivationAction(() =>
+            {
+                OccSensor = preActivationFunc(config);
 
-            AndWhenVacatedFeedback = new BoolFeedback(() => OccSensor.AndWhenVacatedFeedback.BoolValue);
+                RegisterCrestronGenericBase(OccSensor);
 
-            OrWhenVacatedFeedback = new BoolFeedback(() => OccSensor.OrWhenVacatedFeedback.BoolValue);
+                RegisterGlsOdtSensorBaseController(OccSensor);
 
-            UltrasonicAEnabledFeedback = new BoolFeedback(() => OccSensor.UsAEnabledFeedback.BoolValue);
+                AndWhenVacatedFeedback = new BoolFeedback(() => OccSensor.AndWhenVacatedFeedback.BoolValue);
 
-            UltrasonicBEnabledFeedback = new BoolFeedback(() => OccSensor.UsBEnabledFeedback.BoolValue);
+                OrWhenVacatedFeedback = new BoolFeedback(() => OccSensor.OrWhenVacatedFeedback.BoolValue);
 
-            RawOccupancyPirFeedback = new BoolFeedback(() => OccSensor.RawOccupancyPirFeedback.BoolValue);
+                UltrasonicAEnabledFeedback = new BoolFeedback(() => OccSensor.UsAEnabledFeedback.BoolValue);
 
-            RawOccupancyUsFeedback = new BoolFeedback(() => OccSensor.RawOccupancyUsFeedback.BoolValue);
+                UltrasonicBEnabledFeedback = new BoolFeedback(() => OccSensor.UsBEnabledFeedback.BoolValue);
 
-            UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInVacantStateFeedback.UShortValue);
+                RawOccupancyPirFeedback = new BoolFeedback(() => OccSensor.RawOccupancyPirFeedback.BoolValue);
 
-            UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInOccupiedStateFeedback.UShortValue);
+                RawOccupancyUsFeedback = new BoolFeedback(() => OccSensor.RawOccupancyUsFeedback.BoolValue);
+
+                UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInVacantStateFeedback.UShortValue);
+
+                UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInOccupiedStateFeedback.UShortValue);
+
+            });       
         }
 
         /// <summary>
@@ -160,38 +169,51 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
         {
             LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
         }
-    }
 
-    public class GlsOdtOccupancySensorControllerFactory : EssentialsDeviceFactory<GlsOdtOccupancySensorController>
-    {
-        public GlsOdtOccupancySensorControllerFactory()
+        #region PreActivation
+
+        private static GlsOdtCCn GetGlsOdtCCn(DeviceConfig dc)
         {
-            TypeNames = new List<string>() { "glsodtccn" };
-        }
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+            var cresnetId = control.CresnetIdInt;
+            var branchId = control.ControlPortNumber;
+            var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
 
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
-        {
-            Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
-
-            var typeName = dc.Type.ToLower();
-            var key = dc.Key;
-            var name = dc.Name;
-            var comm = CommFactory.GetControlPropertiesConfig(dc);
-
-            var occSensor = new GlsOdtCCn(comm.CresnetIdInt, Global.ControlSystem);
-
-            if (occSensor != null)
+            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
             {
-                return new GlsOdtOccupancySensorController(key, name, occSensor);
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOdtCCn", parentKey);
+                return new GlsOdtCCn(cresnetId, Global.ControlSystem);
             }
-            else
+            var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as IHasCresnetBranches;
+
+            if (cresnetBridge != null)
             {
-                Debug.Console(0, "ERROR: Unable to create Occupancy Sensor Device. Key: '{0}'", key);
-                return null;
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOdtCCn", parentKey);
+                return new GlsOdtCCn(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+        #endregion
+
+        public class GlsOdtOccupancySensorControllerFactory : EssentialsDeviceFactory<GlsOdtOccupancySensorController>
+        {
+            public GlsOdtOccupancySensorControllerFactory()
+            {
+                TypeNames = new List<string>() { "glsodtccn" };
             }
 
 
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
+
+                return new GlsOdtOccupancySensorController(dc.Key, GetGlsOdtCCn, dc);
+            }
+
         }
     }
 
+
+
 }

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

@@ -5,9 +5,9 @@ using System.Text;
 using Crestron.SimplSharp;
 
 using PepperDash.Core;
-using PepperDash.Essentials.Core;
-
-namespace PepperDash.Essentials.Devices.Common.Occupancy
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Core
 {
     /// <summary>
     /// Aggregates the RoomIsOccupied feedbacks of one or more IOccupancyStatusProvider objects

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

@@ -7,12 +7,28 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash_Essentials_Core.Bridges.JoinMaps;
 
-namespace PepperDash.Essentials.Devices.Common.PartitionSensor
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.Gateways;
+using Newtonsoft.Json;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash_Essentials_Core;
+
+namespace PepperDash.Essentials.Core
 {
 	[Description("Wrapper class for GLS Cresnet Partition Sensor")]
 	public class GlsPartitionSensorController : CrestronGenericBridgeableBaseDevice
 	{
-		private readonly GlsPartCn _partitionSensor;
+		private GlsPartCn _partitionSensor;
 
 		public StringFeedback NameFeedback { get; private set; }
 		public BoolFeedback EnableFeedback { get; private set; }
@@ -25,27 +41,26 @@ namespace PepperDash.Essentials.Devices.Common.PartitionSensor
 		public bool TestPartitionSensedFeedback { get; private set; }
 		public int TestSensitivityFeedback { get; private set; }
 
-		/// <summary>
-		/// Constructor
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
-		/// <param name="hardware"></param>
-		public GlsPartitionSensorController(string key, string name, GlsPartCn hardware)
-			: base(key, name, hardware)
+
+		public GlsPartitionSensorController(string key, Func<DeviceConfig, GlsPartCn> preActivationFunc, DeviceConfig config)
+			: base(key, config.Name)
 		{
-			_partitionSensor = hardware;
+            AddPreActivationAction(() =>
+            {
+                _partitionSensor = preActivationFunc(config);
 
-			NameFeedback = new StringFeedback(() => Name);
-			EnableFeedback = new BoolFeedback(() => _partitionSensor.EnableFeedback.BoolValue);
-			PartitionSensedFeedback = new BoolFeedback(() => _partitionSensor.PartitionSensedFeedback.BoolValue);
-			PartitionNotSensedFeedback = new BoolFeedback(() => _partitionSensor.PartitionNotSensedFeedback.BoolValue);
-			SensitivityFeedback = new IntFeedback(() => _partitionSensor.SensitivityFeedback.UShortValue);
+                RegisterCrestronGenericBase(_partitionSensor);
 
-			if (_partitionSensor != null) _partitionSensor.BaseEvent += PartitionSensor_BaseEvent;
+                NameFeedback = new StringFeedback(() => Name);
+                EnableFeedback = new BoolFeedback(() => _partitionSensor.EnableFeedback.BoolValue);
+                PartitionSensedFeedback = new BoolFeedback(() => _partitionSensor.PartitionSensedFeedback.BoolValue);
+                PartitionNotSensedFeedback = new BoolFeedback(() => _partitionSensor.PartitionNotSensedFeedback.BoolValue);
+                SensitivityFeedback = new IntFeedback(() => _partitionSensor.SensitivityFeedback.UShortValue);
+
+                if (_partitionSensor != null) _partitionSensor.BaseEvent += PartitionSensor_BaseEvent;
+            });
 		}
 
-
 		private void PartitionSensor_BaseEvent(GenericBase device, BaseEventArgs args)
 		{
 			Debug.Console(2, this, "EventId: {0}, Index: {1}", args.EventId, args.Index);
@@ -218,5 +233,48 @@ namespace PepperDash.Essentials.Devices.Common.PartitionSensor
 			PartitionNotSensedFeedback.FireUpdate();
 			SensitivityFeedback.FireUpdate();
 		}
+
+        #region PreActivation
+
+        private static GlsPartCn GetGlsPartCnDevice(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 GlsPartCn", parentKey);
+                return new GlsPartCn(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 GlsPartCn", parentKey);
+                return new GlsPartCn(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+        #endregion
+
+
+        public class GlsPartitionSensorControllerFactory : EssentialsDeviceFactory<GlsPartitionSensorController>
+        {
+            public GlsPartitionSensorControllerFactory()
+            {
+                TypeNames = new List<string>() { "glspartcn" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new C2N-RTHS Device");
+
+                return new GlsPartitionSensorController(dc.Key, GetGlsPartCnDevice, dc);
+            }
+        }
+
 	}
 }

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

@@ -172,6 +172,8 @@
     </Compile>
     <Compile Include="Crestron IO\Cards\CenCi33Controller.cs" />
     <Compile Include="Crestron IO\Cards\InternalCardCageController.cs" />
+    <Compile Include="Crestron IO\DinCenCn\DinCenCnController.cs" />
+    <Compile Include="Crestron IO\DinCenCn\IHasCresnetBranches.cs" />
     <Compile Include="Crestron IO\Inputs\CenIoDigIn104Controller.cs" />
     <Compile Include="Crestron IO\Inputs\GenericDigitalInputDevice.cs" />
     <Compile Include="Crestron IO\Inputs\GenericVersiportInputDevice.cs" />
@@ -193,6 +195,7 @@
     <Compile Include="Devices\VolumeDeviceChangeEventArgs.cs" />
     <Compile Include="Factory\DeviceFactory.cs" />
     <Compile Include="Factory\IDeviceFactory.cs" />
+    <Compile Include="Factory\ReadyEventArgs.cs" />
     <Compile Include="Feedbacks\BoolFeedback.cs" />
     <Compile Include="Feedbacks\FeedbackCollection.cs" />
     <Compile Include="Feedbacks\FeedbackEventArgs.cs" />
@@ -214,6 +217,11 @@
     <Compile Include="Monitoring\SystemMonitorController.cs" />
     <Compile Include="Microphone Privacy\MicrophonePrivacyController.cs" />
     <Compile Include="Microphone Privacy\MicrophonePrivacyControllerConfig.cs" />
+    <Compile Include="Occupancy\CenOdtOccupancySensorBaseController.cs" />
+    <Compile Include="Occupancy\GlsOccupancySensorBaseController.cs" />
+    <Compile Include="Occupancy\GlsOdtOccupancySensorController.cs" />
+    <Compile Include="Occupancy\IOccupancyStatusProviderAggregator.cs" />
+    <Compile Include="PartitionSensor\GlsPartitionSensorController.cs" />
     <Compile Include="Plugins\PluginLoader.cs" />
     <Compile Include="Presets\PresetBase.cs" />
     <Compile Include="Plugins\IPluginDeviceFactory.cs" />

essentials-framework/Essentials Core/PepperDashEssentialsBase/Remotes/Hrxx0WirelessRemoteController.cs

@@ -21,30 +21,70 @@ namespace PepperDash.Essentials.Core
     [Description("Wrapper class for all HR-Series remotes")]
     public class Hrxx0WirelessRemoteController : EssentialsBridgeableDevice, IHasFeedback
     {
+        private CenRfgwController _gateway;
+
         private Hr1x0WirelessRemoteBase _remote;
 
         public FeedbackCollection<Feedback> Feedbacks { get; set; }
 
         public CrestronCollection<Button> Buttons { get { return _remote.Button; } }
 
+        private DeviceConfig _config;
+
         public Hrxx0WirelessRemoteController(string key, Func<DeviceConfig, Hr1x0WirelessRemoteBase> preActivationFunc, 
             DeviceConfig config)
             : base(key, config.Name)
         {
             Feedbacks = new FeedbackCollection<Feedback>();
 
-            AddPreActivationAction(() =>
+            var props = JsonConvert.DeserializeObject<CrestronRemotePropertiesConfig>(config.Properties.ToString());
+
+            var type = config.Type;
+            var rfId = (uint)props.Control.InfinetIdInt;
+            _config = config;
+
+            GatewayBase gateway;
+
+            if (props.GatewayDeviceKey == "processor")
             {
-                _remote = preActivationFunc(config);
+                gateway = Global.ControlSystem.ControllerRFGatewayDevice;
+            }
 
-                _remote.ButtonStateChange += new ButtonEventHandler(_remote_ButtonStateChange);
+            else
+            {
+                var gatewayDev = DeviceManager.GetDeviceForKey(props.GatewayDeviceKey) as CenRfgwController;
+                if (gatewayDev == null)
+                {
+                    Debug.Console(0, "GetHr1x0WirelessRemote: Device '{0}' is not a valid device", props.GatewayDeviceKey);
+                }
+                if (gatewayDev != null)
+                {
+                    Debug.Console(0, "GetHr1x0WirelessRemote: Device '{0}' is a valid device", props.GatewayDeviceKey);
+                    gateway = gatewayDev.GateWay;
+                    _gateway = gatewayDev;
+                }
+            }
 
-                Feedbacks.Add(new BoolFeedback("BatteryCritical", () => _remote.BatteryCriticalFeedback.BoolValue));
-                Feedbacks.Add(new BoolFeedback("BatteryLow", () => _remote.BatteryLowFeedback.BoolValue));
-                Feedbacks.Add(new IntFeedback("BatteryVoltage", () => _remote.BatteryVoltageFeedback.UShortValue));
+            if (_gateway == null) return;
 
-                _remote.BaseEvent += new BaseEventHandler(_remote_BaseEvent);
-            });
+            _gateway.IsReadyEvent += _gateway_IsReadyEvent;
+            if (_gateway.IsReady)
+            {
+                AddPreActivationAction(() =>
+                {
+                    _remote = preActivationFunc(config);
+
+                    RegisterEvents();
+                });
+            }
+        }
+
+        void _gateway_IsReadyEvent(object sender, PepperDash_Essentials_Core.IsReadyEventArgs e)
+        {
+            if (e.IsReady != true) return;
+            _remote = GetHr1x0WirelessRemote(_config);
+
+            RegisterEvents();
         }
 
         void _remote_BaseEvent(GenericBase device, BaseEventArgs args)
@@ -57,6 +97,17 @@ namespace PepperDash.Essentials.Core
                 Feedbacks["BatteryVoltage"].FireUpdate();
         }
 
+        private void RegisterEvents()
+        {
+            _remote.ButtonStateChange += _remote_ButtonStateChange;
+
+            Feedbacks.Add(new BoolFeedback("BatteryCritical", () => _remote.BatteryCriticalFeedback.BoolValue));
+            Feedbacks.Add(new BoolFeedback("BatteryLow", () => _remote.BatteryLowFeedback.BoolValue));
+            Feedbacks.Add(new IntFeedback("BatteryVoltage", () => _remote.BatteryVoltageFeedback.UShortValue));
+
+            _remote.BaseEvent += _remote_BaseEvent;
+        }
+
         void _remote_ButtonStateChange(GenericBase device, ButtonEventArgs args)
         {
             try
@@ -137,11 +188,6 @@ namespace PepperDash.Essentials.Core
             return remoteBase;            
         }
 
-        static void gateway_BaseEvent(GenericBase device, BaseEventArgs args)
-        {
-            throw new NotImplementedException();
-        }
-
         #endregion
 
         #region Factory

essentials-framework/Essentials DM/Essentials_DM/Chassis/HdMdNxM4kEController.cs

@@ -4,14 +4,16 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.DM;
+using Newtonsoft.Json;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.DM.Config;
 
 namespace PepperDash.Essentials.DM.Chassis
 {
-    public class HdMdNxM4kEController : Device, IRoutingInputsOutputs, IRouting
+    public class HdMdNxM4kEController : CrestronGenericBaseDevice, IRoutingInputsOutputs, IRouting
     {
         public HdMdNxM Chassis { get; private set; }
 
@@ -27,7 +29,7 @@ namespace PepperDash.Essentials.DM.Chassis
         /// <param name="chassis"></param>
         public HdMdNxM4kEController(string key, string name, HdMdNxM chassis,
             HdMdNxM4kEPropertiesConfig props)
-            : base(key, name)
+            : base(key, name, chassis)
         {
             Chassis = chassis;
 
@@ -99,6 +101,8 @@ namespace PepperDash.Essentials.DM.Chassis
         /// <param name="type"></param>
         /// <param name="properties"></param>
         /// <returns></returns>
+        /// /*
+        /*
         public static HdMdNxM4kEController GetController(string key, string name,
             string type, HdMdNxM4kEPropertiesConfig properties)
         {
@@ -123,6 +127,35 @@ namespace PepperDash.Essentials.DM.Chassis
                 Debug.Console(0, "ERROR Creating device key {0}: \r{1}", key, e);
                 return null;
             }
+        }*/
+
+        #region Factory
+
+        public class HdMdNxM4kEFactory : EssentialsDeviceFactory<HdMdNxM4kEController>
+        {
+            public HdMdNxM4kEFactory()
+            {
+                TypeNames = new List<string>() {"hdmd4x14ke"};
+            }
+
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new HD-MD-NxM-4K-E Device");
+
+                var props = JsonConvert.DeserializeObject<HdMdNxM4kEPropertiesConfig>(dc.Properties.ToString());
+
+                var type = dc.Type.ToLower();
+                var control = props.Control;
+                var ipid = control.IpIdInt;
+                var address = control.TcpSshProperties.Address;
+
+                return new HdMdNxM4kEController(dc.Key, dc.Name, new HdMd4x14kE(ipid, address, Global.ControlSystem), props);
+
+            }
         }
+
+        #endregion
+
     }
 }

essentials-framework/Essentials Devices Common/Essentials Devices Common/Essentials Devices Common.csproj

@@ -114,10 +114,6 @@
     <Compile Include="Codec\iCodecAudio.cs" />
     <Compile Include="ImageProcessors\TVOneCorio.cs" />
     <Compile Include="ImageProcessors\TVOneCorioPropertiesConfig.cs" />
-    <Compile Include="Occupancy\CenOdtOccupancySensorBaseController.cs" />
-    <Compile Include="Occupancy\GlsOdtOccupancySensorController.cs" />
-    <Compile Include="PartitionSensor\GlsPartitionSensorController.cs" />
-    <Compile Include="PartitionSensor\GlsPartitionSensorControllerFactory.cs" />
     <Compile Include="Power Controllers\Digitallogger.cs" />
     <Compile Include="Power Controllers\DigitalLoggerPropertiesConfig.cs" />
     <Compile Include="ImageProcessors\AnalogWay\AnalongWayLiveCore.cs" />
@@ -152,8 +148,6 @@
     <Compile Include="Environment\Somfy\RelayControlledShade.cs" />
     <Compile Include="Factory\DeviceFactory.cs" />
     <Compile Include="Generic\GenericSource.cs" />
-    <Compile Include="Occupancy\GlsOccupancySensorBaseController.cs" />
-    <Compile Include="Occupancy\IOccupancyStatusProviderAggregator.cs" />
     <Compile Include="SetTopBox\SetTopBoxPropertiesConfig.cs" />
     <Compile Include="Streaming\AppleTV.cs" />
     <Compile Include="Audio\GenericAudioOut.cs" />

essentials-framework/Essentials Devices Common/Essentials Devices Common/Factory/DeviceFactory.cs

@@ -17,7 +17,7 @@ using PepperDash.Essentials.Core.CrestronIO;
 using PepperDash.Essentials.Devices.Common;
 using PepperDash.Essentials.Devices.Common.DSP;
 using PepperDash.Essentials.Devices.Common.VideoCodec;
-using PepperDash.Essentials.Devices.Common.Occupancy;
+using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Devices.Common.Environment;
 
 namespace PepperDash.Essentials.Devices.Common

essentials-framework/Essentials Devices Common/Essentials Devices Common/PartitionSensor/GlsPartitionSensorControllerFactory.cs

@@ -1,31 +0,0 @@
-using System.Collections.Generic;
-using Crestron.SimplSharpPro.GeneralIO;
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Config;
-
-namespace PepperDash.Essentials.Devices.Common.PartitionSensor
-{
-	public class GlsPartitionSensorControllerFactory : EssentialsDeviceFactory<GlsPartitionSensorController>
-	{
-		public GlsPartitionSensorControllerFactory()
-		{
-			TypeNames = new List<string>() { "glspartcn" };
-		}
-
-		public override EssentialsDevice BuildDevice(DeviceConfig dc)
-		{
-			Debug.Console(2, "Factory Attempting to create new GLS-PART-CN Device");
-			
-			var comm = CommFactory.GetControlPropertiesConfig(dc);
-			if (comm == null)
-			{
-				Debug.Console(0, "ERROR: Control Properties Config for {0} is null", dc.Key);
-				return null;
-			}
-
-			var sensor = new GlsPartCn(comm.CresnetIdInt, Global.ControlSystem);
-			return new GlsPartitionSensorController(dc.Key, dc.Name, sensor);
-		}
-	}
-}

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/CiscoSparkCodec.cs

@@ -13,7 +13,7 @@ using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Routing;
 using PepperDash.Essentials.Devices.Common.Cameras;
 using PepperDash.Essentials.Devices.Common.Codec;
-using PepperDash.Essentials.Devices.Common.Occupancy;
+using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Devices.Common.VideoCodec;
 
 namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
@@ -1658,7 +1658,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
             {
                 get
                 {
-                    if (CodecStatus.Status.SIP.Registration.Count > 0)
+                    if (CodecStatus.Status.SIP != null && CodecStatus.Status.SIP.Registration.Count > 0)
                     {
                         var match = Regex.Match(CodecStatus.Status.SIP.Registration[0].URI.Value, @"(\d+)"); // extract numbers only
                         if (match.Success)
@@ -1678,17 +1678,26 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
                         return string.Empty;
                     }
                 }
-            }
-            public override string SipUri
-            {
-                get
-                {
-                    if (CodecStatus.Status.SIP.AlternateURI.Primary.URI.Value != null)
-                        return CodecStatus.Status.SIP.AlternateURI.Primary.URI.Value;
-                    else
-                        return string.Empty;
-                }
-            }
+            }
+
+            public override string SipUri
+            {
+                get
+                {
+                    if (CodecStatus.Status.SIP != null && CodecStatus.Status.SIP.AlternateURI.Primary.URI.Value != null)
+                    {
+                        return CodecStatus.Status.SIP.AlternateURI.Primary.URI.Value;
+                    }
+                    else if (CodecStatus.Status.UserInterface != null &&
+                             CodecStatus.Status.UserInterface.ContactInfo.ContactMethod[0].Number.Value != null)
+                    {
+                        return CodecStatus.Status.UserInterface.ContactInfo.ContactMethod[0].Number.Value;
+                    }
+                    else
+                        return string.Empty;
+                }
+            }
+
             public override bool AutoAnswerEnabled
             {
                 get

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ZoomRoom.cs

@@ -13,7 +13,7 @@ using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Routing;
 using PepperDash.Essentials.Devices.Common.Cameras;
 using PepperDash.Essentials.Devices.Common.Codec;
-using PepperDash.Essentials.Devices.Common.Occupancy;
+using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Devices.Common.VideoCodec;
 
 namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom