feat: rename MC Message interface

.github/workflows/docker.yml

@@ -79,7 +79,7 @@ jobs:
 #            contains(steps.setVersion.outputs.version, '-beta-')
         uses: ncipollo/release-action@v1
         with:
-          artifacts: 'output\**\*.*(cpz|cplz)'
+          artifacts: 'output\*.*(cpz|cplz)'
           generateReleaseNotes: true
           prerelease: ${{contains('debug', env.BUILD_TYPE)}}
           tag: ${{ steps.setVersion.outputs.version }}

.github/workflows/main.yml

@@ -42,7 +42,7 @@ jobs:
         uses: ncipollo/release-action@v1
         with:
           updateRelease: true
-          artifacts: 'output\**\*.*(cpz|cplz)'          
+          artifacts: 'output\*.*(cpz|cplz)'          
           tag: ${{ steps.setVersion.outputs.version }}
       - name: Setup Nuget
         run: | 

PepperDash.Essentials.sln

@@ -11,25 +11,18 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PepperDash.Essentials.Core"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug 4.7.2|Any CPU = Debug 4.7.2|Any CPU
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{53E204B7-97DD-441D-A96C-721DF014DF82}.Debug 4.7.2|Any CPU.ActiveCfg = Debug 4.7.2|Any CPU
-		{53E204B7-97DD-441D-A96C-721DF014DF82}.Debug 4.7.2|Any CPU.Build.0 = Debug 4.7.2|Any CPU
 		{53E204B7-97DD-441D-A96C-721DF014DF82}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{53E204B7-97DD-441D-A96C-721DF014DF82}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{53E204B7-97DD-441D-A96C-721DF014DF82}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{53E204B7-97DD-441D-A96C-721DF014DF82}.Release|Any CPU.Build.0 = Release|Any CPU
