Merge branch 'development' into bugfix/Fix-HdMd4x1-controller

.github/scripts/GenerateVersionNumber.ps1

@@ -1,5 +1,8 @@
 $latestVersions = $(git tag --merged origin/main)
 $latestVersion = [version]"0.0.0"
+Write-Host "GITHUB_REF: $($Env:GITHUB_REF)"
+Write-Host "GITHUB_HEAD_REF: $($Env:GITHUB_HEAD_REF)"
+Write-Host "GITHUB_BASE_REF: $($Env:GITHUB_BASE_REF)"
 Foreach ($version in $latestVersions) {
   Write-Host $version
   try {
@@ -17,7 +20,13 @@ Foreach ($version in $latestVersions) {
 $newVersion = [version]$latestVersion
 $phase = ""
 $newVersionString = ""
+
 switch -regex ($Env:GITHUB_REF) {
+  '^refs\/pull\/*.' {
+    $splitRef = $Env:GITHUB_REF -split "/"
+    $phase = "pr$($splitRef[2])"
+    $newVersionString = "{0}.{1}.{2}-{3}-{4}" -f $newVersion.Major, $newVersion.Minor, ($newVersion.Build + 1), $phase, $Env:GITHUB_RUN_NUMBER
+  }
   '^refs\/heads\/main*.' {
     $newVersionString = "{0}.{1}.{2}" -f $newVersion.Major, $newVersion.Minor, $newVersion.Build
   }
@@ -43,6 +52,7 @@ switch -regex ($Env:GITHUB_REF) {
     $phase = 'hotfix'
     $newVersionString = "{0}.{1}.{2}-{3}-{4}" -f $newVersion.Major, $newVersion.Minor, ($newVersion.Build + 1), $phase, $Env:GITHUB_RUN_NUMBER
   }
+  
 }
 
 

.github/workflows/docker.yml

@@ -8,6 +8,9 @@ on:
       - bugfix/*
       - release/*
       - development
+  pull_request:
+    branches:
+      - development
 
 env:
   # solution path doesn't need slashes unless there it is multiple folders deep
@@ -29,14 +32,7 @@ jobs:
         uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      # And any submodules
+          submodules: true
-      - name: Checkout submodules
-        shell: bash
-        run: |
-          git config --global url."https://github.com/".insteadOf "git@github.com:"
-          auth_header="$(git config --local --get http.https://github.com/.extraheader)"
-          git submodule sync --recursive
-          git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1
         # Fetch all tags
       - name: Fetch tags
         run: git fetch --tags

PepperDashEssentials/Example Configuration/SIMPLBridging/SIMPLBridgeExample_configurationFile.json

@@ -175,6 +175,10 @@
             {
               "deviceKey": "gls-odt-1",
               "joinStart": 2751
+            },
+            {
+				"deviceKey": "gls-part-1",
+				"joinStart": 2781
             }
           ]
         }
@@ -427,6 +431,19 @@
             "method": "cresnet"
           }
         }
+      },
+      {
+        "key": "gls-part-1",
+        "uid": 19,
+        "name": "GLS-PART-CN 1",
+        "type": "glspartcn",
+        "group": "partition",
+        "properties": {
+          "control": {
+            "cresnetId": "90",
+            "method": "cresnet"
+          }
+        }
       }
     ],
     "rooms": [],

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/GlsPartitionSensorJoinMap.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash_Essentials_Core.Bridges.JoinMaps
+{
+	public class GlsPartitionSensorJoinMap : JoinMapBaseAdvanced
+	{
+		[JoinName("IsOnline")]
+		public JoinDataComplete IsOnline = new JoinDataComplete(
+			new JoinData()
+			{
+				JoinNumber = 1,
+				JoinSpan = 1
+			},
+			new JoinMetadata()
+			{
+				Description = "Sensor Is Online",
+				JoinCapabilities = eJoinCapabilities.ToSIMPL,
+				JoinType = eJoinType.Digital
+			});
+
+		[JoinName("Name")]
+		public JoinDataComplete Name = new JoinDataComplete(
+			new JoinData()
+			{
+				JoinNumber = 1,
+				JoinSpan = 1
+			},
+			new JoinMetadata()
+			{
+				Description = "Sensor Name",
+				JoinCapabilities = eJoinCapabilities.ToSIMPL,
+				JoinType = eJoinType.Serial
+			});
+
+		[JoinName("Enable")]
+		public JoinDataComplete Enable = new JoinDataComplete(
+			new JoinData()
+			{
+				JoinNumber = 2,
+				JoinSpan = 1
+			},
+			new JoinMetadata()
+			{
+				Description = "Sensor Enable",
+				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
+				JoinType = eJoinType.Digital
+			});
+
+		[JoinName("PartitionSensed")]
+		public JoinDataComplete PartitionSensed = new JoinDataComplete(
+			new JoinData()
+			{
+				JoinNumber = 3,
+				JoinSpan = 1
+			},
+			new JoinMetadata()
+			{
+				Description = "Sensor Partition Sensed",
+				JoinCapabilities = eJoinCapabilities.ToSIMPL,
+				JoinType = eJoinType.Digital
+			});
+
+		[JoinName("PartitionNotSensed")]
+		public JoinDataComplete PartitionNotSensed = new JoinDataComplete(
+			new JoinData()
+			{
+				JoinNumber = 4,
+				JoinSpan = 1
+			},
+			new JoinMetadata()
+			{
+				Description = "Sensor Partition Not Sensed",
+				JoinCapabilities = eJoinCapabilities.ToSIMPL,
+				JoinType = eJoinType.Digital
+			});
+
+		[JoinName("IncreaseSensitivity")]
+		public JoinDataComplete IncreaseSensitivity = new JoinDataComplete(
+			new JoinData()
+			{
+				JoinNumber = 6,
+				JoinSpan = 1
+			},
+			new JoinMetadata()
+			{
+				Description = "Sensor Increase Sensitivity",
+				JoinCapabilities = eJoinCapabilities.FromSIMPL,
+				JoinType = eJoinType.Digital
+			});
+
+		[JoinName("DecreaseSensitivity")]
+		public JoinDataComplete DecreaseSensitivity = new JoinDataComplete(
+			new JoinData()
+			{
+				JoinNumber = 7,
+				JoinSpan = 1
+			},
+			new JoinMetadata()
+			{
+				Description = "Sensor Decrease Sensitivity",
+				JoinCapabilities = eJoinCapabilities.FromSIMPL,
+				JoinType = eJoinType.Digital
+			});
+
+		[JoinName("Sensitivity")]
+		public JoinDataComplete Sensitivity = new JoinDataComplete(
+			new JoinData()
+			{
+				JoinNumber = 2,
+				JoinSpan = 1
+			},
+			new JoinMetadata()
+			{
+				Description = "Sensor Sensitivity",
+				JoinCapabilities = eJoinCapabilities.ToFromSIMPL,
+				JoinType = eJoinType.Analog
+			});
+
+		public GlsPartitionSensorJoinMap(uint joinStart)
+			: base(joinStart, typeof (GlsPartitionSensorJoinMap))
+		{
+
+		}
+	}
+}

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);
+            AddPreActivationAction(() =>
-            HumidityFeedback = new IntFeedback(() => _device.HumidityFeedback.UShortValue);
+            {
+                _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>
+            trilist.OnlineStatusChange += (d, args) =>
-    {
+            {
-        public C2nRthsControllerFactory()
+                if (!args.DeviceOnLine) return;
-        {
+
-            TypeNames = new List<string>() { "c2nrths" };
+                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 ICresnetBridge;
+
+            if (cresnetBridge != null)
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new C2nRths", parentKey);
+                return new C2nRths(cresnetId, cresnetBridge.Branches[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/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]
+                        _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);
+                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 =
+                RedLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Red].BrightnessFeedback);
+                    new IntFeedback(() => (int)_device.Leds[(uint)StatusSign.Led.eLedColor.Red].BrightnessFeedback);
-            GreenLedBrightnessFeedback =
+                GreenLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Green].BrightnessFeedback);
+                    new IntFeedback(() => (int)_device.Leds[(uint)StatusSign.Led.eLedColor.Green].BrightnessFeedback);
-            BlueLedBrightnessFeedback =
+                BlueLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Blue].BrightnessFeedback);
+                    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>
+        #region PreActivation
-    {
+
-        public StatusSignControllerFactory()
+        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 ICresnetBridge;
+
+            if (cresnetBridge != null)
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new StatusSign", parentKey);
+                return new StatusSign(cresnetId, cresnetBridge.Branches[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/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
 {
     [Description("Wrapper class for Crestron Infinet-EX Gateways")]
-	public class CenRfgwController : CrestronGenericBaseDevice
+    public class CenRfgwController : CrestronGenericBaseDevice, IHasReady
-	{
-        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
-    }
-
-
-    #region Factory
-    public class CenRfgwControllerFactory : EssentialsDeviceFactory<CenRfgwController>
     {
-        public CenRfgwControllerFactory()
+        public event EventHandler<IsReadyEventArgs> IsReadyEvent;
+
+        public bool IsReady { get; private set; }
+
+        private GatewayBase _gateway;
+
+        public GatewayBase GateWay
         {
-            TypeNames = new List<string>() { "cenrfgwex", "cenerfgwpoe" };
+            get { return _gateway; }
         }
 
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        /// <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);
+        }
 
-            Debug.Console(1, "Factory Attempting to create new CEN-GWEXER Device");
+        public CenRfgwController(string key, Func<DeviceConfig, GatewayBase> preActivationFunc, DeviceConfig config) :
-
+            base(key, config.Name)
-            var props = JsonConvert.DeserializeObject<EssentialsRfGatewayConfig>(dc.Properties.ToString());
+        {
-
+            IsReady = false;
-            var type = dc.Type.ToLower();
+            FireIsReadyEvent(IsReady);
-            var control = props.Control;
+            AddPreActivationAction(() =>
-            var ipid = control.IpIdInt;
-            var cresnetId = control.CresnetIdInt;
-            var gatewayType = props.GatewayType;
-
-            switch (type)
             {
-                case ("cenrfgwex"):
+                _gateway = preActivationFunc(config);
-                    return CenRfgwController.GetNewExGatewayController(dc.Key, dc.Name,
+
-                        (ushort)ipid, (ushort)cresnetId, gatewayType);
+                IsReady = true;
-                case ("cenerfgwpoe"):
+                RegisterCrestronGenericBase(_gateway);
-                    return CenRfgwController.GetNewErGatewayController(dc.Key, dc.Name,
+                FireIsReadyEvent(IsReady);
-                        (ushort)ipid, (ushort)cresnetId, gatewayType);
+
-                default:
+            });
-                    return null;
+        }
+
+        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/PartitionSensor/GlsPartitionSensorController.cs

@@ -0,0 +1,280 @@
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash_Essentials_Core.Bridges.JoinMaps;
+
+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 GlsPartCn _partitionSensor;
+
+		public StringFeedback NameFeedback { get; private set; }
+		public BoolFeedback EnableFeedback { get; private set; }
+		public BoolFeedback PartitionSensedFeedback { get; private set; }
+		public BoolFeedback PartitionNotSensedFeedback { get; private set; }
+		public IntFeedback SensitivityFeedback { get; private set; }
+
+		public bool InTestMode { get; private set; }
+		public bool TestEnableFeedback { get; private set; }
+		public bool TestPartitionSensedFeedback { get; private set; }
+		public int TestSensitivityFeedback { get; private set; }
+
+
+		public GlsPartitionSensorController(string key, Func<DeviceConfig, GlsPartCn> preActivationFunc, DeviceConfig config)
+			: base(key, config.Name)
+		{
+            AddPreActivationAction(() =>
+            {
+                _partitionSensor = preActivationFunc(config);
+
+                RegisterCrestronGenericBase(_partitionSensor);
+
+                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);
+
+			switch (args.EventId)
+			{
+				case (GlsPartCn.EnableFeedbackEventId):
+					{
+						EnableFeedback.FireUpdate();
+						break;
+					}
+				case (GlsPartCn.PartitionSensedFeedbackEventId):
+					{
+						PartitionSensedFeedback.FireUpdate();
+						break;
+					}
+				case (GlsPartCn.PartitionNotSensedFeedbackEventId):
+					{
+						PartitionNotSensedFeedback.FireUpdate();
+						break;
+					}
+				case (GlsPartCn.SensitivityFeedbackEventId):
+					{
+						SensitivityFeedback.FireUpdate();
+						break;
+					}
+				default:
+					{
+						Debug.Console(2, this, "Unhandled args.EventId: {0}", args.EventId);
+						break;
+					}
+			}
+		}
+
+		public void SetTestMode(bool mode)
+		{
+			InTestMode = mode;
+			Debug.Console(1, this, "InTestMode: {0}", InTestMode.ToString());
+		}
+
+		public void SetTestEnableState(bool state)
+		{
+			if (InTestMode)
+			{
+				TestEnableFeedback = state;
+				Debug.Console(1, this, "TestEnableFeedback: {0}", TestEnableFeedback.ToString());
+				return;
+			}
+
+			Debug.Console(1, this, "InTestMode: {0}, unable to set enable state: {1}", InTestMode.ToString(), state.ToString());
+		}
+
+		public void SetTestPartitionSensedState(bool state)
+		{
+			if (InTestMode)
+			{
+				TestPartitionSensedFeedback = state;
+				Debug.Console(1, this, "TestPartitionSensedFeedback: {0}", TestPartitionSensedFeedback.ToString());
+				return;
+			}
+
+			Debug.Console(1, this, "InTestMode: {0}, unable to set partition state: {1}", InTestMode.ToString(), state.ToString());
+		}
+
+		public void SetTestSensitivityValue(int value)
+		{
+			if (InTestMode)
+			{
+				TestSensitivityFeedback = value;
+				Debug.Console(1, this, "TestSensitivityFeedback: {0}", TestSensitivityFeedback);
+				return;
+			}
+
+			Debug.Console(1, this, "InTestMode: {0}, unable to set sensitivity value: {1}", InTestMode.ToString(), value);
+		}
+
+		public void SetEnableState(bool state)
+		{
+			if (_partitionSensor == null)
+				return;
+
+			_partitionSensor.Enable.BoolValue = state;
+		}
+
+		public void IncreaseSensitivity()
+		{
+			if (_partitionSensor == null)
+				return;
+
+			_partitionSensor.IncreaseSensitivity();
+		}
+
+		public void DecreaseSensitivity()
+		{
+			if (_partitionSensor == null)
+				return;
+
+			_partitionSensor.DecreaseSensitivity();
+		}
+
+		public void SetSensitivity(ushort value)
+		{
+			if (_partitionSensor == null)
+				return;
+
+			_partitionSensor.Sensitivity.UShortValue = value;
+		}
+
+		public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		{
+			var joinMap = new GlsPartitionSensorJoinMap(joinStart);
+			var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+			if (!string.IsNullOrEmpty(joinMapSerialized))
+				joinMap = JsonConvert.DeserializeObject<GlsPartitionSensorJoinMap>(joinMapSerialized);
+
+			if (bridge != null)
+			{
+				bridge.AddJoinMap(Key, joinMap);
+			}
+			else
+			{
+				Debug.Console(0, this, "Please update config to use 'type': 'EiscApiAdvanced' to get all join map features for this device");
+			}
+
+			Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+			Debug.Console(0, this, "Linking to Bridge Type {0}", GetType().Name);
+
+			// link input from simpl
+			trilist.SetSigTrueAction(joinMap.Enable.JoinNumber, () => SetEnableState(true));
+			trilist.SetSigFalseAction(joinMap.Enable.JoinNumber, () => SetEnableState(false));
+			trilist.SetSigTrueAction(joinMap.IncreaseSensitivity.JoinNumber, IncreaseSensitivity);
+			trilist.SetSigTrueAction(joinMap.DecreaseSensitivity.JoinNumber, DecreaseSensitivity);
+			trilist.SetUShortSigAction(joinMap.Sensitivity.JoinNumber, SetSensitivity);
+
+			// 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]);
+			PartitionNotSensedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionNotSensed.JoinNumber]);
+			SensitivityFeedback.LinkInputSig(trilist.UShortInput[joinMap.Sensitivity.JoinNumber]);
+
+			FeedbacksFireUpdates();
+
+			// update when device is online
+			_partitionSensor.OnlineStatusChange += (o, a) =>
+			{
+				if (a.DeviceOnLine)
+				{
+					FeedbacksFireUpdates();
+				}
+			};
+
+			// update when trilist is online
+			trilist.OnlineStatusChange += (o, a) =>
+			{
+				if (a.DeviceOnLine)
+				{
+					FeedbacksFireUpdates();
+				}
+			};
+		}
+
+		private void FeedbacksFireUpdates()
+		{
+			IsOnline.FireUpdate();
+			NameFeedback.FireUpdate();
+			EnableFeedback.FireUpdate();
+			PartitionSensedFeedback.FireUpdate();
+			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 ICresnetBridge;
+
+            if (cresnetBridge != null)
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsPartCn", parentKey);
+                return new GlsPartCn(cresnetId, cresnetBridge.Branches[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

@@ -137,6 +137,7 @@
     <Compile Include="Bridges\JoinMaps\GenericLightingJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\GenericRelayControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\GlsOccupancySensorBaseJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\GlsPartitionSensorJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\HdMdNxM4kEControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\HdMdxxxCEControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\Hrxxx0WirelessRemoteControllerJoinMap.cs" />
@@ -192,6 +193,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" />
@@ -213,6 +215,7 @@
     <Compile Include="Monitoring\SystemMonitorController.cs" />
     <Compile Include="Microphone Privacy\MicrophonePrivacyController.cs" />
     <Compile Include="Microphone Privacy\MicrophonePrivacyControllerConfig.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));
+            if (_gateway == null) return;
-                Feedbacks.Add(new BoolFeedback("BatteryLow", () => _remote.BatteryLowFeedback.BoolValue));
-                Feedbacks.Add(new IntFeedback("BatteryVoltage", () => _remote.BatteryVoltageFeedback.UShortValue));
 
-                _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
@@ -112,22 +163,29 @@ namespace PepperDash.Essentials.Core
                 return null;
             }
 
+            Hr1x0WirelessRemoteBase remoteBase;
             switch (type)
             {
                 case ("hr100"):
-                    return new Hr100(rfId, gateway);
+                    remoteBase = new Hr100(rfId, gateway);
+                    break;
                 case ("hr150"):
-                    return new Hr150(rfId, gateway);
+                    remoteBase = new Hr150(rfId, gateway);
+                    break;
                 case ("hr310"):
-                    return new Hr310(rfId, gateway);
+                    remoteBase = new Hr310(rfId, gateway);
+                    break;
                 default:
                     return null;
             }
-        }
 
-        static void gateway_BaseEvent(GenericBase device, BaseEventArgs args)
+            // register the device when using an internal RF gateway
-        {
+            if (props.GatewayDeviceKey == "processor")
-            throw new NotImplementedException();
+            {
+                remoteBase.RegisterWithLogging(config.Key);
+            }
+
+            return remoteBase;            
         }
 
         #endregion

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

@@ -614,6 +614,13 @@ namespace PepperDash.Essentials.DM
                 var cecPort2 = outputCard.Card2.HdmiOutput;
                 AddDmcHdoPorts(number, cecPort1, cecPort2);
             }
+            else if (type == "dmc4kzhdo")
+            {
+                var outputCard = new Dmc4kzHdoSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                var cecPort2 = outputCard.Card2.HdmiOutput;
+                AddDmcHdoPorts(number, cecPort1, cecPort2);
+            }
             else if (type == "dmchdo")
             {
                 var outputCard = new DmcHdoSingle(number, Chassis);

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

@@ -55,10 +55,28 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
             }
         }
 
-        public GlsOccupancySensorBaseController(string key, string name, GlsOccupancySensorBase sensor)
+        public GlsOccupancySensorBaseController(string key, Func<DeviceConfig, GlsOccupancySensorBase> preActivationFunc,
-            : base(key, name, sensor)
+            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);
 
@@ -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)
+            switch (args.EventId)
-                PirSensorEnabledFeedback.FireUpdate();
+            {
-            else if (args.EventId == GlsOccupancySensorBase.LedFlashEnabledFeedbackEventId)
+                case GlsOccupancySensorBase.PirEnabledFeedbackEventId:
-                LedFlashEnabledFeedback.FireUpdate();
+                    PirSensorEnabledFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.ShortTimeoutEnabledFeedbackEventId)
+                    break;
-                ShortTimeoutEnabledFeedback.FireUpdate();
+                case GlsOccupancySensorBase.LedFlashEnabledFeedbackEventId:
-            else if (args.EventId == GlsOccupancySensorBase.PirSensitivityInOccupiedStateFeedbackEventId)
+                    LedFlashEnabledFeedback.FireUpdate();
-                PirSensitivityInOccupiedStateFeedback.FireUpdate();
+                    break;
-            else if (args.EventId == GlsOccupancySensorBase.PirSensitivityInVacantStateFeedbackEventId)
+                case GlsOccupancySensorBase.ShortTimeoutEnabledFeedbackEventId:
-                PirSensitivityInVacantStateFeedback.FireUpdate();
+                    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 
+            switch (args.EventId)
-                || args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId)
             {
-                Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
+                case Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId:
-                RoomIsOccupiedFeedback.FireUpdate();
+                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>
+        #region PreActivation
-    {
+
-        public GlsOccupancySensorBaseControllerFactory()
+        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 ICresnetBridge;
+
+            if (cresnetBridge != null)
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOirCCn", parentKey);
+                return new GlsOirCCn(cresnetId, cresnetBridge.Branches[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 Devices Common/Essentials Devices Common/Occupancy/GlsOdtOccupancySensorController.cs

@@ -35,26 +35,35 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
         public BoolFeedback RawOccupancyUsFeedback { get; private set; }
 
 
-        public GlsOdtOccupancySensorController(string key, string name, GlsOdtCCn sensor)
+        public GlsOdtOccupancySensorController(string key, Func<DeviceConfig, GlsOdtCCn> preActivationFunc,
-            : base(key, name, sensor)
+            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>
+        #region PreActivation
-    {
+
-        public GlsOdtOccupancySensorControllerFactory()
+        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)
+            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
-        {
-            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)
             {
-                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 ICresnetBridge;
+
+            if (cresnetBridge != null)
             {
-                Debug.Console(0, "ERROR: Unable to create Occupancy Sensor Device. Key: '{0}'", key);
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOdtCCn", parentKey);
-                return null;
+                return new GlsOdtCCn(cresnetId, cresnetBridge.Branches[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 Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/CiscoSparkCodec.cs

@@ -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)
@@ -1679,16 +1679,25 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
                     }
                 }
             }
+
             public override string SipUri
             {
                 get
                 {
-                    if (CodecStatus.Status.SIP.AlternateURI.Primary.URI.Value != null)
+                    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