-		{CB3B11BA-625C-4D35-B663-FDC5BE9A230E}.Debug 4.7.2|Any CPU.ActiveCfg = Debug 4.7.2|Any CPU
-		{CB3B11BA-625C-4D35-B663-FDC5BE9A230E}.Debug 4.7.2|Any CPU.Build.0 = Debug 4.7.2|Any CPU
 		{CB3B11BA-625C-4D35-B663-FDC5BE9A230E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{CB3B11BA-625C-4D35-B663-FDC5BE9A230E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{CB3B11BA-625C-4D35-B663-FDC5BE9A230E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{CB3B11BA-625C-4D35-B663-FDC5BE9A230E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{3D192FED-8FFC-4CB5-B5F7-BA307ABA254B}.Debug 4.7.2|Any CPU.ActiveCfg = Debug 4.7.2|Any CPU
-		{3D192FED-8FFC-4CB5-B5F7-BA307ABA254B}.Debug 4.7.2|Any CPU.Build.0 = Debug 4.7.2|Any CPU
 		{3D192FED-8FFC-4CB5-B5F7-BA307ABA254B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3D192FED-8FFC-4CB5-B5F7-BA307ABA254B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3D192FED-8FFC-4CB5-B5F7-BA307ABA254B}.Release|Any CPU.ActiveCfg = Release|Any CPU

src/Directory.Build.props

@@ -1,6 +1,7 @@
 <Project>
   <PropertyGroup>
     <Version>2.0.0-local</Version>
+    <InformationalVersion>$(Version)</InformationalVersion>
     <Authors>PepperDash Technologies</Authors>
     <Company>PepperDash Technologies</Company>
     <Product>PepperDash Essentials</Product>

src/Directory.Build.targets

@@ -1,26 +1,28 @@
 <Project>
   <ItemGroup>
-    <None Include="$(PackageOutputPath)\$(AssemblyName)\*.cpz" Condition="$(ProjectType) == 'Program'">
+    <None Include="$(TargetDir)\$(TargetName).$(Version).cpz" Condition="$(ProjectType) == 'Program'">
       <Pack>true</Pack>
-      <PackagePath>build;</PackagePath>
+      <PackagePath>content;</PackagePath>
     </None>
-    <None Include="$(PackageOutputPath)\$(AssemblyName)\*.cplz" Condition="$(ProjectType) == 'ProgramLibrary'">
+    <None Include="$(PackageOutputPath)\$(TargetName).$(Version).cplz" Condition="$(ProjectType) == 'ProgramLibrary'">
       <Pack>true</Pack>
-      <PackagePath>build;</PackagePath>
+      <PackagePath>content;</PackagePath>
     </None>
   </ItemGroup>
-  <Target Name="Create CPLZ" AfterTargets="Build; AfterRebuild" Condition="$(ProjectType) == 'ProgramLibrary' And $(TargetDir) != ''">
-    <Message Text="Creating CPLZ $(TargetDir)"></Message>
-    <MakeDir Directories="$(PackageOutputPath)" Condition="!Exists($(PackageOutputPath))" />
-    <MakeDir Directories="$(PackageOutputPath)\$(AssemblyName)" Condition="!Exists('$(PackageOutputPath)\$(AssemblyName)')" />
-    <ZipDirectory SourceDirectory="$(TargetDir)" DestinationFile="$(PackageOutputPath)\$(AssemblyName)\$(TargetName).$(Version).$(TargetFramework).cplz" Overwrite="true"/>    
+  <Target Name="Create CPLZ" AfterTargets="Build; Rebuild" Condition="$(ProjectType) == 'ProgramLibrary'">
+    <Message Text="Creating CPLZ"></Message>
+    <MakeDir Directories="$(PackageOutputPath)" Condition="!Exists($(PackageOutputPath))"></MakeDir>
+    <ZipDirectory SourceDirectory="$(TargetDir)" DestinationFile="$(PackageOutputPath)\$(TargetName).$(Version).cplz" Overwrite="true"/>    
   </Target>
-  <Target Name="Copy CPZ NET6" AfterTargets="SimplSharpPostProcess" Condition="($(ProjectType) == 'Program' And ( '$(TargetFramework)' == 'net6.0' ) Or ( '$(TargetFramework)' == 'net8.0' ))">
-    <Message Text="Copying CPZ"></Message>
-    <Move SourceFiles="$(TargetDir)$(TargetName).cpz" DestinationFiles="$(PackageOutputPath)\$(AssemblyName)\$(TargetName).$(Version).$(TargetFramework).cpz" />
+  <Target Name="Clean CPLZ" AfterTargets="AfterClean" Condition="$(ProjectType) == 'ProgramLibrary'">
+    <Delete Files="$(PackageOutputPath)\$(TargetName).$(Version).cplz"/>
   </Target>
-  <Target Name="Copy CPZ NET47" AfterTargets="SimplSharpPostProcess47" Condition="($(ProjectType) == 'Program' And ( '$(TargetFramework)' != 'net6.0' ) And ( '$(TargetFramework)' != 'net8.0' ))">
+  <Target Name="Copy CPZ" AfterTargets="SimplSharpPostProcess" Condition="$(ProjectType) == 'Program'">
     <Message Text="Copying CPZ"></Message>
-    <Move SourceFiles="$(TargetDir)$(TargetName).cpz" DestinationFiles="$(PackageOutputPath)\$(AssemblyName)\$(TargetName).$(Version).$(TargetFramework).cpz" />
+    <Move SourceFiles="$(TargetDir)$(TargetName).cpz" DestinationFiles="$(TargetDir)$(TargetName).$(Version).cpz" />
+    <Copy SourceFiles="$(TargetDir)$(TargetName).$(Version).cpz" DestinationFiles="$(PackageOutputPath)\$(TargetName).$(Version).cpz"/>
+  </Target>  
+  <Target Name="Clean CPZ" AfterTargets="AfterClean" Condition="$(ProjectType) == 'Program'">
+    <Delete Files="$(PackageOutputPath)\$(TargetName).$(Version).cpz"/>
   </Target>
 </Project>

src/PepperDash.Essentials.Core/Bridges/BridgeBase.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -8,7 +8,7 @@ using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.EthernetCommunication;
 
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
@@ -375,8 +375,7 @@ namespace PepperDash.Essentials.Core.Bridges
         {
             try
             {
-                if (Debug.Level >= 1)
-                    Debug.Console(1, this, "EiscApiAdvanced change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
+                Debug.Console(2, this, "EiscApiAdvanced change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
                 var uo = args.Sig.UserObject;
 
                 if (uo == null) return;

src/PepperDash.Essentials.Core/Bridges/JoinMaps/DigitalLoggerJoinMap.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace PepperDash.Essentials.Core.Bridges
+{
+    [Obsolete("This Device will be moved to a plugin in a future update")]
+    public class DigitalLoggerJoinMap : JoinMapBase
+    {
+        public uint IsOnline { get; set; }
+        public uint CircuitNames { get; set; }
+        public uint CircuitState { get; set; }
+        public uint CircuitCycle { get; set; }
+        public uint CircuitIsCritical { get; set; }
+        public uint CircuitOnCmd { get; set; }
+        public uint CircuitOffCmd { get; set; }
+
+        public DigitalLoggerJoinMap()
+        {
+            // Digital
+            IsOnline = 9;
+            CircuitState = 0;
+            CircuitCycle = 0;
+            CircuitIsCritical = 10;
+            CircuitOnCmd = 10;
+            CircuitOffCmd = 20;
+            // Serial
+            CircuitNames = 0;
+            // Analog
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            IsOnline = IsOnline + joinOffset;
+            CircuitNames = CircuitNames + joinOffset;
+            CircuitState = CircuitState + joinOffset;
+            CircuitCycle = CircuitCycle + joinOffset;
+            CircuitIsCritical = CircuitIsCritical + joinOffset;
+            CircuitOnCmd = CircuitOnCmd + joinOffset;
+            CircuitOffCmd = CircuitOffCmd + joinOffset;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Bridges/JoinMaps/GlsPartitionSensorJoinMap.cs

@@ -155,3 +155,146 @@ namespace PepperDash.Essentials.Core.Bridges.JoinMaps
         }
     }
 }
+
+namespace PepperDash_Essentials_Core.Bridges.JoinMaps
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    [Obsolete("use PepperDash.Essentials.Core.Bridges.JoinMaps version")]
+	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
+            });
+
+        /// <summary>
+        /// Constructor to use when instantiating this Join Map without inheriting from it
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        public GlsPartitionSensorJoinMap(uint joinStart)
+            : this(joinStart, typeof(GlsPartitionSensorJoinMap))
+        {
+
+        }
+
+        /// <summary>
+        /// Constructor to use when extending this Join map
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        /// <param name="type">Type of the child join map</param>
+        protected GlsPartitionSensorJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
+        {
+
+        }
+	}
+}

src/PepperDash.Essentials.Core/Comm and IR/ComSpecJsonConverter.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -7,8 +7,8 @@ using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
 
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 
 using PepperDash.Core;
 

src/PepperDash.Essentials.Core/Comm and IR/CommFactory.cs

@@ -1,11 +1,11 @@
-
+extern alias Full;
 
 using System;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DM;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 

src/PepperDash.Essentials.Core/Comm and IR/CommunicationExtras.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -7,8 +7,8 @@ using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
 
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 
 using PepperDash.Core;
 

src/PepperDash.Essentials.Core/Comm and IR/GenericComm.cs

@@ -1,10 +1,10 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
 using Crestron.SimplSharp.CrestronSockets;
 using Crestron.SimplSharpPro.DeviceSupport;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;

src/PepperDash.Essentials.Core/Comm and IR/GenericHttpClient.cs

@@ -9,7 +9,6 @@ using PepperDash.Core.DebugThings;
 
 namespace PepperDash.Essentials.Core
 {
-	[Obsolete("Please use the builtin HttpClient class instead: https://learn.microsoft.com/en-us/dotnet/fundamentals/networking/http/httpclient-guidelines")]
 	public class GenericHttpClient : Device, IBasicCommunication
 	{
 		public HttpClient Client;

src/PepperDash.Essentials.Core/Comm and IR/IRPortHelper.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -6,8 +6,8 @@ using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharpPro;
 
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 

src/PepperDash.Essentials.Core/Config/BasicConfig.cs

@@ -1,10 +1,10 @@
-
+extern alias Full;
 
 using System.Collections.Generic;
 using System.Linq;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json.Linq;
 
 namespace PepperDash.Essentials.Core.Config
 {

src/PepperDash.Essentials.Core/Config/ConfigPropertiesHelpers.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -7,7 +7,7 @@ using System.Text;
 using Crestron.SimplSharp;
 using PepperDash.Essentials.Core;
 using PepperDash.Core;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json.Linq;
 
 namespace PepperDash.Essentials.Core.Config
 {

src/PepperDash.Essentials.Core/Config/DeviceConfig.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -6,8 +6,8 @@ using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharpPro;
 
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 

src/PepperDash.Essentials.Core/Config/Essentials/ConfigReader.cs

@@ -1,12 +1,12 @@
-
+extern alias Full;
 
 using System;
 using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Core.Config;
 

src/PepperDash.Essentials.Core/Config/Essentials/ConfigUpdater.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -6,8 +6,8 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 using Crestron.SimplSharp.Net.Http;
 using Crestron.SimplSharpPro.Diagnostics;
 

src/PepperDash.Essentials.Core/Config/Essentials/ConfigWriter.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -6,8 +6,8 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core.Config

src/PepperDash.Essentials.Core/Config/Essentials/EssentialsConfig.cs

@@ -1,11 +1,11 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 
 using Crestron.SimplSharp.CrestronIO;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 using PepperDash.Core;
 

src/PepperDash.Essentials.Core/Config/ILoadConfig.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core
+{
+    public interface ILoadConfig
+    {
+        void GoWithLoad();
+    }
+}

src/PepperDash.Essentials.Core/Config/InfoConfig.cs

@@ -1,11 +1,11 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.Reflection;
 
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core.Config
 {

src/PepperDash.Essentials.Core/Crestron IO/C2nIo/C2nIoController.cs

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

src/PepperDash.Essentials.Core/Crestron IO/C2nRts/C2nRthsController.cs

@@ -0,0 +1,150 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using Full.Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    [Description("Wrapper class for the C2N-RTHS sensor")]
+    public class C2nRthsController : CrestronGenericBridgeableBaseDevice
+    {
+        private C2nRths _device;
+
+        public IntFeedback TemperatureFeedback { get; private set; }
+        public IntFeedback HumidityFeedback { get; private set; }
+
+        public C2nRthsController(string key, Func<DeviceConfig, C2nRths> preActivationFunc,
+            DeviceConfig config)
+            : base(key, config.Name)
+        {
+
+            AddPreActivationAction(() =>
+            {
+                _device = preActivationFunc(config);
+
+                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)
+            {
+                case C2nRths.TemperatureFeedbackEventId:
+                    TemperatureFeedback.FireUpdate();
+                    break;
+                case C2nRths.HumidityFeedbackEventId:
+                    HumidityFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+        public void SetTemperatureFormat(bool setToC)
+        {
+            _device.TemperatureFormat.BoolValue = setToC;
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new C2nRthsControllerJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<C2nRthsControllerJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+
+            trilist.SetBoolSigAction(joinMap.TemperatureFormat.JoinNumber, SetTemperatureFormat);
+
+
+
+            IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+            TemperatureFeedback.LinkInputSig(trilist.UShortInput[joinMap.Temperature.JoinNumber]);
+            HumidityFeedback.LinkInputSig(trilist.UShortInput[joinMap.Humidity.JoinNumber]);
+
+            trilist.StringInput[joinMap.Name.JoinNumber].StringValue = Name;
+
+            trilist.OnlineStatusChange += (d, args) =>
+            {
+                if (!args.DeviceOnLine) return;
+
+                UpdateFeedbacksWhenOnline();
+
+                trilist.StringInput[joinMap.Name.JoinNumber].StringValue = Name;
+            };
+        }
+
+        private void UpdateFeedbacksWhenOnline()
+        {
+            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;
+
+            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);
+            }
+        }
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/C3CardControllerBase.cs

@@ -0,0 +1,24 @@
+using System;
+using Crestron.SimplSharpProInternal;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    public class C3CardControllerBase:CrestronGenericBaseDevice
+    {
+        private readonly C3Card _card;
+
+        public C3CardControllerBase(string key, string name, C3Card hardware) : base(key, name, hardware)
+        {
+            _card = hardware;
+        }
+
+        #region Overrides of Object
+
+        public override string ToString()
+        {
+            return String.Format("{0} {1}", Key, _card.ToString());
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/C3Com3Controller.cs

@@ -0,0 +1,29 @@
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.ThreeSeriesCards;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    public class C3Com3Controller:C3CardControllerBase, IComPorts
+    {
+        private readonly C3com3 _card;
+
+        public C3Com3Controller(string key, string name, C3com3 hardware) : base(key, name, hardware)
+        {
+            _card = hardware;
+        }
+
+        #region Implementation of IComPorts
+
+        public CrestronCollection<ComPort> ComPorts
+        {
+            get { return _card.ComPorts; }
+        }
+
+        public int NumberOfComPorts
+        {
+            get { return _card.NumberOfComPorts; }
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/C3Io16Controller.cs

@@ -0,0 +1,29 @@
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.ThreeSeriesCards;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    public class C3Io16Controller:C3CardControllerBase,IIOPorts
+    {
+        private readonly C3io16 _card;
+
+        public C3Io16Controller(string key, string name, C3io16 hardware) : base(key, name, hardware)
+        {
+            _card = hardware;
+        }
+
+        #region Implementation of IIOPorts
+
+        public CrestronCollection<Versiport> VersiPorts
+        {
+            get { return _card.VersiPorts; }
+        }
+
+        public int NumberOfVersiPorts
+        {
+            get { return _card.NumberOfVersiPorts; }
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/C3Ir8Controller.cs

@@ -0,0 +1,29 @@
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.ThreeSeriesCards;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    public class C3Ir8Controller:C3CardControllerBase, IIROutputPorts
+    {
+        private readonly C3ir8 _card;
+
+        public C3Ir8Controller(string key, string name, C3ir8 hardware) : base(key, name, hardware)
+        {
+            _card = hardware;
+        }
+
+        #region Implementation of IIROutputPorts
+
+        public CrestronCollection<IROutputPort> IROutputPorts
+        {
+            get { return _card.IROutputPorts; }
+        }
+
+        public int NumberOfIROutputPorts
+        {
+            get { return _card.NumberOfIROutputPorts; }
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/C3Ry16Controller.cs

@@ -0,0 +1,29 @@
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.ThreeSeriesCards;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    public class C3Ry16Controller:C3CardControllerBase, IRelayPorts
+    {
+        private readonly C3ry16 _card;
+
+        public C3Ry16Controller(string key, string name, C3ry16 hardware) : base(key, name, hardware)
+        {
+            _card = hardware;
+        }
+
+        #region Implementation of IRelayPorts
+
+        public CrestronCollection<Relay> RelayPorts
+        {
+            get { return _card.RelayPorts; }
+        }
+
+        public int NumberOfRelayPorts
+        {
+            get { return _card.NumberOfRelayPorts; }
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/C3Ry8Controller.cs

@@ -0,0 +1,29 @@
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.ThreeSeriesCards;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    public class C3Ry8Controller:C3CardControllerBase, IRelayPorts
+    {
+        private readonly C3ry8 _card;
+
+        public C3Ry8Controller(string key, string name, C3ry8 hardware) : base(key, name, hardware)
+        {
+            _card = hardware;
+        }
+
+        #region Implementation of IRelayPorts
+
+        public CrestronCollection<Relay> RelayPorts
+        {
+            get { return _card.RelayPorts; }
+        }
+
+        public int NumberOfRelayPorts
+        {
+            get { return _card.NumberOfRelayPorts; }
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/CenCi31Controller.cs

@@ -0,0 +1,118 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.ThreeSeriesCards;
+using Full.Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    [ConfigSnippet("\"properties\":{\"card\":\"c3com3\"}")]
+    public class CenCi31Controller : CrestronGenericBaseDevice
+    {
+        private const string CardKeyTemplate = "{0}-card";
+        private const string CardNameTemplate = "{0}:{1}:{2}";
+        private const uint CardSlot = 1;
+        private readonly CenCi31 _cardCage;
+        private readonly CenCi31Configuration _config;
+
+        private readonly Dictionary<string, Func<CenCi31, uint, C3CardControllerBase>> _cardDict; 
+
+        public CenCi31Controller(string key, string name, CenCi31Configuration config, CenCi31 hardware) : base(key, name, hardware)
+        {
+            _cardCage = hardware;
+
+            _config = config;
+
+            _cardDict = new Dictionary<string, Func<CenCi31, uint, C3CardControllerBase>>
+            {
+                {
+                    "c3com3",
+                    (c, s) =>
+                        new C3Com3Controller(String.Format(CardKeyTemplate, key),
+                            String.Format(CardNameTemplate, key, s, "C3Com3"), new C3com3(_cardCage))
+                },
+                {
+                    "c3io16",
+                    (c, s) =>
+                        new C3Io16Controller(String.Format(CardKeyTemplate, key),
+                            String.Format(CardNameTemplate, key, s,"C3Io16"), new C3io16(_cardCage))
+                },
+                {
+                    "c3ir8",
+                    (c, s) =>
+                        new C3Ir8Controller(String.Format(CardKeyTemplate, key),
+                            String.Format(CardNameTemplate, key, s, "C3Ir8"), new C3ir8(_cardCage))
+                },
+                {
+                    "c3ry16",
+                    (c, s) =>
+                        new C3Ry16Controller(String.Format(CardKeyTemplate, key),
+                            String.Format(CardNameTemplate, key, s, "C3Ry16"), new C3ry16(_cardCage))
+                },
+                {
+                    "c3ry8",
+                    (c, s) =>
+                        new C3Ry8Controller(String.Format(CardKeyTemplate, key),
+                            String.Format(CardNameTemplate, key, s, "C3Ry8"), new C3ry8(_cardCage))
+                },
+
+            };
+
+            GetCards();
+        }
+
+        private void GetCards()
+        {
+            Func<CenCi31, uint, C3CardControllerBase> cardBuilder;
+            
+            if (String.IsNullOrEmpty(_config.Card))
+            {
+                Debug.Console(0, this, "No card specified");
+                return;
+            }
+
+            if (!_cardDict.TryGetValue(_config.Card.ToLower(), out cardBuilder))
+            {
+                Debug.Console(0, "Unable to find factory for 3-Series card type {0}.", _config.Card);
+                return;
+            }
+
+            var device = cardBuilder(_cardCage, CardSlot);
+
+            DeviceManager.AddDevice(device);
+        }
+    }
+
+    public class CenCi31Configuration
+    {
+        [JsonProperty("card")]
+        public string Card { get; set; }
+    }
+
+    public class CenCi31ControllerFactory : EssentialsDeviceFactory<CenCi31Controller>
+    {
+        public CenCi31ControllerFactory()
+        {
+            TypeNames = new List<string> {"cenci31"};
+        }
+        #region Overrides of EssentialsDeviceFactory<CenCi31Controller>
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory attempting to build new CEN-CI-1");
+
+            var controlProperties = CommFactory.GetControlPropertiesConfig(dc);
+            var ipId = controlProperties.IpIdInt;
+
+            var cardCage = new CenCi31(ipId, Global.ControlSystem);
+            var config = dc.Properties.ToObject<CenCi31Configuration>();
+
+            return new CenCi31Controller(dc.Key, dc.Name, config, cardCage);
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/CenCi33Controller.cs

@@ -0,0 +1,133 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.ThreeSeriesCards;
+using Full.Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    [ConfigSnippet("\"properties\":{\"cards\":{\"1\":\"c3com3\",\"2\":\"c3ry16\",\"3\":\"c3ry8\"}}")]
+    public class CenCi33Controller : CrestronGenericBaseDevice
+    {
+        private const string CardKeyTemplate = "{0}-card{1}";
+        private const string CardNameTemplate = "{0}:{1}:{2}";
+        private const uint CardSlots = 3;
+        private readonly CenCi33 _cardCage;
+        private readonly CenCi33Configuration _config;
+
+        private readonly Dictionary<string, Func<CenCi33, uint, C3CardControllerBase>> _cardDict; 
+
+        public CenCi33Controller(string key, string name, CenCi33Configuration config, CenCi33 hardware) : base(key, name, hardware)
+        {
+            _cardCage = hardware;
+
+            _config = config;
+
+            _cardDict = new Dictionary<string, Func<CenCi33, uint, C3CardControllerBase>>
+            {
+                {
+                    "c3com3",
+                    (c, s) =>
+                        new C3Com3Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Com3"), new C3com3(s,_cardCage))
+                },
+                {
+                    "c3io16",
+                    (c, s) =>
+                        new C3Io16Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Io16"), new C3io16(s,_cardCage))
+                },
+                {
+                    "c3ir8",
+                    (c, s) =>
+                        new C3Ir8Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Ir8"), new C3ir8(s,_cardCage))
+                },
+                {
+                    "c3ry16",
+                    (c, s) =>
+                        new C3Ry16Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Ry16"), new C3ry16(s,_cardCage))
+                },
+                {
+                    "c3ry8",
+                    (c, s) =>
+                        new C3Ry8Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Ry8"), new C3ry8(s,_cardCage))
+                },
+
+            };
+
+            GetCards();
+        }
+
+        private void GetCards()
+        {
+            if (_config.Cards == null)
+            {
+                Debug.Console(0, this, "No card configuration for this device found");
+                return;
+            }
+
+            for (uint i = 1; i <= CardSlots; i++)
+            {
+                string cardType;
+                if (!_config.Cards.TryGetValue(i, out cardType))
+                {
+                    Debug.Console(1, this, "No card found for slot {0}", i);
+                    continue;
+                }
+
+                if (String.IsNullOrEmpty(cardType))
+                {
+                    Debug.Console(0, this, "No card specified for slot {0}", i);
+                    return;
+                }
+
+                Func<CenCi33, uint, C3CardControllerBase> cardBuilder;
+                if (!_cardDict.TryGetValue(cardType.ToLower(), out cardBuilder))
+                {
+                    Debug.Console(0, "Unable to find factory for 3-Series card type {0}.", cardType);
+                    return;
+                }
+
+                var device = cardBuilder(_cardCage, i);
+
+                DeviceManager.AddDevice(device);
+            }
+        }
+    }
+
+    public class CenCi33Configuration
+    {
+        [JsonProperty("cards")]
+        public Dictionary<uint, string> Cards { get; set; }
+    }
+
+    public class CenCi33ControllerFactory : EssentialsDeviceFactory<CenCi33Controller>
+    {
+        public CenCi33ControllerFactory()
+        {
+            TypeNames = new List<string> {"cenci33"};
+        }
+        #region Overrides of EssentialsDeviceFactory<CenCi33Controller>
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory attempting to build new CEN-CI-3");
+
+            var controlProperties = CommFactory.GetControlPropertiesConfig(dc);
+            var ipId = controlProperties.IpIdInt;
+
+            var cardCage = new CenCi33(ipId, Global.ControlSystem);
+            var config = dc.Properties.ToObject<CenCi33Configuration>();
+
+            return new CenCi33Controller(dc.Key, dc.Name, config, cardCage);
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Cards/InternalCardCageController.cs

@@ -0,0 +1,143 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.ThreeSeriesCards;
+using Full.Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO.Cards
+{
+    [ConfigSnippet("\"properties\":{\"cards\":{\"1\":\"c3com3\",\"2\":\"c3ry16\",\"3\":\"c3ry8\"}}")]
+    public class InternalCardCageController : EssentialsDevice
+    {
+        private const string CardKeyTemplate = "{0}-card{1}";
+        private const string CardNameTemplate = "{0}:{1}:{2}";
+        private const uint CardSlots = 3;
+    
+        private readonly InternalCardCageConfiguration _config;
+
+        private readonly Dictionary<string, Func<uint, C3CardControllerBase>> _cardDict; 
+
+        public InternalCardCageController(string key, string name, InternalCardCageConfiguration config) : base(key, name)
+        {
+            _config = config;
+
+            _cardDict = new Dictionary<string, Func<uint, C3CardControllerBase>>
+            {
+                {
+                    "c3com3",
+                    (s) =>
+                        new C3Com3Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Com3"), new C3com3(s,Global.ControlSystem))
+                },
+                {
+                    "c3io16",
+                    (s) =>
+                        new C3Io16Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Io16"), new C3io16(s,Global.ControlSystem))
+                },
+                {
+                    "c3ir8",
+                    (s) =>
+                        new C3Ir8Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Ir8"), new C3ir8(s,Global.ControlSystem))
+                },
+                {
+                    "c3ry16",
+                    (s) =>
+                        new C3Ry16Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Ry16"), new C3ry16(s,Global.ControlSystem))
+                },
+                {
+                    "c3ry8",
+                    (s) =>
+                        new C3Ry8Controller(String.Format(CardKeyTemplate, key, s),
+                            String.Format(CardNameTemplate, key, s, "C3Ry8"), new C3ry8(s,Global.ControlSystem))
+                },
+
+            };
+
+            GetCards();
+        }
+
+        private void GetCards()
+        {
+            if (_config.Cards == null)
+            {
+                Debug.Console(0, this, "No card configuration for this device found");
+                return;
+            }
+
+            for (uint i = 1; i <= CardSlots; i++)
+            {
+                string cardType;
+                if (!_config.Cards.TryGetValue(i, out cardType))
+                {
+                    Debug.Console(0, this, "No card found for slot {0}", i);
+                    continue;
+                }
+
+                if (String.IsNullOrEmpty(cardType))
+                {
+                    Debug.Console(0, this, "No card specified for slot {0}", i);
+                    continue;
+                }
+
+                Func<uint, C3CardControllerBase> cardBuilder;
+                if (!_cardDict.TryGetValue(cardType.ToLower(), out cardBuilder))
+                {
+                    Debug.Console(0, "Unable to find factory for 3-Series card type {0}.", cardType);
+                    continue;
+                }
+
+                try
+                {
+                    var device = cardBuilder(i);
+
+
+                    DeviceManager.AddDevice(device);
+                }
+                catch (InvalidOperationException ex)
+                {
+                    Debug.Console(0, this, Debug.ErrorLogLevel.Error,
+                        "Unable to add card {0} to internal card cage.\r\nError Message: {1}\r\nStack Trace: {2}",
+                        cardType, ex.Message, ex.StackTrace);
+                }
+            }
+        }
+    }
+
+    public class InternalCardCageConfiguration
+    {
+        [JsonProperty("cards")]
+        public Dictionary<uint, string> Cards { get; set; }
+    }
+
+    public class InternalCardCageControllerFactory : EssentialsDeviceFactory<InternalCardCageController>
+    {
+        public InternalCardCageControllerFactory()
+        {
+            TypeNames = new List<string> {"internalcardcage"};
+        }
+        #region Overrides of EssentialsDeviceFactory<InternalCardCageController>
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory attempting to build new Internal Card Cage Controller");
+
+            if (!Global.ControlSystem.SupportsThreeSeriesPlugInCards)
+            {
+                Debug.Console(0, Debug.ErrorLogLevel.Warning, "Current control system does NOT support 3-Series cards. Everything is NOT awesome.");
+                return null;
+            }
+
+            var config = dc.Properties.ToObject<InternalCardCageConfiguration>();
+
+            return new InternalCardCageController(dc.Key, dc.Name, config);
+        }
+
+        #endregion
+    }
+}

src/PepperDash.Essentials.Core/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 DIN-CEN-CN2 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);
+            }
+        }
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/DinIo8/DinIo8Controller.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    public class DinIo8Controller:CrestronGenericBaseDevice, IIOPorts
+    {
+        private DinIo8 _device;
+
+        public DinIo8Controller(string key, Func<DeviceConfig, DinIo8> preActivationFunc, DeviceConfig config):base(key, config.Name)
+        {
+            AddPreActivationAction(() =>
+            {
+                _device = preActivationFunc(config);
+
+                RegisterCrestronGenericBase(_device);
+            });
+        }
+
+        #region Implementation of IIOPorts
+
+        public CrestronCollection<Versiport> VersiPorts
+        {
+            get { return _device.VersiPorts; }
+        }
+
+        public int NumberOfVersiPorts
+        {
+            get { return _device.NumberOfVersiPorts; }
+        }
+
+        #endregion
+
+
+    }
+
+    public class DinIo8ControllerFactory : EssentialsDeviceFactory<DinIo8Controller>
+    {
+        public DinIo8ControllerFactory()
+        {
+            TypeNames = new List<string>() { "DinIo8" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new DinIo8 Device");
+
+            return new DinIo8Controller(dc.Key, GetDinIo8Device, dc);
+        }
+
+        static DinIo8 GetDinIo8Device(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 DinIo8", parentKey);
+                return new DinIo8(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 DinIo8", parentKey);
+                return new DinIo8(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/IOPortConfig.cs

@@ -1,11 +1,11 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core.CrestronIO
 {

src/PepperDash.Essentials.Core/Crestron IO/Inputs/CenIoDigIn104Controller.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Essentials.Core.Config;
+
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Wrapper class for CEN-IO-DIGIN-104 digital input module
+    /// </summary>
+    [Description("Wrapper class for the CEN-IO-DIGIN-104 diginal input module")]
+    public class CenIoDigIn104Controller : CrestronGenericBaseDevice, IDigitalInputPorts
+    {
+        public CenIoDi104 Di104 { get; private set; }
+
+        public CenIoDigIn104Controller(string key, string name, CenIoDi104 di104)
+            : base(key, name)
+        {
+            Di104 = di104;
+        }
+
+        #region IDigitalInputPorts Members
+
+        public CrestronCollection<DigitalInput> DigitalInputPorts
+        {
+            get { return Di104.DigitalInputPorts; }
+        }
+
+        public int NumberOfDigitalInputPorts
+        {
+            get { return Di104.NumberOfDigitalInputPorts; }
+        }
+
+        #endregion
+    }
+
+    public class CenIoDigIn104ControllerFactory : EssentialsDeviceFactory<CenIoDigIn104Controller>
+    {
+        public CenIoDigIn104ControllerFactory()
+        {
+            TypeNames = new List<string>() { "ceniodigin104" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new CEN-DIGIN-104 Device");
+
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+	        if (control == null)
+	        {
+				Debug.Console(1, "Factory failed to create a new CEN-DIGIN-104 Device, control properties not found");
+				return null;
+	        }
+            var ipid = control.IpIdInt;
+			if (ipid != 0) return new CenIoDigIn104Controller(dc.Key, dc.Name, new CenIoDi104(ipid, Global.ControlSystem));
+
+			Debug.Console(1, "Factory failed to create a new CEN-IO-IR-104 Device using IP-ID-{0}", ipid);
+			return null;
+        }
+    }
+
+}

src/PepperDash.Essentials.Core/Crestron IO/Inputs/GenericDigitalInputDevice.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -7,7 +7,7 @@ using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;

src/PepperDash.Essentials.Core/Crestron IO/Inputs/GenericVersiportAnalogInputDevice.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -13,7 +13,7 @@ using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Bridges;
 
 
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core.CrestronIO
 {

src/PepperDash.Essentials.Core/Crestron IO/Inputs/GenericVersiportInputDevice.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -13,7 +13,7 @@ using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Bridges;
 
 
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core.CrestronIO
 {

src/PepperDash.Essentials.Core/Crestron IO/Ir/CenIoIr104Controller.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Essentials.Core.Config;
+
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Wrapper class for CEN-IO-IR-104 module
+    /// </summary>
+    [Description("Wrapper class for the CEN-IO-IR-104 module")]
+    public class CenIoIr104Controller : CrestronGenericBaseDevice, IIROutputPorts
+    {
+	    private readonly CenIoIr104 _ir104;
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="ir104"></param>
+        public CenIoIr104Controller(string key, string name, CenIoIr104 ir104)
+            : base(key, name, ir104)
+        {
+            _ir104 = ir104;
+        }
+
+        #region IDigitalInputPorts Members
+
+		/// <summary>
+		/// IR port collection
+		/// </summary>
+		public CrestronCollection<IROutputPort> IROutputPorts
+        {
+            get { return _ir104.IROutputPorts; }
+        }
+
+		/// <summary>
+		/// Number of relay ports property
+		/// </summary>
+		public int NumberOfIROutputPorts
+        {
+            get { return _ir104.NumberOfIROutputPorts; }
+        }
+
+        #endregion
+    }
+
+	/// <summary>
+	/// CEN-IO-IR-104 controller fatory
+	/// </summary>
+    public class CenIoIr104ControllerFactory : EssentialsDeviceFactory<CenIoIr104Controller>
+    {
+		/// <summary>
+		/// Constructor
+		/// </summary>
+        public CenIoIr104ControllerFactory()
+        {
+            TypeNames = new List<string>() { "cenioir104" };
+        }
+
+		/// <summary>
+		/// Build device CEN-IO-IR-104
+		/// </summary>
+		/// <param name="dc"></param>
+		/// <returns></returns>
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new CEN-IO-IR-104 Device");
+
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+			if (control == null)
+			{
+				Debug.Console(1, "Factory failed to create a new CEN-IO-IR-104 Device, control properties not found");
+				return null;
+			}
+
+            var ipid = control.IpIdInt;
+			if(ipid != 0) return new CenIoIr104Controller(dc.Key, dc.Name, new CenIoIr104(ipid, Global.ControlSystem));
+
+			Debug.Console(1, "Factory failed to create a new CEN-IO-IR-104 Device using IP-ID-{0}", ipid);
+			return null;
+        }
+    }
+
+}

src/PepperDash.Essentials.Core/Crestron IO/Outputs/GenericVersiportOutputDevice.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -13,7 +13,7 @@ using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Bridges;
 
 
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core.CrestronIO
 {

src/PepperDash.Essentials.Core/Crestron IO/Relay/CenIoRy104Controller.cs

@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Wrapper class for CEN-IO-RY-104 relay module
+    /// </summary>
+    [Description("Wrapper class for the CEN-IO-RY-104 relay module")]
+    public class CenIoRy104Controller : CrestronGenericBaseDevice, IRelayPorts
+    {
+        private readonly CenIoRy104 _ry104;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="ry104"></param>
+        public CenIoRy104Controller(string key, string name, CenIoRy104 ry104)
+            : base(key, name, ry104)
+        {
+            _ry104 = ry104;
+        }
+
+        /// <summary>
+        /// Relay port collection
+        /// </summary>
+        public CrestronCollection<Relay> RelayPorts
+        {
+            get { return _ry104.RelayPorts; }
+        }
+    
+        /// <summary>
+        /// Number of relay ports property
+        /// </summary>
+        public int NumberOfRelayPorts
+        {
+            get { return _ry104.NumberOfRelayPorts; }
+        }        
+    }
+
+    /// <summary>
+    /// CEN-IO-RY Controller factory
+    /// </summary>
+    public class CenIoRy104ControllerFactory : EssentialsDeviceFactory<CenIoRy104Controller>
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public CenIoRy104ControllerFactory()
+        {
+            TypeNames = new List<string>() { "ceniory104" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create a new CEN-IO-RY-104 Device");
+
+            var controlPropertiesConfig = CommFactory.GetControlPropertiesConfig(dc);
+            if (controlPropertiesConfig == null)
+            {
+				Debug.Console(1, "Factory failed to create a new CEN-IO-RY-104 Device, control properties not found");
+                return null;
+            }
+
+            var ipid = controlPropertiesConfig.IpIdInt;
+            if (ipid != 0) return new CenIoRy104Controller(dc.Key, dc.Name, new CenIoRy104(ipid, Global.ControlSystem));
+            
+            Debug.Console(1, "Factory failed to create a new CEN-IO-RY-104 Device using IP-ID-{0}", ipid);
+            return null;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Crestron IO/Relay/GenericRelayDevice.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -7,7 +7,7 @@ using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;

src/PepperDash.Essentials.Core/Crestron IO/StatusSign/StatusSignController.cs

@@ -0,0 +1,225 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using Full.Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    [Description("Wrapper class for the Crestron StatusSign device")]
+    public class StatusSignController : CrestronGenericBridgeableBaseDevice
+    {
+        private StatusSign _device;
+
+        public BoolFeedback RedLedEnabledFeedback { get; private set; }
+        public BoolFeedback GreenLedEnabledFeedback { get; private set; }
+        public BoolFeedback BlueLedEnabledFeedback { get; private set; }
+
+        public IntFeedback RedLedBrightnessFeedback { get; private set; }
+        public IntFeedback GreenLedBrightnessFeedback { get; private set; }
+        public IntFeedback BlueLedBrightnessFeedback { get; private set; }
+
+        public StatusSignController(string key, Func<DeviceConfig, StatusSign> preActivationFunc, DeviceConfig config) : base(key, config.Name)
+        {
+            AddPreActivationAction(() =>
+            {
+                _device = preActivationFunc(config);
+
+                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]
+                                .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);
+
+                if (_device != null) _device.BaseEvent += _device_BaseEvent;
+
+            });
+        }
+
+        void _device_BaseEvent(GenericBase device, BaseEventArgs args)
+        {
+            switch (args.EventId)
+            {
+                case StatusSign.LedBrightnessFeedbackEventId:
+                    RedLedBrightnessFeedback.FireUpdate();
+                    GreenLedBrightnessFeedback.FireUpdate();
+                    BlueLedBrightnessFeedback.FireUpdate();
+                    break;
+                case StatusSign.LedControlFeedbackEventId:
+                    RedLedEnabledFeedback.FireUpdate();
+                    GreenLedEnabledFeedback.FireUpdate();
+                    BlueLedEnabledFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+        public void EnableLedControl(bool red, bool green, bool blue)
+        {
+            _device.Leds[(uint) StatusSign.Led.eLedColor.Red].Control.BoolValue = red;
+            _device.Leds[(uint)StatusSign.Led.eLedColor.Green].Control.BoolValue = green;
+            _device.Leds[(uint)StatusSign.Led.eLedColor.Blue].Control.BoolValue = blue;
+        }
+
+        public void SetColor(uint red, uint green, uint blue)
+        {
+            try
+            {
+                _device.Leds[(uint)StatusSign.Led.eLedColor.Red].Brightness =
+                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(red);
+            }
+            catch (InvalidOperationException)
+            {
+                Debug.Console(1, this, "Error converting value to Red LED brightness. value: {0}", red);
+            }
+            try
+            {
+                _device.Leds[(uint)StatusSign.Led.eLedColor.Green].Brightness =
+                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(green);
+            }
+            catch (InvalidOperationException)
+            {
+                Debug.Console(1, this, "Error converting value to Green LED brightness. value: {0}", green);
+            }
+
+            try
+            {
+                _device.Leds[(uint)StatusSign.Led.eLedColor.Blue].Brightness =
+                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(blue);
+            }
+            catch (InvalidOperationException)
+            {
+                Debug.Console(1, this, "Error converting value to Blue LED brightness. value: {0}", blue);
+            }
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new StatusSignControllerJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<StatusSignControllerJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            trilist.SetBoolSigAction(joinMap.RedControl.JoinNumber, b => EnableControl(trilist, joinMap, this));
+            trilist.SetBoolSigAction(joinMap.GreenControl.JoinNumber, b => EnableControl(trilist, joinMap, this));
+            trilist.SetBoolSigAction(joinMap.BlueControl.JoinNumber, b => EnableControl(trilist, joinMap, this));
+
+            trilist.SetUShortSigAction(joinMap.RedLed.JoinNumber, u => SetColor(trilist, joinMap, this));
+            trilist.SetUShortSigAction(joinMap.GreenLed.JoinNumber, u => SetColor(trilist, joinMap, this));
+            trilist.SetUShortSigAction(joinMap.BlueLed.JoinNumber, u => SetColor(trilist, joinMap, this));
+
+            trilist.StringInput[joinMap.Name.JoinNumber].StringValue = Name;
+
+            IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+            RedLedEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RedControl.JoinNumber]);
+            BlueLedEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.BlueControl.JoinNumber]);
+            GreenLedEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.GreenControl.JoinNumber]);
+
+            RedLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.RedLed.JoinNumber]);
+            BlueLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.BlueLed.JoinNumber]);
+            GreenLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.GreenLed.JoinNumber]);
+        }
+
+        private static void EnableControl(BasicTriList triList, StatusSignControllerJoinMap joinMap,
+            StatusSignController device)
+        {
+            var redEnable = triList.BooleanOutput[joinMap.RedControl.JoinNumber].BoolValue;
+            var greenEnable = triList.BooleanOutput[joinMap.GreenControl.JoinNumber].BoolValue;
+            var blueEnable = triList.BooleanOutput[joinMap.BlueControl.JoinNumber].BoolValue;
+            device.EnableLedControl(redEnable, greenEnable, blueEnable);
+        }
+
+        private static void SetColor(BasicTriList triList, StatusSignControllerJoinMap joinMap,
+            StatusSignController device)
+        {
+            var redBrightness = triList.UShortOutput[joinMap.RedLed.JoinNumber].UShortValue;
+            var greenBrightness = triList.UShortOutput[joinMap.GreenLed.JoinNumber].UShortValue;
+            var blueBrightness = triList.UShortOutput[joinMap.BlueLed.JoinNumber].UShortValue;
+
+            device.SetColor(redBrightness, greenBrightness, blueBrightness);
+        }
+
+        #region PreActivation
+
+        private static StatusSign GetStatusSignDevice(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 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);
+            }
+        }
+    }
+
+    
+}

src/PepperDash.Essentials.Core/Crestron/CrestronGenericBaseDevice.cs

@@ -8,6 +8,9 @@ using PepperDash.Essentials.Core.Bridges;
 
 namespace PepperDash.Essentials.Core
 {
+	/// <summary>
+	/// A bridge class to cover the basic features of GenericBase hardware
+	/// </summary>
 	public abstract class CrestronGenericBaseDevice : EssentialsDevice, IOnline, IHasFeedback, ICommunicationMonitor, IUsageTracking
 	{
 	    protected GenericBase Hardware;

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IHasBranding.cs

@@ -7,4 +7,14 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
         bool BrandingEnabled { get; }
         void InitializeBranding(string roomKey);
     }
+}
+
+namespace PepperDash_Essentials_Core.DeviceTypeInterfaces
+{
+    [Obsolete("Use PepperDash.Essentials.Core.DeviceTypeInterfaces")]
+    public interface IHasBranding
+    {
+        bool BrandingEnabled { get; }
+        void InitializeBranding(string roomKey);
+    }
 }

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IHasPhoneDialing.cs

@@ -12,4 +12,18 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
         void EndPhoneCall();
         void SendDtmfToPhone(string digit);
     }
+}
+
+namespace PepperDash_Essentials_Core.DeviceTypeInterfaces
+{
+    [Obsolete("Use PepperDash.Essentials.Core.DeviceTypeInterfaces")]
+    public interface IHasPhoneDialing
+    {
+        BoolFeedback PhoneOffHookFeedback { get; }
+        StringFeedback CallerIdNameFeedback { get; }
+        StringFeedback CallerIdNumberFeedback { get; }
+        void DialPhoneCall(string number);
+        void EndPhoneCall();
+        void SendDtmfToPhone(string digit);
+    }
 }

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/ILanguageDefinition.cs

@@ -16,3 +16,20 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
         List<LanguageLabel> RoomNames { get; set; } 
     }
 }
+
+namespace PepperDash_Essentials_Core.DeviceTypeInterfaces
+{
+    [Obsolete("Use PepperDash.Essentials.Core.DeviceTypeInterfaces")]
+    public interface ILanguageDefinition
+    {
+        string LocaleName { get; set; }
+        string FriendlyName { get; set; }
+        bool Enable { get; set; }
+        List<LanguageLabel> UiLabels { get; set; }
+        List<LanguageLabel> Sources { get; set; }
+        List<LanguageLabel> Destinations { get; set; }
+        List<LanguageLabel> SourceGroupNames { get; set; }
+        List<LanguageLabel> DestinationGroupNames { get; set; }
+        List<LanguageLabel> RoomNames { get; set; }
+    }
+}

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/ILanguageProvider.cs

@@ -11,3 +11,15 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
     }
 
 }
+
+namespace PepperDash_Essentials_Core.DeviceTypeInterfaces
+{
+    [Obsolete("Use PepperDash.Essentials.Core.DeviceTypeInterfaces")]
+    public interface ILanguageProvider
+    {
+        ILanguageDefinition CurrentLanguage { get; set; }
+
+        event EventHandler CurrentLanguageChanged;
+    }
+
+}

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IMobileControl.cs

@@ -1,4 +1,6 @@
 using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
@@ -17,8 +19,39 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
     /// Describes a MobileSystemController that accepts IEssentialsRoom
     /// </summary>
     public interface IMobileControl3 : IMobileControl
+    {       
+        void SendMessageObject(IMobileControlMessage o);
+
+        void AddAction(string key, Action<JToken> action);
+
+        void RemoveAction(string key);
+
+        void AddDeviceMessenger(IMobileControlMessenger messenger);
+
+        bool CheckForDeviceMessenger(string key);
+    }
+
+    /// <summary>
+    /// Describes a mobile control messenger
+    /// </summary>
+    public interface IMobileControlMessenger: IKeyed
     {
-        void CreateMobileControlRoomBridge(IEssentialsRoom room, IMobileControl parent);
+        IMobileControl3 AppServerController { get; }
+        string MessagePath { get; }
+        void RegisterWithAppServer(IMobileControl3 appServerController);
+    }
+
+    public interface IMobileControlMessage
+    {
+        [JsonProperty("type")]
+        string Type { get; }
+
+        [JsonProperty("clientId", NullValueHandling = NullValueHandling.Ignore)]
+        string ClientId { get; }
+
+        [JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
+        JToken Content { get; }
+
     }
 
     /// <summary>
@@ -32,8 +65,6 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
 
         event EventHandler<EventArgs> ClientJoined;
 
-        event EventHandler<EventArgs> AppUrlChanged;
-
         string UserCode { get; }
 
         string QrCodeUrl { get; }
@@ -43,7 +74,5 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
         string McServerUrl { get; }
 
         string RoomName { get; }
-
-        string AppUrl { get; }
     }
 }

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IPower.cs

@@ -13,6 +13,17 @@ using PepperDash.Essentials.Core.SmartObjects;
 
 namespace PepperDash.Essentials.Core
 {
+	/// <summary>
+	/// Defines the ability to power a device on and off
+	/// </summary>
+    [Obsolete("Will be replaced by IHasPowerControlWithFeedback")]
+	public interface IPower
+	{
+		void PowerOn();
+		void PowerOff();
+		void PowerToggle();
+        BoolFeedback PowerIsOnFeedback { get; }
+	}
 
     /// <summary>
     /// Adds feedback for current power state

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/LanguageLabel.cs

@@ -10,4 +10,16 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
         public string DisplayText { get; set; }
         public uint JoinNumber { get; set; }
     }
+}
+
+namespace PepperDash_Essentials_Core.DeviceTypeInterfaces
+{
+    [Obsolete("Use PepperDash.Essentials.Core.DeviceTypeInterfaces")]
+    public class LanguageLabel
+    {
+        public string Key { get; set; }
+        public string Description { get; set; }
+        public string DisplayText { get; set; }
+        public uint JoinNumber { get; set; }
+    }
 }

src/PepperDash.Essentials.Core/Devices/DestinationListItem.cs

@@ -1,6 +1,6 @@
-
+extern alias Full;
 
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 using PepperDash.Essentials.Core;
 
 namespace PepperDash.Essentials.Core

src/PepperDash.Essentials.Core/Devices/DeviceJsonApi.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections;
@@ -7,7 +7,7 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.Reflection;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 using PepperDash.Core;
 

src/PepperDash.Essentials.Core/Devices/GenericIRController.cs

@@ -1,10 +1,10 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using Crestron.SimplSharpPro.DeviceSupport;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;

src/PepperDash.Essentials.Core/Devices/GenericMonitoredTcpDevice.cs

@@ -35,6 +35,35 @@ namespace PepperDash.Essentials.Core.Devices
 		{
 		}
 
+
+		/// <summary>
+		/// Generic monitor for TCP reachability.  Default with 30s poll, 120s warning and 300s error times
+		/// </summary>
+		[Obsolete]
+		public GenericCommunicationMonitoredDevice(string key, string name, string hostname, int port, string pollString)
+			: this(key, name, hostname, port, pollString, 30000, 120000, 300000)
+		{
+		}
+
+		/// <summary>
+		/// Monitor for TCP reachability
+		/// </summary>
+		[Obsolete]
+		public GenericCommunicationMonitoredDevice(string key, string name, string hostname, int port, string pollString, 
+			long pollTime, long warningTime, long errorTime)
+			: base(key, name)
+		{
+			Client = new GenericTcpIpClient(key + "-tcp", hostname, port, 512);
+			CommunicationMonitor = new GenericCommunicationMonitor(this, Client, pollTime, warningTime, errorTime, pollString);
+
+			// ------------------------------------------------------DELETE THIS
+			CommunicationMonitor.StatusChange += (o, a) =>
+			{
+				Debug.Console(2, this, "Communication monitor status change: {0}", a.Status);
+			};
+		}
+
+
 		public override bool CustomActivate()
 		{
 			CommunicationMonitor.Start();

src/PepperDash.Essentials.Core/Devices/IrOutputPortController.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -6,7 +6,7 @@ using System.Linq;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json.Linq;
 using PepperDash.Essentials.Core.Config;
 
 

src/PepperDash.Essentials.Core/Devices/PC/InRoomPc.cs

@@ -10,7 +10,9 @@ using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core.Devices
 {
-	[Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
+	/// <summary>
+	/// This DVD class should cover most IR, one-way DVD and Bluray fuctions
+	/// </summary>
 	public class InRoomPc : EssentialsDevice, IHasFeedback, IRoutingOutputs, IAttachVideoStatus, IUiDisplayInfo, IUsageTracking
 	{
 		public uint DisplayUiType { get { return DisplayUiConstants.TypeLaptop; } }
@@ -63,7 +65,6 @@ namespace PepperDash.Essentials.Core.Devices
         #endregion
 	}
 
-    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
     public class InRoomPcFactory : EssentialsDeviceFactory<InRoomPc>
     {
         public InRoomPcFactory()

src/PepperDash.Essentials.Core/Devices/PC/Laptop.cs

@@ -10,9 +10,10 @@ using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core.Devices
 {
-
-    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
-    public class Laptop : EssentialsDevice, IHasFeedback, IRoutingOutputs, IAttachVideoStatus, IUiDisplayInfo, IUsageTracking
+	/// <summary>
+	/// This DVD class should cover most IR, one-way DVD and Bluray fuctions
+	/// </summary>
+	public class Laptop : EssentialsDevice, IHasFeedback, IRoutingOutputs, IAttachVideoStatus, IUiDisplayInfo, IUsageTracking
 	{
 		public uint DisplayUiType { get { return DisplayUiConstants.TypeLaptop; } }
 		public string IconName { get; set; }
@@ -64,7 +65,6 @@ namespace PepperDash.Essentials.Core.Devices
         #endregion
 	}
 
-    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
     public class LaptopFactory : EssentialsDeviceFactory<Laptop>
     {
         public LaptopFactory()

src/PepperDash.Essentials.Core/Devices/PresentationDeviceType.cs

@@ -9,6 +9,18 @@ using Crestron.SimplSharpPro.UI;
 
 namespace PepperDash.Essentials.Core
 {
+	//[Obsolete]
+	//public class PresentationDeviceType
+	//{
+	//    public const ushort Default = 1;
+	//    public const ushort CableSetTopBox = 2;
+	//    public const ushort SatelliteSetTopBox = 3;
+	//    public const ushort Dvd = 4;
+	//    public const ushort Bluray = 5;
+	//    public const ushort PC = 9;
+	//    public const ushort Laptop = 10;
+	//}
+
 	public enum PresentationSourceType
 	{
 		None, Dvd, Laptop, PC, SetTopBox, VCR

src/PepperDash.Essentials.Core/Devices/ReconfigurableDevice.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -9,8 +9,8 @@ using Crestron.SimplSharpPro.DeviceSupport;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 
 namespace PepperDash.Essentials.Core.Devices
 {

src/PepperDash.Essentials.Core/Devices/SourceListItem.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -6,9 +6,9 @@ using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharpPro;
 
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Converters;
+using Full.Newtonsoft.Json.Linq;
 using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core

src/PepperDash.Essentials.Core/Display/BasicIrDisplay.cs

@@ -14,12 +14,15 @@ using PepperDash.Essentials.Core.Routing;
 
 namespace PepperDash.Essentials.Core
 {
-	[Obsolete("Please use PepperDash.Essentials.Device.Common, this will be removed in 2.1")]
+    [Description("Wrapper class for a Basic IR Display")]
     public class BasicIrDisplay : DisplayBase, IBasicVolumeControls, IBridgeAdvanced
 	{
 		public IrOutputPortController IrPort { get; private set; }
 		public ushort IrPulseTime { get; set; }
 
+        [Obsolete("This property will be removed in version 2.0.0")]
+        public override BoolFeedback PowerIsOnFeedback { get; protected set; }
+
         protected Func<bool> PowerIsOnFeedbackFunc
         {
             get { return () => _PowerIsOn; }
@@ -43,6 +46,14 @@ namespace PepperDash.Essentials.Core
 			IrPort = new IrOutputPortController(key + "-ir", port, irDriverFilepath);
 			DeviceManager.AddDevice(IrPort);
 
+            PowerIsOnFeedback = new BoolFeedback(PowerIsOnFeedbackFunc);
+
+            PowerIsOnFeedback.OutputChange += (o, a) =>
+            {
+                Debug.Console(2, this, "Power on={0}", _PowerIsOn);
+                if (_PowerIsOn) StartWarmingTimer();
+                else StartCoolingTimer();
+            };
 			IsWarmingUpFeedback.OutputChange += (o, a) => Debug.Console(2, this, "Warming up={0}", _IsWarmingUp);
 			IsCoolingDownFeedback.OutputChange += (o, a) => Debug.Console(2, this, "Cooling down={0}", _IsCoolingDown);
 
@@ -106,17 +117,20 @@ namespace PepperDash.Essentials.Core
 		{
 			IrPort.Pulse(IROutputStandardCommands.IROut_POWER_ON, IrPulseTime);
             _PowerIsOn = true;
+            PowerIsOnFeedback.FireUpdate();
 		}
 
 		public override void PowerOff()
 		{
             _PowerIsOn = false;
+            PowerIsOnFeedback.FireUpdate();
 			IrPort.Pulse(IROutputStandardCommands.IROut_POWER_OFF, IrPulseTime);
 		}
 
 		public override void PowerToggle()
 		{
             _PowerIsOn = false;
+            PowerIsOnFeedback.FireUpdate();
 			IrPort.Pulse(IROutputStandardCommands.IROut_POWER, IrPulseTime);
 		}
 
@@ -179,7 +193,7 @@ namespace PepperDash.Essentials.Core
 						action();
 				};
 
-			if (!_PowerIsOn)
+			if (!PowerIsOnFeedback.BoolValue)
 			{
 				PowerOn();
 				EventHandler<FeedbackEventArgs> oneTimer = null;
@@ -203,7 +217,6 @@ namespace PepperDash.Essentials.Core
 	    }
 	}
 
-    [Obsolete("Please use PepperDash.Essentials.Device.Common, this will be removed in 2.1")]
     public class BasicIrDisplayFactory : EssentialsDeviceFactory<BasicIrDisplay>
     {
         public BasicIrDisplayFactory()

src/PepperDash.Essentials.Core/Display/DisplayBase.cs

@@ -1,22 +1,26 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.DM;
 using Crestron.SimplSharpPro.DM.Endpoints;
 using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 
 
 namespace PepperDash.Essentials.Core
 {
-	[Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
-    public abstract class DisplayBase : EssentialsDevice, IHasFeedback, IRoutingSinkWithSwitching, IHasPowerControl, IWarmingCooling, IUsageTracking
+	/// <summary>
+	/// 
+	/// </summary>
+    public abstract class DisplayBase : EssentialsDevice, IHasFeedback, IRoutingSinkWithSwitching, IHasPowerControl, IWarmingCooling, IUsageTracking, IPower
 	{
         public event SourceInfoChangeHandler CurrentSourceChange;
 
@@ -47,6 +51,9 @@ namespace PepperDash.Essentials.Core
 		public BoolFeedback IsCoolingDownFeedback { get; protected set; }
 		public BoolFeedback IsWarmingUpFeedback { get; private set; }
 
+        [Obsolete("This property will be removed in version 2.0.0")]
+        public abstract BoolFeedback PowerIsOnFeedback { get; protected set; }
+
         public UsageTracking UsageTracker { get; set; }
 
 		public uint WarmupTime { get; set; }
@@ -253,14 +260,16 @@ namespace PepperDash.Essentials.Core
 
     }
 
-	[Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
+	/// <summary>
+	/// 
+	/// </summary>
     public abstract class TwoWayDisplayBase : DisplayBase, IRoutingFeedback, IHasPowerControlWithFeedback
 	{
         public StringFeedback CurrentInputFeedback { get; private set; }
 
         abstract protected Func<string> CurrentInputFeedbackFunc { get; }
 
-        public BoolFeedback PowerIsOnFeedback { get; protected set; }
+        public override BoolFeedback PowerIsOnFeedback { get; protected set; }
 
         abstract protected Func<bool> PowerIsOnFeedbackFunc { get; }
 

src/PepperDash.Essentials.Core/Display/MockDisplay.cs

@@ -16,8 +16,10 @@ using PepperDash.Essentials.Core.Config;
 
 namespace PepperDash.Essentials.Core
 {
-    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
-    public class MockDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, IBridgeAdvanced
+	/// <summary>
+	/// 
+	/// </summary>
+	public class MockDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, IBridgeAdvanced
 
 	{
 		public RoutingInputPort HdmiIn1 { get; private set; }
@@ -218,8 +220,6 @@ namespace PepperDash.Essentials.Core
 	    }
 	}
 
-
-    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
     public class MockDisplayFactory : EssentialsDeviceFactory<MockDisplay>
     {
         public MockDisplayFactory()

src/PepperDash.Essentials.Core/Extensions/JsonExtensions.cs

@@ -1,12 +1,12 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 
 namespace PepperDash.Essentials.Core
 {

src/PepperDash.Essentials.Core/Factory/DeviceFactory.cs

@@ -1,8 +1,8 @@
-
+extern alias Full;
 
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.Reflection;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 using System;
@@ -189,7 +189,7 @@ namespace PepperDash.Essentials.Core
                 CrestronConsole.ConsoleCommandResponse(
                     @"Type: '{0}' 
                     CType: '{1}' 
-                    Description: {2}", type.Key, cType, description);
+                    Description: {2}{3}", type.Key, cType, description, CrestronEnvironment.NewLine);
             }
         }
 

src/PepperDash.Essentials.Core/Factory/ProcessorExtensionDeviceFactory.cs

@@ -1,6 +1,6 @@
-
+extern alias Full;
 using Crestron.SimplSharp.Reflection;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
@@ -70,9 +70,9 @@ namespace PepperDash.Essentials.Core
             ProcessorExtensionDeviceFactory.ProcessorExtensionFactoryMethods.Add(extensionName, wrapper);
         }
 
-        private static void CheckForSecrets(IEnumerable<Newtonsoft.Json.Linq.JProperty> obj)
+        private static void CheckForSecrets(IEnumerable<Full.Newtonsoft.Json.Linq.JProperty> obj)
         {
-            foreach (var prop in obj.Where(prop => prop.Value as Newtonsoft.Json.Linq.JObject != null))
+            foreach (var prop in obj.Where(prop => prop.Value as Full.Newtonsoft.Json.Linq.JObject != null))
             {
                 if (prop.Name.ToLower() == "secret")
                 {
@@ -80,7 +80,7 @@ namespace PepperDash.Essentials.Core
                     //var secret = GetSecret(JsonConvert.DeserializeObject<SecretsPropertiesConfig>(prop.Children().First().ToString()));
                     prop.Parent.Replace(secret);
                 }
-                var recurseProp = prop.Value as Newtonsoft.Json.Linq.JObject;
+                var recurseProp = prop.Value as Full.Newtonsoft.Json.Linq.JObject;
                 if (recurseProp == null) return;
                 CheckForSecrets(recurseProp.Properties());
             }
@@ -120,7 +120,7 @@ namespace PepperDash.Essentials.Core
 
                 var typeName = localDc.Type.ToLower();
 
-                var jObject = properties as Newtonsoft.Json.Linq.JObject;
+                var jObject = properties as Full.Newtonsoft.Json.Linq.JObject;
                 if (jObject != null)
                 {
                     var jProp = jObject.Properties();

src/PepperDash.Essentials.Core/Factory/ReadyEventArgs.cs

@@ -23,3 +23,24 @@ namespace PepperDash.Essentials.Core
         bool IsReady { get; }
     }
 }
+
+namespace PepperDash_Essentials_Core
+{
+    [Obsolete("Use PepperDash.Essentials.Core")]
+    public class IsReadyEventArgs : EventArgs
+    {
+        public bool IsReady { get; set; }
+
+        public IsReadyEventArgs(bool data)
+        {
+            IsReady = data;
+        }
+    }
+
+    [Obsolete("Use PepperDash.Essentials.Core")]
+    public interface IHasReady
+    {
+        event EventHandler<IsReadyEventArgs> IsReadyEvent;
+        bool IsReady { get; }
+    }
+}

src/PepperDash.Essentials.Core/Fusion/EssentialsHuddleSpaceFusionSystemControllerBase.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -10,7 +10,7 @@ using Crestron.SimplSharp.CrestronXml;
 using Crestron.SimplSharp.CrestronXml.Serialization;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.Fusion;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 
@@ -252,7 +252,7 @@ namespace PepperDash.Essentials.Core.Fusion
                     ? new FusionRoomGuids(Room.Name, _ipId, RoomGuid, FusionStaticAssets)
                     : new FusionRoomGuids(Room.Name, _ipId, RoomGuid, FusionStaticAssets, FusionOccSensor);
 
-                var json = JsonConvert.SerializeObject(_guiDs, Newtonsoft.Json.Formatting.Indented);
+                var json = JsonConvert.SerializeObject(_guiDs, Full.Newtonsoft.Json.Formatting.Indented);
 
                 using (var sw = new StreamWriter(filePath))
                 {

src/PepperDash.Essentials.Core/Fusion/FusionCustomPropertiesBridge.cs

@@ -1,12 +1,12 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core;

src/PepperDash.Essentials.Core/Gateways/CenCn2Controller.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash_Essentials_Core.Gateways
+{
+    public class CenCn2Controller
+    {
+    }
+}

src/PepperDash.Essentials.Core/Gateways/CenRfgwController.cs

@@ -0,0 +1,197 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.Gateways;
+using Full.Newtonsoft.Json;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+
+namespace PepperDash.Essentials.Core
+{
+    [Description("Wrapper class for Crestron Infinet-EX Gateways")]
+    public class CenRfgwController : CrestronGenericBaseDevice, IHasReady
+    {
+        public event EventHandler<IsReadyEventArgs> IsReadyEvent;
+
+        public bool IsReady { get; private set; }
+
+        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>
+        /// <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
+    }
+
+    
+}
+
+

src/PepperDash.Essentials.Core/Gateways/EssentialsRfGatewayConfig.cs

@@ -0,0 +1,25 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+
+namespace PepperDash.Essentials.Core
+{
+    public class EssentialsRfGatewayConfig
+    {
+        [JsonProperty("control")]
+        public EssentialsControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("gatewayType")]
+        public string GatewayType { get; set; }
+
+     }
+}

src/PepperDash.Essentials.Core/Global/Global.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Linq;
@@ -14,9 +14,9 @@ using Crestron.SimplSharpPro.DM;
 using PepperDash.Core;
 using PepperDash.Essentials.License;
 
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Newtonsoft.Json.Schema;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Linq;
+using Full.Newtonsoft.Json.Schema;
 
 
 namespace PepperDash.Essentials.Core

src/PepperDash.Essentials.Core/JoinMaps/JoinMapBase.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -12,7 +12,7 @@ using Crestron.SimplSharp;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core
 {
@@ -81,6 +81,97 @@ namespace PepperDash.Essentials.Core
 
     }
 
+    /// <summary>
+    /// Base class for join maps
+    /// </summary>
+    [Obsolete("This is being deprecated in favor of JoinMapBaseAdvanced")]
+    public abstract class JoinMapBase
+    {
+        /// <summary>
+        /// Modifies all the join numbers by adding the offset.  This should never be called twice
+        /// </summary>
+        /// <param name="joinStart"></param>
+        public abstract void OffsetJoinNumbers(uint joinStart);
+
+        /// <summary>
+        /// The collection of joins and associated metadata
+        /// </summary>
+        public Dictionary<string, JoinMetadata> Joins = new Dictionary<string, JoinMetadata>();
+
+        /// <summary>
+        /// Prints the join information to console
+        /// </summary>
+        public void PrintJoinMapInfo()
+        {
+            CrestronConsole.ConsoleCommandResponse("{0}:\n", GetType().Name);
+
+            // Get the joins of each type and print them
+            CrestronConsole.ConsoleCommandResponse("Digitals:");
+            var digitals = Joins.Where(j => (j.Value.JoinType & eJoinType.Digital) == eJoinType.Digital).ToDictionary(j => j.Key, j => j.Value);
+            CrestronConsole.ConsoleCommandResponse("Found {0} Digital Joins", digitals.Count); 
+            PrintJoinList(GetSortedJoins(digitals));
+
+            CrestronConsole.ConsoleCommandResponse("Analogs:");
+            var analogs = Joins.Where(j => (j.Value.JoinType & eJoinType.Analog) == eJoinType.Analog).ToDictionary(j => j.Key, j => j.Value);
+            CrestronConsole.ConsoleCommandResponse("Found {0} Analog Joins", analogs.Count); 
+            PrintJoinList(GetSortedJoins(analogs));
+
+            CrestronConsole.ConsoleCommandResponse("Serials:");
+            var serials = Joins.Where(j => (j.Value.JoinType & eJoinType.Serial) == eJoinType.Serial).ToDictionary(j => j.Key, j => j.Value);
+            CrestronConsole.ConsoleCommandResponse("Found {0} Serial Joins", serials.Count);
+            PrintJoinList(GetSortedJoins(serials));
+
+        }
+
+        /// <summary>
+        /// Returns  a sorted list by JoinNumber
+        /// </summary>
+        /// <param name="joins"></param>
+        /// <returns></returns>
+        List<KeyValuePair<string, JoinMetadata>> GetSortedJoins(Dictionary<string, JoinMetadata> joins)
+        {
+            var sortedJoins = joins.ToList();
+
+            sortedJoins.Sort((pair1, pair2) => pair1.Value.JoinNumber.CompareTo(pair2.Value.JoinNumber));
+
+            return sortedJoins;
+        }
+
+        void PrintJoinList(List<KeyValuePair<string, JoinMetadata>> joins)
+        {
+            foreach (var join in joins)
+            {
+                CrestronConsole.ConsoleCommandResponse(
+                    @"Join Number: {0} | Label: '{1}' | JoinSpan: '{2}' | Type: '{3}' | Capabilities: '{4}'",
+                        join.Value.JoinNumber,
+                        join.Value.Label,
+                        join.Value.JoinSpan,
+                        join.Value.JoinType.ToString(),
+                        join.Value.JoinCapabilities.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Returns the join number for the join with the specified key
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public uint GetJoinForKey(string key)
+        {
+            return Joins.ContainsKey(key) ? Joins[key].JoinNumber : 0;
+        }
+
+        /// <summary>
+        /// Returns the join span for the join with the specified key
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public uint GetJoinSpanForKey(string key)
+        {
+            return Joins.ContainsKey(key) ? Joins[key].JoinSpan : 0;
+        }
+    }
+
     /// <summary>
     /// Base class for join maps
     /// </summary>
@@ -341,6 +432,27 @@ namespace PepperDash.Essentials.Core
     public class JoinMetadata
     {
         private string _description;
+
+        /// <summary>
+        /// Join number (based on join offset value)
+        /// </summary>
+        [JsonProperty("joinNumber")]
+        [Obsolete]
+        public uint JoinNumber { get; set; }
+        /// <summary>
+        /// Join range span.  If join indicates the start of a range of joins, this indicated the maximum number of joins in the range
+        /// </summary>
+        [Obsolete]
+        [JsonProperty("joinSpan")]
+        public uint JoinSpan { get; set; }
+
+        /// <summary>
+        /// A label for the join to better describe its usage
+        /// </summary>
+        [Obsolete("Use Description instead")]
+        [JsonProperty("label")]
+        public string Label { get { return _description; } set { _description = value; } }
+
         /// <summary>
         /// A description for the join to better describe its usage
         /// </summary>

src/PepperDash.Essentials.Core/Lighting/LightingBase.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -7,13 +7,12 @@ using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 
 namespace PepperDash.Essentials.Core.Lighting
 {
-    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
     public abstract class LightingBase : EssentialsBridgeableDevice, ILightingScenes
     {
         #region ILightingScenes Members

src/PepperDash.Essentials.Core/Monitoring/SystemMonitorController.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -7,8 +7,8 @@ using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.Diagnostics;
 using PepperDash.Core;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
+using Full.Newtonsoft.Json;
+using Full.Newtonsoft.Json.Converters;
 using PepperDash.Essentials.Core.Bridges;
 
 namespace PepperDash.Essentials.Core.Monitoring

src/PepperDash.Essentials.Core/Occupancy/CenOdtOccupancySensorBaseController.cs

@@ -0,0 +1,777 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Resources;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using Full.Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.Core
+{
+	[Description("Wrapper class for CEN-ODT-C-POE")]
+    [ConfigSnippet("\"properties\": {\"control\": {\"method\": \"cresnet\",\"cresnetId\": \"97\"},\"enablePir\": true,\"enableLedFlash\": true,\"enableRawStates\":true,\"remoteTimeout\": 30,\"internalPhotoSensorMinChange\": 0,\"externalPhotoSensorMinChange\": 0,\"enableUsA\": true,\"enableUsB\": true,\"orWhenVacatedState\": true}")]
+	public class CenOdtOccupancySensorBaseController : CrestronGenericBridgeableBaseDevice, IOccupancyStatusProvider
+	{
+		public CenOdtCPoe OccSensor { get; private set; }
+
+        public GlsOccupancySensorPropertiesConfig PropertiesConfig { get; private set; }
+
+		public BoolFeedback RoomIsOccupiedFeedback { get; private set; }
+
+		public BoolFeedback GraceOccupancyDetectedFeedback { get; private set; }
+
+		public BoolFeedback RawOccupancyFeedback { get; private set; }
+
+		public BoolFeedback PirSensorEnabledFeedback { get; private set; }
+
+		public BoolFeedback LedFlashEnabledFeedback { get; private set; }
+
+		public BoolFeedback ShortTimeoutEnabledFeedback { get; private set; }
+
+		public IntFeedback PirSensitivityInVacantStateFeedback { get; private set; }
+
+		public IntFeedback PirSensitivityInOccupiedStateFeedback { get; private set; }
+
+		public IntFeedback CurrentTimeoutFeedback { get; private set; }
+
+		public IntFeedback RemoteTimeoutFeedback { get; private set; }
+
+		public IntFeedback InternalPhotoSensorValue { get; set; }
+
+		public IntFeedback ExternalPhotoSensorValue { get; set; }
+
+		public BoolFeedback OrWhenVacatedFeedback { get; private set; }
+
+		public BoolFeedback AndWhenVacatedFeedback { get; private set; }
+
+		public BoolFeedback UltrasonicAEnabledFeedback { get; private set; }
+
+		public BoolFeedback UltrasonicBEnabledFeedback { get; private set; }
+
+		public IntFeedback UltrasonicSensitivityInVacantStateFeedback { get; private set; }
+
+		public IntFeedback UltrasonicSensitivityInOccupiedStateFeedback { get; private set; }
+
+		public BoolFeedback RawOccupancyPirFeedback { get; private set; }
+
+		public BoolFeedback RawOccupancyUsFeedback { get; private set; }
+
+        public BoolFeedback IdentityModeFeedback { get; private set; }
+
+		// Debug properties
+		public bool InTestMode { get; private set; }
+
+		public bool TestRoomIsOccupiedFeedback { get; private set; }
+
+		public Func<bool> RoomIsOccupiedFeedbackFunc
+		{
+			get
+			{
+				return () => InTestMode ? TestRoomIsOccupiedFeedback : OccSensor.OccupancyDetectedFeedback.BoolValue;
+			}
+		}
+
+		public CenOdtOccupancySensorBaseController(string key, string name, CenOdtCPoe sensor, GlsOccupancySensorPropertiesConfig config)
+			: base(key, name, sensor)
+		{
+            PropertiesConfig = config;
+
+			OccSensor = sensor;
+
+			RoomIsOccupiedFeedback = new BoolFeedback(RoomIsOccupiedFeedbackFunc);
+
+			PirSensorEnabledFeedback = new BoolFeedback(() => OccSensor.PassiveInfraredSensorEnabledFeedback.BoolValue);
+
+			LedFlashEnabledFeedback = new BoolFeedback(() => OccSensor.LedFlashEnabledFeedback.BoolValue);
+
+			ShortTimeoutEnabledFeedback = new BoolFeedback(() => OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
+
+			PirSensitivityInVacantStateFeedback = new IntFeedback(() => (int)OccSensor.PassiveInfraredSensorSensitivityInVacantStateFeedback);
+
+			PirSensitivityInOccupiedStateFeedback = new IntFeedback(() => (int)OccSensor.PassiveInfraredSensorSensitivityInOccupiedStateFeedback);
+
+			CurrentTimeoutFeedback = new IntFeedback(() => OccSensor.CurrentTimeoutFeedback.UShortValue);
+
+			RemoteTimeoutFeedback = new IntFeedback(() => OccSensor.RemoteTimeout.UShortValue);
+
+			GraceOccupancyDetectedFeedback = new BoolFeedback(() => OccSensor.GraceOccupancyDetectedFeedback.BoolValue);
+
+			RawOccupancyFeedback = new BoolFeedback(() => OccSensor.RawOccupancyDetectedFeedback.BoolValue);
+
+			InternalPhotoSensorValue = new IntFeedback(() => OccSensor.InternalPhotoSensorValueFeedback.UShortValue);
+
+			//ExternalPhotoSensorValue = new IntFeedback(() => OccSensor.ex.UShortValue);
+
+			AndWhenVacatedFeedback = new BoolFeedback(() => OccSensor.AndWhenVacatedFeedback.BoolValue);
+
+			OrWhenVacatedFeedback = new BoolFeedback(() => OccSensor.OrWhenVacatedFeedback.BoolValue);
+
+			UltrasonicAEnabledFeedback = new BoolFeedback(() => OccSensor.UltrasonicSensorSideAEnabledFeedback.BoolValue);
+
+			UltrasonicBEnabledFeedback = new BoolFeedback(() => OccSensor.UltrasonicSensorSideBEnabledFeedback.BoolValue);
+
+			RawOccupancyPirFeedback = new BoolFeedback(() => OccSensor.RawOccupancyDetectedByPassiveInfraredSensorFeedback.BoolValue);
+
+			RawOccupancyUsFeedback = new BoolFeedback(() => OccSensor.RawOccupancyDetectedByUltrasonicSensorFeedback.BoolValue);
+
+            IdentityModeFeedback = new BoolFeedback(()=>OccSensor.IdentityModeOnFeedback.BoolValue);
+
+			UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => (int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback);
+
+			UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => (int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback);
+
+			OccSensor.BaseEvent += new Crestron.SimplSharpPro.BaseEventHandler(OccSensor_BaseEvent);
+
+			OccSensor.CenOccupancySensorChange += new GenericEventHandler(OccSensor_CenOccupancySensorChange);
+
+            AddPostActivationAction(() =>
+            {
+                OccSensor.OnlineStatusChange += (o, a) =>
+                {
+                    if (a.DeviceOnLine)
+                    {
+                        ApplySettingsToSensorFromConfig();
+                    }
+                };
+
+                if (OccSensor.IsOnline)
+                {
+                    ApplySettingsToSensorFromConfig();
+
+                }
+            }); 
+		}
+
+        /// <summary>
+        /// Applies any sensor settings defined in config 
+        /// </summary>
+        protected virtual void ApplySettingsToSensorFromConfig()
+        {
+            Debug.Console(1, this, "Checking config for settings to apply");
+
+            if (PropertiesConfig.EnablePir != null)
+            {
+                SetPirEnable((bool)PropertiesConfig.EnablePir);
+            }
+
+            if (PropertiesConfig.EnableLedFlash != null)
+            {
+                SetLedFlashEnable((bool)PropertiesConfig.EnableLedFlash);
+            }
+
+            if (PropertiesConfig.RemoteTimeout != null)
+            {
+                SetRemoteTimeout((ushort)PropertiesConfig.RemoteTimeout);
+            }
+
+            if (PropertiesConfig.ShortTimeoutState != null)
+            {
+                SetShortTimeoutState((bool)PropertiesConfig.ShortTimeoutState);
+            }
+
+            if (PropertiesConfig.EnableRawStates != null)
+            {
+                EnableRawStates((bool)PropertiesConfig.EnableRawStates);
+            }
+
+            if (PropertiesConfig.InternalPhotoSensorMinChange != null)
+            {
+                SetInternalPhotoSensorMinChange((ushort)PropertiesConfig.InternalPhotoSensorMinChange);
+            }
+
+            if (PropertiesConfig.EnableUsA != null)
+            {
+                SetUsAEnable((bool)PropertiesConfig.EnableUsA);
+            }
+
+            if (PropertiesConfig.EnableUsB != null)
+            {
+                SetUsBEnable((bool)PropertiesConfig.EnableUsB);
+            }
+
+            if (PropertiesConfig.OrWhenVacatedState != null)
+            {
+                SetOrWhenVacatedState((bool)PropertiesConfig.OrWhenVacatedState);
+            }
+
+            if (PropertiesConfig.AndWhenVacatedState != null)
+            {
+                SetAndWhenVacatedState((bool)PropertiesConfig.AndWhenVacatedState);
+            }
+
+            // TODO [ ] feature/cenoodtcpoe-sensor-sensitivity-configuration
+            if (PropertiesConfig.UsSensitivityOccupied != null)
+            {
+                SetUsSensitivityOccupied((ushort)PropertiesConfig.UsSensitivityOccupied);
+            }
+
+            if (PropertiesConfig.UsSensitivityVacant != null)
+            {
+                SetUsSensitivityVacant((ushort)PropertiesConfig.UsSensitivityVacant);
+            }
+
+            if (PropertiesConfig.PirSensitivityOccupied != null)
+            {
+                SetPirSensitivityOccupied((ushort)PropertiesConfig.PirSensitivityOccupied);
+            }
+
+            if (PropertiesConfig.PirSensitivityVacant != null)
+            {
+                SetPirSensitivityVacant((ushort)PropertiesConfig.PirSensitivityVacant);
+            }
+        }
+
+		/// <summary>
+		/// Catches events for feedbacks on the base class.  Any extending wrapper class should call this delegate after it checks for it's own event IDs.
+		/// </summary>
+		/// <param name="device"></param>
+		/// <param name="args"></param>
+		protected virtual void OccSensor_CenOccupancySensorChange(object device, GenericEventArgs 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();
+			else if (args.EventId == GlsOccupancySensorBase.RawOccupancyPirFeedbackEventId)
+				RawOccupancyPirFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId)
+				RawOccupancyUsFeedback.FireUpdate();
+		}
+
+		protected virtual void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+		{
+			Debug.Console(2, this, "PoEOccupancySensorChange  EventId: {0}", args.EventId);
+
+			if (args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId
+				|| args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId)
+			{
+				Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
+				RoomIsOccupiedFeedback.FireUpdate();
+			}
+			else if (args.EventId == GlsOccupancySensorBase.TimeoutFeedbackEventId)
+				CurrentTimeoutFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.TimeoutLocalFeedbackEventId)
+				RemoteTimeoutFeedback.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();
+			else if (args.EventId == GlsOccupancySensorBase.AndWhenVacatedFeedbackEventId)
+				AndWhenVacatedFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.OrWhenVacatedFeedbackEventId)
+				OrWhenVacatedFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.UsAEnabledFeedbackEventId)
+				UltrasonicAEnabledFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.UsBEnabledFeedbackEventId)
+				UltrasonicBEnabledFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInOccupiedStateFeedbackEventId)
+				UltrasonicSensitivityInOccupiedStateFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInVacantStateFeedbackEventId)
+				UltrasonicSensitivityInVacantStateFeedback.FireUpdate();
+		}
+
+		public void SetTestMode(bool mode)
+		{
+			InTestMode = mode;
+
+			Debug.Console(1, this, "In Mock Mode: '{0}'", InTestMode);
+		}
+
+		public void SetTestOccupiedState(bool state)
+		{
+			if (!InTestMode)
+				Debug.Console(1, "Mock mode not enabled");
+			else
+			{
+				TestRoomIsOccupiedFeedback = state;
+
+				RoomIsOccupiedFeedback.FireUpdate();
+			}
+		}
+
+        /// <summary>
+        /// Sets the identity mode on or off
+        /// </summary>
+        /// <param name="state"></param>
+	    public void SetIdentityMode(bool state)
+        {
+            if (state)
+                OccSensor.IdentityModeOn();
+            else
+                OccSensor.IdentityModeOff();
+
+            Debug.Console(1, this, "Identity Mode: {0}", OccSensor.IdentityModeOnFeedback.BoolValue ? "On" : "Off");
+        }
+
+	    /// <summary>
+		/// Enables or disables the PIR sensor
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetPirEnable(bool state)
+		{
+			if (state)
+			{
+				OccSensor.EnablePassiveInfraredSensor();
+			}
+			else
+			{
+				OccSensor.DisablePassiveInfraredSensor();
+			}
+		}
+
+		/// <summary>
+		/// Enables or disables the LED Flash
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetLedFlashEnable(bool state)
+		{
+			if (state)
+			{
+				OccSensor.EnableLedFlash();
+			}
+			else
+			{
+				OccSensor.DisableLedFlash();
+			}
+		}
+
+		/// <summary>
+		/// Enables or disables short timeout based on state
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetShortTimeoutState(bool state)
+		{
+			if (state)
+			{
+				OccSensor.EnableShortTimeout();
+			}
+			else
+			{
+				OccSensor.DisableShortTimeout();
+			}
+		}
+
+		public void IncrementPirSensitivityInOccupiedState(bool pressRelease)
+		{
+			if ((int)OccSensor.PassiveInfraredSensorSensitivityInOccupiedStateFeedback != 3)
+			{
+				OccSensor.PassiveInfraredSensorSensitivityInOccupiedState = OccSensor.PassiveInfraredSensorSensitivityInOccupiedStateFeedback + 1;
+			}
+		}
+
+		public void DecrementPirSensitivityInOccupiedState(bool pressRelease)
+		{
+			if ((int)OccSensor.PassiveInfraredSensorSensitivityInOccupiedStateFeedback != 0)
+			{
+				OccSensor.PassiveInfraredSensorSensitivityInOccupiedState = OccSensor.PassiveInfraredSensorSensitivityInOccupiedStateFeedback - 1;
+			}
+		}
+
+		public void IncrementPirSensitivityInVacantState(bool pressRelease)
+		{
+			if ((int)OccSensor.PassiveInfraredSensorSensitivityInVacantStateFeedback != 3)
+			{
+				OccSensor.PassiveInfraredSensorSensitivityInVacantState = OccSensor.PassiveInfraredSensorSensitivityInVacantStateFeedback + 1;
+			}
+		}
+
+		public void DecrementPirSensitivityInVacantState(bool pressRelease)
+		{
+			if ((int)OccSensor.PassiveInfraredSensorSensitivityInVacantStateFeedback != 0)
+			{
+				OccSensor.PassiveInfraredSensorSensitivityInVacantState = OccSensor.PassiveInfraredSensorSensitivityInVacantStateFeedback - 1;
+			}
+		}
+
+		public void IncrementUsSensitivityInOccupiedState(bool pressRelease)
+		{
+			if ((int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback < 3)
+			{
+				OccSensor.UltrasonicSensorSensitivityInOccupiedState = OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback + 1;
+			}
+			else if ((int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback > 4)
+			{
+				OccSensor.UltrasonicSensorSensitivityInOccupiedState = OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback - 1;
+			}
+			else if ((int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback == 4)
+			{
+				OccSensor.UltrasonicSensorSensitivityInOccupiedState = 0;
+			}
+		}
+
+		public void DecrementUsSensitivityInOccupiedState(bool pressRelease)
+		{
+			if ((int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback > 0
+				&& (int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback < 4)
+			{
+				OccSensor.UltrasonicSensorSensitivityInOccupiedState = OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback - 1;
+			}
+			else if ((int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback > 3
+				&& (int)OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback < 7)
+			{
+				OccSensor.UltrasonicSensorSensitivityInOccupiedState = OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback + 1;
+			}
+		}
+
+		public void IncrementUsSensitivityInVacantState(bool pressRelease)
+		{
+			if ((int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback < 3)
+			{
+				OccSensor.UltrasonicSensorSensitivityInVacantState = OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback + 1;
+			}
+			else if ((int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback > 4)
+			{
+				OccSensor.UltrasonicSensorSensitivityInVacantState = OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback - 1;
+			}
+			else if ((int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback == 4)
+			{
+				OccSensor.UltrasonicSensorSensitivityInVacantState = 0;
+			}
+		}
+
+		public void DecrementUsSensitivityInVacantState(bool pressRelease)
+		{
+			if ((int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback > 0
+				&& (int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback < 4)
+			{
+				OccSensor.UltrasonicSensorSensitivityInVacantState = OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback - 1;
+			}
+			else if ((int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback > 3
+				&& (int)OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback < 7)
+			{
+				OccSensor.UltrasonicSensorSensitivityInVacantState = OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback + 1;
+			}
+		}
+
+		public void ForceOccupied()
+		{
+			OccSensor.ForceOccupied();
+		}
+
+		public void ForceVacant()
+		{
+			OccSensor.ForceVacant();
+		}
+
+		public void EnableRawStates(bool state)
+		{
+			if (state)
+			{
+				OccSensor.EnableRawStates();
+			}
+			else
+				OccSensor.DisableRawStates();
+		}
+
+		public void SetRemoteTimeout(ushort time)
+		{
+			OccSensor.RemoteTimeout.UShortValue = time;
+		}
+
+		public void SetInternalPhotoSensorMinChange(ushort value)
+		{
+			OccSensor.InternalPhotoSensorMinimumChange.UShortValue = value;
+		}
+
+		/// <summary>
+		/// Sets the OrWhenVacated state
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetOrWhenVacatedState(bool state)
+		{
+			if (state)
+			{
+				OccSensor.OrWhenVacated();
+			}
+		}
+
+		/// <summary>
+		/// Sets the AndWhenVacated state
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetAndWhenVacatedState(bool state)
+		{
+			if (state)
+			{
+				OccSensor.AndWhenVacated();
+			}
+		}
+
+		/// <summary>
+		/// Enables or disables the Ultrasonic A sensor
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetUsAEnable(bool state)
+		{
+			if (state)
+			{
+				OccSensor.EnableUltrasonicSensorSideA();
+			}
+			else
+			{
+				OccSensor.DisableUltrasonicSensorSideA();
+			}
+		}
+
+
+		/// <summary>
+		/// Enables or disables the Ultrasonic B sensor
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetUsBEnable(bool state)
+		{
+			if (state)
+			{
+				OccSensor.EnableUltrasonicSensorSideB();
+			}
+			else
+			{
+				OccSensor.DisableUltrasonicSensorSideB();
+			}
+		}
+
+        /// <summary>
+        /// Sets the US sensor sensitivity for occupied state
+        /// </summary>
+        /// <param name="sensitivity"></param>
+	    public void SetUsSensitivityOccupied(ushort sensitivity)
+        {
+            var level = (eSensitivityLevel) sensitivity;
+            if (level == 0) return;
+
+            OccSensor.UltrasonicSensorSensitivityInOccupiedState = level;
+        }
+
+        /// <summary>
+        /// Sets the US sensor sensitivity for vacant state
+        /// </summary>
+        /// <param name="sensitivity"></param>
+        public void SetUsSensitivityVacant(ushort sensitivity)
+        {
+            var level = (eSensitivityLevel)sensitivity;
+            if (level == 0) return;
+
+            OccSensor.UltrasonicSensorSensitivityInVacantState = level;
+        }
+
+        /// <summary>
+        /// Sets the PIR sensor sensitivity for occupied state
+        /// </summary>
+        /// <param name="sensitivity"></param>
+        public void SetPirSensitivityOccupied(ushort sensitivity)
+        {
+            var level = (eSensitivityLevel)sensitivity;
+            if (level == 0) return;
+
+            OccSensor.PassiveInfraredSensorSensitivityInOccupiedState = level;
+        }
+
+        /// <summary>
+        /// Sets the PIR sensor sensitivity for vacant state
+        /// </summary>
+        /// <param name="sensitivity"></param>
+        public void SetPirSensitivityVacant(ushort sensitivity)
+        {
+            var level = (eSensitivityLevel)sensitivity;
+            if (level == 0) return;
+
+            OccSensor.PassiveInfraredSensorSensitivityInVacantState = level;
+        }
+
+		/// <summary>
+		/// Method to print current settings to console
+		/// </summary>
+		public void GetSettings()
+		{
+			var dash = new string('*', 50);
+			CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+
+            Debug.Console(0, this, "Vacancy Detected: {0}",
+                OccSensor.VacancyDetectedFeedback.BoolValue);
+
+			Debug.Console(0, Key, "Timeout Current: {0} | Remote: {1}",
+				OccSensor.CurrentTimeoutFeedback.UShortValue,
+				OccSensor.RemoteTimeout.UShortValue);
+
+			Debug.Console(0, Key, "Short Timeout Enabled: {0}",
+				OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
+
+			Debug.Console(0, Key, "PIR Sensor Enabled: {0} | Sensitivity Occupied: {1} | Sensitivity Vacant: {2}", 
+				OccSensor.PassiveInfraredSensorEnabledFeedback.BoolValue,
+				OccSensor.PassiveInfraredSensorSensitivityInOccupiedStateFeedback,
+				OccSensor.PassiveInfraredSensorSensitivityInVacantStateFeedback);
+
+			Debug.Console(0, Key, "Ultrasonic Enabled A: {0} | B: {1}", 
+				OccSensor.UltrasonicSensorSideAEnabledFeedback.BoolValue,
+				OccSensor.UltrasonicSensorSideBEnabledFeedback.BoolValue);
+
+			Debug.Console(0, Key, "Ultrasonic Sensitivity Occupied: {0} | Vacant: {1}",
+				OccSensor.UltrasonicSensorSensitivityInOccupiedStateFeedback,
+				OccSensor.UltrasonicSensorSensitivityInVacantStateFeedback);
+
+			CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+		}
+
+
+		public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		{
+			LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
+		}
+
+		protected void LinkOccSensorToApi(CenOdtOccupancySensorBaseController occController,
+			BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		{
+			CenOdtOccupancySensorBaseJoinMap joinMap = new CenOdtOccupancySensorBaseJoinMap(joinStart);
+
+			var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+			if (!string.IsNullOrEmpty(joinMapSerialized))
+				joinMap = JsonConvert.DeserializeObject<CenOdtOccupancySensorBaseJoinMap>(joinMapSerialized);
+
+			if (bridge != null)
+			{
+				bridge.AddJoinMap(Key, joinMap);
+			}
+			else
+			{
+				Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+			}
+
+			Debug.Console(1, occController, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+			occController.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.Online.JoinNumber]);
+			trilist.StringInput[joinMap.Name.JoinNumber].StringValue = occController.Name;
+
+			trilist.OnlineStatusChange += new Crestron.SimplSharpPro.OnlineStatusChangeEventHandler((d, args) =>
+			{
+				if (args.DeviceOnLine)
+				{
+					trilist.StringInput[joinMap.Name.JoinNumber].StringValue = occController.Name;
+				}
+			}
+			);
+
+			// Occupied status
+			trilist.SetSigTrueAction(joinMap.ForceOccupied.JoinNumber, new Action(() => occController.ForceOccupied()));
+			trilist.SetSigTrueAction(joinMap.ForceVacant.JoinNumber, new Action(() => occController.ForceVacant()));
+			occController.RoomIsOccupiedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RoomOccupiedFeedback.JoinNumber]);
+			occController.RoomIsOccupiedFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.RoomVacantFeedback.JoinNumber]);
+			occController.RawOccupancyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyFeedback.JoinNumber]);
+			trilist.SetBoolSigAction(joinMap.EnableRawStates.JoinNumber, new Action<bool>((b) => occController.EnableRawStates(b)));
+
+			// Timouts
+			trilist.SetUShortSigAction(joinMap.Timeout.JoinNumber, new Action<ushort>((u) => occController.SetRemoteTimeout(u)));
+			occController.CurrentTimeoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.Timeout.JoinNumber]);
+			occController.RemoteTimeoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.TimeoutLocalFeedback.JoinNumber]);
+
+			// LED Flash
+			trilist.SetSigTrueAction(joinMap.EnableLedFlash.JoinNumber, new Action(() => occController.SetLedFlashEnable(true)));
+			trilist.SetSigTrueAction(joinMap.DisableLedFlash.JoinNumber, new Action(() => occController.SetLedFlashEnable(false)));
+			occController.LedFlashEnabledFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.EnableLedFlash.JoinNumber]);
+
+			// Short Timeout
+			trilist.SetSigTrueAction(joinMap.EnableShortTimeout.JoinNumber, new Action(() => occController.SetShortTimeoutState(true)));
+			trilist.SetSigTrueAction(joinMap.DisableShortTimeout.JoinNumber, new Action(() => occController.SetShortTimeoutState(false)));
+			occController.ShortTimeoutEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableShortTimeout.JoinNumber]);
+
+			// PIR Sensor
+			trilist.SetSigTrueAction(joinMap.EnablePir.JoinNumber, new Action(() => occController.SetPirEnable(true)));
+			trilist.SetSigTrueAction(joinMap.DisablePir.JoinNumber, new Action(() => occController.SetPirEnable(false)));
+			occController.PirSensorEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnablePir.JoinNumber]);
+
+			// PIR Sensitivity in Occupied State
+			trilist.SetBoolSigAction(joinMap.IncrementPirInOccupiedState.JoinNumber, new Action<bool>((b) => occController.IncrementPirSensitivityInOccupiedState(b)));
+			trilist.SetBoolSigAction(joinMap.DecrementPirInOccupiedState.JoinNumber, new Action<bool>((b) => occController.DecrementPirSensitivityInOccupiedState(b)));
+			occController.PirSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInOccupiedState.JoinNumber]);
+
+			// PIR Sensitivity in Vacant State
+			trilist.SetBoolSigAction(joinMap.IncrementPirInVacantState.JoinNumber, new Action<bool>((b) => occController.IncrementPirSensitivityInVacantState(b)));
+			trilist.SetBoolSigAction(joinMap.DecrementPirInVacantState.JoinNumber, new Action<bool>((b) => occController.DecrementPirSensitivityInVacantState(b)));
+			occController.PirSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInVacantState.JoinNumber]);
+
+			// OR When Vacated
+			trilist.SetBoolSigAction(joinMap.OrWhenVacated.JoinNumber, new Action<bool>((b) => occController.SetOrWhenVacatedState(b)));
+			occController.OrWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.OrWhenVacated.JoinNumber]);
+
+			// AND When Vacated
+			trilist.SetBoolSigAction(joinMap.AndWhenVacated.JoinNumber, new Action<bool>((b) => occController.SetAndWhenVacatedState(b)));
+			occController.AndWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.AndWhenVacated.JoinNumber]);
+
+			// Ultrasonic A Sensor
+			trilist.SetSigTrueAction(joinMap.EnableUsA.JoinNumber, new Action(() => occController.SetUsAEnable(true)));
+			trilist.SetSigTrueAction(joinMap.DisableUsA.JoinNumber, new Action(() => occController.SetUsAEnable(false)));
+			occController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsA.JoinNumber]);
+
+			// Ultrasonic B Sensor
+			trilist.SetSigTrueAction(joinMap.EnableUsB.JoinNumber, new Action(() => occController.SetUsBEnable(true)));
+			trilist.SetSigTrueAction(joinMap.DisableUsB.JoinNumber, new Action(() => occController.SetUsBEnable(false)));
+			occController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsB.JoinNumber]);
+
+			// US Sensitivity in Occupied State
+			trilist.SetBoolSigAction(joinMap.IncrementUsInOccupiedState.JoinNumber, new Action<bool>((b) => occController.IncrementUsSensitivityInOccupiedState(b)));
+			trilist.SetBoolSigAction(joinMap.DecrementUsInOccupiedState.JoinNumber, new Action<bool>((b) => occController.DecrementUsSensitivityInOccupiedState(b)));
+			occController.UltrasonicSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInOccupiedState.JoinNumber]);
+
+			// US Sensitivity in Vacant State
+			trilist.SetBoolSigAction(joinMap.IncrementUsInVacantState.JoinNumber, new Action<bool>((b) => occController.IncrementUsSensitivityInVacantState(b)));
+			trilist.SetBoolSigAction(joinMap.DecrementUsInVacantState.JoinNumber, new Action<bool>((b) => occController.DecrementUsSensitivityInVacantState(b)));
+			occController.UltrasonicSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInVacantState.JoinNumber]);
+
+			//Sensor Raw States
+			occController.RawOccupancyPirFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyPirFeedback.JoinNumber]);
+			occController.RawOccupancyUsFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyUsFeedback.JoinNumber]);  
+         
+            // Identity mode
+		    trilist.SetBoolSigAction(joinMap.IdentityMode.JoinNumber, occController.SetIdentityMode);
+            occController.IdentityModeFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IdentityModeFeedback.JoinNumber]);
+		}
+
+		public class CenOdtOccupancySensorBaseControllerFactory : EssentialsDeviceFactory<CenOdtOccupancySensorBaseController>
+		{
+			public CenOdtOccupancySensorBaseControllerFactory()
+			{
+				TypeNames = new List<string>() { "cenodtcpoe", "cenodtocc" };
+			}
+
+			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 props = dc.Properties.ToObject<GlsOccupancySensorPropertiesConfig>();
+
+				var occSensor = new CenOdtCPoe(comm.IpIdInt, Global.ControlSystem);
+
+				if (occSensor == null)
+				{
+					Debug.Console(0, "ERROR: Unable to create Occupancy Sensor Device. Key: '{0}'", key);
+					return null;
+				}
+
+				return new CenOdtOccupancySensorBaseController(key, name, occSensor, props);
+			}
+		}
+	}
+}

src/PepperDash.Essentials.Core/Occupancy/EssentialsGlsOccupancySensorBaseController.cs.orig

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.GeneralIO;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Devices.Common.Occupancy
+{
+    public class EssentialsGlsOccupancySensorBaseController : CrestronGenericBaseDevice, IOccupancyStatusProvider
+    {
+        public GlsOccupancySensorBase OccSensor { get; private set; }
+
+        public BoolFeedback RoomIsOccupiedFeedback { get; private set; }
+
+<<<<<<< HEAD
+		/// <summary>
+		/// Set by debugging functions	
+		/// </summary>
+		public bool InMockMode { get; private set; }
+
+		public bool MockRoomIsOccupiedFeedback { get; private set; }
+=======
+        // Debug properties
+        public bool InTestMode { get; private set; }
+
+        public bool TestRoomIsOccupiedFeedback { get; private set; }
+>>>>>>> origin/feature/ecs-342-neil
+
+        public Func<bool> RoomIsOccupiedFeedbackFunc
+        {
+            get
+            {
+<<<<<<< HEAD
+                return () => InMockMode ? MockRoomIsOccupiedFeedback : OccSensor.OccupancyDetectedFeedback.BoolValue;
+=======
+                return () => InTestMode ? TestRoomIsOccupiedFeedback : OccSensor.OccupancyDetectedFeedback.BoolValue;
+>>>>>>> origin/feature/ecs-342-neil
+            }
+        }
+
+        public EssentialsGlsOccupancySensorBaseController(string key, string name, GlsOccupancySensorBase sensor, GlsOccupancySensorConfigurationProperties props)
+            : base(key, name, sensor)
+        {
+            OccSensor = sensor;
+			RoomIsOccupiedFeedback = new BoolFeedback(RoomIsOccupiedFeedbackFunc);
+
+            OccSensor.GlsOccupancySensorChange += new GlsOccupancySensorChangeEventHandler(sensor_GlsOccupancySensorChange);
+        }
+
+        void sensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
+        {
+            RoomIsOccupiedFeedback.FireUpdate();
+        }
+
+        public void SetTestMode(bool mode)
+        {
+            InTestMode = mode;
+
+            Debug.Console(1, this, "In Mock Mode: '{0}'", InTestMode);
+        }
+
+        public void SetTestOccupiedState(bool state)
+        {
+            if (!InTestMode)
+                Debug.Console(1, "Mock mode not enabled");
+            else
+            {
+                TestRoomIsOccupiedFeedback = state;
+
+                RoomIsOccupiedFeedback.FireUpdate();
+            }
+        }
+    }
+
+	/// <summary>
+	/// 
+	/// </summary>
+    public class GlsOccupancySensorConfigurationProperties
+    {
+        public string CresnetId { get; set; }
+        public string Model { get; set; }
+    }
+}

src/PepperDash.Essentials.Core/Occupancy/GlsOccupancySensorBaseController.cs

@@ -0,0 +1,541 @@
+extern alias Full;
+
+using System;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using Full.Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.Core
+{
+	[Description("Wrapper class for Single Technology GLS Occupancy Sensors")]
+    [ConfigSnippet("\"properties\": {\"control\": {\"method\": \"cresnet\",\"cresnetId\": \"97\"},\"enablePir\": true,\"enableLedFlash\": true,\"enableRawStates\":true,\"remoteTimeout\": 30,\"internalPhotoSensorMinChange\": 0,\"externalPhotoSensorMinChange\": 0}")]
+	public abstract class GlsOccupancySensorBaseController : CrestronGenericBridgeableBaseDevice, IOccupancyStatusProvider
+	{
+        public GlsOccupancySensorPropertiesConfig PropertiesConfig { get; private set; }
+
+	    protected GlsOccupancySensorBase OccSensor;
+
+		public BoolFeedback RoomIsOccupiedFeedback { get; private set; }
+
+		public BoolFeedback GraceOccupancyDetectedFeedback { get; private set; }
+
+		public BoolFeedback RawOccupancyFeedback { get; private set; }
+
+		public BoolFeedback PirSensorEnabledFeedback { get; private set; }
+
+		public BoolFeedback LedFlashEnabledFeedback { get; private set; }
+
+		public BoolFeedback ShortTimeoutEnabledFeedback { get; private set; }
+
+		public IntFeedback PirSensitivityInVacantStateFeedback { get; private set; }
+
+		public IntFeedback PirSensitivityInOccupiedStateFeedback { get; private set; }
+
+		public IntFeedback CurrentTimeoutFeedback { get; private set; }
+
+		public IntFeedback LocalTimoutFeedback { get; private set; }
+
+		public IntFeedback InternalPhotoSensorValue { get; set; }
+
+		public IntFeedback ExternalPhotoSensorValue { get; set; }
+
+		// Debug properties
+		public bool InTestMode { get; private set; }
+
+		public bool TestRoomIsOccupiedFeedback { get; private set; }
+
+		public Func<bool> RoomIsOccupiedFeedbackFunc
+		{
+			get
+			{
+				return () => InTestMode ? TestRoomIsOccupiedFeedback : OccSensor.OccupancyDetectedFeedback.BoolValue;
+			}
+		}
+
+	    protected GlsOccupancySensorBaseController(string key, DeviceConfig config)
+			: this(key, config.Name, config)
+		{
+		}
+
+	    protected GlsOccupancySensorBaseController(string key, string name, DeviceConfig config)
+            : base(key, name) 
+        {
+
+            var props = config.Properties.ToObject<GlsOccupancySensorPropertiesConfig>();
+
+            if (props != null)
+            {
+                PropertiesConfig = props;
+            }
+            else
+            {
+                Debug.Console(1, this, "props are null.  Unable to deserialize into GlsOccupancySensorPropertiesConfig");
+            }
+
+            AddPostActivationAction(() =>
+                {
+                    OccSensor.OnlineStatusChange += (o, a) =>
+                    {
+                        if (a.DeviceOnLine)
+                        {
+                            ApplySettingsToSensorFromConfig();
+                        }
+                    };
+
+                    if (OccSensor.IsOnline)
+                    {
+                        ApplySettingsToSensorFromConfig();
+
+                    }
+                });
+        }
+
+
+        /// <summary>
+        /// Applies any sensor settings defined in config 
+        /// </summary>
+        protected virtual void ApplySettingsToSensorFromConfig()
+        {
+            Debug.Console(1, this, "Attempting to apply settings to sensor from config");
+
+            if (PropertiesConfig.EnablePir != null)
+            {
+                Debug.Console(1, this, "EnablePir found, attempting to set value from config");
+                SetPirEnable((bool)PropertiesConfig.EnablePir);
+            }
+            else
+            {
+                Debug.Console(1, this, "EnablePir null, no value specified in config");
+            }
+
+            if (PropertiesConfig.EnableLedFlash != null)
+            {
+                Debug.Console(1, this, "EnableLedFlash found, attempting to set value from config");
+                SetLedFlashEnable((bool)PropertiesConfig.EnableLedFlash);
+            }
+
+            if (PropertiesConfig.RemoteTimeout != null)
+            {
+                Debug.Console(1, this, "RemoteTimeout found, attempting to set value from config");
+                SetRemoteTimeout((ushort)PropertiesConfig.RemoteTimeout);
+            }
+            else
+            {
+                Debug.Console(1, this, "RemoteTimeout null, no value specified in config");
+            }
+
+            if (PropertiesConfig.ShortTimeoutState != null)
+            {
+                SetShortTimeoutState((bool)PropertiesConfig.ShortTimeoutState);
+            }
+
+            if (PropertiesConfig.EnableRawStates != null)
+            {
+                EnableRawStates((bool)PropertiesConfig.EnableRawStates);
+            }
+
+            if (PropertiesConfig.InternalPhotoSensorMinChange != null)
+            {
+                SetInternalPhotoSensorMinChange((ushort)PropertiesConfig.InternalPhotoSensorMinChange);
+            }
+
+            if (PropertiesConfig.ExternalPhotoSensorMinChange != null)
+            {
+                SetExternalPhotoSensorMinChange((ushort)PropertiesConfig.ExternalPhotoSensorMinChange);
+            }
+        }
+
+		protected void RegisterGlsOccupancySensorBaseController(GlsOccupancySensorBase occSensor)
+		{
+			OccSensor = occSensor;
+
+			RoomIsOccupiedFeedback = new BoolFeedback(RoomIsOccupiedFeedbackFunc);
+
+			PirSensorEnabledFeedback = new BoolFeedback(() => OccSensor.PirEnabledFeedback.BoolValue);
+
+			LedFlashEnabledFeedback = new BoolFeedback(() => OccSensor.LedFlashEnabledFeedback.BoolValue);
+
+			ShortTimeoutEnabledFeedback = new BoolFeedback(() => OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
+
+			PirSensitivityInVacantStateFeedback =
+				new IntFeedback(() => OccSensor.PirSensitivityInVacantStateFeedback.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);
+
+			RawOccupancyFeedback = new BoolFeedback(() => OccSensor.RawOccupancyFeedback.BoolValue);
+
+			InternalPhotoSensorValue = new IntFeedback(() => OccSensor.InternalPhotoSensorValueFeedback.UShortValue);
+
+			ExternalPhotoSensorValue = new IntFeedback(() => OccSensor.ExternalPhotoSensorValueFeedback.UShortValue);
+
+			OccSensor.BaseEvent += OccSensor_BaseEvent;
+
+			OccSensor.GlsOccupancySensorChange += OccSensor_GlsOccupancySensorChange;
+		}
+
+
+		/// <summary>
+		/// Catches events for feedbacks on the base class.  Any extending wrapper class should call this delegate after it checks for it's own event IDs.
+		/// </summary>
+		/// <param name="device"></param>
+		/// <param name="args"></param>
+		protected virtual void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
+		{
+			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);
+
+			switch (args.EventId)
+			{
+				case GlsOccupancySensorBase.RoomVacantFeedbackEventId:
+				case 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;
+			}
+		}
+
+		public void SetTestMode(bool mode)
+		{
+			InTestMode = mode;
+
+			Debug.Console(1, this, "In Mock Mode: '{0}'", InTestMode);
+		}
+
+		public void SetTestOccupiedState(bool state)
+		{
+			if (!InTestMode)
+				Debug.Console(1, "Mock mode not enabled");
+			else
+			{
+				TestRoomIsOccupiedFeedback = state;
+
+				RoomIsOccupiedFeedback.FireUpdate();
+			}
+		}
+
+	    /// <summary>
+	    /// Enables or disables the PIR sensor
+	    /// </summary>
+	    /// <param name="state"></param>
+	    public void SetPirEnable(bool state)
+	    {
+	        Debug.Console(1, this, "Setting EnablePir to: {0}", state);
+
+	        OccSensor.EnablePir.BoolValue = state;
+	        OccSensor.DisablePir.BoolValue = !state;
+	    }
+
+	    /// <summary>
+	    /// Enables or disables the LED Flash
+	    /// </summary>
+	    /// <param name="state"></param>
+	    public void SetLedFlashEnable(bool state)
+	    {
+	        OccSensor.EnableLedFlash.BoolValue = state;
+	        OccSensor.DisableLedFlash.BoolValue = !state;
+	    }
+
+	    /// <summary>
+	    /// Enables or disables short timeout based on state
+	    /// </summary>
+	    /// <param name="state"></param>
+	    public void SetShortTimeoutState(bool state)
+	    {
+	        OccSensor.EnableShortTimeout.BoolValue = state;
+	        OccSensor.DisableShortTimeout.BoolValue = !state;
+	    }
+
+	    public void IncrementPirSensitivityInOccupiedState(bool pressRelease)
+		{
+			OccSensor.IncrementPirSensitivityInOccupiedState.BoolValue = pressRelease;
+		}
+
+		public void DecrementPirSensitivityInOccupiedState(bool pressRelease)
+		{
+			OccSensor.DecrementPirSensitivityInOccupiedState.BoolValue = pressRelease;
+		}
+
+		public void IncrementPirSensitivityInVacantState(bool pressRelease)
+		{
+			OccSensor.IncrementPirSensitivityInVacantState.BoolValue = pressRelease;
+		}
+
+		public void DecrementPirSensitivityInVacantState(bool pressRelease)
+		{
+			OccSensor.DecrementPirSensitivityInVacantState.BoolValue = pressRelease;
+		}
+
+        /// <summary>
+        /// Pulse ForceOccupied on the sensor for .5 seconds
+        /// </summary>
+	    public void ForceOccupied()
+	    {
+	        CrestronInvoke.BeginInvoke((o) =>
+	        {
+	            ForceOccupied(true);
+	            CrestronEnvironment.Sleep(500);
+	            ForceOccupied(false);
+	        });
+	    }
+
+		public void ForceOccupied(bool value)
+		{
+			OccSensor.ForceOccupied.BoolValue = value;
+		}
+
+        /// <summary>
+        /// Pulse ForceVacant on the sensor for .5 seconds
+        /// </summary>
+	    public void ForceVacant()
+	    {
+            CrestronInvoke.BeginInvoke((o) =>
+            {
+                ForceVacant(true);
+                CrestronEnvironment.Sleep(500);
+                ForceVacant(false);
+            });
+	    }
+
+		public void ForceVacant(bool value)
+		{
+			OccSensor.ForceVacant.BoolValue = value;
+		}
+
+		public void EnableRawStates(bool state)
+		{
+			OccSensor.EnableRawStates.BoolValue = state;
+		}
+
+		public void SetRemoteTimeout(ushort time)
+		{
+            Debug.Console(1, this, "Setting RemoteTimout to: {0}", time);
+
+			OccSensor.RemoteTimeout.UShortValue = time;
+		}
+
+		public void SetInternalPhotoSensorMinChange(ushort value)
+		{
+			OccSensor.InternalPhotoSensorMinimumChange.UShortValue = value;
+		}
+
+		public void SetExternalPhotoSensorMinChange(ushort value)
+		{
+			OccSensor.ExternalPhotoSensorMinimumChange.UShortValue = value;
+		}
+
+	    /// <summary>
+	    /// Method to print current occ settings to console.
+	    /// </summary>
+	    public virtual void GetSettings()
+		{
+			var dash = new string('*', 50);
+			CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+
+            Debug.Console(0, this, "Vacancy Detected: {0}",
+                OccSensor.VacancyDetectedFeedback.BoolValue);
+
+			Debug.Console(0, this, "Timeout Current: {0} | Local: {1}",
+				OccSensor.CurrentTimeoutFeedback.UShortValue,
+				OccSensor.LocalTimeoutFeedback.UShortValue);
+
+			Debug.Console(0, this, "Short Timeout Enabled: {0}",
+				OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
+
+			Debug.Console(0, this, "PIR Sensor Enabled: {0} | Sensitivity Occupied: {1} | Sensitivity Vacant: {2}",
+				OccSensor.PirEnabledFeedback.BoolValue,
+				OccSensor.PirSensitivityInOccupiedStateFeedback.UShortValue,
+				OccSensor.PirSensitivityInVacantStateFeedback.UShortValue);
+
+			CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+		}
+
+		protected void LinkOccSensorToApi(GlsOccupancySensorBaseController occController, BasicTriList trilist,
+			uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		{
+			var joinMap = new GlsOccupancySensorBaseJoinMap(joinStart);
+
+			var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+			if (!string.IsNullOrEmpty(joinMapSerialized))
+				joinMap = JsonConvert.DeserializeObject<GlsOccupancySensorBaseJoinMap>(joinMapSerialized);
+
+			if (bridge != null)
+			{
+				bridge.AddJoinMap(Key, joinMap);
+			}
+			else
+			{
+				Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+			}
+
+			Debug.Console(1, occController, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+			occController.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+			trilist.StringInput[joinMap.Name.JoinNumber].StringValue = occController.Name;
+
+			trilist.OnlineStatusChange += (d, args) =>
+			{
+				if (args.DeviceOnLine)
+				{
+					trilist.StringInput[joinMap.Name.JoinNumber].StringValue = occController.Name;
+				}
+			};
+
+			LinkSingleTechSensorToApi(occController, trilist, joinMap);
+
+			LinkDualTechSensorToApi(occController, trilist, joinMap);
+		}
+
+	    private static void LinkDualTechSensorToApi(GlsOccupancySensorBaseController occController, BasicTriList trilist,
+	        GlsOccupancySensorBaseJoinMap joinMap)
+	    {
+	        var odtOccController = occController as GlsOdtOccupancySensorController;
+
+	        if (odtOccController == null)
+	        {
+	            return;
+	        }
+	        // OR When Vacated
+	        trilist.SetBoolSigAction(joinMap.OrWhenVacated.JoinNumber, odtOccController.SetOrWhenVacatedState);
+	        odtOccController.OrWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.OrWhenVacated.JoinNumber]);
+
+	        // AND When Vacated
+	        trilist.SetBoolSigAction(joinMap.AndWhenVacated.JoinNumber, odtOccController.SetAndWhenVacatedState);
+	        odtOccController.AndWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.AndWhenVacated.JoinNumber]);
+
+	        // Ultrasonic A Sensor
+	        trilist.SetSigTrueAction(joinMap.EnableUsA.JoinNumber, () => odtOccController.SetUsAEnable(true));
+	        trilist.SetSigTrueAction(joinMap.DisableUsA.JoinNumber, () => odtOccController.SetUsAEnable(false));
+	        odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsA.JoinNumber]);
+
+	        // Ultrasonic B Sensor
+	        trilist.SetSigTrueAction(joinMap.EnableUsB.JoinNumber, () => odtOccController.SetUsBEnable(true));
+	        trilist.SetSigTrueAction(joinMap.DisableUsB.JoinNumber, () => odtOccController.SetUsBEnable(false));
+	        odtOccController.UltrasonicBEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsB.JoinNumber]);
+
+	        // US Sensitivity in Occupied State
+	        trilist.SetBoolSigAction(joinMap.IncrementUsInOccupiedState.JoinNumber,
+	            odtOccController.IncrementUsSensitivityInOccupiedState);
+	        trilist.SetBoolSigAction(joinMap.DecrementUsInOccupiedState.JoinNumber,
+	            odtOccController.DecrementUsSensitivityInOccupiedState);
+	        odtOccController.UltrasonicSensitivityInOccupiedStateFeedback.LinkInputSig(
+	            trilist.UShortInput[joinMap.UsSensitivityInOccupiedState.JoinNumber]);
+
+	        // US Sensitivity in Vacant State
+	        trilist.SetBoolSigAction(joinMap.IncrementUsInVacantState.JoinNumber,
+	            odtOccController.IncrementUsSensitivityInVacantState);
+	        trilist.SetBoolSigAction(joinMap.DecrementUsInVacantState.JoinNumber,
+	            odtOccController.DecrementUsSensitivityInVacantState);
+	        odtOccController.UltrasonicSensitivityInVacantStateFeedback.LinkInputSig(
+	            trilist.UShortInput[joinMap.UsSensitivityInVacantState.JoinNumber]);
+
+	        //Sensor Raw States
+	        odtOccController.RawOccupancyPirFeedback.LinkInputSig(
+	            trilist.BooleanInput[joinMap.RawOccupancyPirFeedback.JoinNumber]);
+	        odtOccController.RawOccupancyUsFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyUsFeedback.JoinNumber]);
+	    }
+
+	    private static void LinkSingleTechSensorToApi(GlsOccupancySensorBaseController occController, BasicTriList trilist,
+	        GlsOccupancySensorBaseJoinMap joinMap)
+	    {
+// Occupied status
+	        trilist.SetBoolSigAction(joinMap.ForceOccupied.JoinNumber, occController.ForceOccupied);
+	        trilist.SetBoolSigAction(joinMap.ForceVacant.JoinNumber, occController.ForceVacant);
+	        occController.RoomIsOccupiedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RoomOccupiedFeedback.JoinNumber]);
+	        occController.RoomIsOccupiedFeedback.LinkComplementInputSig(
+	            trilist.BooleanInput[joinMap.RoomVacantFeedback.JoinNumber]);
+	        occController.RawOccupancyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyFeedback.JoinNumber]);
+	        trilist.SetBoolSigAction(joinMap.EnableRawStates.JoinNumber, occController.EnableRawStates);
+
+	        // Timouts
+	        trilist.SetUShortSigAction(joinMap.Timeout.JoinNumber, occController.SetRemoteTimeout);
+	        occController.CurrentTimeoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.Timeout.JoinNumber]);
+	        occController.LocalTimoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.TimeoutLocalFeedback.JoinNumber]);
+
+	        // LED Flash
+	        trilist.SetSigTrueAction(joinMap.EnableLedFlash.JoinNumber, () => occController.SetLedFlashEnable(true));
+	        trilist.SetSigTrueAction(joinMap.DisableLedFlash.JoinNumber, () => occController.SetLedFlashEnable(false));
+	        occController.LedFlashEnabledFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.EnableLedFlash.JoinNumber]);
+
+	        // Short Timeout
+	        trilist.SetSigTrueAction(joinMap.EnableShortTimeout.JoinNumber, () => occController.SetShortTimeoutState(true));
+	        trilist.SetSigTrueAction(joinMap.DisableShortTimeout.JoinNumber, () => occController.SetShortTimeoutState(false));
+	        occController.ShortTimeoutEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableShortTimeout.JoinNumber]);
+
+	        // PIR Sensor
+	        trilist.SetSigTrueAction(joinMap.EnablePir.JoinNumber, () => occController.SetPirEnable(true));
+	        trilist.SetSigTrueAction(joinMap.DisablePir.JoinNumber, () => occController.SetPirEnable(false));
+	        occController.PirSensorEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnablePir.JoinNumber]);
+
+	        // PIR Sensitivity in Occupied State
+	        trilist.SetBoolSigAction(joinMap.IncrementPirInOccupiedState.JoinNumber,
+	            occController.IncrementPirSensitivityInOccupiedState);
+	        trilist.SetBoolSigAction(joinMap.DecrementPirInOccupiedState.JoinNumber,
+	            occController.DecrementPirSensitivityInOccupiedState);
+	        occController.PirSensitivityInOccupiedStateFeedback.LinkInputSig(
+	            trilist.UShortInput[joinMap.PirSensitivityInOccupiedState.JoinNumber]);
+
+	        // PIR Sensitivity in Vacant State
+	        trilist.SetBoolSigAction(joinMap.IncrementPirInVacantState.JoinNumber,
+	            occController.IncrementPirSensitivityInVacantState);
+	        trilist.SetBoolSigAction(joinMap.DecrementPirInVacantState.JoinNumber,
+	            occController.DecrementPirSensitivityInVacantState);
+	        occController.PirSensitivityInVacantStateFeedback.LinkInputSig(
+	            trilist.UShortInput[joinMap.PirSensitivityInVacantState.JoinNumber]);
+	    }
+	}
+
+
+
+}

src/PepperDash.Essentials.Core/Occupancy/GlsOccupancySensorPropertiesConfig.cs

@@ -0,0 +1,83 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using Full.Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines configuration properties for Crestron GLS series occupancy sensors
+    /// </summary>
+    public class GlsOccupancySensorPropertiesConfig
+    {
+        // Single Technology Sensors (PIR): GlsOccupancySensorBase
+        [JsonProperty("enablePir")]
+        public bool? EnablePir { get; set; }
+
+        [JsonProperty("enableLedFlash")]
+        public bool? EnableLedFlash { get; set; }
+
+        [JsonProperty("shortTimeoutState")]
+        public bool? ShortTimeoutState { get; set; }
+
+        [JsonProperty("enableRawStates")]
+        public bool? EnableRawStates { get; set; }
+
+        [JsonProperty("remoteTimeout")]
+        public ushort? RemoteTimeout { get; set; }
+
+        [JsonProperty("internalPhotoSensorMinChange")]
+        public ushort? InternalPhotoSensorMinChange { get; set; }
+
+        [JsonProperty("externalPhotoSensorMinChange")]
+        public ushort? ExternalPhotoSensorMinChange { get; set; }
+
+        // Dual Technology Sensors: GlsOdtCCn
+        [JsonProperty("enableUsA")]
+        public bool? EnableUsA { get; set; }
+
+        [JsonProperty("enableUsB")]
+        public bool? EnableUsB { get; set; }
+
+        [JsonProperty("orWhenVacatedState")]
+        public bool? OrWhenVacatedState { get; set; }
+
+        [JsonProperty("andWhenVacatedState")]
+        public bool? AndWhenVacatedState { get; set; }
+
+        // PoE Sensors: CenOdtCPoe
+
+        /// <summary>
+        /// Sets the sensitivity level for US while sensor is in occupied state
+        /// 1 = low; 2 = medium; 3 = high; 4 = xlow; 5 = 2xlow; 6 = 3xlow
+        /// </summary>
+        [JsonProperty("usSensitivityOccupied")]
+        public ushort? UsSensitivityOccupied { get; set; }
+
+        /// <summary>
+        /// Sets the sensitivity level for US while sensor is in vacant state
+        /// 1 = low; 2 = medium; 3 = high; 4 = xlow; 5 = 2xlow; 6 = 3xlow
+        /// </summary>
+        [JsonProperty("usSensitivityVacant")]
+        public ushort? UsSensitivityVacant { get; set; }
+
+        /// <summary>
+        /// Sets the sensitivity level for PIR while sensor is in occupied state
+        /// 1 = low; 2 = medium; 3 = high
+        /// </summary>
+        [JsonProperty("pirSensitivityOccupied")]
+        public ushort? PirSensitivityOccupied { get; set; }
+
+        /// <summary>
+        /// Sets the sensitivity level for PIR while sensor is in vacant state
+        /// 1 = low; 2 = medium; 3 = high
+        /// </summary>
+        [JsonProperty("pirSensitivityVacant")]
+        public ushort? PirSensitivityVacant { get; set; }
+    }
+}

src/PepperDash.Essentials.Core/Occupancy/GlsOdtOccupancySensorController.cs

@@ -0,0 +1,284 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.Core
+{
+	[Description("Wrapper class for Dual Technology GLS Occupancy Sensors")]
+    [ConfigSnippet("\"properties\": {\"control\": {\"method\": \"cresnet\",\"cresnetId\": \"97\"},\"enablePir\": true,\"enableLedFlash\": true,\"enableRawStates\":true,\"remoteTimeout\": 30,\"internalPhotoSensorMinChange\": 0,\"externalPhotoSensorMinChange\": 0,\"enableUsA\": true,\"enableUsB\": true,\"orWhenVacatedState\": true}")]
+    public class GlsOdtOccupancySensorController : GlsOccupancySensorBaseController
+	{
+	    private GlsOdtCCn _occSensor;
+
+		public BoolFeedback OrWhenVacatedFeedback { get; private set; }
+
+		public BoolFeedback AndWhenVacatedFeedback { get; private set; }
+
+		public BoolFeedback UltrasonicAEnabledFeedback { get; private set; }
+
+		public BoolFeedback UltrasonicBEnabledFeedback { get; private set; }
+
+		public IntFeedback UltrasonicSensitivityInVacantStateFeedback { get; private set; }
+
+		public IntFeedback UltrasonicSensitivityInOccupiedStateFeedback { get; private set; }
+
+		public BoolFeedback RawOccupancyPirFeedback { get; private set; }
+
+		public BoolFeedback RawOccupancyUsFeedback { get; private set; }
+
+
+		public GlsOdtOccupancySensorController(string key, Func<DeviceConfig, GlsOdtCCn> preActivationFunc,
+			DeviceConfig config)
+			: base(key, config.Name, config)
+		{
+			AddPreActivationAction(() =>
+			{
+				_occSensor = preActivationFunc(config);
+
+				RegisterCrestronGenericBase(_occSensor);
+
+				RegisterGlsOccupancySensorBaseController(_occSensor);
+
+				AndWhenVacatedFeedback = new BoolFeedback(() => _occSensor.AndWhenVacatedFeedback.BoolValue);
+
+				OrWhenVacatedFeedback = new BoolFeedback(() => _occSensor.OrWhenVacatedFeedback.BoolValue);
+
+				UltrasonicAEnabledFeedback = new BoolFeedback(() => _occSensor.UsAEnabledFeedback.BoolValue);
+
+				UltrasonicBEnabledFeedback = new BoolFeedback(() => _occSensor.UsBEnabledFeedback.BoolValue);
+
+				RawOccupancyPirFeedback = new BoolFeedback(() => _occSensor.RawOccupancyPirFeedback.BoolValue);
+
+				RawOccupancyUsFeedback = new BoolFeedback(() => _occSensor.RawOccupancyUsFeedback.BoolValue);
+
+				UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => _occSensor.UsSensitivityInVacantStateFeedback.UShortValue);
+
+				UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => _occSensor.UsSensitivityInOccupiedStateFeedback.UShortValue);
+
+			});	
+		}
+
+        protected override void ApplySettingsToSensorFromConfig()
+        {
+            base.ApplySettingsToSensorFromConfig();
+
+            if (PropertiesConfig.EnableUsA != null)
+            {
+                Debug.Console(1, this, "EnableUsA found, attempting to set value from config");
+                SetUsAEnable((bool)PropertiesConfig.EnableUsA);   
+            }
+            else
+            {
+                Debug.Console(1, this, "EnableUsA null, no value specified in config");
+            }
+
+
+            if (PropertiesConfig.EnableUsB != null)
+            {
+                Debug.Console(1, this, "EnableUsB found, attempting to set value from config");
+                SetUsBEnable((bool)PropertiesConfig.EnableUsB);
+            }
+            else
+            {
+                Debug.Console(1, this, "EnablePir null, no value specified in config");
+            }
+
+
+            if (PropertiesConfig.OrWhenVacatedState != null)
+            {
+                SetOrWhenVacatedState((bool)PropertiesConfig.OrWhenVacatedState);
+            }
+
+            if (PropertiesConfig.AndWhenVacatedState != null)
+            {
+                SetAndWhenVacatedState((bool)PropertiesConfig.AndWhenVacatedState);
+            }
+        }
+
+		/// <summary>
+		/// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
+		/// Then calls the base delegate method to ensure any common event IDs are captured.
+		/// </summary>
+		/// <param name="device"></param>
+		/// <param name="args"></param>
+		protected override void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
+		{
+		    switch (args.EventId)
+		    {
+		        case GlsOccupancySensorBase.AndWhenVacatedFeedbackEventId:
+		            AndWhenVacatedFeedback.FireUpdate();
+		            break;
+		        case GlsOccupancySensorBase.OrWhenVacatedFeedbackEventId:
+		            OrWhenVacatedFeedback.FireUpdate();
+		            break;
+		        case GlsOccupancySensorBase.UsAEnabledFeedbackEventId:
+		            UltrasonicAEnabledFeedback.FireUpdate();
+		            break;
+		        case GlsOccupancySensorBase.UsBEnabledFeedbackEventId:
+		            UltrasonicBEnabledFeedback.FireUpdate();
+		            break;
+		        case GlsOccupancySensorBase.UsSensitivityInOccupiedStateFeedbackEventId:
+		            UltrasonicSensitivityInOccupiedStateFeedback.FireUpdate();
+		            break;
+		        case GlsOccupancySensorBase.UsSensitivityInVacantStateFeedbackEventId:
+		            UltrasonicSensitivityInVacantStateFeedback.FireUpdate();
+		            break;
+		    }
+
+		    base.OccSensor_GlsOccupancySensorChange(device, args);
+		}
+
+	    /// <summary>
+		/// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
+		/// Then calls the base delegate method to ensure any common event IDs are captured.
+		/// </summary>
+		/// <param name="device"></param>
+		/// <param name="args"></param>
+		protected override void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+	    {
+	        switch (args.EventId)
+	        {
+	            case GlsOccupancySensorBase.RawOccupancyPirFeedbackEventId:
+	                RawOccupancyPirFeedback.FireUpdate();
+	                break;
+	            case GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId:
+	                RawOccupancyUsFeedback.FireUpdate();
+	                break;
+	        }
+
+	        base.OccSensor_BaseEvent(device, args);
+	    }
+
+	    /// <summary>
+		/// Sets the OrWhenVacated state
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetOrWhenVacatedState(bool state)
+		{
+			_occSensor.OrWhenVacated.BoolValue = state;
+		}
+
+		/// <summary>
+		/// Sets the AndWhenVacated state
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetAndWhenVacatedState(bool state)
+		{
+			_occSensor.AndWhenVacated.BoolValue = state;
+		}
+
+		/// <summary>
+		/// Enables or disables the Ultrasonic A sensor
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetUsAEnable(bool state)
+		{
+			_occSensor.EnableUsA.BoolValue = state;
+			_occSensor.DisableUsA.BoolValue = !state;
+		}
+
+
+		/// <summary>
+		/// Enables or disables the Ultrasonic B sensor
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetUsBEnable(bool state)
+		{
+			_occSensor.EnableUsB.BoolValue = state;
+			_occSensor.DisableUsB.BoolValue = !state;
+		}
+
+		public void IncrementUsSensitivityInOccupiedState(bool pressRelease)
+		{
+			_occSensor.IncrementUsSensitivityInOccupiedState.BoolValue = pressRelease;
+		}
+
+		public void DecrementUsSensitivityInOccupiedState(bool pressRelease)
+		{
+			_occSensor.DecrementUsSensitivityInOccupiedState.BoolValue = pressRelease;
+		}
+
+		public void IncrementUsSensitivityInVacantState(bool pressRelease)
+		{
+			_occSensor.IncrementUsSensitivityInVacantState.BoolValue = pressRelease;
+		}
+
+		public void DecrementUsSensitivityInVacantState(bool pressRelease)
+		{
+			_occSensor.DecrementUsSensitivityInVacantState.BoolValue = pressRelease;
+		}
+
+		public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		{
+			LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
+		}
+
+		/// <summary>
+		/// Method to print occ sensor settings to console.
+		/// </summary>
+		public override void GetSettings()
+		{
+            base.GetSettings();
+
+			Debug.Console(0, this, "Ultrasonic Enabled A: {0} | B: {1}",
+				_occSensor.UsAEnabledFeedback.BoolValue,
+				_occSensor.UsBEnabledFeedback.BoolValue);
+
+			Debug.Console(0, this, "Ultrasonic Sensitivity Occupied: {0} | Vacant: {1}",
+				_occSensor.UsSensitivityInOccupiedStateFeedback.UShortValue,
+				_occSensor.UsSensitivityInVacantStateFeedback.UShortValue);
+
+            var dash = new string('*', 50);
+			CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+		}
+
+	}
+
+    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);
+        }
+
+        private static GlsOdtCCn GetGlsOdtCCn(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 GlsOdtCCn", parentKey);
+                return new GlsOdtCCn(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 GlsOdtCCn", parentKey);
+                return new GlsOdtCCn(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+    }
+
+
+
+}

src/PepperDash.Essentials.Core/Occupancy/GlsOirOccupancySensorController.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core
+{
+    public class GlsOirOccupancySensorController:GlsOccupancySensorBaseController
+    {
+        private GlsOirCCn _occSensor;
+
+        public GlsOirOccupancySensorController(string key, Func<DeviceConfig, GlsOirCCn> preActivationFunc,DeviceConfig config) : this(key,config.Name, preActivationFunc, config)
+        {
+        }
+
+        public GlsOirOccupancySensorController(string key, string name, Func<DeviceConfig, GlsOirCCn> preActivationFunc, DeviceConfig config) : base(key, name, config)
+        {
+            AddPreActivationAction(() =>
+            {
+                _occSensor = preActivationFunc(config);
+
+                RegisterCrestronGenericBase(_occSensor);
+
+                RegisterGlsOccupancySensorBaseController(_occSensor);
+            });
+        }
+
+        #region Overrides of CrestronGenericBridgeableBaseDevice
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
+        }
+
+        #endregion
+    }
+
+    public class GlsOccupancySensorBaseControllerFactory : EssentialsDeviceFactory<GlsOccupancySensorBaseController>
+    {
+        public GlsOccupancySensorBaseControllerFactory()
+        {
+            TypeNames = new List<string> { "glsoirccn" };
+        }
+
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new GlsOirOccupancySensorController Device");
+
+            return new GlsOirOccupancySensorController(dc.Key, GetGlsOirCCn, dc);
+        }
+
+        private static GlsOirCCn GetGlsOirCCn(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 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;
+        }
+
+    }
+}

src/PepperDash.Essentials.Core/Occupancy/IOccupancyStatusProviderAggregator.cs

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

src/PepperDash.Essentials.Core/Occupancy/OccupancyAggregatorConfig.cs

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

src/PepperDash.Essentials.Core/PartitionSensor/GlsPartitionSensorController.cs

@@ -0,0 +1,366 @@
+extern alias Full;
+
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using Full.Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Bridges.JoinMaps;
+
+using System;
+using System.Collections.Generic;
+using PepperDash.Essentials.Core.Config;
+using PepperDash_Essentials_Core.PartitionSensor;
+
+namespace PepperDash.Essentials.Core
+{
+	[Description("Wrapper class for GLS Cresnet Partition Sensor")]
+	public class GlsPartitionSensorController : CrestronGenericBridgeableBaseDevice, IPartitionStateProvider
+	{
+
+        public GlsPartitionSensorPropertiesConfig PropertiesConfig { get; private set; }
+        
+        private GlsPartCn _partitionSensor;
+
+		public BoolFeedback EnableFeedback { get; private set; }
+		public BoolFeedback PartitionPresentFeedback { 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)
+		{
+
+		    var props = config.Properties.ToObject<GlsPartitionSensorPropertiesConfig>();
+		    if (props != null)
+		    {
+		        PropertiesConfig = props;
+		    }
+		    else
+		    {
+		        Debug.Console(1, this, "props are null.  Unable to deserialize into GlsPartSensorPropertiesConfig");
+		    }
+
+            AddPreActivationAction(() =>
+            {
+                _partitionSensor = preActivationFunc(config);
+                
+                RegisterCrestronGenericBase(_partitionSensor);
+                                
+                EnableFeedback = new BoolFeedback(() => InTestMode ? TestEnableFeedback : _partitionSensor.EnableFeedback.BoolValue);
+                PartitionPresentFeedback = new BoolFeedback(() => InTestMode ? TestPartitionSensedFeedback : _partitionSensor.PartitionSensedFeedback.BoolValue);
+                PartitionNotSensedFeedback = new BoolFeedback(() => InTestMode ? !TestPartitionSensedFeedback : _partitionSensor.PartitionNotSensedFeedback.BoolValue);
+                SensitivityFeedback = new IntFeedback(() => InTestMode ? TestSensitivityFeedback : _partitionSensor.SensitivityFeedback.UShortValue);
+
+                if (_partitionSensor != null)
+                {
+                    _partitionSensor.BaseEvent += PartitionSensor_BaseEvent;                    
+                }
+            });
+
+            AddPostActivationAction(() =>
+            {
+                _partitionSensor.OnlineStatusChange += (o, a) =>
+                {
+                    if (a.DeviceOnLine)
+                    {
+                        ApplySettingsToSensorFromConfig();
+                    }
+                };
+
+                if (_partitionSensor.IsOnline)
+                {
+                    ApplySettingsToSensorFromConfig();
+                }
+            });
+		}        
+
+	    private void ApplySettingsToSensorFromConfig()
+	    {
+	        if (_partitionSensor.IsOnline == false) return;
+
+            // Default to enable
+            _partitionSensor.Enable.BoolValue = true;
+
+	        Debug.Console(1, this, "Attempting to apply settings to sensor from config");
+
+            if (PropertiesConfig.Sensitivity != null)
+            {
+                Debug.Console(1, this, "Sensitivity found, attempting to set value '{0}' from config",
+                    PropertiesConfig.Sensitivity);
+                _partitionSensor.Sensitivity.UShortValue = (ushort)PropertiesConfig.Sensitivity;
+            }
+            else
+            {
+                Debug.Console(1, this, "Sensitivity null, no value specified in config");
+            }
+
+            if (PropertiesConfig.Enable != null)
+            {
+                Debug.Console(1, this, "Enable found, attempting to set value '{0}' from config",
+                    PropertiesConfig.Enable);
+                _partitionSensor.Enable.BoolValue = (bool)PropertiesConfig.Enable;
+            }
+            else
+            {
+                Debug.Console(1, this, "Enable null, no value specified in config");
+            }
+
+	    }
+
+	    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):
+					{
+                        Debug.Console(1, this, "Partition Sensed State: {0}", _partitionSensor.PartitionSensedFeedback.BoolValue);
+						PartitionPresentFeedback.FireUpdate();
+						break;
+					}
+				case (GlsPartCn.PartitionNotSensedFeedbackEventId):
+					{
+                        Debug.Console(1, this, "Partition Not Sensed State: {0}", _partitionSensor.PartitionNotSensedFeedback.BoolValue);
+						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;
+
+			    EnableFeedback.FireUpdate();
+
+				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;
+
+                PartitionPresentFeedback.FireUpdate();
+                PartitionNotSensedFeedback.FireUpdate();
+
+				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;
+
+                SensitivityFeedback.FireUpdate();
+				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 GetSettings()
+	    {
+	        var dash = new string('*', 50);
+	        CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+
+	        Debug.Console(0, this, "Enabled State: {0}", _partitionSensor.EnableFeedback.BoolValue);
+
+	        Debug.Console(0, this, "Partition Sensed State: {0}", _partitionSensor.PartitionSensedFeedback.BoolValue);
+	        Debug.Console(0, this, "Partition Not Sensed State: {0}", _partitionSensor.PartitionNotSensedFeedback.BoolValue);
+
+	        Debug.Console(0, this, "Sensitivity Value: {0}", _partitionSensor.SensitivityFeedback.UShortValue);
+
+	        CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+	    }
+
+	    public void SetEnableState(bool state)
+		{
+            Debug.Console(2, this, "Sensor is {0}, SetEnableState: {1}", _partitionSensor == null ? "null" : "not null", state);
+			if (_partitionSensor == null)
+				return;
+
+			_partitionSensor.Enable.BoolValue = state;
+		}
+
+		public void IncreaseSensitivity()
+		{
+            Debug.Console(2, this, "Sensor is {0}, IncreaseSensitivity", _partitionSensor == null ? "null" : "not null");
+			if (_partitionSensor == null)
+				return;
+
+			_partitionSensor.IncreaseSensitivity();
+		}
+
+		public void DecreaseSensitivity()
+		{
+            Debug.Console(2, this, "Sensor is {0}, DecreaseSensitivity", _partitionSensor == null ? "null" : "not null");
+			if (_partitionSensor == null)
+				return;
+
+			_partitionSensor.DecreaseSensitivity();
+		}
+
+		public void SetSensitivity(ushort value)
+		{
+            Debug.Console(2, this, "Sensor is {0}, SetSensitivity: {1}", _partitionSensor == null ? "null" : "not null", 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);
+
+            IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);            
+		    trilist.StringInput[joinMap.Name.JoinNumber].StringValue = _partitionSensor.Name;
+			
+		    trilist.SetBoolSigAction(joinMap.Enable.JoinNumber, SetEnableState);
+            EnableFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Enable.JoinNumber]);
+
+            PartitionPresentFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionSensed.JoinNumber]);
+            PartitionNotSensedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.PartitionNotSensed.JoinNumber]);
+
+			trilist.SetSigTrueAction(joinMap.IncreaseSensitivity.JoinNumber, IncreaseSensitivity);
+			trilist.SetSigTrueAction(joinMap.DecreaseSensitivity.JoinNumber, DecreaseSensitivity);
+
+            SensitivityFeedback.LinkInputSig(trilist.UShortInput[joinMap.Sensitivity.JoinNumber]);
+            trilist.SetUShortSigAction(joinMap.Sensitivity.JoinNumber, SetSensitivity);
+
+			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)
+				{
+				    trilist.StringInput[joinMap.Name.JoinNumber].StringValue = _partitionSensor.Name;
+					FeedbacksFireUpdates();
+				}
+			};
+		}
+
+		private void FeedbacksFireUpdates()
+		{
+			IsOnline.FireUpdate();			
+			EnableFeedback.FireUpdate();
+			PartitionPresentFeedback.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 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 GlsPartitionSensorController Device");
+
+                return new GlsPartitionSensorController(dc.Key, GetGlsPartCnDevice, dc);
+            }
+        }
+
+	}
+}

src/PepperDash.Essentials.Core/PartitionSensor/GlsPartitionSensorPropertiesConfig.cs

@@ -0,0 +1,26 @@
+extern alias Full;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Full.Newtonsoft.Json;
+
+namespace PepperDash_Essentials_Core.PartitionSensor
+{
+    public class GlsPartitionSensorPropertiesConfig
+    {
+        /// <summary>
+        /// Sets the sensor sensitivity        
+        /// </summary>
+        /// <remarks>
+        /// The sensitivity range shall be between 1(lowest) to 10 (highest).
+        /// </remarks>
+        [JsonProperty("sensitivity")]
+        public ushort? Sensitivity { get; set; }
+
+        [JsonProperty("enable")]
+        public bool? Enable { get; set; }
+    }
+}

src/PepperDash.Essentials.Core/PepperDash.Essentials.Core.csproj

@@ -1,11 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <ProjectType>ProgramLibrary</ProjectType>
-    <Configurations>Debug;Release;Debug 4.7.2</Configurations>
   </PropertyGroup>
   <PropertyGroup>
-    <TargetFrameworks>net472;net6</TargetFrameworks>
-    <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
+    <TargetFramework>net472</TargetFramework>
     <OutputPath>bin\$(Configuration)\</OutputPath>
     <AssemblyName>PepperDash.Essentials.Core</AssemblyName>
     <RootNamespace>PepperDash.Essentials.Core</RootNamespace>
@@ -15,22 +13,23 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugType>full</DebugType>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug 4.7.2|AnyCPU'">
-    <DebugType>full</DebugType>
-  </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Remove="Web\**" />
-    <EmbeddedResource Remove="Web\**" />
-    <None Remove="Web\**" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Crestron.SimplSharp.SDK.ProgramLibrary" Version="2.20.42" />
-    <PackageReference Include="PepperDashCore" Version="2.0.0-beta-383" />
+    <PackageReference Include="Crestron.SimplSharp.SDK.ProgramLibrary" Version="2.20.31" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.2">
+      <Aliases>Full</Aliases>
+    </PackageReference>
+    <PackageReference Include="PepperDashCore" Version="2.0.0-alpha-375" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Crestron\CrestronGenericBaseDevice.cs.orig" />
+    <None Include="Occupancy\EssentialsGlsOccupancySensorBaseController.cs.orig" />
   </ItemGroup>
 </Project>

src/PepperDash.Essentials.Core/Plugins/PluginLoader.cs

@@ -75,11 +75,6 @@ namespace PepperDash.Essentials
                             version = Global.AssemblyVersion;
                             break;
                         }
-                    case ("PepperDash_Essentials_DM.dll"):
-                        {
-                            version = Global.AssemblyVersion;
-                            break;
-                        }
                     case ("Essentials Devices Common.dll"):
                         {
                             version = Global.AssemblyVersion;

src/PepperDash.Essentials.Core/Presets/DevicePresets.cs

@@ -1,11 +1,11 @@
- 
+extern alias Full; 
 
 using System;
 using System.Collections.Generic;
 using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 using PepperDash.Core;
 
 //using SSMono.IO;

src/PepperDash.Essentials.Core/Presets/PresetBase.cs

@@ -1,4 +1,4 @@
-
+extern alias Full;
 
 using System;
 using System.Collections.Generic;
@@ -6,7 +6,7 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 
-using Newtonsoft.Json;
+using Full.Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core.Presets
 {