build: test

When route requests made during a destination's cooldown cycle were handled, the event subscription was *NOT* being removed, resulting in the request being run on *EVERY* subsequent cooldown complete event.

.github/workflows/docker.yml

@@ -66,6 +66,8 @@ jobs:
       # Build the solutions in the docker image
       - name: Build Solution        
         run: msbuild .\$($Env:SOLUTION_FILE).sln /p:Platform="Any CPU" /p:Configuration="Debug" /p:Version="${{ steps.setVersion.outputs.version }}" -m
+      - name: Pack Solution
+        run: dotnet pack .\$($Env:SOLUTION_FILE).sln --configuration $env:BUILD_TYPE --output ./output /p:Version="${{ steps.setVersion.outputs.version }}"
       - name: Create tag for non-rc builds
         if: contains(steps.setVersion.outputs.version, 'alpha')
         run: |

.github/workflows/main.yml

@@ -37,6 +37,8 @@ jobs:
         run: nuget restore .\$($Env:SOLUTION_FILE).sln
       - name: Build Solution        
         run: msbuild .\$($Env:SOLUTION_FILE).sln /p:Platform="Any CPU" /p:Configuration="Debug" /p:Version="${{ steps.setVersion.outputs.version }}" -m      
+      - name: Pack Solution
+        run: dotnet pack .\$($Env:SOLUTION_FILE).sln --configuration $env:BUILD_TYPE --output ./output /p:Version="${{ steps.setVersion.outputs.version }}"
       - name: Upload Release
         id: create_release
         uses: ncipollo/release-action@v1

README.md

@@ -1,63 +1,65 @@
-# PepperDash Essentials Framework (c) 2020
-
-## [Latest Release](https://github.com/PepperDash/Essentials/releases/latest)
-
-## License
-
-Provided under MIT license
-
-## Overview
-
-PepperDash Essentials is an open source Crestron framework that can be configured as a standalone program capable of running a wide variety of system designs and can also be utilized as a plug-in architecture to augment other Simpl# Pro and Simpl Windows programs.
-
-Essentials Framework is a collection of C# / Simpl# Pro libraries that can be utilized in several different manners. It is currently operating as a 100% configuration-driven system, and can be extended to add different workflows and behaviors, either through the addition of further device "types" or via the plug-in mechanism. The framework is a collection of "things" that are all related and interconnected, but in general do not have dependencies on each other.
-
-## Minimum Requirements
-
-- Essentials Framework runs on any Crestron 3-series processor, **4-series** processor or Crestron's VC-4 platform.
-- To edit and compile the source, Microsoft Visual Studio 2008 Professional with SP1 is required.
-- Crestron's Simpl# Plugin is also required (must be obtained from Crestron).
-
-## Dependencies
-
-The [PepperDash.Core](https://github.com/PepperDash/PepperDashCore) SIMPL# library is required. It is referenced via nuget. You must have nuget.exe installed and in the `PATH` environment variable to use the following command. Nuget.exe is available at [nuget.org](https://dist.nuget.org/win-x86-commandline/latest/nuget.exe).
-
-### Installing Dependencies
-
-To install dependencies once nuget.exe is installed, run the following command:
-`nuget install .\packages.config -OutputDirectory .\packages -excludeVersion`.
-To verify that the packages installed correctly, open Essentials and make sure that all references are found, then try and build it.
-
-### Installing Different versions of PepperDash Core
-
-If you need a different version of PepperDash Core, use the command `nuget install .\packages.config -OutputDirectory .\packages -excludeVersion -Version {versionToGet}`. Omitting the `-Version` option will pull the version indicated in the packages.config file.
-
-## Utilization
-
-Essentials was originally conceptualized as a standalone application for running control system logic entirely in Simpl# Pro. It is primarily designed around accomplishing this goal, but during development, it became obvious that it could easily be leveraged to also serve as a partner application to one or more SIMPL Windows programs.
-
-Utilization of Essentials Framework falls into the following categories:
-
-1. Standalone Control System Application for controlling one or more rooms. See [Standalone Use](https://github.com/PepperDash/Essentials/wiki/Standalone-Use#standalone-application)
-
-2. Partner Application to a SIMPL Windows program. This allows for several useful advantages. See [SIMPL Windows Bridging](https://github.com/PepperDash/Essentials/wiki/SIMPL-Bridging#simpl-windows-bridging)
-
-- Dynamic device instantiation. Devices can be defined in configuration and instantiated at runtime and then bridged to a SIMPL Windows program via EISC.
-
-- Advanced logic. Some logic operations that cannot be affectively accomplished in SIMPL Windows (ex. JSON/XML serialization/deserialization, database operations, etc.) can be done in the Simpl# Pro environment and the necessary input and output bridged to a SIMPL Windows program via EISC.
-
-3. Hybrid Application that may contain elements of both standalone control and SIMPL partner application integration.
-
-- There may be a use case where a device can only be defined in a single application, but that device may need to be interacted with from multiple applications. The device can be defined in an Essentials application, interacted with in that application and also bridged to one or more SIMPL Windows applications.
-
-## Documentation
-
-For detailed documentation, see the [Wiki](https://github.com/PepperDash/EssentialsFramework/wiki).
-
-## Support
-
-* Check out our [Discord Server](https://discord.gg/rWyeRH3K)
-
-## How-To (Getting Started)
-
-See [Getting Started](https://github.com/PepperDash/Essentials/wiki/Get-started#how-to-get-started)
+# PepperDash Essentials Framework (c) 2020
+
+## [Latest Release](https://github.com/PepperDash/Essentials/releases/latest)
+
+## License
+
+Provided under MIT license
+
+## Overview
+
+PepperDash Essentials is an open source Crestron framework that can be configured as a standalone program capable of running a wide variety of system designs and can also be utilized as a plug-in architecture to augment other Simpl# Pro and Simpl Windows programs.
+
+Essentials Framework is a collection of C# / Simpl# Pro libraries that can be utilized in several different manners. It is currently operating as a 100% configuration-driven system, and can be extended to add different workflows and behaviors, either through the addition of further device "types" or via the plug-in mechanism. The framework is a collection of "things" that are all related and interconnected, but in general do not have dependencies on each other.
+
+## Minimum Requirements
+
+- Essentials Framework runs on any Crestron 3-series processor, **4-series** processor or Crestron's VC-4 platform.
+- To edit and compile the source, Microsoft Visual Studio 2008 Professional with SP1 is required.
+- Crestron's Simpl# Plugin is also required (must be obtained from Crestron).
+
+## Dependencies
+
+The [PepperDash.Core](https://github.com/PepperDash/PepperDashCore) SIMPL# library is required. It is referenced via nuget. You must have nuget.exe installed and in the `PATH` environment variable to use the following command. Nuget.exe is available at [nuget.org](https://dist.nuget.org/win-x86-commandline/latest/nuget.exe).
+
+### Installing Dependencies
+
+To install dependencies once nuget.exe is installed, run the following command:
+`nuget install .\packages.config -OutputDirectory .\packages -excludeVersion`.
+To verify that the packages installed correctly, open Essentials and make sure that all references are found, then try and build it.
+
+### Installing Different versions of PepperDash Core
+
+If you need a different version of PepperDash Core, use the command `nuget install .\packages.config -OutputDirectory .\packages -excludeVersion -Version {versionToGet}`. Omitting the `-Version` option will pull the version indicated in the packages.config file.
+
+## Utilization
+
+Essentials was originally conceptualized as a standalone application for running control system logic entirely in Simpl# Pro. It is primarily designed around accomplishing this goal, but during development, it became obvious that it could easily be leveraged to also serve as a partner application to one or more SIMPL Windows programs.
+
+Utilization of Essentials Framework falls into the following categories:
+
+1. Standalone Control System Application for controlling one or more rooms. See [Standalone Use](https://github.com/PepperDash/Essentials/wiki/Standalone-Use#standalone-application)
+
+2. Partner Application to a SIMPL Windows program. This allows for several useful advantages. See [SIMPL Windows Bridging](https://github.com/PepperDash/Essentials/wiki/SIMPL-Bridging#simpl-windows-bridging)
+
+- Dynamic device instantiation. Devices can be defined in configuration and instantiated at runtime and then bridged to a SIMPL Windows program via EISC.
+
+- Advanced logic. Some logic operations that cannot be affectively accomplished in SIMPL Windows (ex. JSON/XML serialization/deserialization, database operations, etc.) can be done in the Simpl# Pro environment and the necessary input and output bridged to a SIMPL Windows program via EISC.
+
+3. Hybrid Application that may contain elements of both standalone control and SIMPL partner application integration.
+
+- There may be a use case where a device can only be defined in a single application, but that device may need to be interacted with from multiple applications. The device can be defined in an Essentials application, interacted with in that application and also bridged to one or more SIMPL Windows applications.
+
+## Documentation
+
+For detailed documentation, see the [Wiki](https://github.com/PepperDash/EssentialsFramework/wiki).
+
+## Support
+
+* Check out our [Discord Server](https://discord.gg/rWyeRH3K)
+
+## How-To (Getting Started)
+
+See [Getting Started](https://github.com/PepperDash/Essentials/wiki/Get-started#how-to-get-started)
+
+

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

@@ -3,7 +3,7 @@
 using System;
 using System.Collections.Generic;
 using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.EthernetCommunication;
@@ -18,81 +18,6 @@ using Serilog.Events;
 
 namespace PepperDash.Essentials.Core.Bridges
 {
-    /// <summary>
-    /// Helper methods for bridges
-    /// </summary>
-    public static class BridgeHelper
-    {
-        public static void PrintJoinMap(string command)
-        {
-            var targets = command.Split(' ');
-
-            var bridgeKey = targets[0].Trim();
-
-            var bridge = DeviceManager.GetDeviceForKey(bridgeKey) as EiscApiAdvanced;
-
-            if (bridge == null)
-            {
-                Debug.LogMessage(LogEventLevel.Information, "Unable to find advanced bridge with key: '{0}'", bridgeKey);
-                return;
-            }
-
-            if (targets.Length > 1)
-            {
-                var deviceKey = targets[1].Trim();
-
-                if (string.IsNullOrEmpty(deviceKey)) return;
-                bridge.PrintJoinMapForDevice(deviceKey);
-            }
-            else
-            {
-                bridge.PrintJoinMaps();
-            }
-        }
-        public static void JoinmapMarkdown(string command)
-        {
-            var targets = command.Split(' ');
-
-            var bridgeKey = targets[0].Trim();
-
-            var bridge = DeviceManager.GetDeviceForKey(bridgeKey) as EiscApiAdvanced;
-
-            if (bridge == null)
-            {
-                Debug.LogMessage(LogEventLevel.Information, "Unable to find advanced bridge with key: '{0}'", bridgeKey);
-                return;
-            }
-
-            if (targets.Length > 1)
-            {
-                var deviceKey = targets[1].Trim();
-
-                if (string.IsNullOrEmpty(deviceKey)) return;
-                bridge.MarkdownJoinMapForDevice(deviceKey, bridgeKey);
-            }
-            else
-            {
-                bridge.MarkdownForBridge(bridgeKey);
-
-            }
-        }
-    }
-
-
-    /// <summary>
-    /// Base class for all bridge class variants
-    /// </summary>
-    public class BridgeBase : EssentialsDevice
-    {
-        public BridgeApi Api { get; protected set; }
-
-        public BridgeBase(string key) :
-            base(key)
-        {
-
-        }
-    }
-
     /// <summary>
     /// Base class for bridge API variants
     /// </summary>
@@ -168,19 +93,15 @@ namespace PepperDash.Essentials.Core.Bridges
 
                 Debug.LogMessage(LogEventLevel.Debug, this, "Linking Device: '{0}'", device.Key);
 
-                if (!typeof(IBridgeAdvanced).IsAssignableFrom(device.GetType().GetCType()))
+                if (device is IBridgeAdvanced bridge)
                 {
-                    Debug.LogMessage(LogEventLevel.Information, this,
-                        "{0} is not compatible with this bridge type. Please use 'eiscapi' instead, or updae the device.",
-                        device.Key);
+                    bridge.LinkToApi(Eisc, d.JoinStart, d.JoinMapKey, this);
                     continue;
                 }
 
-                var bridge = device as IBridgeAdvanced;
-                if (bridge != null)
-                {
-                    bridge.LinkToApi(Eisc, d.JoinStart, d.JoinMapKey, this);
-                }
+                Debug.LogMessage(LogEventLevel.Information, this,
+                        "{0} is not compatible with this bridge type. Please use 'eiscapi' instead, or updae the device.",
+                        device.Key);
             }
         }
 
@@ -249,11 +170,11 @@ namespace PepperDash.Essentials.Core.Bridges
         /// </summary>
         public virtual void PrintJoinMaps()
         {
-            Debug.LogMessage(LogEventLevel.Information, this, "Join Maps for EISC IPID: {0}", Eisc.ID.ToString("X"));
+            CrestronConsole.ConsoleCommandResponse("Join Maps for EISC IPID: {0}\r\n", Eisc.ID.ToString("X"));
 
             foreach (var joinMap in JoinMaps)
             {
-                Debug.LogMessage(LogEventLevel.Information, "Join map for device '{0}':", joinMap.Key);
+                CrestronConsole.ConsoleCommandResponse("Join map for device '{0}':", joinMap.Key);
                 joinMap.Value.PrintJoinMapInfo();
             }
         }

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

@@ -0,0 +1,66 @@
+using PepperDash.Core;
+using Serilog.Events;
+
+//using PepperDash.Essentials.Devices.Common.Cameras;
+
+namespace PepperDash.Essentials.Core.Bridges
+{
+    /// <summary>
+    /// Helper methods for bridges
+    /// </summary>
+    public static class BridgeHelper
+    {
+        public static void PrintJoinMap(string command)
+        {
+            var targets = command.Split(' ');
+
+            var bridgeKey = targets[0].Trim();
+
+            if (!(DeviceManager.GetDeviceForKey(bridgeKey) is EiscApiAdvanced bridge))
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Unable to find advanced bridge with key: '{0}'", bridgeKey);
+                return;
+            }
+
+            if (targets.Length > 1)
+            {
+                var deviceKey = targets[1].Trim();
+
+                if (string.IsNullOrEmpty(deviceKey)) return;
+                bridge.PrintJoinMapForDevice(deviceKey);
+            }
+            else
+            {
+                bridge.PrintJoinMaps();
+            }
+        }
+        public static void JoinmapMarkdown(string command)
+        {
+            var targets = command.Split(' ');
+
+            var bridgeKey = targets[0].Trim();
+
+            var bridge = DeviceManager.GetDeviceForKey(bridgeKey) as EiscApiAdvanced;
+
+            if (bridge == null)
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Unable to find advanced bridge with key: '{0}'", bridgeKey);
+                return;
+            }
+
+            if (targets.Length > 1)
+            {
+                var deviceKey = targets[1].Trim();
+
+                if (string.IsNullOrEmpty(deviceKey)) return;
+                bridge.MarkdownJoinMapForDevice(deviceKey, bridgeKey);
+            }
+            else
+            {
+                bridge.MarkdownForBridge(bridgeKey);
+
+            }
+        }
+    }
+
+}

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

@@ -93,6 +93,7 @@ namespace PepperDash.Essentials.Core
 
         void OnDataReceived(string s)
         {
+			var eventSubscribed = false;
 
             var bytesHandler = BytesReceived;
             if (bytesHandler != null)
@@ -101,6 +102,7 @@ namespace PepperDash.Essentials.Core
 				if (StreamDebugging.RxStreamDebuggingIsEnabled)
 					Debug.LogMessage(LogEventLevel.Information, this, "Received: '{0}'", ComTextHelper.GetEscapedText(bytes));
                 bytesHandler(this, new GenericCommMethodReceiveBytesArgs(bytes));
+				eventSubscribed = true;
             }
             var textHandler = TextReceived;
             if (textHandler != null)
@@ -108,7 +110,10 @@ namespace PepperDash.Essentials.Core
 				if (StreamDebugging.RxStreamDebuggingIsEnabled)
 					Debug.LogMessage(LogEventLevel.Information, this, "Received: '{0}'", s);
                 textHandler(this, new GenericCommMethodReceiveTextArgs(s));
+				eventSubscribed = true;
             }
+
+			if(!eventSubscribed) Debug.LogMessage(LogEventLevel.Warning, this, "Received data but no handler is registered");
         }
 
 		public override bool Deactivate()

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

@@ -23,12 +23,12 @@ namespace PepperDash.Essentials.Core
     {
         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
         {
-            if (objectType == typeof(ComPort.ComPortSpec))
+            if (objectType == typeof(ComPort.ComPortSpec?))
             {
                 var newSer = new JsonSerializer();
                 newSer.Converters.Add(new ComSpecPropsJsonConverter());
                 newSer.ObjectCreationHandling = ObjectCreationHandling.Replace;
-                return newSer.Deserialize<ComPort.ComPortSpec>(reader);
+                return newSer.Deserialize<ComPort.ComPortSpec?>(reader);
             }
             return null;
         }
@@ -38,7 +38,7 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         public override bool CanConvert(Type objectType)
         {
-            return objectType == typeof(ComPort.ComPortSpec);
+            return objectType == typeof(ComPort.ComPortSpec?);
         }
 
         public override bool CanRead { get { return true; } }

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

@@ -51,7 +51,7 @@ namespace PepperDash.Essentials.Core
 				switch (controlConfig.Method)
 				{
 					case eControlMethod.Com:
-						comm = new ComPortController(deviceConfig.Key + "-com", GetComPort, controlConfig.ComParams, controlConfig);
+						comm = new ComPortController(deviceConfig.Key + "-com", GetComPort, controlConfig.ComParams.Value, controlConfig);
 						break;
                     case eControlMethod.Cec:
                         comm = new CecPortController(deviceConfig.Key + "-cec", GetCecPort, controlConfig);
@@ -115,7 +115,7 @@ namespace PepperDash.Essentials.Core
 			var comPar = config.ComParams;
 			var dev = GetIComPortsDeviceFromManagedDevice(config.ControlPortDevKey);
 			if (dev != null && config.ControlPortNumber <= dev.NumberOfComPorts)
-				return dev.ComPorts[config.ControlPortNumber];
+				return dev.ComPorts[config.ControlPortNumber.Value];
 			Debug.LogMessage(LogEventLevel.Information, "GetComPort: Device '{0}' does not have com port {1}", config.ControlPortDevKey, config.ControlPortNumber);
 			return null;
 		}
@@ -201,23 +201,26 @@ namespace PepperDash.Essentials.Core
     /// <summary>
     /// 
     /// </summary>
-    public class EssentialsControlPropertiesConfig : 
-        PepperDash.Core.ControlPropertiesConfig
+    public class EssentialsControlPropertiesConfig :
+        ControlPropertiesConfig
     {
 
+        [JsonProperty("comParams", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(ComSpecJsonConverter))]
-        public ComPort.ComPortSpec ComParams { get; set; }		
+        public ComPort.ComPortSpec? ComParams { get; set; }
 
-		public string CresnetId { get; set; }
+        [JsonProperty("cresnetId", NullValueHandling = NullValueHandling.Ignore)]
+        public string CresnetId { get; set; }
 
         /// <summary>
         /// Attempts to provide uint conversion of string CresnetId
         /// </summary>
+        [JsonIgnore]
         public uint CresnetIdInt
         {
             get
             {
-                try 
+                try
                 {
                     return Convert.ToUInt32(CresnetId, 16);
                 }
@@ -228,11 +231,13 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        [JsonProperty("infinetId", NullValueHandling = NullValueHandling.Ignore)]
         public string InfinetId { get; set; }
 
         /// <summary>
         /// Attepmts to provide uiont conversion of string InifinetId
         /// </summary>
+        [JsonIgnore]
         public uint InfinetIdInt
         {
             get

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

@@ -0,0 +1,20 @@
+using Crestron.SimplSharpPro;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.Config
+{
+    public class AudioControlPointListItem
+    {
+        [JsonProperty("levelControls")]
+        public Dictionary<string, LevelControlListItem> LevelControls { get; set; } = new Dictionary<string, LevelControlListItem>();
+
+        [JsonProperty("presets")]
+        public Dictionary<string, PresetListItem> Presets { get; set; } = new Dictionary<string, PresetListItem>();
+
+    }
+}

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

@@ -5,6 +5,7 @@ using System.Linq;
 using Newtonsoft.Json;
 
 using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core.Devices;
 
 namespace PepperDash.Essentials.Core.Config
 {
@@ -25,8 +26,11 @@ namespace PepperDash.Essentials.Core.Config
         [JsonProperty("destinationLists")]
         public Dictionary<string, Dictionary<string, DestinationListItem>> DestinationLists { get; set; }
 
-        [JsonProperty("levelControlLists")]
-        public Dictionary<string, Dictionary<string, LevelControlListItem>> LevelControlLists { get; set; }
+        [JsonProperty("audioControlPointLists")]
+        public Dictionary<string, AudioControlPointListItem> AudioControlPointLists { get; set; }
+
+        [JsonProperty("cameraLists")]
+        public Dictionary<string, Dictionary<string, CameraListItem>> CameraLists { get; set; }
 
         [JsonProperty("tieLines")]
 		public List<TieLineConfig> TieLines { get; set; }
@@ -40,7 +44,8 @@ namespace PepperDash.Essentials.Core.Config
             Devices = new List<DeviceConfig>();
             SourceLists = new Dictionary<string, Dictionary<string, SourceListItem>>();
             DestinationLists = new Dictionary<string, Dictionary<string, DestinationListItem>>();
-            LevelControlLists = new Dictionary<string, Dictionary<string, LevelControlListItem>>();
+            AudioControlPointLists = new Dictionary<string, AudioControlPointListItem>();
+            CameraLists = new Dictionary<string, Dictionary<string, CameraListItem>>();
             TieLines = new List<TieLineConfig>();
             JoinMaps = new Dictionary<string, JObject>();
         }
@@ -50,7 +55,7 @@ namespace PepperDash.Essentials.Core.Config
 		/// </summary>
 		public Dictionary<string, SourceListItem> GetSourceListForKey(string key)
 		{
-			if (string.IsNullOrEmpty(key) || !SourceLists.ContainsKey(key))
+			if (SourceLists == null || string.IsNullOrEmpty(key) || !SourceLists.ContainsKey(key))
 				return null;
 			
 			return SourceLists[key];
@@ -63,25 +68,36 @@ namespace PepperDash.Essentials.Core.Config
         /// <returns>DestinationList if the key exists, null otherwise</returns>
 	    public Dictionary<string, DestinationListItem> GetDestinationListForKey(string key)
 	    {
-	        if (string.IsNullOrEmpty(key) || !DestinationLists.ContainsKey(key))
+	        if (DestinationLists == null || string.IsNullOrEmpty(key) || !DestinationLists.ContainsKey(key))
 	        {
 	            return null;
 	        }
 
 	        return DestinationLists[key];
-	    } 
+	    }
 
         /// <summary>
-        /// Retrieves a LevelControlList based on the key
+        /// Retrieves a AudioControlPointList based on the key
         /// </summary>
         /// <param name="key">key of the list to retrieve</param>
-        /// <returns>LevelControlList if the key exists, null otherwise</returns>
-        public Dictionary<string, LevelControlListItem> GetLevelControlListForKey(string key)
+        /// <returns>AudioControlPointList if the key exists, null otherwise</returns>
+        public AudioControlPointListItem GetAudioControlPointListForKey(string key)
         {
-            if (string.IsNullOrEmpty(key) || !LevelControlLists.ContainsKey(key))
+            if (AudioControlPointLists == null ||  string.IsNullOrEmpty(key) || !AudioControlPointLists.ContainsKey(key))
                 return null;
 
-            return LevelControlLists[key];
+            return AudioControlPointLists[key];
+        }
+
+        /// <summary>
+        /// Checks CameraLists for a given list and returns it if found. Otherwise, returns null
+        /// </summary>
+        public Dictionary<string, CameraListItem> GetCameraListForKey(string key)
+        {
+            if (CameraLists == null || string.IsNullOrEmpty(key) || !CameraLists.ContainsKey(key))
+                return null;
+
+            return CameraLists[key];
         }
 
         /// <summary>

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

@@ -31,9 +31,17 @@ namespace PepperDash.Essentials.Core.Config
 				if (string.IsNullOrEmpty(SystemUrl))
 					return "missing url";
 
-                var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/systems\/(.*)\/#.*");
-                string uuid = result.Groups[1].Value;
-                return uuid;
+				if (SystemUrl.Contains("#"))
+				{
+					var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/systems\/(.*)\/#.*");
+					string uuid = result.Groups[1].Value;
+					return uuid;
+				} else
+				{
+                    var result = Regex.Match(SystemUrl, @"https?:\/\/.*\/systems\/(.*)\/.*");
+                    string uuid = result.Groups[1].Value;
+                    return uuid;
+                }
             }
         }
 
@@ -44,10 +52,18 @@ namespace PepperDash.Essentials.Core.Config
             {
 				if (string.IsNullOrEmpty(TemplateUrl))
 					return "missing template url";
-       
-				var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/templates\/(.*)\/#.*");
-                string uuid = result.Groups[1].Value;
-                return uuid;
+
+				if (TemplateUrl.Contains("#"))
+				{
+					var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/templates\/(.*)\/#.*");
+					string uuid = result.Groups[1].Value;
+					return uuid;
+				} else
+				{
+                    var result = Regex.Match(TemplateUrl, @"https?:\/\/.*\/system-templates\/(.*)\/system-template-versions\/(.*)\/.*");
+                    string uuid = result.Groups[2].Value;
+                    return uuid;
+                }
             }
         }
 

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

@@ -1,18 +1,16 @@
 
 
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
-
-using Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Core.Config
 {
-	/// <summary>
-	/// Represents the info section of a Config file
-	/// </summary>
-	public class InfoConfig
+    /// <summary>
+    /// Represents the info section of a Config file
+    /// </summary>
+    public class InfoConfig
 	{
 		[JsonProperty("name")]
 		public string Name { get; set; }

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

@@ -15,8 +15,22 @@ namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
     /// <example>
     /// See MockDisplay for example implemntation
     /// </example>
+    [Obsolete("Use IHasInputs<T> instead.  Will be removed for 2.0 release")]
     public interface IHasInputs<T, TSelector>: IKeyName
     {
         ISelectableItems<T> Inputs { get; }
     }
+
+
+    /// <summary>
+    /// Describes a device that has selectable inputs
+    /// </summary>
+    /// <typeparam name="T">the type to use as the key for each input item. Most likely an enum or string</typeparam>\
+    /// <example>
+    /// See MockDisplay for example implemntation
+    /// </example>
+    public interface IHasInputs<T> : IKeyName
+    {
+        ISelectableItems<T> Inputs { get; }
+    }
 }

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

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
+{
+    public interface IHumiditySensor
+    {
+        /// <summary>
+        ///  Reports the relative humidity level. Level ranging from 0 to 100 (for 0% to 100%
+        ///  RH). EventIds: HumidityFeedbackFeedbackEventId will trigger to indicate change.
+        /// </summary>
+        IntFeedback HumidityFeedback { get; }
+
+    }
+}

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

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
+{
+    public interface ITemperatureSensor
+    {
+        /// <summary>
+        ///  The values will range from -400 to +1760 (for -40° to +176° F) or -400 to +800
+        ///    (for -40° to +80° C)in tenths of a degree.
+        /// </summary>
+        IntFeedback TemperatureFeedback { get; }
+
+
+        BoolFeedback TemperatureInCFeedback { get; }
+
+        void SetTemperatureFormat(bool setToC);
+    }
+}

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

@@ -0,0 +1,42 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Essentials.Core
+{
+    public abstract class AudioControlListItemBase
+    {
+        /// <summary>
+        /// Key of the parent device in the DeviceManager
+        /// </summary>
+        [JsonProperty("parentDeviceKey")]
+        public string ParentDeviceKey { get; set; }
+
+        /// <summary>
+        /// Optional key of the item in the parent device
+        /// </summary>
+        [JsonProperty("itemKey")]
+        public string ItemKey { get; set; }
+
+        /// <summary>
+        /// A name that will override the items's name on the UI
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Indicates if the item should be included in the user accessible list
+        /// </summary>
+        [JsonProperty("includeInUserList")]
+        public bool IncludeInUserList { get; set; }
+
+        /// <summary>
+        /// Used to specify the order of the items in the source list when displayed
+        /// </summary>
+        [JsonProperty("order")]
+        public int Order { get; set; }
+    }
+}

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

@@ -0,0 +1,76 @@
+using Newtonsoft.Json;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    public class CameraListItem
+    {
+        [JsonProperty("deviceKey")]
+        public string DeviceKey { get; set; }
+
+        /// <summary>
+        /// Returns the source Device for this, if it exists in DeviceManager
+        /// </summary>
+        [JsonIgnore]
+        public Device CameraDevice
+        {
+            get
+            {
+                if (_cameraDevice == null)
+                    _cameraDevice = DeviceManager.GetDeviceForKey(DeviceKey) as Device;
+                return _cameraDevice;
+            }
+        }
+        Device _cameraDevice;
+
+        /// <summary>
+        /// Gets either the source's Name or this AlternateName property, if 
+        /// defined.  If source doesn't exist, returns "Missing source"
+        /// </summary>
+        [JsonProperty("preferredName")]
+        public string PreferredName
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(Name))
+                {
+                    if (CameraDevice == null)
+                        return "---";
+                    return CameraDevice.Name;
+                }
+                return Name;
+            }
+        }
+
+        /// <summary>
+        /// A name that will override the source's name on the UI
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+
+        /// <summary>
+        /// Specifies and icon for the source list item
+        /// </summary>
+        [JsonProperty("icon")]
+        public string Icon { get; set; }
+
+        /// <summary>
+        /// Alternate icon
+        /// </summary>
+		[JsonProperty("altIcon", NullValueHandling = NullValueHandling.Ignore)]
+        public string AltIcon { get; set; }
+
+        /// <summary>
+        /// Indicates if the item should be included in the user facing list
+        /// </summary>
+		[JsonProperty("includeInUserList")]
+        public bool IncludeInUserList { get; set; }
+
+        /// <summary>
+        /// Used to specify the order of the items in the source list when displayed
+        /// </summary>
+		[JsonProperty("order")]
+        public int Order { get; set; }
+    }
+}

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

@@ -1,131 +1,198 @@
 
 
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using Serilog.Events;
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
-using Newtonsoft.Json;
-
-using PepperDash.Core;
-using Serilog.Events;
+using System.Reflection;
+using System.Threading.Tasks;
 
 
 namespace PepperDash.Essentials.Core
 {
-	public class DeviceJsonApi
-	{
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="json"></param>
-		public static void DoDeviceActionWithJson(string json)
-		{
-		    if (String.IsNullOrEmpty(json))
-		    {
-		        CrestronConsole.ConsoleCommandResponse(
-		            "Please provide a JSON object matching the format {\"deviceKey\":\"myDevice\", \"methodName\":\"someMethod\", \"params\": [\"param1\", true]}.\r\nIf the method has no parameters, the \"params\" object may be omitted.");
-		        return;
-		    }
-		    try
-		    {
-		        var action = JsonConvert.DeserializeObject<DeviceActionWrapper>(json);
+    public class DeviceJsonApi
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="json"></param>
+        public static void DoDeviceActionWithJson(string json)
+        {
+            if (String.IsNullOrEmpty(json))
+            {
+                CrestronConsole.ConsoleCommandResponse(
+                    "Please provide a JSON object matching the format {\"deviceKey\":\"myDevice\", \"methodName\":\"someMethod\", \"params\": [\"param1\", true]}.\r\nIf the method has no parameters, the \"params\" object may be omitted.");
+                return;
+            }
+            try
+            {
+                var action = JsonConvert.DeserializeObject<DeviceActionWrapper>(json);
 
-		        DoDeviceAction(action);
-		    }
-		    catch (Exception ex)
-		    {
-		        CrestronConsole.ConsoleCommandResponse("Incorrect format for JSON. Please check that the format matches {\"deviceKey\":\"myDevice\", \"methodName\":\"someMethod\", \"params\": [\"param1\", true]}");
-		    }
-		    
-		}
+                DoDeviceAction(action);
+            }
+            catch (Exception)
+            {
+                CrestronConsole.ConsoleCommandResponse("Incorrect format for JSON. Please check that the format matches {\"deviceKey\":\"myDevice\", \"methodName\":\"someMethod\", \"params\": [\"param1\", true]}");
+            }
+
+        }
 
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="action"></param>
-		public static void DoDeviceAction(DeviceActionWrapper action)
-		{
-			var key = action.DeviceKey;
-			var obj = FindObjectOnPath(key);
-		    if (obj == null)
-		    {
-		        CrestronConsole.ConsoleCommandResponse("Unable to find object at path {0}", key);
-		        return;
-		    }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="action"></param>
+        public static void DoDeviceAction(DeviceActionWrapper action)
+        {
+            var key = action.DeviceKey;
+            var obj = FindObjectOnPath(key);
+            if (obj == null)
+            {
+                CrestronConsole.ConsoleCommandResponse("Unable to find object at path {0}", key);
+                return;
+            }
 
-		    if (action.Params == null)
-		    {
+            if (action.Params == null)
+            {
                 //no params, so setting action.Params to empty array
-		        action.Params = new object[0];
-		    }
+                action.Params = new object[0];
+            }
 
-		    CType t = obj.GetType();
-		    try
-		    {
-		        var methods = t.GetMethods().Where(m => m.Name == action.MethodName).ToList();
+            Type t = obj.GetType();
+            try
+            {
+                var methods = t.GetMethods().Where(m => m.Name == action.MethodName).ToList();
 
-		        var method = methods.Count == 1 ? methods[0] : methods.FirstOrDefault(m => m.GetParameters().Length == action.Params.Length);
+                var method = methods.Count == 1 ? methods[0] : methods.FirstOrDefault(m => m.GetParameters().Length == action.Params.Length);
 
-		        if (method == null)
-		        {
-		            CrestronConsole.ConsoleCommandResponse(
-		                "Unable to find method with name {0} and that matches parameters {1}", action.MethodName,
-		                action.Params);
-		            return;
-		        }
+                if (method == null)
+                {
+                    CrestronConsole.ConsoleCommandResponse(
+                        "Unable to find method with name {0} and that matches parameters {1}", action.MethodName,
+                        action.Params);
+                    return;
+                }
                 var mParams = method.GetParameters();
 
                 var convertedParams = mParams
                                     .Select((p, i) => ConvertType(action.Params[i], p.ParameterType))
                                     .ToArray();
-                method.Invoke(obj, convertedParams);
 
-		        CrestronConsole.ConsoleCommandResponse("Method {0} successfully called on device {1}", method.Name,
-		            action.DeviceKey);
-		    }
-		    catch (Exception ex)
-		    {
-		        CrestronConsole.ConsoleCommandResponse("Unable to call method with name {0}. {1}", action.MethodName,
-		            ex.Message);}
-		}
+                Task.Run(() =>
+                    {
+                        try
+                        {
+                            Debug.LogMessage(LogEventLevel.Verbose, "Calling method {methodName} on device {deviceKey}", null, method.Name, action.DeviceKey);
+                            method.Invoke(obj, convertedParams);
+                        }
+                        catch (Exception e)
+                        {
+                            Debug.LogMessage(e, "Error invoking method {methodName} on device {deviceKey}", null, method.Name, action.DeviceKey);
+                        }
+                    });
 
-	    private static object ConvertType(object value, Type conversionType)
-	    {
-	        if (!conversionType.IsEnum)
-	        {
-	            return Convert.ChangeType(value, conversionType, System.Globalization.CultureInfo.InvariantCulture);
-	        }
+                CrestronConsole.ConsoleCommandResponse("Method {0} successfully called on device {1}", method.Name,
+                    action.DeviceKey);
+            }
+            catch (Exception ex)
+            {
+                CrestronConsole.ConsoleCommandResponse("Unable to call method with name {0}. {1}", action.MethodName,
+                    ex.Message);
+            }
+        }
 
-	        var stringValue = Convert.ToString(value);
+        public static async Task DoDeviceActionAsync(DeviceActionWrapper action)
+        {
+            var key = action.DeviceKey;
+            var obj = FindObjectOnPath(key);
+            if (obj == null)
+            {
+                Debug.LogMessage(LogEventLevel.Warning, "Unable to find object at path {deviceKey}", null, key);
+                return;
+            }
 
-	        if (String.IsNullOrEmpty(stringValue))
-	        {
-	            throw new InvalidCastException(
-	                String.Format("{0} cannot be converted to a string prior to conversion to enum"));
-	        }
-	        return Enum.Parse(conversionType, stringValue, true);
-	    }
+            if (action.Params == null)
+            {
+                //no params, so setting action.Params to empty array
+                action.Params = new object[0];
+            }
 
-		/// <summary>
-		/// Gets the properties on a device
-		/// </summary>
-		/// <param name="key"></param>
-		/// <returns></returns>
-		public static string GetProperties(string deviceObjectPath)
-		{
-			var obj = FindObjectOnPath(deviceObjectPath);
-			if (obj == null)
-				return "{ \"error\":\"No Device\"}";
+            Type t = obj.GetType();
+            try
+            {
+                var methods = t.GetMethods().Where(m => m.Name == action.MethodName).ToList();
 
-			CType t = obj.GetType();
-			// get the properties and set them into a new collection of NameType wrappers
-			var props = t.GetProperties().Select(p => new PropertyNameType(p, obj));
-			return JsonConvert.SerializeObject(props, Formatting.Indented);
-		}
+                var method = methods.Count == 1 ? methods[0] : methods.FirstOrDefault(m => m.GetParameters().Length == action.Params.Length);
+
+                if (method == null)
+                {
+                    Debug.LogMessage(LogEventLevel.Warning,
+                        "Unable to find method with name {methodName} and that matches parameters {@parameters}", null, action.MethodName,
+                        action.Params);
+                    return;
+                }
+                var mParams = method.GetParameters();
+
+                var convertedParams = mParams
+                                    .Select((p, i) => ConvertType(action.Params[i], p.ParameterType))
+                                    .ToArray();
+
+                await Task.Run(() =>
+                {
+                    try
+                    {
+                        Debug.LogMessage(LogEventLevel.Verbose, "Calling method {methodName} on device {deviceKey} with {@params}", null, method.Name, action.DeviceKey, action.Params);
+                        method.Invoke(obj, convertedParams);
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogMessage(e, "Error invoking method {methodName} on device {deviceKey}", null, method.Name, action.DeviceKey);
+                    }
+                });
+            }
+            catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Unable to call method with name {methodName} with {@parameters}", null, action.MethodName, action.Params);
+            }
+        }
+
+        private static object ConvertType(object value, Type conversionType)
+        {
+            if (!conversionType.IsEnum)
+            {
+                return Convert.ChangeType(value, conversionType, System.Globalization.CultureInfo.InvariantCulture);
+            }
+
+            var stringValue = Convert.ToString(value);
+
+            if (String.IsNullOrEmpty(stringValue))
+            {
+                throw new InvalidCastException(
+                    String.Format("{0} cannot be converted to a string prior to conversion to enum"));
+            }
+            return Enum.Parse(conversionType, stringValue, true);
+        }
+
+        /// <summary>
+        /// Gets the properties on a device
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static string GetProperties(string deviceObjectPath)
+        {
+            var obj = FindObjectOnPath(deviceObjectPath);
+            if (obj == null)
+                return "{ \"error\":\"No Device\"}";
+
+            Type t = obj.GetType();
+            // get the properties and set them into a new collection of NameType wrappers
+            var props = t.GetProperties().Select(p => new PropertyNameType(p, obj));
+            return JsonConvert.SerializeObject(props, Formatting.Indented);
+        }
 
         /// <summary>
         /// Gets a property from a device path by name
@@ -136,10 +203,10 @@ namespace PepperDash.Essentials.Core
         public static object GetPropertyByName(string deviceObjectPath, string propertyName)
         {
             var dev = FindObjectOnPath(deviceObjectPath);
-            if(dev == null)
+            if (dev == null)
                 return "{ \"error\":\"No Device\"}";
-	
-            object prop = dev.GetType().GetCType().GetProperty(propertyName).GetValue(dev, null);
+
+            object prop = dev.GetType().GetProperty(propertyName).GetValue(dev, null);
 
             // var prop = t.GetProperty(propertyName);
             if (prop != null)
@@ -153,126 +220,126 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-		/// <summary>
-		/// Gets the methods on a device
-		/// </summary>
-		/// <param name="key"></param>
-		/// <returns></returns>
-		public static string GetMethods(string deviceObjectPath)
-		{
-			var obj = FindObjectOnPath(deviceObjectPath);
-			if (obj == null)
-				return "{ \"error\":\"No Device\"}";
+        /// <summary>
+        /// Gets the methods on a device
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static string GetMethods(string deviceObjectPath)
+        {
+            var obj = FindObjectOnPath(deviceObjectPath);
+            if (obj == null)
+                return "{ \"error\":\"No Device\"}";
 
-			// Package up method names using helper objects
-			CType t = obj.GetType();
-			var methods = t.GetMethods()
-				.Where(m => !m.IsSpecialName)
-				.Select(p => new MethodNameParams(p));
-			return JsonConvert.SerializeObject(methods, Formatting.Indented);
-		}
+            // Package up method names using helper objects
+            Type t = obj.GetType();
+            var methods = t.GetMethods()
+                .Where(m => !m.IsSpecialName)
+                .Select(p => new MethodNameParams(p));
+            return JsonConvert.SerializeObject(methods, Formatting.Indented);
+        }
 
-		public static string GetApiMethods(string deviceObjectPath)
-		{
-			var obj = FindObjectOnPath(deviceObjectPath);
-			if (obj == null)
-				return "{ \"error\":\"No Device\"}";
+        public static string GetApiMethods(string deviceObjectPath)
+        {
+            var obj = FindObjectOnPath(deviceObjectPath);
+            if (obj == null)
+                return "{ \"error\":\"No Device\"}";
 
-			// Package up method names using helper objects
-			CType t = obj.GetType();
-			var methods = t.GetMethods()
-				.Where(m => !m.IsSpecialName)
-				.Where(m => m.GetCustomAttributes(typeof(ApiAttribute), true).Any())
-				.Select(p => new MethodNameParams(p));
-			return JsonConvert.SerializeObject(methods, Formatting.Indented);
-		}
-			
+            // Package up method names using helper objects
+            Type t = obj.GetType();
+            var methods = t.GetMethods()
+                .Where(m => !m.IsSpecialName)
+                .Where(m => m.GetCustomAttributes(typeof(ApiAttribute), true).Any())
+                .Select(p => new MethodNameParams(p));
+            return JsonConvert.SerializeObject(methods, Formatting.Indented);
+        }
 
-		/// <summary>
-		///  Walks down a dotted object path, starting with a Device, and returns the object
-		///  at the end of the path
-		/// </summary>
-		public static object FindObjectOnPath(string deviceObjectPath)
-		{
-			var path = deviceObjectPath.Split('.');
 
-			var dev = DeviceManager.GetDeviceForKey(path[0]);
-			if (dev == null)
-			{
-				Debug.LogMessage(LogEventLevel.Information, "Device {0} not found", path[0]);
-				return null;
-			}
+        /// <summary>
+        ///  Walks down a dotted object path, starting with a Device, and returns the object
+        ///  at the end of the path
+        /// </summary>
+        public static object FindObjectOnPath(string deviceObjectPath)
+        {
+            var path = deviceObjectPath.Split('.');
 
-			// loop through any dotted properties
-			object obj = dev;
-			if (path.Length > 1)
-			{
-				for (int i = 1; i < path.Length; i++)
-				{
-					var objName = path[i];
-					string indexStr = null;
-					var indexOpen = objName.IndexOf('[');
-					if (indexOpen != -1)
-					{
-						var indexClose = objName.IndexOf(']');
-						if (indexClose == -1)
-						{
-							Debug.LogMessage(LogEventLevel.Information, dev, "ERROR Unmatched index brackets");
-							return null;
-						}
-						// Get the index and strip quotes if any
-						indexStr = objName.Substring(indexOpen + 1, indexClose - indexOpen - 1).Replace("\"", "");
-						objName = objName.Substring(0, indexOpen);
-						Debug.LogMessage(LogEventLevel.Information, dev, "  Checking for collection '{0}', index '{1}'", objName, indexStr);
-					}
+            var dev = DeviceManager.GetDeviceForKey(path[0]);
+            if (dev == null)
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Device {0} not found", path[0]);
+                return null;
+            }
 
-					CType oType = obj.GetType();
-					var prop = oType.GetProperty(objName);
-					if (prop == null)
-					{
-						Debug.LogMessage(LogEventLevel.Information, dev, "Property {0} not found on {1}", objName, path[i - 1]);
-						return null;
-					}
-					// if there's an index, try to get the property
-					if (indexStr != null)
-					{
-						if (!typeof(ICollection).IsAssignableFrom(prop.PropertyType))
-						{
-							Debug.LogMessage(LogEventLevel.Information, dev, "Property {0} is not collection", objName);
-							return null;
-						}
-						var collection = prop.GetValue(obj, null) as ICollection;
-						// Get the indexed items "property"
-						var indexedPropInfo = prop.PropertyType.GetProperty("Item");
-						// These are the parameters for the indexing. Only care about one
-						var indexParams = indexedPropInfo.GetIndexParameters();
-						if (indexParams.Length > 0)
-						{
-							Debug.LogMessage(LogEventLevel.Information, "  Indexed, param type: {0}", indexParams[0].ParameterType.Name);
-							var properParam = Convert.ChangeType(indexStr, indexParams[0].ParameterType,
-								System.Globalization.CultureInfo.InvariantCulture);
-							try
-							{
-								obj = indexedPropInfo.GetValue(collection, new object[] { properParam });
-							}
-							// if the index is bad, catch it here.
-							catch (Crestron.SimplSharp.Reflection.TargetInvocationException e)
-							{
-								if (e.InnerException is ArgumentOutOfRangeException)
-									Debug.LogMessage(LogEventLevel.Information, "  Index Out of range");
-								else if (e.InnerException is KeyNotFoundException)
-									Debug.LogMessage(LogEventLevel.Information, "  Key not found");
-								return null;
-							}
-						}
+            // loop through any dotted properties
+            object obj = dev;
+            if (path.Length > 1)
+            {
+                for (int i = 1; i < path.Length; i++)
+                {
+                    var objName = path[i];
+                    string indexStr = null;
+                    var indexOpen = objName.IndexOf('[');
+                    if (indexOpen != -1)
+                    {
+                        var indexClose = objName.IndexOf(']');
+                        if (indexClose == -1)
+                        {
+                            Debug.LogMessage(LogEventLevel.Information, dev, "ERROR Unmatched index brackets");
+                            return null;
+                        }
+                        // Get the index and strip quotes if any
+                        indexStr = objName.Substring(indexOpen + 1, indexClose - indexOpen - 1).Replace("\"", "");
+                        objName = objName.Substring(0, indexOpen);
+                        Debug.LogMessage(LogEventLevel.Information, dev, "  Checking for collection '{0}', index '{1}'", objName, indexStr);
+                    }
 
-					}
-					else
-						obj = prop.GetValue(obj, null);
-				}
-			}
-			return obj;
-		}
+                    Type oType = obj.GetType();
+                    var prop = oType.GetProperty(objName);
+                    if (prop == null)
+                    {
+                        Debug.LogMessage(LogEventLevel.Information, dev, "Property {0} not found on {1}", objName, path[i - 1]);
+                        return null;
+                    }
+                    // if there's an index, try to get the property
+                    if (indexStr != null)
+                    {
+                        if (!typeof(ICollection).IsAssignableFrom(prop.PropertyType))
+                        {
+                            Debug.LogMessage(LogEventLevel.Information, dev, "Property {0} is not collection", objName);
+                            return null;
+                        }
+                        var collection = prop.GetValue(obj, null) as ICollection;
+                        // Get the indexed items "property"
+                        var indexedPropInfo = prop.PropertyType.GetProperty("Item");
+                        // These are the parameters for the indexing. Only care about one
+                        var indexParams = indexedPropInfo.GetIndexParameters();
+                        if (indexParams.Length > 0)
+                        {
+                            Debug.LogMessage(LogEventLevel.Information, "  Indexed, param type: {0}", indexParams[0].ParameterType.Name);
+                            var properParam = Convert.ChangeType(indexStr, indexParams[0].ParameterType,
+                                System.Globalization.CultureInfo.InvariantCulture);
+                            try
+                            {
+                                obj = indexedPropInfo.GetValue(collection, new object[] { properParam });
+                            }
+                            // if the index is bad, catch it here.
+                            catch (TargetInvocationException e)
+                            {
+                                if (e.InnerException is ArgumentOutOfRangeException)
+                                    Debug.LogMessage(LogEventLevel.Information, "  Index Out of range");
+                                else if (e.InnerException is KeyNotFoundException)
+                                    Debug.LogMessage(LogEventLevel.Information, "  Key not found");
+                                return null;
+                            }
+                        }
+
+                    }
+                    else
+                        obj = prop.GetValue(obj, null);
+                }
+            }
+            return obj;
+        }
 
         /// <summary>
         /// Sets a property on an object.
@@ -287,7 +354,7 @@ namespace PepperDash.Essentials.Core
             //if (obj == null)
             //    return "{\"error\":\"No object found\"}";
 
-            //CType t = obj.GetType();
+            //Type t = obj.GetType();
 
 
             //// get the properties and set them into a new collection of NameType wrappers
@@ -295,78 +362,85 @@ namespace PepperDash.Essentials.Core
             //return JsonConvert.SerializeObject(props, Formatting.Indented);
         }
 
-        
-	}
 
-	public class DeviceActionWrapper
-	{
-		public string DeviceKey { get; set; }
-		public string MethodName { get; set; }
-		public object[] Params { get; set; }
-	}
+    }
 
-	public class PropertyNameType
-	{
-        object Parent;
+    public class DeviceActionWrapper
+    {
+        public string DeviceKey { get; set; }
+        public string MethodName { get; set; }
+        public object[] Params { get; set; }
+    }
 
-		[JsonIgnore]
-		public PropertyInfo PropInfo { get; private set; }
-		public string Name { get { return PropInfo.Name; } }
-		public string Type { get { return PropInfo.PropertyType.Name; } }
-        public string Value { get 
+    public class PropertyNameType
+    {
+        private object Parent;
+
+        [JsonIgnore]
+        public PropertyInfo PropInfo { get; private set; }
+        public string Name { get { return PropInfo.Name; } }
+        public string Type { get { return PropInfo.PropertyType.Name; } }
+        public string Value
         {
-            if (PropInfo.CanRead)
+            get
             {
-                try
+                if (PropInfo.CanRead)
                 {
-                    return PropInfo.GetValue(Parent, null).ToString();
+                    try
+                    {
+                        return PropInfo.GetValue(Parent, null).ToString();
+                    }
+                    catch (Exception)
+                    {
+                        return null;
+                    }
                 }
-                catch (Exception)
-                {
+                else
                     return null;
-                }
             }
-            else
-                return null;    
-        } }
+        }
 
         public bool CanRead { get { return PropInfo.CanRead; } }
         public bool CanWrite { get { return PropInfo.CanWrite; } }
 
 
-		public PropertyNameType(PropertyInfo info, object parent)
-		{
-			PropInfo = info;
+        public PropertyNameType(PropertyInfo info, object parent)
+        {
+            PropInfo = info;
             Parent = parent;
-		}
-	}
+        }
+    }
 
-	public class MethodNameParams
-	{
-		[JsonIgnore]
-		public MethodInfo MethodInfo { get; private set; }
+    public class MethodNameParams
+    {
+        [JsonIgnore]
+        public MethodInfo MethodInfo { get; private set; }
 
-		public string Name { get { return MethodInfo.Name; } }
-		public IEnumerable<NameType> Params { get {
-			return MethodInfo.GetParameters().Select(p => 
-				new NameType { Name = p.Name, Type = p.ParameterType.Name });
-		} }
+        public string Name { get { return MethodInfo.Name; } }
+        public IEnumerable<NameType> Params
+        {
+            get
+            {
+                return MethodInfo.GetParameters().Select(p =>
+                    new NameType { Name = p.Name, Type = p.ParameterType.Name });
+            }
+        }
 
-		public MethodNameParams(MethodInfo info)
-		{
-			MethodInfo = info;
-		}
-	}
+        public MethodNameParams(MethodInfo info)
+        {
+            MethodInfo = info;
+        }
+    }
 
-	public class NameType
-	{
-		public string Name { get; set; }
-		public string Type { get; set; }
-	}
+    public class NameType
+    {
+        public string Name { get; set; }
+        public string Type { get; set; }
+    }
 
-	[AttributeUsage(AttributeTargets.All)]
-	public class ApiAttribute : CAttribute
-	{
+    [AttributeUsage(AttributeTargets.All)]
+    public class ApiAttribute : Attribute
+    {
 
-	}
+    }
 }

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

@@ -1,50 +1,50 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using Crestron.SimplSharp;
+using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
-
 using PepperDash.Core;
 using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
 
 
 namespace PepperDash.Essentials.Core
 {
-	public static class DeviceManager
-	{
+    public static class DeviceManager
+    {
         public static event EventHandler<EventArgs> AllDevicesActivated;
         public static event EventHandler<EventArgs> AllDevicesRegistered;
+        public static event EventHandler<EventArgs> AllDevicesInitialized;
 
-	    private static readonly CCriticalSection DeviceCriticalSection = new CCriticalSection();
-	    private static readonly CEvent AllowAddDevicesCEvent = new CEvent(false, true);
-		//public static List<Device> Devices { get { return _Devices; } }
-		//static List<Device> _Devices = new List<Device>();
+        private static readonly CCriticalSection DeviceCriticalSection = new CCriticalSection();
+        private static readonly CEvent AllowAddDevicesCEvent = new CEvent(false, true);
 
-		static readonly Dictionary<string, IKeyed> Devices = new Dictionary<string, IKeyed>(StringComparer.OrdinalIgnoreCase);
+        //public static List<Device> Devices { get { return _Devices; } }
+        //static List<Device> _Devices = new List<Device>();
 
-		/// <summary>
-		/// Returns a copy of all the devices in a list
-		/// </summary>
-		public static List<IKeyed> AllDevices { get { return new List<IKeyed>(Devices.Values); } }
+        private static readonly Dictionary<string, IKeyed> Devices = new Dictionary<string, IKeyed>(StringComparer.OrdinalIgnoreCase);
 
-	    public static bool AddDeviceEnabled;
+        /// <summary>
+        /// Returns a copy of all the devices in a list
+        /// </summary>
+        public static List<IKeyed> AllDevices { get { return new List<IKeyed>(Devices.Values); } }
 
-		public static void Initialize(CrestronControlSystem cs)
-		{
-		    AddDeviceEnabled = true;
-			CrestronConsole.AddNewConsoleCommand(ListDeviceCommStatuses, "devcommstatus", "Lists the communication status of all devices",
-				ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(ListDeviceFeedbacks, "devfb", "Lists current feedbacks", 
-				ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(ListDevices, "devlist", "Lists current managed devices", 
-				ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(DeviceJsonApi.DoDeviceActionWithJson, "devjson", "", 
-				ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetProperties(s)), "devprops", "", ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetMethods(s)), "devmethods", "", ConsoleAccessLevelEnum.AccessOperator);
-			CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetApiMethods(s)), "apimethods", "", ConsoleAccessLevelEnum.AccessOperator);
+        public static bool AddDeviceEnabled;
+
+        public static void Initialize(CrestronControlSystem cs)
+        {
+            AddDeviceEnabled = true;
+            CrestronConsole.AddNewConsoleCommand(ListDeviceCommStatuses, "devcommstatus", "Lists the communication status of all devices",
+                ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(ListDeviceFeedbacks, "devfb", "Lists current feedbacks",
+                ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(ListDevices, "devlist", "Lists current managed devices",
+                ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(DeviceJsonApi.DoDeviceActionWithJson, "devjson", "",
+                ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetProperties(s)), "devprops", "", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetMethods(s)), "devmethods", "", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(s => CrestronConsole.ConsoleCommandResponse(DeviceJsonApi.GetApiMethods(s)), "apimethods", "", ConsoleAccessLevelEnum.AccessOperator);
             CrestronConsole.AddNewConsoleCommand(SimulateComReceiveOnDevice, "devsimreceive",
                 "Simulates incoming data on a com device", ConsoleAccessLevelEnum.AccessOperator);
 
@@ -52,77 +52,89 @@ namespace PepperDash.Essentials.Core
             CrestronConsole.AddNewConsoleCommand(s => DisableAllDeviceStreamDebugging(), "disableallstreamdebug", "disables stream debugging on all devices", ConsoleAccessLevelEnum.AccessOperator);
         }
 
-		/// <summary>
-		/// Calls activate steps on all Device class items
-		/// </summary>
-		public static void ActivateAll()
-		{
-		    try
-		    {
+        /// <summary>
+        /// Calls activate steps on all Device class items
+        /// </summary>
+        public static void ActivateAll()
+        {
+            try
+            {
                 OnAllDevicesRegistered();
 
-		        DeviceCriticalSection.Enter();
+                DeviceCriticalSection.Enter();
                 AddDeviceEnabled = false;
-		        // PreActivate all devices
-                Debug.LogMessage(LogEventLevel.Information,"****PreActivation starting...****");
-		        foreach (var d in Devices.Values)
-		        {
-		            try
-		            {
-		                if (d is Device)
-		                    (d as Device).PreActivate();
-		            }
-		            catch (Exception e)
-		            {
+                // PreActivate all devices
+                Debug.LogMessage(LogEventLevel.Information, "****PreActivation starting...****");
+                foreach (var d in Devices.Values)
+                {
+                    try
+                    { 
+                        if (d is Device)
+                            (d as Device).PreActivate();
+                    }
+                    catch (Exception e)
+                    {
                         Debug.LogMessage(LogEventLevel.Information, d, "ERROR: Device {1} PreActivation failure: {0}", e.Message, d.Key);
                         Debug.LogMessage(LogEventLevel.Debug, d, "Stack Trace: {0}", e.StackTrace);
-		            }
-		        }
+                    }
+                }
                 Debug.LogMessage(LogEventLevel.Information, "****PreActivation complete****");
-		        Debug.LogMessage(LogEventLevel.Information, "****Activation starting...****");
+                Debug.LogMessage(LogEventLevel.Information, "****Activation starting...****");
 
-		        // Activate all devices
-		        foreach (var d in Devices.Values)
-		        {
-		            try
-		            {
-		                if (d is Device)
-		                    (d as Device).Activate();
-		            }
-		            catch (Exception e)
-		            {
+                // Activate all devices
+                foreach (var d in Devices.Values)
+                {
+                    try
+                    {
+                        if (d is Device)
+                            (d as Device).Activate();
+                    }
+                    catch (Exception e)
+                    {
                         Debug.LogMessage(LogEventLevel.Information, d, "ERROR: Device {1} Activation failure: {0}", e.Message, d.Key);
                         Debug.LogMessage(LogEventLevel.Debug, d, "Stack Trace: {0}", e.StackTrace);
-		            }
-		        }
+                    }
+                }
 
                 Debug.LogMessage(LogEventLevel.Information, "****Activation complete****");
                 Debug.LogMessage(LogEventLevel.Information, "****PostActivation starting...****");
 
-		        // PostActivate all devices
-		        foreach (var d in Devices.Values)
-		        {
-		            try
-		            {
-		                if (d is Device)
-		                    (d as Device).PostActivate();
-		            }
-		            catch (Exception e)
-		            {
-		                Debug.LogMessage(LogEventLevel.Information, d, "ERROR: Device {1} PostActivation failure: {0}", e.Message, d.Key);
-		                Debug.LogMessage(LogEventLevel.Debug, d, "Stack Trace: {0}", e.StackTrace);
-		            }
-		        }
+                // PostActivate all devices
+                foreach (var d in Devices.Values)
+                {
+                    try
+                    {
+                        if (d is Device)
+                            (d as Device).PostActivate();
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogMessage(LogEventLevel.Information, d, "ERROR: Device {1} PostActivation failure: {0}", e.Message, d.Key);
+                        Debug.LogMessage(LogEventLevel.Debug, d, "Stack Trace: {0}", e.StackTrace);
+                    }
+                }
 
                 Debug.LogMessage(LogEventLevel.Information, "****PostActivation complete****");
 
                 OnAllDevicesActivated();
-		    }
-		    finally
-		    {
+            }
+            finally
+            {
                 DeviceCriticalSection.Leave();
-		    }
-		}
+            }
+        }
+
+        private static void DeviceManager_Initialized(object sender, EventArgs e)
+        {
+            var allInitialized = Devices.Values.OfType<EssentialsDevice>().All(d => d.IsInitialized);
+
+            if (allInitialized)
+            {
+                Debug.LogMessage(LogEventLevel.Information, "****All Devices Initalized****");
+
+                OnAllDevicesInitialized();
+            }
+        }
 
         private static void OnAllDevicesActivated()
         {
@@ -142,77 +154,85 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-		/// <summary>
-		/// Calls activate on all Device class items
-		/// </summary>
-		public static void DeactivateAll()
-		{
-		    try
-		    {
-		        DeviceCriticalSection.Enter();
-		        foreach (var d in Devices.Values.OfType<Device>())
-		        {
-		            d.Deactivate();
-		        }
-		    }
-		    finally
-		    {
-		        DeviceCriticalSection.Leave();
-		    }
-		}
+        private static void OnAllDevicesInitialized()
+        {
+            var handler = AllDevicesInitialized;
+            if (handler != null)
+            {
+                handler(null, new EventArgs());
+            }
+        }
 
-		//static void ListMethods(string devKey)
-		//{
-		//    var dev = GetDeviceForKey(devKey);
-		//    if(dev != null)
-		//    {
-		//        var type = dev.GetType().GetCType();
-		//        var methods = type.GetMethods(BindingFlags.Public|BindingFlags.Instance);
-		//        var sb = new StringBuilder();
-		//        sb.AppendLine(string.Format("{2} methods on [{0}] ({1}):", dev.Key, type.Name, methods.Length));
-		//        foreach (var m in methods)
-		//        {
-		//            sb.Append(string.Format("{0}(", m.Name));
-		//            var pars = m.GetParameters();
-		//            foreach (var p in pars)
-		//                sb.Append(string.Format("({1}){0} ", p.Name, p.ParameterType.Name));
-		//            sb.AppendLine(")");
-		//        }
-		//        CrestronConsole.ConsoleCommandResponse(sb.ToString());
-		//    }
-		//}
+        /// <summary>
+        /// Calls activate on all Device class items
+        /// </summary>
+        public static void DeactivateAll()
+        {
+            try
+            {
+                DeviceCriticalSection.Enter();
+                foreach (var d in Devices.Values.OfType<Device>())
+                {
+                    d.Deactivate();
+                }
+            }
+            finally
+            {
+                DeviceCriticalSection.Leave();
+            }
+        }
 
-	    private static void ListDevices(string s)
-	    {
-	        Debug.LogMessage(LogEventLevel.Information, "{0} Devices registered with Device Manager:", Devices.Count);
-	        var sorted = Devices.Values.ToList();
-	        sorted.Sort((a, b) => a.Key.CompareTo(b.Key));
+        //static void ListMethods(string devKey)
+        //{
+        //    var dev = GetDeviceForKey(devKey);
+        //    if(dev != null)
+        //    {
+        //        var type = dev.GetType().GetType();
+        //        var methods = type.GetMethods(BindingFlags.Public|BindingFlags.Instance);
+        //        var sb = new StringBuilder();
+        //        sb.AppendLine(string.Format("{2} methods on [{0}] ({1}):", dev.Key, type.Name, methods.Length));
+        //        foreach (var m in methods)
+        //        {
+        //            sb.Append(string.Format("{0}(", m.Name));
+        //            var pars = m.GetParameters();
+        //            foreach (var p in pars)
+        //                sb.Append(string.Format("({1}){0} ", p.Name, p.ParameterType.Name));
+        //            sb.AppendLine(")");
+        //        }
+        //        CrestronConsole.ConsoleCommandResponse(sb.ToString());
+        //    }
+        //}
 
-	        foreach (var d in sorted)
-	        {
-	            var name = d is IKeyName ? (d as IKeyName).Name : "---";
-	            Debug.LogMessage(LogEventLevel.Information, "  [{0}] {1}", d.Key, name);
-	        }
-	    }
+        private static void ListDevices(string s)
+        {
+            Debug.LogMessage(LogEventLevel.Information, "{0} Devices registered with Device Manager:", Devices.Count);
+            var sorted = Devices.Values.ToList();
+            sorted.Sort((a, b) => a.Key.CompareTo(b.Key));
 
-	    private static void ListDeviceFeedbacks(string devKey)
-	    {
-	        var dev = GetDeviceForKey(devKey);
-	        if (dev == null)
-	        {
-	            Debug.LogMessage(LogEventLevel.Information, "Device '{0}' not found", devKey);
-	            return;
-	        }
-	        var statusDev = dev as IHasFeedback;
-	        if (statusDev == null)
-	        {
-	            Debug.LogMessage(LogEventLevel.Information, "Device '{0}' does not have visible feedbacks", devKey);
-	            return;
-	        }
-	        statusDev.DumpFeedbacksToConsole(true);
-	    }
+            foreach (var d in sorted)
+            {
+                var name = d is IKeyName ? (d as IKeyName).Name : "---";
+                Debug.LogMessage(LogEventLevel.Information, "  [{0}] {1}", d.Key, name);
+            }
+        }
 
-	    //static void ListDeviceCommands(string devKey)
+        private static void ListDeviceFeedbacks(string devKey)
+        {
+            var dev = GetDeviceForKey(devKey);
+            if (dev == null)
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Device '{0}' not found", devKey);
+                return;
+            }
+            if (!(dev is IHasFeedback statusDev))
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Device '{0}' does not have visible feedbacks", devKey);
+                return;
+            }
+            statusDev.DumpFeedbacksToConsole(true);
+        }
+
+        //static void ListDeviceCommands(string devKey)
         //{
         //    var dev = GetDeviceForKey(devKey);
         //    if (dev == null)
@@ -223,134 +243,135 @@ namespace PepperDash.Essentials.Core
         //    Debug.LogMessage(LogEventLevel.Information, "This needs to be reworked.  Stay tuned.", devKey);
         //}
 
-	    private static void ListDeviceCommStatuses(string input)
-	    {
-	        var sb = new StringBuilder();
-	        foreach (var dev in Devices.Values.OfType<ICommunicationMonitor>())
-	        {
-	            sb.Append(string.Format("{0}: {1}\r", dev,
-	                dev.CommunicationMonitor.Status));
-	        }
-	        CrestronConsole.ConsoleCommandResponse(sb.ToString());
-	    }
+        private static void ListDeviceCommStatuses(string input)
+        {
+
+            foreach (var dev in Devices.Values.OfType<ICommunicationMonitor>())
+            {
+                CrestronConsole.ConsoleCommandResponse($"{dev}: {dev.CommunicationMonitor.Status}{Environment.NewLine}");
+            }
+        }
 
 
-	    //static void DoDeviceCommand(string command)
+        //static void DoDeviceCommand(string command)
         //{
         //    Debug.LogMessage(LogEventLevel.Information, "Not yet implemented.  Stay tuned");
         //}
 
-		public static void AddDevice(IKeyed newDev)
-		{
-		    try
-		    {
-		        if (!DeviceCriticalSection.TryEnter())
-		        {
-		            Debug.LogMessage(LogEventLevel.Information, "Currently unable to add devices to Device Manager. Please try again");
-		            return;
-		        }
-		        // Check for device with same key
-		        //var existingDevice = _Devices.FirstOrDefault(d => d.Key.Equals(newDev.Key, StringComparison.OrdinalIgnoreCase));
-		        ////// If it exists, remove or warn??
-		        //if (existingDevice != null)
+        public static void AddDevice(IKeyed newDev)
+        {
+            try
+            {
+                if (!DeviceCriticalSection.TryEnter())
+                {
+                    Debug.LogMessage(LogEventLevel.Information, "Currently unable to add devices to Device Manager. Please try again");
+                    return;
+                }
+                // Check for device with same key
+                //var existingDevice = _Devices.FirstOrDefault(d => d.Key.Equals(newDev.Key, StringComparison.OrdinalIgnoreCase));
+                ////// If it exists, remove or warn??
+                //if (existingDevice != null)
 
-		        if (!AddDeviceEnabled)
-		        {
-		            Debug.LogMessage(LogEventLevel.Information, "All devices have been activated. Adding new devices is not allowed.");
-		            return;
-		        }
+                if (!AddDeviceEnabled)
+                {
+                    Debug.LogMessage(LogEventLevel.Information, "All devices have been activated. Adding new devices is not allowed.");
+                    return;
+                }
 
-		        if (Devices.ContainsKey(newDev.Key))
-		        {
-		            Debug.LogMessage(LogEventLevel.Information, newDev, "WARNING: A device with this key already exists.  Not added to manager");
-		            return;
-		        }
-		        Devices.Add(newDev.Key, newDev);
-		        //if (!(_Devices.Contains(newDev)))
-		        //    _Devices.Add(newDev);
-		    }
-		    finally
-		    {
-		        DeviceCriticalSection.Leave();
-		    }
-		}
+                if (Devices.ContainsKey(newDev.Key))
+                {
+                    Debug.LogMessage(LogEventLevel.Information, newDev, "WARNING: A device with this key already exists.  Not added to manager");
+                    return;
+                }
+                Devices.Add(newDev.Key, newDev);
+                //if (!(_Devices.Contains(newDev)))
+                //    _Devices.Add(newDev);
 
-	    public static void AddDevice(IEnumerable<IKeyed> devicesToAdd)
-	    {
-	        try
-	        {
-	            if (!DeviceCriticalSection.TryEnter())
-	            {
-	                Debug.LogMessage(LogEventLevel.Information,
-	                    "Currently unable to add devices to Device Manager. Please try again");
-	                return;
-	            }
-	            if (!AddDeviceEnabled)
-	            {
-	                Debug.LogMessage(LogEventLevel.Information,
-	                    "All devices have been activated. Adding new devices is not allowed.");
-	                return;
-	            }
+                if (newDev is EssentialsDevice essentialsDev)
+                    essentialsDev.Initialized += DeviceManager_Initialized;
+            }
+            finally
+            {
+                DeviceCriticalSection.Leave();
+            }
+        }
 
-	            foreach (var dev in devicesToAdd)
-	            {
-	                try
-	                {
-	                    Devices.Add(dev.Key, dev);
-	                }
-	                catch (ArgumentException ex)
-	                {
-	                    Debug.LogMessage(LogEventLevel.Information, "Error adding device with key {0} to Device Manager: {1}\r\nStack Trace: {2}",
-	                        dev.Key, ex.Message, ex.StackTrace);
-	                }
-	            }
-	        }
-	        finally
-	        {
-	            DeviceCriticalSection.Leave();
-	        }
-	    }
+        public static void AddDevice(IEnumerable<IKeyed> devicesToAdd)
+        {
+            try
+            {
+                if (!DeviceCriticalSection.TryEnter())
+                {
+                    Debug.LogMessage(LogEventLevel.Information,
+                        "Currently unable to add devices to Device Manager. Please try again");
+                    return;
+                }
+                if (!AddDeviceEnabled)
+                {
+                    Debug.LogMessage(LogEventLevel.Information,
+                        "All devices have been activated. Adding new devices is not allowed.");
+                    return;
+                }
 
-		public static void RemoveDevice(IKeyed newDev)
-		{
-		    try
-		    {
+                foreach (var dev in devicesToAdd)
+                {
+                    try
+                    {
+                        Devices.Add(dev.Key, dev);
+                    }
+                    catch (ArgumentException ex)
+                    {
+                        Debug.LogMessage(LogEventLevel.Information, "Error adding device with key {0} to Device Manager: {1}\r\nStack Trace: {2}",
+                            dev.Key, ex.Message, ex.StackTrace);
+                    }
+                }
+            }
+            finally
+            {
+                DeviceCriticalSection.Leave();
+            }
+        }
+
+        public static void RemoveDevice(IKeyed newDev)
+        {
+            try
+            {
                 DeviceCriticalSection.Enter();
-		        if (newDev == null)
-		            return;
-		        if (Devices.ContainsKey(newDev.Key))
-		            Devices.Remove(newDev.Key);
-		            //if (_Devices.Contains(newDev))
-		            //    _Devices.Remove(newDev);
-		        else
-		            Debug.LogMessage(LogEventLevel.Information, "Device manager: Device '{0}' does not exist in manager.  Cannot remove", newDev.Key);
-		    }
-		    finally
-		    {
-		        DeviceCriticalSection.Leave();
-		    }
-		}
+                if (newDev == null)
+                    return;
+                if (Devices.ContainsKey(newDev.Key))
+                    Devices.Remove(newDev.Key);
+                //if (_Devices.Contains(newDev))
+                //    _Devices.Remove(newDev);
+                else
+                    Debug.LogMessage(LogEventLevel.Information, "Device manager: Device '{0}' does not exist in manager.  Cannot remove", newDev.Key);
+            }
+            finally
+            {
+                DeviceCriticalSection.Leave();
+            }
+        }
 
-		public static IEnumerable<string> GetDeviceKeys()
-		{
-		        //return _Devices.Select(d => d.Key).ToList();
-		        return Devices.Keys;
-		}
+        public static IEnumerable<string> GetDeviceKeys()
+        {
+            //return _Devices.Select(d => d.Key).ToList();
+            return Devices.Keys;
+        }
 
-		public static IEnumerable<IKeyed> GetDevices()
-		{
-		        //return _Devices.Select(d => d.Key).ToList();
-		        return Devices.Values;
-		}
+        public static IEnumerable<IKeyed> GetDevices()
+        {
+            //return _Devices.Select(d => d.Key).ToList();
+            return Devices.Values;
+        }
 
-		public static IKeyed GetDeviceForKey(string key)
-		{
-		        //return _Devices.FirstOrDefault(d => d.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
-		        if (key != null && Devices.ContainsKey(key))
-		            return Devices[key];
+        public static IKeyed GetDeviceForKey(string key)
+        {
+            //return _Devices.FirstOrDefault(d => d.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+            if (key != null && Devices.ContainsKey(key))
+                return Devices[key];
 
-		        return null;
-		}
+            return null;
+        }
 
         /// <summary>
         /// Console handler that simulates com port data receive 
@@ -367,8 +388,7 @@ namespace PepperDash.Essentials.Core
             }
             //Debug.LogMessage(LogEventLevel.Verbose, "**** {0} - {1} ****", match.Groups[1].Value, match.Groups[2].Value);
 
-            var com = GetDeviceForKey(match.Groups[1].Value) as ComPortController;
-            if (com == null)
+            if (!(GetDeviceForKey(match.Groups[1].Value) is ComPortController com))
             {
                 CrestronConsole.ConsoleCommandResponse("'{0}' is not a comm port device", match.Groups[1].Value);
                 return;
@@ -423,16 +443,15 @@ namespace PepperDash.Essentials.Core
             var deviceKey = args[0];
             var setting = args[1];
 
-            var timeout= String.Empty;
+            var timeout = String.Empty;
 
             if (args.Length >= 3)
             {
                 timeout = args[2];
             }
 
-            var device = GetDeviceForKey(deviceKey) as IStreamDebugging;
 
-            if (device == null)
+            if (!(GetDeviceForKey(deviceKey) is IStreamDebugging device))
             {
                 CrestronConsole.ConsoleCommandResponse("Unable to get device with key: {0}", deviceKey);
                 return;
@@ -479,13 +498,11 @@ namespace PepperDash.Essentials.Core
         {
             foreach (var device in AllDevices)
             {
-                var streamDevice = device as IStreamDebugging;
-
-                if (streamDevice != null)
+                if (device is IStreamDebugging streamDevice)
                 {
                     streamDevice.StreamDebugging.SetDebuggingWithDefaultTimeout(eStreamDebuggingSetting.Off);
                 }
             }
         }
-	}
+    }
 }

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

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
@@ -17,6 +17,24 @@ namespace PepperDash.Essentials.Core
     [Description("The base Essentials Device Class")]
     public abstract class EssentialsDevice : Device
     {
+        public event EventHandler Initialized;
+
+        private bool _isInitialized;
+        public bool IsInitialized { 
+            get { return _isInitialized; }
+            private set 
+            { 
+                if (_isInitialized == value) return;
+                
+                _isInitialized = value;
+
+                if (_isInitialized)
+                {
+                    Initialized?.Invoke(this, new EventArgs());
+                }
+            } 
+        }
+
         protected EssentialsDevice(string key)
             : base(key)
         {
@@ -41,6 +59,8 @@ namespace PepperDash.Essentials.Core
                 try
                 {
                     Initialize();
+
+                    IsInitialized = true;
                 }
                 catch (Exception ex)
                 {

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

@@ -1,17 +0,0 @@
-using System.Collections.Generic;
-
-namespace PepperDash.Essentials.Core
-{
-    public interface IHasDspPresets
-    {
-        List<IDspPreset> Presets { get; }
-
-        void RecallPreset(IDspPreset preset);
-
-    }
-
-    public interface IDspPreset
-    {
-        string Name { get; }
-    }
-}

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

@@ -0,0 +1,12 @@
+using PepperDash.Core;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core
+{
+    public interface IDspPresets
+    {
+        Dictionary<string, IKeyName> Presets { get; }
+
+        void RecallPreset(string key);
+    }
+}

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

@@ -1,7 +1,5 @@
-using System.Collections.Generic;
+using System;
 using System.Linq;
-using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharp.Reflection;
 
 using PepperDash.Core;
 using Serilog.Events;
@@ -23,7 +21,7 @@ namespace PepperDash.Essentials.Core
 	{
 		public static void DumpFeedbacksToConsole(this IHasFeedback source, bool getCurrentStates)
 		{
-            CType t = source.GetType();
+            Type t = source.GetType();
             // get the properties and set them into a new collection of NameType wrappers
             var props = t.GetProperties().Select(p => new PropertyNameType(p, t));
 

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

@@ -5,13 +5,13 @@ using System.Text;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 using PepperDash.Core;
+using PepperDash.Essentials.Core.Devices;
 
 namespace PepperDash.Essentials.Core
 {
-    public class LevelControlListItem
+    public class LevelControlListItem : AudioControlListItemBase
     {
-        [JsonProperty("deviceKey")]
-        public string DeviceKey { get; set; }
+
 
         [JsonIgnore]
         public IBasicVolumeWithFeedback LevelControl
@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.Core
             get
             {
                 if (_levelControl == null)
-                    _levelControl = DeviceManager.GetDeviceForKey(DeviceKey) as IBasicVolumeWithFeedback;
+                    _levelControl = DeviceManager.GetDeviceForKey(ParentDeviceKey) as IBasicVolumeWithFeedback;
                 return _levelControl;
             }
         }
@@ -34,8 +34,8 @@ namespace PepperDash.Essentials.Core
             get
             {
                 if (!string.IsNullOrEmpty(Name)) return Name;
-                else 
-                { 
+                else
+                {
                     if (LevelControl is IKeyName namedLevelControl)
                     {
                         if (namedLevelControl == null)
@@ -48,22 +48,21 @@ namespace PepperDash.Essentials.Core
         }
 
         /// <summary>
-        /// A name that will override the items's name on the UI
+        /// The key of the device in the DeviceManager for control
         /// </summary>
-        [JsonProperty("name")]
-        public string Name { get; set; }
-
-        /// <summary>
-        /// Indicates if the item should be included in the user accessible list
-        /// </summary>
-        [JsonProperty("includeInUserList")]
-        public bool IncludeInUserList { get; set; }
-
-        /// <summary>
-        /// Used to specify the order of the items in the source list when displayed
-        /// </summary>
-        [JsonProperty("order")]
-        public int Order { get; set; }
+        [JsonProperty("deviceKey")]
+        public string DeviceKey
+        {
+            get
+            {
+                if(string.IsNullOrEmpty(ItemKey)) return ParentDeviceKey;
+                else
+                {
+                    return DeviceManager.AllDevices.
+                    Where(d => d.Key.Contains(ParentDeviceKey) && d.Key.Contains(ItemKey)).FirstOrDefault()?.Key ?? $"{ParentDeviceKey}--{ItemKey}";
+                }
+            }
+        }
 
         /// <summary>
         /// Indicates if the item is a level, mute , or both
@@ -76,8 +75,8 @@ namespace PepperDash.Essentials.Core
     [Flags]
     public enum eLevelControlType
     {
-        Level = 0,
-        Mute = 1,
+        Level = 1,
+        Mute = 2,
         LevelAndMute = Level | Mute,
     }
 }

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

@@ -5,7 +5,6 @@ using Crestron.SimplSharpPro;
 
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Core.Routing;
 using PepperDash.Core;
 using Serilog.Events;
 

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

@@ -5,7 +5,6 @@ using Crestron.SimplSharpPro;
 
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
-using PepperDash.Essentials.Core.Routing;
 using PepperDash.Core;
 using Serilog.Events;
 
@@ -70,7 +69,7 @@ namespace PepperDash.Essentials.Core.Devices
     {
         public LaptopFactory()
         {
-            TypeNames = new List<string>() { "laptop" };
+            TypeNames = new List<string>() { "deprecated" };
         }
 
         public override EssentialsDevice BuildDevice(DeviceConfig dc)

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

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+    public class PresetListItem : AudioControlListItemBase
+    {
+        [JsonIgnore]
+        public IKeyName Preset
+        {
+            get
+            {
+                if (_preset == null)
+                {
+                    var parent = DeviceManager.GetDeviceForKey(ParentDeviceKey) as IDspPresets;
+                    if (parent == null || !parent.Presets.ContainsKey(ItemKey))
+                        return null;
+                    _preset = parent.Presets[ItemKey];
+                }
+                return _preset;
+            }
+        }
+        private IKeyName _preset;
+
+        /// <summary>
+        /// Gets the name from the device if it implements IKeyName or else returns the Name property
+        /// </summary>
+        [JsonProperty("preferredName")]
+        public string PreferredName
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(Name)) return Name;
+
+                else return Preset.Name;
+            }
+        }
+    }
+}

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

@@ -1,128 +1,121 @@
-
-
-using System;
-using System.Collections.Generic;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.CrestronIO;
-using Crestron.SimplSharpPro;
-
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Linq;
 using PepperDash.Core;
+using System.Collections.Generic;
 
 namespace PepperDash.Essentials.Core
 {
-	/// <summary>
-	/// 
-	/// </summary>
-	public enum eSourceListItemType
-	{
-		Route, Off, Other, SomethingAwesomerThanThese
-	}
+    /// <summary>
+    /// 
+    /// </summary>
+    public enum eSourceListItemType
+    {
+        Route, Off, Other, SomethingAwesomerThanThese
+    }
 
-	/// <summary>
-	/// Represents an item in a source list - can be deserialized into.
-	/// </summary>
-	public class SourceListItem
-	{
-		[JsonProperty("sourceKey")]
-		public string SourceKey { get; set; }
+    /// <summary>
+    /// Represents an item in a source list - can be deserialized into.
+    /// </summary>
+    public class SourceListItem
+    {
+        [JsonProperty("sourceKey")]
+        public string SourceKey { get; set; }
 
-		/// <summary>
-		/// Returns the source Device for this, if it exists in DeviceManager
-		/// </summary>
-		[JsonIgnore]
-		public Device SourceDevice
-		{
-			get
-			{
-				if (_SourceDevice == null)
-					_SourceDevice = DeviceManager.GetDeviceForKey(SourceKey) as Device;
-				return _SourceDevice;
-			}
-		}
-		Device _SourceDevice;
+        /// <summary>
+        /// Returns the source Device for this, if it exists in DeviceManager
+        /// </summary>
+        [JsonIgnore]
+        public Device SourceDevice
+        {
+            get
+            {
+                if (_SourceDevice == null)
+                    _SourceDevice = DeviceManager.GetDeviceForKey(SourceKey) as Device;
+                return _SourceDevice;
+            }
+        }
 
-		/// <summary>
-		/// Gets either the source's Name or this AlternateName property, if 
-		/// defined.  If source doesn't exist, returns "Missing source"
-		/// </summary>
-		[JsonProperty("preferredName")]
-		public string PreferredName
-		{
-			get
-			{
-				if (string.IsNullOrEmpty(Name))
-				{
-					if (SourceDevice == null)
-						return "---";
-					return SourceDevice.Name;
-				}
-				return Name;
-			}
-		}
+        private Device _SourceDevice;
 
-		/// <summary>
-		/// A name that will override the source's name on the UI
-		/// </summary>
-		[JsonProperty("name")]
-		public string Name { get; set; }
+        /// <summary>
+        /// Gets either the source's Name or this AlternateName property, if 
+        /// defined.  If source doesn't exist, returns "Missing source"
+        /// </summary>
+        [JsonProperty("preferredName")]
+        public string PreferredName
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(Name))
+                {
+                    if (SourceDevice == null)
+                        return "---";
+                    return SourceDevice.Name;
+                }
+                return Name;
+            }
+        }
+
+        /// <summary>
+        /// A name that will override the source's name on the UI
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
 
         /// <summary>
         /// Specifies and icon for the source list item
         /// </summary>
 		[JsonProperty("icon")]
-		public string Icon { get; set; }
+        public string Icon { get; set; }
 
         /// <summary>
         /// Alternate icon
         /// </summary>
 		[JsonProperty("altIcon")]
-		public string AltIcon { get; set; }
+        public string AltIcon { get; set; }
 
         /// <summary>
         /// Indicates if the item should be included in the source list
         /// </summary>
 		[JsonProperty("includeInSourceList")]
-		public bool IncludeInSourceList { get; set; }
+        public bool IncludeInSourceList { get; set; }
 
         /// <summary>
         /// Used to specify the order of the items in the source list when displayed
         /// </summary>
 		[JsonProperty("order")]
-		public int Order { get; set; }
+        public int Order { get; set; }
 
         /// <summary>
         /// The key of the device for volume control
         /// </summary>
 		[JsonProperty("volumeControlKey")]
-		public string VolumeControlKey { get; set; }
+        public string VolumeControlKey { get; set; }
 
         /// <summary>
         /// The type of source list item
         /// </summary>
 		[JsonProperty("type")]
-		[JsonConverter(typeof(StringEnumConverter))]
-		public eSourceListItemType Type { get; set; }
+        [JsonConverter(typeof(StringEnumConverter))]
+        public eSourceListItemType Type { get; set; }
 
         /// <summary>
         /// The list of routes to execute for this source list item
         /// </summary>
 		[JsonProperty("routeList")]
-		public List<SourceRouteListItem> RouteList { get; set; }
+        public List<SourceRouteListItem> RouteList { get; set; }
 
         /// <summary>
         /// Indicates if this source should be disabled for sharing to the far end call participants via codec content
         /// </summary>
 		[JsonProperty("disableCodecSharing")]
-		public bool DisableCodecSharing { get; set; }
+        public bool DisableCodecSharing { get; set; }
 
         /// <summary>
         /// Indicates if this source should be disabled for routing to a shared output
         /// </summary>
 		[JsonProperty("disableRoutedSharing")]
-		public bool DisableRoutedSharing { get; set; }
+        public bool DisableRoutedSharing { get; set; }
 
         [JsonProperty("destinations")]
         public List<eSourceListItemDestinationTypes> Destinations { get; set; }
@@ -144,25 +137,46 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("isAudioSource")]
         public bool IsAudioSource { get; set; }
 
-		public SourceListItem()
-		{
-			Icon = "Blank";
-		}
+        /// <summary>
+        /// Hide source on UI when Avanced Sharing is enabled
+        /// </summary>
+        [JsonProperty("disableAdvancedRouting")]
+        public bool DisableAdvancedRouting { get; set; }
 
-        
-	}
+        /// <summary>
+        /// Hide source on UI when Simpl Sharing is enabled
+        /// </summary>
+        [JsonProperty("disableSimpleRouting")]
+        public bool DisableSimpleRouting { get; set; }
 
-	public class SourceRouteListItem
-	{
-		[JsonProperty("sourceKey")]
-		public string SourceKey { get; set; }
+        public SourceListItem()
+        {
+            Icon = "Blank";
+        }
 
-		[JsonProperty("destinationKey")]
-		public string DestinationKey { get; set; }
+        public override string ToString()
+        {
+            return $"{SourceKey}:{Name}";
+        }
+    }
 
-		[JsonProperty("type")]
-		public eRoutingSignalType Type { get; set; }
-	}
+    public class SourceRouteListItem
+    {
+        [JsonProperty("sourceKey")]
+        public string SourceKey { get; set; }
+
+        [JsonProperty("sourcePortKey")]
+        public string SourcePortKey { get; set; }
+
+        [JsonProperty("destinationKey")]
+        public string DestinationKey { get; set; }
+
+        [JsonProperty("destinationPortKey")]
+        public string DestinationPortKey { get; set; }
+
+        [JsonProperty("type")]
+        public eRoutingSignalType Type { get; set; }
+    }
 
     /// <summary>
     /// Defines the valid destination types for SourceListItems in a room
@@ -172,7 +186,12 @@ namespace PepperDash.Essentials.Core
         defaultDisplay,
         leftDisplay,
         rightDisplay,
+        centerDisplay,
         programAudio,
-        codecContent
+        codecContent,
+        frontLeftDisplay,
+        frontRightDisplay,
+        rearLeftDisplay,
+        rearRightDisplay,
     }
 }

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

@@ -10,7 +10,6 @@ using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Bridges;
-using PepperDash.Essentials.Core.Routing;
 using Serilog.Events;
 
 namespace PepperDash.Essentials.Core

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

@@ -1,25 +1,23 @@
 
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
 using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Bridges;
 using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 
 namespace PepperDash.Essentials.Core
 {
-	[Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
+    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
     public abstract class DisplayBase : EssentialsDevice, IHasFeedback, IRoutingSinkWithSwitching, IHasPowerControl, IWarmingCooling, IUsageTracking
 	{
         public event SourceInfoChangeHandler CurrentSourceChange;
+        public event InputChangedEventHandler InputChanged;
 
         public string CurrentSourceInfoKey { get; set; }
         public SourceListItem CurrentSourceInfo
@@ -96,7 +94,9 @@ namespace PepperDash.Essentials.Core
 			}
 		}
 
-	    public abstract void ExecuteSwitch(object selector);
+        public RoutingInputPort CurrentInputPort => throw new NotImplementedException();
+
+        public abstract void ExecuteSwitch(object selector);
 
 	    protected void LinkDisplayToApi(DisplayBase displayDevice, BasicTriList trilist, uint joinStart, string joinMapKey,
 	        EiscApiAdvanced bridge)
@@ -266,16 +266,16 @@ namespace PepperDash.Essentials.Core
         abstract protected Func<bool> PowerIsOnFeedbackFunc { get; }
 
 
-        public static MockDisplay DefaultDisplay
-        { 
-			get 
-			{
-				if (_DefaultDisplay == null)
-					_DefaultDisplay = new MockDisplay("default", "Default Display");
-				return _DefaultDisplay;
-			} 
-		}
-		static MockDisplay _DefaultDisplay;
+  //      public static MockDisplay DefaultDisplay
+  //      { 
+		//	get 
+		//	{
+		//		if (_DefaultDisplay == null)
+		//			_DefaultDisplay = new MockDisplay("default", "Default Display");
+		//		return _DefaultDisplay;
+		//	} 
+		//}
+		//static MockDisplay _DefaultDisplay;
 
 		public TwoWayDisplayBase(string key, string name)
 			: base(key, name)

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

@@ -1,224 +0,0 @@
-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 PepperDash.Core;
-using PepperDash.Essentials.Core.Bridges;
-using PepperDash.Essentials.Core.Routing;
-using PepperDash.Essentials.Core.Config;
-using Serilog.Events;
-
-namespace PepperDash.Essentials.Core
-{
-    [Obsolete("Please use PepperDash.Essentials.Devices.Common, this will be removed in 2.1")]
-    public class MockDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, IBridgeAdvanced
-
-	{
-		public RoutingInputPort HdmiIn1 { get; private set; }
-		public RoutingInputPort HdmiIn2 { get; private set; }
-		public RoutingInputPort HdmiIn3 { get; private set; }
-		public RoutingInputPort ComponentIn1 { get; private set; }
-		public RoutingInputPort VgaIn1 { get; private set; }
-
-		bool _PowerIsOn;
-		bool _IsWarmingUp;
-		bool _IsCoolingDown;
-
-        protected override Func<bool> PowerIsOnFeedbackFunc
-        {
-            get
-            {
-                return () =>
-                    {
-                        Debug.LogMessage(LogEventLevel.Verbose, this, "*************************************************** Display Power is {0}", _PowerIsOn ? "on" : "off");
-                        return _PowerIsOn;
-                    };
-        } }
-		protected override Func<bool> IsCoolingDownFeedbackFunc
-        {
-            get
-            {
-                return () =>
-                {
-                    Debug.LogMessage(LogEventLevel.Verbose, this, "*************************************************** {0}", _IsCoolingDown ? "Display is cooling down" : "Display has finished cooling down");
-                    return _IsCoolingDown;
-                };
-            }
-        }
-		protected override Func<bool> IsWarmingUpFeedbackFunc
-        {
-            get
-            {
-                return () =>
-                {
-                    Debug.LogMessage(LogEventLevel.Verbose, this, "*************************************************** {0}", _IsWarmingUp ? "Display is warming up" : "Display has finished warming up");
-                    return _IsWarmingUp;
-                };
-            }
-        }
-        protected override Func<string> CurrentInputFeedbackFunc { get { return () => "Not Implemented"; } }
-
-        int VolumeHeldRepeatInterval = 200;
-        ushort VolumeInterval = 655;
-		ushort _FakeVolumeLevel = 31768;
-		bool _IsMuted;
-
-		public MockDisplay(string key, string name)
-			: base(key, name)
-		{
-			HdmiIn1 = new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			HdmiIn2 = new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			HdmiIn3 = new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-			ComponentIn1 = new RoutingInputPort(RoutingPortNames.ComponentIn, eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Component, null, this);
-			VgaIn1 = new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Composite, null, this);
-			InputPorts.AddRange(new[] { HdmiIn1, HdmiIn2, HdmiIn3, ComponentIn1, VgaIn1 });
-
-			VolumeLevelFeedback = new IntFeedback(() => { return _FakeVolumeLevel; });
-			MuteFeedback = new BoolFeedback("MuteOn", () => _IsMuted);
-
-            WarmupTime = 10000;
-            CooldownTime = 10000;
-		}
-
-		public override void PowerOn()
-		{
-			if (!PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
-			{
-				_IsWarmingUp = true;
-				IsWarmingUpFeedback.InvokeFireUpdate();
-				// Fake power-up cycle
-				WarmupTimer = new CTimer(o =>
-					{
-						_IsWarmingUp = false;
-						_PowerIsOn = true;
-						IsWarmingUpFeedback.InvokeFireUpdate();
-						PowerIsOnFeedback.InvokeFireUpdate();
-					}, WarmupTime);
-			}
-		}
-
-		public override void PowerOff()
-		{
-			// If a display has unreliable-power off feedback, just override this and
-			// remove this check.
-			if (PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
-			{
-				_IsCoolingDown = true;
-				IsCoolingDownFeedback.InvokeFireUpdate();
-				// Fake cool-down cycle
-				CooldownTimer = new CTimer(o =>
-					{
-						Debug.LogMessage(LogEventLevel.Verbose, this, "Cooldown timer ending");
-						_IsCoolingDown = false;
-						IsCoolingDownFeedback.InvokeFireUpdate();
-                        _PowerIsOn = false;
-                        PowerIsOnFeedback.InvokeFireUpdate();
-					}, CooldownTime);
-			}
-		}		
-		
-		public override void PowerToggle()
-		{
-			if (PowerIsOnFeedback.BoolValue && !IsWarmingUpFeedback.BoolValue)
-				PowerOff();
-			else if (!PowerIsOnFeedback.BoolValue && !IsCoolingDownFeedback.BoolValue)
-				PowerOn();
-		}
-
-		public override void ExecuteSwitch(object selector)
-		{
-			Debug.LogMessage(LogEventLevel.Verbose, this, "ExecuteSwitch: {0}", selector);
-
-		    if (!_PowerIsOn)
-		    {
-		        PowerOn();
-		    }
-		}
-
-
-
-		#region IBasicVolumeWithFeedback Members
-
-		public IntFeedback VolumeLevelFeedback { get; private set; }
-
-		public void SetVolume(ushort level)
-		{
-			_FakeVolumeLevel = level;
-			VolumeLevelFeedback.InvokeFireUpdate();
-		}
-
-		public void MuteOn()
-		{
-			_IsMuted = true;
-			MuteFeedback.InvokeFireUpdate();
-		}
-
-		public void MuteOff()
-		{
-			_IsMuted = false;
-			MuteFeedback.InvokeFireUpdate();
-		}
-
-		public BoolFeedback MuteFeedback { get; private set; }
-
-		#endregion
-
-		#region IBasicVolumeControls Members
-
-		public void VolumeUp(bool pressRelease)
-		{
-            //while (pressRelease)
-            //{
-                Debug.LogMessage(LogEventLevel.Verbose, this, "Volume Down {0}", pressRelease);
-                if (pressRelease)
-                {
-                    var newLevel = _FakeVolumeLevel + VolumeInterval;
-                    SetVolume((ushort)newLevel);
-                    CrestronEnvironment.Sleep(VolumeHeldRepeatInterval);
-                }
-            //}
-		}
-
-		public void VolumeDown(bool pressRelease)
-		{
-            //while (pressRelease)
-            //{
-                Debug.LogMessage(LogEventLevel.Verbose, this, "Volume Up {0}", pressRelease);
-                if (pressRelease)
-                {
-                    var newLevel = _FakeVolumeLevel - VolumeInterval;
-                    SetVolume((ushort)newLevel);
-                    CrestronEnvironment.Sleep(VolumeHeldRepeatInterval);
-                }
-            //}
-		}
-
-		public void MuteToggle()
-		{
-			_IsMuted = !_IsMuted;
-			MuteFeedback.InvokeFireUpdate();
-		}
-
-		#endregion
-
-	    public void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-	    {
-	        LinkDisplayToApi(this, trilist, joinStart, joinMapKey, bridge);
-	    }
-	}
-
-
-
-}

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

@@ -1,7 +1,7 @@
 
 
 using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
@@ -14,13 +14,13 @@ namespace PepperDash.Essentials.Core
 {
     public class DeviceFactoryWrapper
     {
-        public CType CType { get; set; }
+        public Type Type { get; set; }
         public string Description { get; set; }
         public Func<DeviceConfig, IKeyed> FactoryMethod { get; set; }
 
         public DeviceFactoryWrapper()
         {
-            CType = null;
+            Type = null;
             Description = "Not Available";
         }
     }
@@ -40,7 +40,7 @@ namespace PepperDash.Essentials.Core
                 {
                     try
                     {
-                        var factory = (IDeviceFactory)Crestron.SimplSharp.Reflection.Activator.CreateInstance(type);
+                        var factory = (IDeviceFactory)Activator.CreateInstance(type);
                         factory.LoadTypeFactories();
                     }
                     catch (Exception e)
@@ -69,7 +69,7 @@ namespace PepperDash.Essentials.Core
             DeviceFactory.FactoryMethods.Add(typeName, new DeviceFactoryWrapper() { FactoryMethod = method});
 		}
 
-        public static void AddFactoryForType(string typeName, string description, CType cType, Func<DeviceConfig, IKeyed> method)
+        public static void AddFactoryForType(string typeName, string description, Type Type, Func<DeviceConfig, IKeyed> method)
         {
             //Debug.LogMessage(LogEventLevel.Debug, "Adding factory method for type '{0}'", typeName);
 
@@ -79,7 +79,7 @@ namespace PepperDash.Essentials.Core
                 return;
             }
 
-            var wrapper = new DeviceFactoryWrapper() { CType = cType, Description = description, FactoryMethod = method };
+            var wrapper = new DeviceFactoryWrapper() { Type = Type, Description = description, FactoryMethod = method };
             DeviceFactory.FactoryMethods.Add(typeName, wrapper);
         }
 
@@ -149,18 +149,7 @@ namespace PepperDash.Essentials.Core
             }
             catch (Exception ex)
             {
-                Debug.LogMessage(LogEventLevel.Error, "Exception occurred while creating device {0}: {1}", dc.Key, ex.Message);
-
-                Debug.LogMessage(LogEventLevel.Verbose, "{0}", ex.StackTrace);
-
-                if (ex.InnerException == null)
-                {
-                    return null;
-                }
-
-                Debug.LogMessage(LogEventLevel.Error, "Inner exception while creating device {0}: {1}", dc.Key,
-                    ex.InnerException.Message);
-                Debug.LogMessage(LogEventLevel.Verbose, "{0}", ex.InnerException.StackTrace);
+                Debug.LogMessage(ex, "Exception occurred while creating device {0}: {1}", null, dc.Key, ex.Message);
                 return null;
             }
         }
@@ -180,17 +169,17 @@ namespace PepperDash.Essentials.Core
             foreach (var type in types.OrderBy(t => t.Key))
             {
                 var description = type.Value.Description;
-                var cType = "Not Specified by Plugin";
+                var Type = "Not Specified by Plugin";
 
-                if (type.Value.CType != null)
+                if (type.Value.Type != null)
                 {
-                    cType = type.Value.CType.FullName;
+                    Type = type.Value.Type.FullName;
                 }
 
                 CrestronConsole.ConsoleCommandResponse(
                     @"Type: '{0}' 
-                    CType: '{1}' 
-                    Description: {2}{3}", type.Key, cType, description, CrestronEnvironment.NewLine);
+                    Type: '{1}' 
+                    Description: {2}{3}", type.Key, Type, description, CrestronEnvironment.NewLine);
             }
         }
 

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

@@ -1,14 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharp.Reflection;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core.Config;
-
-namespace PepperDash.Essentials.Core
+namespace PepperDash.Essentials.Core
 {
     /// <summary>
     /// Defines a class that is capable of loading device types

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

@@ -1,5 +1,5 @@
 
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 using Serilog.Events;
@@ -25,7 +25,7 @@ namespace PepperDash.Essentials.Core
                 {
                     try
                     {
-                        var factory = (IProcessorExtensionDeviceFactory)Crestron.SimplSharp.Reflection.Activator.CreateInstance(extension);
+                        var factory = (IProcessorExtensionDeviceFactory)Activator.CreateInstance(extension);
                         factory.LoadFactories();
                     }
                     catch( Exception e )
@@ -55,7 +55,7 @@ namespace PepperDash.Essentials.Core
             ProcessorExtensionDeviceFactory.ProcessorExtensionFactoryMethods.Add(extensionName, new DeviceFactoryWrapper() { FactoryMethod = method });
         }
 
-        public static void AddFactoryForType(string extensionName, string description, CType cType, Func<DeviceConfig, IKeyed> method)
+        public static void AddFactoryForType(string extensionName, string description, Type Type, Func<DeviceConfig, IKeyed> method)
         {
             //Debug.LogMessage(LogEventLevel.Debug, "Adding factory method for type '{0}'", typeName);
 
@@ -65,7 +65,7 @@ namespace PepperDash.Essentials.Core
                 return;
             }
 
-            var wrapper = new DeviceFactoryWrapper() { CType = cType, Description = description, FactoryMethod = method };
+            var wrapper = new DeviceFactoryWrapper() { Type = Type, Description = description, FactoryMethod = method };
             ProcessorExtensionDeviceFactory.ProcessorExtensionFactoryMethods.Add(extensionName, wrapper);
         }
 

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

@@ -1,9 +1,5 @@
 
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharp.CrestronXml;
@@ -14,6 +10,10 @@ using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
 using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 
 namespace PepperDash.Essentials.Core.Fusion
 {

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

@@ -137,6 +137,7 @@ namespace PepperDash.Essentials.Core
         public static void SetFilePathPrefix(string prefix)
         {
             FilePathPrefix = prefix;
+            Debug.LogMessage(LogEventLevel.Information, "File Path Prefix set to '{0}'", FilePathPrefix);
         }
 
         static string _AssemblyVersion;

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

@@ -5,7 +5,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Text;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 using Crestron.SimplSharp.CrestronIO;
 using Crestron.SimplSharp;
 
@@ -107,19 +107,20 @@ namespace PepperDash.Essentials.Core
         }
 
         protected void AddJoins(Type type)
-        {
+        {            
             var fields =
-                type.GetCType()
-                    .GetFields(BindingFlags.Public | BindingFlags.Instance)
-                    .Where(f => f.IsDefined(typeof (JoinNameAttribute), true));
+                type.GetFields(BindingFlags.Public | BindingFlags.Instance)
+                    .Where(f => f.IsDefined(typeof (JoinNameAttribute), true)).ToList();
+
+            Debug.LogMessage(LogEventLevel.Debug, "Got {fields} with JoinNameAttribute", fields.Count);
 
             foreach (var field in fields)
             {
                 var childClass = Convert.ChangeType(this, type, null);
 
-                var value = field.GetValue(childClass) as JoinDataComplete; //this here is JoinMapBaseAdvanced, not the child class. JoinMapBaseAdvanced has no fields.
+                //this here is JoinMapBaseAdvanced, not the child class. JoinMapBaseAdvanced has no fields.
 
-                if (value == null)
+                if (!(field.GetValue(childClass) is JoinDataComplete value))
                 {
                     Debug.LogMessage(LogEventLevel.Information, "Unable to cast base class to {0}", type.Name);
                     continue;
@@ -129,7 +130,7 @@ namespace PepperDash.Essentials.Core
 
                 var joinName = value.GetNameAttribute(field);
 
-                if (String.IsNullOrEmpty(joinName)) continue;
+                if (string.IsNullOrEmpty(joinName)) continue;
 
                 Joins.Add(joinName, value);
             }
@@ -155,29 +156,37 @@ namespace PepperDash.Essentials.Core
         {
             var sb = new StringBuilder();
 
-            // Get the joins of each type and print them
-            sb.AppendLine(String.Format("# {0}", GetType().Name));
-            sb.AppendLine();
-            sb.AppendLine("## Digitals");
-            sb.AppendLine();
-            // Get the joins of each type and print them
-            var digitals =
-                Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Digital) == eJoinType.Digital)
-                    .ToDictionary(j => j.Key, j => j.Value);
-            var digitalSb = AppendJoinList(GetSortedJoins(digitals));
-            digitalSb.AppendLine("## Analogs");
-            digitalSb.AppendLine();
+            var lineEnding = "\r\n";
 
-            var analogs =
-                Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Analog) == eJoinType.Analog)
+            var digitals =
+                Joins.Where(j => j.Value.Metadata.JoinType.HasFlag(eJoinType.Digital))
+                    .ToDictionary(j => j.Key, j => j.Value);
+
+            var analogs = Joins.Where(j => j.Value.Metadata.JoinType.HasFlag(eJoinType.Analog))
                     .ToDictionary(j => j.Key, j => j.Value);
-            var analogSb = AppendJoinList(GetSortedJoins(analogs));
-            analogSb.AppendLine("## Serials");
-            analogSb.AppendLine();
 
             var serials =
-                Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Serial) == eJoinType.Serial)
+                Joins.Where(j => j.Value.Metadata.JoinType.HasFlag(eJoinType.Serial))
                     .ToDictionary(j => j.Key, j => j.Value);
+
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Debug, "Digital join count {digitalCount} Analog join count {analogCount} Serial join count {serialCount}", null, digitals.Count, analogs.Count, serials.Count);
+
+            // Get the joins of each type and print them
+            sb.Append($"# {GetType().Name}\r\n");
+            sb.Append(lineEnding);
+            sb.Append($"## Digitals{lineEnding}");
+            sb.Append(lineEnding);
+            // Get the joins of each type and print them
+            
+            var digitalSb = AppendJoinList(GetSortedJoins(digitals));
+            digitalSb.Append($"## Analogs{lineEnding}");
+            digitalSb.Append(lineEnding);
+            
+            var analogSb = AppendJoinList(GetSortedJoins(analogs));
+            analogSb.Append($"## Serials{lineEnding}");
+            analogSb.Append(lineEnding);
+
+            
             var serialSb = AppendJoinList(GetSortedJoins(serials));
 
             sb.EnsureCapacity(sb.Length + digitalSb.Length + analogSb.Length + serialSb.Length);
@@ -202,7 +211,7 @@ namespace PepperDash.Essentials.Core
 
         private static void WriteJoinmapMarkdown(StringBuilder stringBuilder, string pluginType, string bridgeKey, string deviceKey)
         {
-            var fileName = String.Format("{0}{1}{2}__{3}__{4}.md", Global.FilePathPrefix, "joinMaps/", pluginType, bridgeKey, deviceKey);
+            var fileName = string.Format("{0}{1}{2}__{3}__{4}.md", Global.FilePathPrefix, "joinMaps/", pluginType, bridgeKey, deviceKey);
 
             using (var sw = new StreamWriter(fileName))
             {
@@ -230,7 +239,7 @@ namespace PepperDash.Essentials.Core
         static StringBuilder AppendJoinList(List<KeyValuePair<string, JoinDataComplete>> joins)
         {
             var sb = new StringBuilder();
-            const string stringFormatter = "| {0} | {1} | {2} | {3} | {4} |";
+            const string stringFormatter = "| {0} | {1} | {2} | {3} | {4} |\r\n";
             const int joinNumberLen = 11;
             const int joinSpanLen = 9;
             const int typeLen = 19;
@@ -238,25 +247,25 @@ namespace PepperDash.Essentials.Core
             var descriptionLen = (from @join in joins select @join.Value into j select j.Metadata.Description.Length).Concat(new[] {11}).Max();
 
             //build header
-            sb.AppendLine(String.Format(stringFormatter, 
-                String.Format("Join Number").PadRight(joinNumberLen, ' '), 
-                String.Format("Join Span").PadRight(joinSpanLen, ' '), 
-                String.Format("Description").PadRight(descriptionLen, ' '), 
-                String.Format("Type").PadRight(typeLen, ' '),
-                 String.Format("Capabilities").PadRight(capabilitiesLen, ' ')));
+            sb.Append(string.Format(stringFormatter,
+                string.Format("Join Number").PadRight(joinNumberLen, ' '),
+                string.Format("Join Span").PadRight(joinSpanLen, ' '),
+                string.Format("Description").PadRight(descriptionLen, ' '),
+                string.Format("Type").PadRight(typeLen, ' '),
+                 string.Format("Capabilities").PadRight(capabilitiesLen, ' ')));
             //build table seperator
-            sb.AppendLine(String.Format(stringFormatter,
-                new String('-', joinNumberLen),
-                new String('-', joinSpanLen),
-                new String('-', descriptionLen),
-                new String('-', typeLen),
-                new String('-', capabilitiesLen)));
+            sb.Append(string.Format(stringFormatter,
+                new string('-', joinNumberLen),
+                new string('-', joinSpanLen),
+                new string('-', descriptionLen),
+                new string('-', typeLen),
+                new string('-', capabilitiesLen)));
 
             foreach (var join in joins)
             {
-                sb.AppendLine(join.Value.GetMarkdownFormattedData(stringFormatter, descriptionLen));
+                sb.Append(join.Value.GetMarkdownFormattedData(stringFormatter, descriptionLen));
             }
-            sb.AppendLine();
+            sb.Append("\r\n");
             return sb;
         }
 
@@ -411,10 +420,10 @@ namespace PepperDash.Essentials.Core
         {
 
             //Fixed Width Headers
-            var joinNumberLen = String.Format("Join Number").Length;
-            var joinSpanLen = String.Format("Join Span").Length;
-            var typeLen = String.Format("AnalogDigitalSerial").Length;
-            var capabilitiesLen = String.Format("ToFromFusion").Length;
+            var joinNumberLen = string.Format("Join Number").Length;
+            var joinSpanLen = string.Format("Join Span").Length;
+            var typeLen = string.Format("AnalogDigitalSerial").Length;
+            var capabilitiesLen = string.Format("ToFromFusion").Length;
 
             //Track which one failed, if it did
             const string placeholder = "unknown";
@@ -430,13 +439,13 @@ namespace PepperDash.Essentials.Core
 
             try
             {
-                dataArray["joinNumber"] = String.Format("{0}", JoinNumber.ToString(CultureInfo.InvariantCulture).ReplaceIfNullOrEmpty(placeholder)).PadRight(joinNumberLen, ' ');
-                dataArray["joinSpan"] = String.Format("{0}", JoinSpan.ToString(CultureInfo.InvariantCulture).ReplaceIfNullOrEmpty(placeholder)).PadRight(joinSpanLen, ' ');
-                dataArray["description"] = String.Format("{0}", Metadata.Description.ReplaceIfNullOrEmpty(placeholder)).PadRight(descriptionLen, ' ');
-                dataArray["joinType"] = String.Format("{0}", Metadata.JoinType.ToString().ReplaceIfNullOrEmpty(placeholder)).PadRight(typeLen, ' ');
-                dataArray["capabilities"] = String.Format("{0}", Metadata.JoinCapabilities.ToString().ReplaceIfNullOrEmpty(placeholder)).PadRight(capabilitiesLen, ' ');
+                dataArray["joinNumber"] = string.Format("{0}", JoinNumber.ToString(CultureInfo.InvariantCulture).ReplaceIfNullOrEmpty(placeholder)).PadRight(joinNumberLen, ' ');
+                dataArray["joinSpan"] = string.Format("{0}", JoinSpan.ToString(CultureInfo.InvariantCulture).ReplaceIfNullOrEmpty(placeholder)).PadRight(joinSpanLen, ' ');
+                dataArray["description"] = string.Format("{0}", Metadata.Description.ReplaceIfNullOrEmpty(placeholder)).PadRight(descriptionLen, ' ');
+                dataArray["joinType"] = string.Format("{0}", Metadata.JoinType.ToString().ReplaceIfNullOrEmpty(placeholder)).PadRight(typeLen, ' ');
+                dataArray["capabilities"] = string.Format("{0}", Metadata.JoinCapabilities.ToString().ReplaceIfNullOrEmpty(placeholder)).PadRight(capabilitiesLen, ' ');
 
-                return String.Format(stringFormatter,
+                return string.Format(stringFormatter,
                     dataArray["joinNumber"],
                     dataArray["joinSpan"],
                     dataArray["description"],
@@ -454,8 +463,8 @@ namespace PepperDash.Essentials.Core
                     errorKey = item.Key;
                     break;
                 }
-                Debug.LogMessage(LogEventLevel.Information, "Unable to decode join metadata {1}- {0}", e.Message, !String.IsNullOrEmpty(errorKey) ? (' ' + errorKey) : String.Empty);
-                return String.Format(stringFormatter,
+                Debug.LogMessage(LogEventLevel.Information, "Unable to decode join metadata {1}- {0}", e.Message, !string.IsNullOrEmpty(errorKey) ? (' ' + errorKey) : string.Empty);
+                return string.Format(stringFormatter,
                     dataArray["joinNumber"],
                     dataArray["joinSpan"],
                     dataArray["description"],
@@ -501,7 +510,7 @@ namespace PepperDash.Essentials.Core
         public string GetNameAttribute(MemberInfo memberInfo)
         {
             var name = string.Empty;
-            var attribute = (JoinNameAttribute)CAttribute.GetCustomAttribute(memberInfo, typeof(JoinNameAttribute));
+            var attribute = (JoinNameAttribute)Attribute.GetCustomAttribute(memberInfo, typeof(JoinNameAttribute));
 
             if (attribute == null) return name;
 
@@ -514,13 +523,13 @@ namespace PepperDash.Essentials.Core
     
 
     [AttributeUsage(AttributeTargets.All)]
-    public class JoinNameAttribute : CAttribute
+    public class JoinNameAttribute : Attribute
     {
         private string _Name;
 
         public JoinNameAttribute(string name)
         {
-            Debug.LogMessage(LogEventLevel.Verbose, "Setting Attribute Name: {0}", name);
+            Debug.LogMessage(LogEventLevel.Verbose, "Setting Attribute Name: {0}",null, name);
             _Name = name;
         }
 

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

@@ -110,7 +110,7 @@ namespace PepperDash.Essentials.Core.Monitoring
             _uptimePollTimer = null;
         }
 
-        private void PollUptime(object obj)
+        public void PollUptime(object obj)
         {
             var consoleResponse = string.Empty;
 
@@ -142,19 +142,22 @@ namespace PepperDash.Essentials.Core.Monitoring
             _uptime = uptimeRaw.Substring(forIndex + 4);
         }
 
-	    private static void ProcessorReboot()
+	    public static void ProcessorReboot()
 	    {
 		    if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server) return;
+            Debug.LogMessage(LogEventLevel.Information, "Rebooting...");
 
-		    var response = string.Empty;
+
+            var response = string.Empty;
 		    CrestronConsole.SendControlSystemCommand("reboot", ref response);
 	    }
 
-		private static void ProgramReset(uint index)
+		public static void ProgramReset(uint index)
 		{
 			if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server) return;
+            Debug.LogMessage(LogEventLevel.Information, "Resetting Program {0}...", index);
 
-			if (index <= 0 || index > 10) return;
+            if (index <= 0 || index > 10) return;
 
 			var cmd = string.Format("progreset -p:{0}", index);
 

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

@@ -1,9 +1,5 @@
-using System;
+using PepperDash.Core;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core
 {
@@ -26,6 +22,11 @@ namespace PepperDash.Essentials.Core
         {
             get
             {
+                if (IsInAutoMode)
+                {
+                    return _partitionSensor.PartitionPresentFeedback.BoolValue;
+                }
+
                 return _partitionPresent;
             }
             set
@@ -73,11 +74,11 @@ namespace PepperDash.Essentials.Core
             PartitionPresentFeedback.FireUpdate();
         }
 
-        void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
+        private void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
         {
             if (IsInAutoMode)
             {
-                PartitionPresentFeedback.FireUpdate();
+                PartitionPresent = e.BoolValue;
             }
         }
 
@@ -87,6 +88,8 @@ namespace PepperDash.Essentials.Core
 
         public void SetAutoMode()
         {
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, $"Setting {Key} to Auto Mode", this);
+
             IsInAutoMode = true;
             if (PartitionPresentFeedback != null)
             {
@@ -101,11 +104,16 @@ namespace PepperDash.Essentials.Core
             {
                 _partitionSensor.PartitionPresentFeedback.OutputChange -= PartitionPresentFeedback_OutputChange;
                 _partitionSensor.PartitionPresentFeedback.OutputChange += PartitionPresentFeedback_OutputChange;
+                PartitionPresent = _partitionSensor.PartitionPresentFeedback.BoolValue;
             }
+
+            PartitionPresentFeedback.FireUpdate();
         }
 
         public void SetManualMode()
         {
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, $"Setting {Key} to Manual Mode", this);
+
             IsInAutoMode = false;
             if (PartitionPresentFeedback != null)
             {
@@ -119,7 +127,10 @@ namespace PepperDash.Essentials.Core
             if (_partitionSensor != null)
             {
                 _partitionSensor.PartitionPresentFeedback.OutputChange -= PartitionPresentFeedback_OutputChange;
+                PartitionPresent = _partitionSensor.PartitionPresentFeedback.BoolValue;
             }
+
+            PartitionPresentFeedback.FireUpdate();
         }
 
 

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

@@ -11,6 +11,9 @@
     <RootNamespace>PepperDash.Essentials.Core</RootNamespace>
     <Title>PepperDash Essentials Core</Title>
     <PackageId>PepperDash.Essentials.Core</PackageId>
+    <InformationalVersion>$(Version)</InformationalVersion>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+    <Version>2.0.0-local</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugType>full</DebugType>
@@ -22,8 +25,8 @@
     <DebugType>pdbonly</DebugType>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Crestron.SimplSharp.SDK.ProgramLibrary" Version="2.20.42" />
-    <PackageReference Include="PepperDashCore" Version="2.0.0-alpha-407" />
+    <PackageReference Include="Crestron.SimplSharp.SDK.ProgramLibrary" Version="2.20.66" />
+    <PackageReference Include="PepperDashCore" Version="2.0.0-alpha-424" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Crestron\CrestronGenericBaseDevice.cs.orig" />

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

@@ -1,14 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharp.CrestronIO;
-using Crestron.SimplSharp.Reflection;
+using System.Reflection;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using Serilog.Events;
+using Newtonsoft.Json;
 
 namespace PepperDash.Essentials
 {
@@ -27,24 +27,31 @@ namespace PepperDash.Essentials
         /// </summary>
         static List<LoadedAssembly> LoadedPluginFolderAssemblies;
 
+        public static LoadedAssembly EssentialsAssembly { get; private set; }
+
+        public static LoadedAssembly PepperDashCoreAssembly { get; private set; }
+
+        public static List<LoadedAssembly> EssentialsPluginAssemblies { get; private set; }
+
         /// <summary>
         /// The directory to look in for .cplz plugin packages
         /// </summary>
-        static string _pluginDirectory = Global.FilePathPrefix + "plugins";
+        static string _pluginDirectory => Global.FilePathPrefix + "plugins";
 
         /// <summary>
         /// The directory where plugins will be moved to and loaded from
         /// </summary>
-        static string _loadedPluginsDirectoryPath = _pluginDirectory + Global.DirectorySeparator + "loadedAssemblies";
+        static string _loadedPluginsDirectoryPath => _pluginDirectory + Global.DirectorySeparator + "loadedAssemblies";
 
         // The temp directory where .cplz archives will be unzipped to
-        static string _tempDirectory = _pluginDirectory + Global.DirectorySeparator + "temp";
+        static string _tempDirectory => _pluginDirectory + Global.DirectorySeparator + "temp";
 
 
         static PluginLoader()
         {
             LoadedAssemblies = new List<LoadedAssembly>();
             LoadedPluginFolderAssemblies = new List<LoadedAssembly>();
+            EssentialsPluginAssemblies = new List<LoadedAssembly>();
         }
 
         /// <summary>
@@ -59,7 +66,7 @@ namespace PepperDash.Essentials
 
             Debug.LogMessage(LogEventLevel.Verbose, "Found {0} Assemblies", assemblyFiles.Length);
 
-            foreach (var fi in assemblyFiles)
+            foreach (var fi in assemblyFiles.Where(fi => fi.Name.Contains("Essentials") || fi.Name.Contains("PepperDash")))
             {
                 string version = string.Empty;
                 Assembly assembly = null;
@@ -69,6 +76,7 @@ namespace PepperDash.Essentials
                     case ("PepperDashEssentials.dll"):
                         {
                             version = Global.AssemblyVersion;
+                            EssentialsAssembly = new LoadedAssembly(fi.Name, version, assembly);
                             break;
                         }
                     case ("PepperDash_Essentials_Core.dll"):
@@ -81,9 +89,12 @@ namespace PepperDash.Essentials
                             version = Global.AssemblyVersion;
                             break;
                         }
-                    case ("PepperDash_Core.dll"):
+                    case ("PepperDashCore.dll"):
                         {
-                            version = PepperDash.Core.Debug.PepperDashCoreVersion;
+                            Debug.LogMessage(LogEventLevel.Verbose, "Found PepperDash_Core.dll");
+                            version = Debug.PepperDashCoreVersion;
+                            Debug.LogMessage(LogEventLevel.Verbose, "PepperDash_Core Version: {0}", version);
+                            PepperDashCoreAssembly = new LoadedAssembly(fi.Name, version, assembly);
                             break;
                         }
                 }
@@ -119,24 +130,31 @@ namespace PepperDash.Essentials
         /// <param name="fileName"></param>
         static LoadedAssembly LoadAssembly(string filePath)
         {
-            //Debug.LogMessage(LogEventLevel.Verbose, "Attempting to load {0}", filePath);
-            var assembly = Assembly.LoadFrom(filePath);
-            if (assembly != null)
+            try
             {
-                var assyVersion = GetAssemblyVersion(assembly);
+                //Debug.LogMessage(LogEventLevel.Verbose, "Attempting to load {0}", filePath);
+                var assembly = Assembly.LoadFrom(filePath);
+                if (assembly != null)
+                {
+                    var assyVersion = GetAssemblyVersion(assembly);
 
-                var loadedAssembly = new LoadedAssembly(assembly.GetName().Name, assyVersion, assembly);
-                LoadedAssemblies.Add(loadedAssembly);
-                Debug.LogMessage(LogEventLevel.Information, "Loaded assembly '{0}', version {1}", loadedAssembly.Name, loadedAssembly.Version);
-                return loadedAssembly;
-            }
-            else
+                    var loadedAssembly = new LoadedAssembly(assembly.GetName().Name, assyVersion, assembly);
+                    LoadedAssemblies.Add(loadedAssembly);
+                    Debug.LogMessage(LogEventLevel.Information, "Loaded assembly '{0}', version {1}", loadedAssembly.Name, loadedAssembly.Version);
+                    return loadedAssembly;
+                }
+                else
+                {
+                    Debug.LogMessage(LogEventLevel.Information, "Unable to load assembly: '{0}'", filePath);
+                }
+
+                return null;
+            } catch(Exception ex)
             {
-                Debug.LogMessage(LogEventLevel.Information, "Unable to load assembly: '{0}'", filePath);
+                Debug.LogMessage(ex, "Error loading assembly from {path}", null, filePath);
+                return null;
             }
 
-            return null;
-
         }
 
         /// <summary>
@@ -144,7 +162,7 @@ namespace PepperDash.Essentials
         /// </summary>
         /// <param name="assembly"></param>
         /// <returns></returns>
-        static string GetAssemblyVersion(Assembly assembly)
+        public static string GetAssemblyVersion(Assembly assembly)
         {
             var ver = assembly.GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false);
             if (ver != null && ver.Length > 0)
@@ -190,12 +208,19 @@ namespace PepperDash.Essentials
         /// <param name="command"></param>
         public static void ReportAssemblyVersions(string command)
         {
-
-            CrestronConsole.ConsoleCommandResponse("Loaded Assemblies:" + CrestronEnvironment.NewLine);
-            foreach (var assembly in LoadedAssemblies)
+            CrestronConsole.ConsoleCommandResponse("Essentials Version: {0}" + CrestronEnvironment.NewLine, Global.AssemblyVersion);
+            CrestronConsole.ConsoleCommandResponse("PepperDash Core Version: {0}" + CrestronEnvironment.NewLine, PepperDashCoreAssembly.Version);
+            CrestronConsole.ConsoleCommandResponse("Essentials Plugin Versions:" + CrestronEnvironment.NewLine);
+            foreach (var assembly in EssentialsPluginAssemblies)
             {
                 CrestronConsole.ConsoleCommandResponse("{0} Version: {1}" + CrestronEnvironment.NewLine, assembly.Name, assembly.Version);
             }
+
+            //CrestronConsole.ConsoleCommandResponse("Loaded Assemblies:" + CrestronEnvironment.NewLine);
+            //foreach (var assembly in LoadedAssemblies)
+            //{
+            //    CrestronConsole.ConsoleCommandResponse("{0} Version: {1}" + CrestronEnvironment.NewLine, assembly.Name, assembly.Version);
+            //}
         }
         /// <summary>
         /// Moves any .dll assemblies not already loaded from the plugins folder to loadedPlugins folder
@@ -354,7 +379,7 @@ namespace PepperDash.Essentials
                 try
                 {
                     var assy = loadedAssembly.Assembly;
-                    CType[] types = {};
+                    Type[] types = {};
                     try
                     {
                         types = assy.GetTypes();
@@ -375,7 +400,7 @@ namespace PepperDash.Essentials
                             if (typeof (IPluginDeviceFactory).IsAssignableFrom(type) && !type.IsAbstract)
                             {
                                 var plugin =
-                                    (IPluginDeviceFactory) Crestron.SimplSharp.Reflection.Activator.CreateInstance(type);
+                                    (IPluginDeviceFactory)Activator.CreateInstance(type);
                                 LoadCustomPlugin(plugin, loadedAssembly);
                             }
                         }
@@ -432,6 +457,9 @@ namespace PepperDash.Essentials
 
             Debug.LogMessage(LogEventLevel.Information, "Loading plugin: {0}", loadedAssembly.Name);
             plugin.LoadTypeFactories();
+
+            if(!EssentialsPluginAssemblies.Contains(loadedAssembly))
+                EssentialsPluginAssemblies.Add(loadedAssembly);
         }
 
         /// <summary>
@@ -439,7 +467,7 @@ namespace PepperDash.Essentials
         /// </summary>
         /// <param name="type"></param>
         /// <param name="loadPlugin"></param>
-        static void LoadCustomLegacyPlugin(CType type, MethodInfo loadPlugin, LoadedAssembly loadedAssembly)
+        static void LoadCustomLegacyPlugin(Type type, MethodInfo loadPlugin, LoadedAssembly loadedAssembly)
         {
             Debug.LogMessage(LogEventLevel.Verbose, "LoadPlugin method found in {0}", type.Name);
 
@@ -486,6 +514,8 @@ namespace PepperDash.Essentials
         /// </summary>
         public static void LoadPlugins()
         {
+            Debug.LogMessage(LogEventLevel.Information, "Attempting to Load Plugins from {_pluginDirectory}", _pluginDirectory);
+
             if (Directory.Exists(_pluginDirectory))
             {
                 Debug.LogMessage(LogEventLevel.Information, "Plugins directory found, checking for plugins");
@@ -514,8 +544,11 @@ namespace PepperDash.Essentials
     /// </summary>
     public class LoadedAssembly
     {
+        [JsonProperty("name")]
         public string Name { get; private set; }
+        [JsonProperty("version")]
         public string Version { get; private set; }
+        [JsonIgnore]
         public Assembly Assembly { get; private set; }
 
         public LoadedAssembly(string name, string version, Assembly assembly)

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

@@ -130,6 +130,8 @@ namespace PepperDash.Essentials.Core.Presets
                     var pl = JsonConvert.DeserializeObject<PresetsList>(File.ReadToEnd(_filePath, Encoding.ASCII));
                     Name = pl.Name;
                     PresetsList = pl.Channels;
+
+                    Debug.LogMessage(LogEventLevel.Verbose, this, "Loaded {0} presets", PresetsList.Count);
                 }
                 catch (Exception e)
                 {

src/PepperDash.Essentials.Core/Room/Combining/EssentialsRoomCombiner.cs

@@ -1,11 +1,12 @@
-using System;
+using Crestron.SimplSharp;
+using PepperDash.Core;
+using PepperDash.Core.Logging;
+using Serilog.Events;
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using Crestron.SimplSharp;
-
-using PepperDash.Core;
-using Serilog.Events;
-using Newtonsoft.Json;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace PepperDash.Essentials.Core
 {
@@ -35,7 +36,7 @@ namespace PepperDash.Essentials.Core
             }
             set
             {
-                if(value == _isInAutoMode)
+                if (value == _isInAutoMode)
                 {
                     return;
                 }
@@ -49,6 +50,8 @@ namespace PepperDash.Essentials.Core
 
         private int _scenarioChangeDebounceTimeSeconds = 10; // default to 10s
 
+        private Mutex _scenarioChange = new Mutex();
+
         public EssentialsRoomCombiner(string key, EssentialsRoomCombinerPropertiesConfig props)
             : base(key)
         {
@@ -81,7 +84,15 @@ namespace PepperDash.Essentials.Core
                 SetupPartitionStateProviders();
 
                 SetRooms();
+            });
 
+
+            // Subscribe to the AllDevicesInitialized event
+            // We need to wait until all devices are initialized in case
+            // any actions are dependent on 3rd party devices already being
+            // connected and initialized
+            DeviceManager.AllDevicesInitialized += (o, a) =>
+            {
                 if (IsInAutoMode)
                 {
                     DetermineRoomCombinationScenario();
@@ -90,10 +101,10 @@ namespace PepperDash.Essentials.Core
                 {
                     SetRoomCombinationScenario(_propertiesConfig.defaultScenarioKey);
                 }
-            });
+            };
         }
 
-        void CreateScenarios()
+        private void CreateScenarios()
         {
             foreach (var scenarioConfig in _propertiesConfig.Scenarios)
             {
@@ -102,21 +113,29 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-        void SetRooms()
+        private void SetRooms()
         {
             _rooms = new List<IEssentialsRoom>();
 
             foreach (var roomKey in _propertiesConfig.RoomKeys)
             {
-                var room = DeviceManager.GetDeviceForKey(roomKey) as IEssentialsRoom;
-                if (room != null)
+                var room = DeviceManager.GetDeviceForKey(roomKey);
+
+                if (DeviceManager.GetDeviceForKey(roomKey) is IEssentialsRoom essentialsRoom)
                 {
-                    _rooms.Add(room);
+                    _rooms.Add(essentialsRoom);
                 }
             }
+
+            var rooms = DeviceManager.AllDevices.OfType<IEssentialsRoom>().Cast<Device>();
+
+            foreach (var room in rooms)
+            {
+                room.Deactivate();
+            }
         }
 
-        void SetupPartitionStateProviders()
+        private void SetupPartitionStateProviders()
         {
             foreach (var pConfig in _propertiesConfig.Partitions)
             {
@@ -130,18 +149,18 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-        void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
+        private void PartitionPresentFeedback_OutputChange(object sender, FeedbackEventArgs e)
         {
             StartDebounceTimer();
         }
 
-        void StartDebounceTimer()
+        private void StartDebounceTimer()
         {
             // default to 500ms for manual mode
             var time = 500;
 
             // if in auto mode, debounce the scenario change
-            if(IsInAutoMode) time = _scenarioChangeDebounceTimeSeconds * 1000;
+            if (IsInAutoMode) time = _scenarioChangeDebounceTimeSeconds * 1000;
 
             if (_scenarioChangeDebounceTimer == null)
             {
@@ -156,7 +175,7 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Determines the current room combination scenario based on the state of the partition sensors
         /// </summary>
-        void DetermineRoomCombinationScenario()
+        private void DetermineRoomCombinationScenario()
         {
             if (_scenarioChangeDebounceTimer != null)
             {
@@ -164,14 +183,20 @@ namespace PepperDash.Essentials.Core
                 _scenarioChangeDebounceTimer = null;
             }
 
+            this.LogInformation("Determining Combination Scenario");
+
             var currentScenario = RoomCombinationScenarios.FirstOrDefault((s) =>
             {
+                this.LogDebug("Checking scenario {scenarioKey}", s.Key);
                 // iterate the partition states
                 foreach (var partitionState in s.PartitionStates)
                 {
+                    this.LogDebug("checking PartitionState {partitionStateKey}", partitionState.PartitionKey);
                     // get the partition by key
                     var partition = Partitions.FirstOrDefault((p) => p.Key.Equals(partitionState.PartitionKey));
 
+                    this.LogDebug("Expected State: {partitionPresent} Actual State: {partitionState}", partitionState.PartitionPresent, partition.PartitionPresentFeedback.BoolValue);
+
                     if (partition != null && partitionState.PartitionPresent != partition.PartitionPresentFeedback.BoolValue)
                     {
                         // the partition can't be found or the state doesn't match
@@ -184,10 +209,41 @@ namespace PepperDash.Essentials.Core
 
             if (currentScenario != null)
             {
-                CurrentScenario = currentScenario;
+                this.LogInformation("Found combination Scenario {scenarioKey}", currentScenario.Key);
+                ChangeScenario(currentScenario);
             }
         }
 
+        private async Task ChangeScenario(IRoomCombinationScenario newScenario)
+        {
+            
+
+                if (newScenario == _currentScenario)
+                {
+                    return;
+                }
+
+                // Deactivate the old scenario first
+                if (_currentScenario != null)
+                {
+                    Debug.LogMessage(LogEventLevel.Information, "Deactivating scenario {currentScenario}", this, _currentScenario.Name);
+                    await _currentScenario.Deactivate();
+                }
+
+                _currentScenario = newScenario;
+
+                // Activate the new scenario
+                if (_currentScenario != null)
+                {
+                    Debug.LogMessage(LogEventLevel.Debug, $"Current Scenario: {_currentScenario.Name}", this);
+                    await _currentScenario.Activate();
+                }
+
+                RoomCombinationScenarioChanged?.Invoke(this, new EventArgs());
+
+            
+        }
+
         #region IEssentialsRoomCombiner Members
 
         public event EventHandler<EventArgs> RoomCombinationScenarioChanged;
@@ -198,33 +254,6 @@ namespace PepperDash.Essentials.Core
             {
                 return _currentScenario;
             }
-            private set
-            {
-                if (value != _currentScenario)
-                {
-                    // Deactivate the old scenario first
-                    if (_currentScenario != null)
-                    {
-                        _currentScenario.Deactivate();
-                    }
-
-                    _currentScenario = value;
-
-                    // Activate the new scenario
-                    if (_currentScenario != null)
-                    {
-                        _currentScenario.Activate();
-
-                        Debug.LogMessage(LogEventLevel.Debug, $"Current Scenario: {_currentScenario.Name}", this);
-                    }
-
-                    var handler = RoomCombinationScenarioChanged;
-                    if (handler != null)
-                    {
-                        handler(this, new EventArgs());
-                    }
-                }
-            }
         }
 
         public BoolFeedback IsInAutoModeFeedback { get; private set; }
@@ -232,16 +261,35 @@ namespace PepperDash.Essentials.Core
         public void SetAutoMode()
         {
             IsInAutoMode = true;
+
+            foreach (var partition in Partitions)
+            {
+                partition.SetAutoMode();
+            }
+
+            DetermineRoomCombinationScenario();
         }
 
         public void SetManualMode()
         {
             IsInAutoMode = false;
+
+            foreach (var partition in Partitions)
+            {
+                partition.SetManualMode();
+            }
         }
 
         public void ToggleMode()
         {
-            IsInAutoMode = !IsInAutoMode;
+            if (IsInAutoMode)
+            {
+                SetManualMode();
+            }
+            else
+            {
+                SetAutoMode();
+            }
         }
 
         public List<IRoomCombinationScenario> RoomCombinationScenarios { get; private set; }

src/PepperDash.Essentials.Core/Room/Combining/IEssentialsRoomCombiner.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Newtonsoft.Json;
 using PepperDash.Core;
 
@@ -87,12 +88,12 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Activates this room combination scenario
         /// </summary>
-        void Activate();
+        Task Activate();
 
         /// <summary>
         /// Deactivates this room combination scenario
         /// </summary>
-        void Deactivate();
+        Task Deactivate();
 
         /// <summary>
         /// The state of the partitions that would activate this scenario

src/PepperDash.Essentials.Core/Room/Combining/RoomCombinationScenario.cs

@@ -1,22 +1,16 @@
-
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
+using Newtonsoft.Json;
 using PepperDash.Core;
-
-using Newtonsoft.Json;
+using PepperDash.Core.Logging;
 using Serilog.Events;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace PepperDash.Essentials.Core
 {
     /// <summary>
     /// Represents a room combination scenario
     /// </summary>
-    public class RoomCombinationScenario: IRoomCombinationScenario, IKeyName
+    public class RoomCombinationScenario : IRoomCombinationScenario, IKeyName
     {
         private RoomCombinationScenarioConfig _config;
 
@@ -40,7 +34,7 @@ namespace PepperDash.Essentials.Core
             get { return _isActive; }
             set
             {
-                if(value == _isActive)
+                if (value == _isActive)
                 {
                     return;
                 }
@@ -76,33 +70,43 @@ namespace PepperDash.Essentials.Core
             IsActiveFeedback = new BoolFeedback(() => _isActive);
         }
 
-        public void Activate()
+        public async Task Activate()
         {
-            Debug.LogMessage(LogEventLevel.Debug, "Activating Scenario: '{0}' with {1} action(s) defined", Name, activationActions.Count);   
+            this.LogInformation("Activating Scenario {name} with {activationActionCount} action(s) defined", Name, activationActions.Count);
+
+            List<Task> tasks = new List<Task>();
 
             if (activationActions != null)
             {
                 foreach (var action in activationActions)
                 {
-                    DeviceJsonApi.DoDeviceAction(action);
+                    this.LogInformation("Running Activation action {@action}", action);
+                    tasks.Add(DeviceJsonApi.DoDeviceActionAsync(action));
                 }
             }
 
+            await Task.WhenAll(tasks);
+
             IsActive = true;
         }
 
-        public void Deactivate()
+        public async Task Deactivate()
         {
-            Debug.LogMessage(LogEventLevel.Debug, "Deactivating Scenario: '{0}' with {1} action(s) defined", Name, deactivationActions.Count);
+            this.LogInformation("Deactivating Scenario {name} with {deactivationActionCount} action(s) defined", Name, deactivationActions.Count);
+
+            List<Task> tasks = new List<Task>();
 
             if (deactivationActions != null)
             {
                 foreach (var action in deactivationActions)
                 {
-                    DeviceJsonApi.DoDeviceAction(action);
+                    this.LogInformation("Running deactivation action {actionDeviceKey}:{actionMethod}", action.DeviceKey, action.MethodName);
+                    tasks.Add( DeviceJsonApi.DoDeviceActionAsync(action));
                 }
             }
 
+            await Task.WhenAll(tasks);
+
             IsActive = false;
         }
 

src/PepperDash.Essentials.Core/Room/Config/EssentialsRoomConfig.cs

@@ -198,8 +198,11 @@ namespace PepperDash.Essentials.Room.Config
         public string SourceListKey { get; set; }
         [JsonProperty("destinationListKey")]
         public string DestinationListKey { get; set; }
-        [JsonProperty("levelControlListKey")]
-        public string LevelControlListKey { get; set; }
+        [JsonProperty("audioControlPointListKey")]
+        public string AudioControlPointListKey { get; set; }
+        [JsonProperty("cameraListKey")]
+        public string CameraListKey { get; set; }
+
 
         [JsonProperty("defaultSourceItem")]
         public string DefaultSourceItem { get; set; }

src/PepperDash.Essentials.Core/Room/EssentialsRoomBase.cs

@@ -110,12 +110,12 @@ namespace PepperDash.Essentials.Core
             }
         }
 
-        private string _levelControlListKey;
-        public string LevelControlListKey
+        private string _audioControlPointListKey;
+        public string AudioControlPointListKey
         {
             get
             {
-                if (string.IsNullOrEmpty(_levelControlListKey))
+                if (string.IsNullOrEmpty(_audioControlPointListKey))
                 {
                     return _defaultListKey;
                 }
@@ -126,14 +126,35 @@ namespace PepperDash.Essentials.Core
             }
             protected set
             {
-                if (value != _levelControlListKey)
+                if (value != _audioControlPointListKey)
                 {
-                    _levelControlListKey = value;
+                    _audioControlPointListKey = value;
                 }
             }
         }
 
-
+        private string _cameraListKey;
+        public string CameraListKey
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(_cameraListKey))
+                {
+                    return _defaultListKey;
+                }
+                else
+                {
+                    return _cameraListKey;
+                }
+            }
+            protected set
+            {
+                if (value != _cameraListKey)
+                {
+                    _cameraListKey = value;
+                }
+            }
+        }
 
         /// <summary>
         /// Timer used for informing the UIs of a shutdown

src/PepperDash.Essentials.Core/Room/IEssentialsRoom.cs

@@ -29,7 +29,9 @@ namespace PepperDash.Essentials.Core
 
         string DestinationListKey { get; }
 
-        string LevelControlListKey { get; }
+        string AudioControlPointListKey { get; }
+
+        string CameraListKey { get; }
 
         SecondsCountdownTimer ShutdownPromptTimer { get; }
         int ShutdownPromptSeconds { get; }

src/PepperDash.Essentials.Core/Room/Interfaces.cs

@@ -40,7 +40,7 @@ namespace PepperDash.Essentials.Core
     {
         void RunRouteAction(string routeKey, string sourceListKey);
 
-        void RunRouteAction(string routeKey, string sourceListKey, Action successCallback);
+        void RunRouteAction(string routeKey, string sourceListKey, Action successCallback);        
     }
 
     /// <summary>

src/PepperDash.Essentials.Core/Routing/DummyRoutingInputsDevice.cs

@@ -8,7 +8,7 @@ using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core.Routing
 {
-	public class DummyRoutingInputsDevice : Device, IRoutingSource
+	public class DummyRoutingInputsDevice : Device, IRoutingSource, IRoutingOutputs
 	{
 		/// <summary>
 		/// A single output port, backplane, audioVideo

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

@@ -0,0 +1,355 @@
+using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Debug = PepperDash.Core.Debug;
+
+
+namespace PepperDash.Essentials.Core
+{
+
+    /// <summary>
+    /// Extensions added to any IRoutingInputs classes to provide discovery-based routing
+    /// on those destinations.
+    /// </summary>
+    public static class Extensions
+    {
+        private static readonly Dictionary<string, RouteRequest> RouteRequests = new Dictionary<string, RouteRequest>();
+
+        /// <summary>
+        /// Gets any existing RouteDescriptor for a destination, clears it using ReleaseRoute
+        /// and then attempts a new Route and if sucessful, stores that RouteDescriptor
+        /// in RouteDescriptorCollection.DefaultCollection
+        /// </summary>        
+        public static void ReleaseAndMakeRoute(this IRoutingInputs destination, IRoutingOutputs source, eRoutingSignalType signalType, string destinationPortKey = "", string sourcePortKey = "")
+        {
+            // Remove this line before committing!!!!!
+            var frame = new StackFrame(1, true);
+            Debug.LogMessage(LogEventLevel.Information, "ReleaseAndMakeRoute Called from {method} with params {destinationKey}:{sourceKey}:{signalType}:{destinationPortKey}:{sourcePortKey}", frame.GetMethod().Name, destination.Key, source.Key, signalType.ToString(), destinationPortKey, sourcePortKey);
+
+            var inputPort = string.IsNullOrEmpty(destinationPortKey) ? null : destination.InputPorts.FirstOrDefault(p => p.Key == destinationPortKey);
+            var outputPort = string.IsNullOrEmpty(sourcePortKey) ? null : source.OutputPorts.FirstOrDefault(p => p.Key == sourcePortKey);
+
+            ReleaseAndMakeRoute(destination, source, signalType, inputPort, outputPort);
+        }
+
+        public static void RemoveRouteRequestForDestination(string destinationKey)
+        {
+            Debug.LogMessage(LogEventLevel.Information, "Removing route request for {destination}", null, destinationKey);
+
+            var result = RouteRequests.Remove(destinationKey);
+
+            var messageTemplate = result ? "Route Request for {destination} removed" : "Route Request for {destination} not found";
+
+            Debug.LogMessage(LogEventLevel.Information, messageTemplate, null, destinationKey);
+        }
+
+        private static void ReleaseAndMakeRoute(IRoutingInputs destination, IRoutingOutputs source, eRoutingSignalType signalType, RoutingInputPort destinationPort = null, RoutingOutputPort sourcePort = null)
+        {
+            if (destination == null) throw new ArgumentNullException(nameof(destination));
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (destinationPort == null) Debug.LogMessage(LogEventLevel.Information, "Destination port is null");
+            if (sourcePort == null) Debug.LogMessage(LogEventLevel.Information, "Source port is null");
+
+            var routeRequest = new RouteRequest
+            {
+                Destination = destination,
+                DestinationPort = destinationPort,
+                Source = source,
+                SourcePort = sourcePort,
+                SignalType = signalType
+            };
+
+            
+
+            var coolingDevice = destination as IWarmingCooling;
+
+            //We already have a route request for this device, and it's a cooling device and is cooling
+            if (RouteRequests.TryGetValue(destination.Key, out RouteRequest existingRouteRequest) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == true)
+            {                
+                coolingDevice.IsCoolingDownFeedback.OutputChange -= existingRouteRequest.HandleCooldown;
+
+                coolingDevice.IsCoolingDownFeedback.OutputChange += routeRequest.HandleCooldown;
+
+                RouteRequests[destination.Key] = routeRequest;
+
+                Debug.LogMessage(LogEventLevel.Information, "Device: {destination} is cooling down and already has a routing request stored.  Storing new route request to route to source key: {sourceKey}", null, destination.Key, routeRequest.Source.Key);
+
+                return;
+            }
+
+            //New Request
+            if (coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == true)
+            {               
+                coolingDevice.IsCoolingDownFeedback.OutputChange += routeRequest.HandleCooldown;
+
+                RouteRequests.Add(destination.Key, routeRequest);
+
+                Debug.LogMessage(LogEventLevel.Information, "Device: {destination} is cooling down. Storing route request to route to source key: {sourceKey}", null, destination.Key, routeRequest.Source.Key);
+                return;
+            }
+
+            if (RouteRequests.ContainsKey(destination.Key) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == false)
+            {
+                var handledRequest = RouteRequests[destination.Key];
+
+                coolingDevice.IsCoolingDownFeedback.OutputChange -= handledRequest.HandleCooldown;
+
+                RouteRequests.Remove(destination.Key);
+
+                Debug.LogMessage(LogEventLevel.Information, "Device: {destination} is NOT cooling down.  Removing stored route request and routing to source key: {sourceKey}", null, destination.Key, routeRequest.Source.Key);
+            }
+
+            destination.ReleaseRoute(destinationPort?.Key ?? string.Empty);
+
+            RunRouteRequest(routeRequest);
+        }
+
+        private static void RunRouteRequest(RouteRequest request)
+        {
+            if (request.Source == null)
+                return;
+
+            var (audioOrSingleRoute, videoRoute) = request.Destination.GetRouteToSource(request.Source, request.SignalType, request.DestinationPort, request.SourcePort);
+
+            if (audioOrSingleRoute == null && videoRoute == null)
+                return;
+
+            RouteDescriptorCollection.DefaultCollection.AddRouteDescriptor(audioOrSingleRoute);
+
+            if (videoRoute != null)
+            {
+                RouteDescriptorCollection.DefaultCollection.AddRouteDescriptor(videoRoute);
+            }
+
+            Debug.LogMessage(LogEventLevel.Verbose, "Executing full route", request.Destination);
+
+            audioOrSingleRoute.ExecuteRoutes();
+            videoRoute?.ExecuteRoutes();
+        }
+
+        public static void ReleaseRoute(this IRoutingInputs destination)
+        {
+            ReleaseRoute(destination, string.Empty);
+        }
+
+        /// <summary>
+        /// Will release the existing route on the destination, if it is found in 
+        /// RouteDescriptorCollection.DefaultCollection
+        /// </summary>
+        /// <param name="destination"></param>       
+        public static void ReleaseRoute(this IRoutingInputs destination, string inputPortKey)
+        {
+
+            Debug.LogMessage(LogEventLevel.Information, "Release route for {inputPortKey}", destination, string.IsNullOrEmpty(inputPortKey) ? "auto" : inputPortKey);
+
+            if (RouteRequests.TryGetValue(destination.Key, out RouteRequest existingRequest) && destination is IWarmingCooling)
+            {
+                var coolingDevice = destination as IWarmingCooling;
+
+                coolingDevice.IsCoolingDownFeedback.OutputChange -= existingRequest.HandleCooldown;
+            }
+
+            RouteRequests.Remove(destination.Key);
+
+            var current = RouteDescriptorCollection.DefaultCollection.RemoveRouteDescriptor(destination, inputPortKey);
+            if (current != null)
+            {
+                Debug.LogMessage(LogEventLevel.Debug, "Releasing current route: {0}", destination, current.Source.Key);
+                current.ReleaseRoutes();
+            }
+        }
+
+        /// <summary>
+        /// Builds a RouteDescriptor that contains the steps necessary to make a route between devices.  
+        /// Routes of type AudioVideo will be built as two separate routes, audio and video. If
+        /// a route is discovered, a new RouteDescriptor is returned.  If one or both parts
+        /// of an audio/video route are discovered a route descriptor is returned.  If no route is 
+        /// discovered, then null is returned
+        /// </summary>
+        public static (RouteDescriptor, RouteDescriptor) GetRouteToSource(this IRoutingInputs destination, IRoutingOutputs source, eRoutingSignalType signalType, RoutingInputPort destinationPort, RoutingOutputPort sourcePort)
+        {
+            // if it's a single signal type, find the route
+            if (!signalType.HasFlag(eRoutingSignalType.AudioVideo))
+            {
+                var singleTypeRouteDescriptor = new RouteDescriptor(source, destination, destinationPort, signalType);
+                Debug.LogMessage(LogEventLevel.Debug, "Attempting to build source route from {sourceKey} of type {type}", destination, source.Key, signalType);
+
+                if (!destination.GetRouteToSource(source, null, null, signalType, 0, singleTypeRouteDescriptor, destinationPort, sourcePort))
+                    singleTypeRouteDescriptor = null;
+
+                foreach (var route in singleTypeRouteDescriptor.Routes)
+                {
+                    Debug.LogMessage(LogEventLevel.Verbose, "Route for device: {route}", destination, route.ToString());
+                }
+
+                return (singleTypeRouteDescriptor, null);
+            }
+            // otherwise, audioVideo needs to be handled as two steps.
+
+            Debug.LogMessage(LogEventLevel.Debug, "Attempting to build source route from {sourceKey} of type {type}", destination, source.Key);
+
+            var audioRouteDescriptor = new RouteDescriptor(source, destination, destinationPort, eRoutingSignalType.Audio);
+
+            var audioSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Audio, 0, audioRouteDescriptor, destinationPort, sourcePort);
+
+            if (!audioSuccess)
+                Debug.LogMessage(LogEventLevel.Debug, "Cannot find audio route to {0}", destination, source.Key);
+
+            var videoRouteDescriptor = new RouteDescriptor(source, destination, destinationPort, eRoutingSignalType.Video);
+
+            var videoSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Video, 0, videoRouteDescriptor, destinationPort, sourcePort);
+
+            if (!videoSuccess)
+                Debug.LogMessage(LogEventLevel.Debug, "Cannot find video route to {0}", destination, source.Key);
+
+            foreach (var route in audioRouteDescriptor.Routes)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "Audio route for device: {route}", destination, route.ToString());
+            }
+
+            foreach (var route in videoRouteDescriptor.Routes)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "Video route for device: {route}", destination, route.ToString());
+            }
+
+
+            if (!audioSuccess && !videoSuccess)
+                return (null, null);
+
+
+            return (audioRouteDescriptor, videoRouteDescriptor);
+        }
+
+        /// <summary>
+        /// The recursive part of this.  Will stop on each device, search its inputs for the 
+        /// desired source and if not found, invoke this function for the each input port
+        /// hoping to find the source.
+        /// </summary>
+        /// <param name="destination"></param>
+        /// <param name="source"></param>
+        /// <param name="destinationPort">The RoutingOutputPort whose link is being checked for a route</param>
+        /// <param name="alreadyCheckedDevices">Prevents Devices from being twice-checked</param>
+        /// <param name="signalType">This recursive function should not be called with AudioVideo</param>
+        /// <param name="cycle">Just an informational counter</param>
+        /// <param name="routeTable">The RouteDescriptor being populated as the route is discovered</param>
+        /// <returns>true if source is hit</returns>
+        private static bool GetRouteToSource(this IRoutingInputs destination, IRoutingOutputs source,
+            RoutingOutputPort outputPortToUse, List<IRoutingInputsOutputs> alreadyCheckedDevices,
+                eRoutingSignalType signalType, int cycle, RouteDescriptor routeTable, RoutingInputPort destinationPort, RoutingOutputPort sourcePort)
+        {
+            cycle++;
+
+            Debug.LogMessage(LogEventLevel.Verbose, "GetRouteToSource: {cycle} {sourceKey}:{sourcePortKey}--> {destinationKey}:{destinationPortKey} {type}", null, cycle, source.Key, sourcePort?.Key ?? "auto", destination.Key, destinationPort?.Key ?? "auto", signalType.ToString());
+
+            RoutingInputPort goodInputPort = null;
+
+            IEnumerable<TieLine> destinationTieLines;
+            TieLine directTie = null;
+
+            if (destinationPort == null)
+            {
+
+                destinationTieLines = TieLineCollection.Default.Where(t =>
+                    t.DestinationPort.ParentDevice.Key == destination.Key && (t.Type == signalType || t.Type.HasFlag(eRoutingSignalType.AudioVideo)));
+            }
+            else
+            {
+                destinationTieLines = TieLineCollection.Default.Where(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.DestinationPort.Key == destinationPort.Key && (t.Type == signalType || t.Type.HasFlag(eRoutingSignalType.AudioVideo)));
+            }
+
+            // find the TieLine without a port
+            if (destinationPort == null && sourcePort == null)
+            {
+                directTie = destinationTieLines.FirstOrDefault(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.SourcePort.ParentDevice.Key == source.Key);
+            }
+            // find a tieLine to a specific destination port without a specific source port
+            else if (destinationPort != null && sourcePort == null)
+            {
+                directTie = destinationTieLines.FirstOrDefault(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.DestinationPort.Key == destinationPort.Key && t.SourcePort.ParentDevice.Key == source.Key);
+            }
+            // find a tieline to a specific source port without a specific destination port
+            else if (destinationPort == null & sourcePort != null)
+            {
+                directTie = destinationTieLines.FirstOrDefault(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.SourcePort.ParentDevice.Key == source.Key && t.SourcePort.Key == sourcePort.Key);
+            }
+            // find a tieline to a specific source port and destination port
+            else if (destinationPort != null && sourcePort != null)
+            {
+                directTie = destinationTieLines.FirstOrDefault(t => t.DestinationPort.ParentDevice.Key == destination.Key && t.DestinationPort.Key == destinationPort.Key && t.SourcePort.ParentDevice.Key == source.Key && t.SourcePort.Key == sourcePort.Key);
+            }
+
+            if (directTie != null) // Found a tie directly to the source
+            {
+                goodInputPort = directTie.DestinationPort;
+            }
+            else // no direct-connect.  Walk back devices.
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "is not directly connected to {sourceKey}. Walking down tie lines", destination, source.Key);
+
+                // No direct tie? Run back out on the inputs' attached devices... 
+                // Only the ones that are routing devices
+                var midpointTieLines = destinationTieLines.Where(t => t.SourcePort.ParentDevice is IRoutingInputsOutputs);
+
+                //Create a list for tracking already checked devices to avoid loops, if it doesn't already exist from previous iteration
+                if (alreadyCheckedDevices == null)
+                    alreadyCheckedDevices = new List<IRoutingInputsOutputs>();
+                alreadyCheckedDevices.Add(destination as IRoutingInputsOutputs);
+
+                foreach (var tieLine in midpointTieLines)
+                {
+                    var midpointDevice = tieLine.SourcePort.ParentDevice as IRoutingInputsOutputs;
+
+                    // Check if this previous device has already been walked
+                    if (alreadyCheckedDevices.Contains(midpointDevice))
+                    {
+                        Debug.LogMessage(LogEventLevel.Verbose, "Skipping input {midpointDeviceKey} on {destinationKey}, this was already checked", destination, midpointDevice.Key, destination.Key);
+                        continue;
+                    }
+
+                    var midpointOutputPort = tieLine.SourcePort;
+
+                    Debug.LogMessage(LogEventLevel.Verbose, "Trying to find route on {midpointDeviceKey}", destination, midpointDevice.Key);
+
+                    // haven't seen this device yet.  Do it.  Pass the output port to the next
+                    // level to enable switching on success
+                    var upstreamRoutingSuccess = midpointDevice.GetRouteToSource(source, midpointOutputPort,
+                        alreadyCheckedDevices, signalType, cycle, routeTable, null, sourcePort);
+
+                    if (upstreamRoutingSuccess)
+                    {
+                        Debug.LogMessage(LogEventLevel.Verbose, "Upstream device route found", destination);
+                        Debug.LogMessage(LogEventLevel.Verbose, "Route found on {midpointDeviceKey}", destination, midpointDevice.Key);
+                        Debug.LogMessage(LogEventLevel.Verbose, "TieLine: SourcePort: {SourcePort} DestinationPort: {DestinationPort}", destination, tieLine.SourcePort, tieLine.DestinationPort);
+                        goodInputPort = tieLine.DestinationPort;
+                        break; // Stop looping the inputs in this cycle
+                    }
+                }
+            }
+
+
+            if (goodInputPort == null)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "No route found to {0}", destination, source.Key);
+                return false;
+            }
+
+            // we have a route on corresponding inputPort. *** Do the route ***
+
+            if (destination is IRoutingSink)
+            {
+                // it's a sink device
+                routeTable.Routes.Add(new RouteSwitchDescriptor(goodInputPort));
+            }
+            else if (destination is IRouting)
+            {
+                routeTable.Routes.Add(new RouteSwitchDescriptor(outputPortToUse, goodInputPort));
+            }
+            else // device is merely IRoutingInputOutputs
+                Debug.LogMessage(LogEventLevel.Verbose, "No routing. Passthrough device", destination);
+
+            return true;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Routing/IHasCurrentSourceInfoChange.cs

@@ -0,0 +1,30 @@
+/* Unmerged change from project 'PepperDash.Essentials.Core (net6)'
+Before:
+namespace PepperDash.Essentials.Core.Routing.Interfaces
+After:
+using PepperDash;
+using PepperDash.Essentials;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Routing;
+using PepperDash.Essentials.Core.Routing;
+using PepperDash.Essentials.Core.Routing.Interfaces
+*/
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// The handler type for a Room's SourceInfoChange
+    /// </summary>
+    public delegate void SourceInfoChangeHandler(SourceListItem info, ChangeType type);
+    //*******************************************************************************************
+    // Interfaces
+
+    /// <summary>
+    /// For rooms with a single presentation source, change event
+    /// </summary>
+    public interface IHasCurrentSourceInfoChange
+    {
+        string CurrentSourceInfoKey { get; set; }
+        SourceListItem CurrentSourceInfo { get; set; }
+        event SourceInfoChangeHandler CurrentSourceChange;
+    }
+}

src/PepperDash.Essentials.Core/Routing/IInputSync.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace PepperDash.Essentials.Core.Routing
 {
-    public interface IVideoSync: IKeyed
+    public interface IVideoSync : IKeyed
     {
         bool VideoSyncDetected { get; }
 

src/PepperDash.Essentials.Core/Routing/IRmcRouting.cs

@@ -0,0 +1,10 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines a receiver that has internal routing (DM-RMC-4K-Z-SCALER-C)
+    /// </summary>
+    public interface IRmcRouting : IRoutingNumeric
+    {
+        IntFeedback AudioVideoSourceNumericFeedback { get; }
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRmcRoutingWithFeedback.cs

@@ -0,0 +1,9 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an IRmcRouting with a feedback event 
+    /// </summary>
+    public interface IRmcRoutingWithFeedback : IRmcRouting
+    {
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRouting.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines a midpoint device as have internal routing.  Any devices in the middle of the
+    /// signal chain, that do switching, must implement this for routing to work otherwise
+    /// the routing algorithm will treat the IRoutingInputsOutputs device as a passthrough
+    /// device.
+    /// </summary>
+    public interface IRouting : IRoutingInputsOutputs
+	{
+		void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType);        
+    }    
+
+    /*public interface IRouting<TInputSelector,TOutputSelector> : IRoutingInputsOutputs
+    {
+        void ExecuteSwitch(TInputSelector inputSelector, TOutputSelector outputSelector, eRoutingSignalType signalType);
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingFeedback.cs

@@ -0,0 +1,16 @@
+using System;
+
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an event structure for reporting output route data
+    /// </summary>
+    public interface IRoutingFeedback : IKeyName
+    {
+        event EventHandler<RoutingNumericEventArgs> NumericSwitchChange;
+        //void OnSwitchChange(RoutingNumericEventArgs e);
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingHasVideoInputSyncFeedbacks.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+
+	public interface IRoutingHasVideoInputSyncFeedbacks
+	{
+		FeedbackCollection<BoolFeedback> VideoInputSyncFeedbacks { get; }
+	}	
+}

src/PepperDash.Essentials.Core/Routing/IRoutingInputs.cs

@@ -0,0 +1,18 @@
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines a class that has a collection of RoutingInputPorts
+    /// </summary>
+    public interface IRoutingInputs : IKeyed
+	{
+		RoutingPortCollection<RoutingInputPort> InputPorts { get; }
+	}
+
+/*    public interface IRoutingInputs<TSelector> : IKeyed
+    {
+        RoutingPortCollection<RoutingInputPort<TSelector>, TSelector> InputPorts { get; }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingInputsExtensions.cs

@@ -1,426 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DM;
-
-using PepperDash.Core;
-using Serilog.Events;
-
-
-namespace PepperDash.Essentials.Core
-{
-    public class RouteRequest
-    {
-        public IRoutingSink Destination {get; set;}
-        public IRoutingOutputs Source {get; set;}
-        public eRoutingSignalType SignalType {get; set;}
-
-        public void HandleCooldown(object sender, FeedbackEventArgs args)
-        {
-            var coolingDevice = sender as IWarmingCooling;
-            
-            if(args.BoolValue == false)
-            {
-                Destination.ReleaseAndMakeRoute(Source, SignalType);
-                
-                if(sender == null) return;
-
-                coolingDevice.IsCoolingDownFeedback.OutputChange -= HandleCooldown;
-            }
-        }
-    }
-
-	/// <summary>
-	/// Extensions added to any IRoutingInputs classes to provide discovery-based routing
-	/// on those destinations.
-	/// </summary>
-	public static class IRoutingInputsExtensions
-	{
-        private static Dictionary<string, RouteRequest> RouteRequests = new Dictionary<string, RouteRequest>();
-		/// <summary>
-		/// Gets any existing RouteDescriptor for a destination, clears it using ReleaseRoute
-		/// and then attempts a new Route and if sucessful, stores that RouteDescriptor
-		/// in RouteDescriptorCollection.DefaultCollection
-		/// </summary>
-		public static void ReleaseAndMakeRoute(this IRoutingSink destination, IRoutingOutputs source, eRoutingSignalType signalType)
-		{
-            var routeRequest = new RouteRequest { 
-                        Destination = destination,
-                        Source = source,
-                        SignalType = signalType
-                    };
-
-            var coolingDevice = destination as IWarmingCooling;
-
-            RouteRequest existingRouteRequest;
-
-            //We already have a route request for this device, and it's a cooling device and is cooling
-            if (RouteRequests.TryGetValue(destination.Key, out existingRouteRequest) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == true)
-            {     
-                coolingDevice.IsCoolingDownFeedback.OutputChange -= existingRouteRequest.HandleCooldown;
-
-                coolingDevice.IsCoolingDownFeedback.OutputChange += routeRequest.HandleCooldown;
-
-                RouteRequests[destination.Key] = routeRequest;
-
-                Debug.LogMessage(LogEventLevel.Verbose, "******************************************************** Device: {0} is cooling down and already has a routing request stored.  Storing new route request to route to source key: {1}", destination.Key, routeRequest.Source.Key);
-
-                return;
-            }            
-            
-            //New Request
-            if (coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == true)
-            {
-                coolingDevice.IsCoolingDownFeedback.OutputChange -= routeRequest.HandleCooldown;
-
-                coolingDevice.IsCoolingDownFeedback.OutputChange += routeRequest.HandleCooldown;
-
-                RouteRequests.Add(destination.Key, routeRequest);
-
-                Debug.LogMessage(LogEventLevel.Verbose, "******************************************************** Device: {0} is cooling down.  Storing route request to route to source key: {1}", destination.Key, routeRequest.Source.Key);
-                return;
-            }
-
-            if (RouteRequests.ContainsKey(destination.Key) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == false)
-            {
-                RouteRequests.Remove(destination.Key);
-                Debug.LogMessage(LogEventLevel.Verbose, "******************************************************** Device: {0} is NOT cooling down.  Removing stored route request and routing to source key: {1}", destination.Key, routeRequest.Source.Key);
-            }
-
-            destination.ReleaseRoute();
-
-			RunRouteRequest(routeRequest);
-		}
-
-        public static void RunRouteRequest(RouteRequest request)
-        {
-            if (request.Source == null) return;
-            var newRoute = request.Destination.GetRouteToSource(request.Source, request.SignalType);
-            if (newRoute == null) return;
-            RouteDescriptorCollection.DefaultCollection.AddRouteDescriptor(newRoute);
-            Debug.LogMessage(LogEventLevel.Verbose, request.Destination, "Executing full route");
-            newRoute.ExecuteRoutes();
-        }
-
-		/// <summary>
-		/// Will release the existing route on the destination, if it is found in 
-		/// RouteDescriptorCollection.DefaultCollection
-		/// </summary>
-		/// <param name="destination"></param>
-        public static void ReleaseRoute(this IRoutingSink destination)
-		{
-            RouteRequest existingRequest;
-
-            if (RouteRequests.TryGetValue(destination.Key, out existingRequest) && destination is IWarmingCooling)
-            {
-                var coolingDevice = destination as IWarmingCooling;
-
-                coolingDevice.IsCoolingDownFeedback.OutputChange -= existingRequest.HandleCooldown;
-            }
-
-            RouteRequests.Remove(destination.Key);
-
-			var current = RouteDescriptorCollection.DefaultCollection.RemoveRouteDescriptor(destination);
-			if (current != null)
-			{
-				Debug.LogMessage(LogEventLevel.Debug, destination, "Releasing current route: {0}", current.Source.Key);
-				current.ReleaseRoutes();
-			}
-		}
-
-		/// <summary>
-		/// Builds a RouteDescriptor that contains the steps necessary to make a route between devices.  
-		/// Routes of type AudioVideo will be built as two separate routes, audio and video. If
-		/// a route is discovered, a new RouteDescriptor is returned.  If one or both parts
-		/// of an audio/video route are discovered a route descriptor is returned.  If no route is 
-		/// discovered, then null is returned
-		/// </summary>
-        public static RouteDescriptor GetRouteToSource(this IRoutingSink destination, IRoutingOutputs source, eRoutingSignalType signalType)
-		{
-			var routeDescr = new RouteDescriptor(source, destination, signalType);
-			// if it's a single signal type, find the route
-			if ((signalType & (eRoutingSignalType.Audio & eRoutingSignalType.Video)) == (eRoutingSignalType.Audio & eRoutingSignalType.Video))
-			{
-				Debug.LogMessage(LogEventLevel.Debug, destination, "Attempting to build source route from {0}", source.Key);
-				if (!destination.GetRouteToSource(source, null, null, signalType, 0, routeDescr))
-					routeDescr = null;
-			}
-			// otherwise, audioVideo needs to be handled as two steps.
-			else
-			{
-				Debug.LogMessage(LogEventLevel.Debug, destination, "Attempting to build audio and video routes from {0}", source.Key);
-				var audioSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Audio, 0, routeDescr);
-				if (!audioSuccess)
-					Debug.LogMessage(LogEventLevel.Debug, destination, "Cannot find audio route to {0}", source.Key);
-				var videoSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Video, 0, routeDescr);
-				if (!videoSuccess)
-					Debug.LogMessage(LogEventLevel.Debug, destination, "Cannot find video route to {0}", source.Key);
-				if (!audioSuccess && !videoSuccess)
-					routeDescr = null;
-			}
-
-            //Debug.LogMessage(LogEventLevel.Debug, destination, "Route{0} discovered", routeDescr == null ? " NOT" : "");
-			return routeDescr;
-		}
-
-		/// <summary>
-		/// The recursive part of this.  Will stop on each device, search its inputs for the 
-		/// desired source and if not found, invoke this function for the each input port
-		/// hoping to find the source.
-		/// </summary>
-		/// <param name="destination"></param>
-		/// <param name="source"></param>
-		/// <param name="outputPortToUse">The RoutingOutputPort whose link is being checked for a route</param>
-		/// <param name="alreadyCheckedDevices">Prevents Devices from being twice-checked</param>
-		/// <param name="signalType">This recursive function should not be called with AudioVideo</param>
-		/// <param name="cycle">Just an informational counter</param>
-		/// <param name="routeTable">The RouteDescriptor being populated as the route is discovered</param>
-		/// <returns>true if source is hit</returns>
-		static bool GetRouteToSource(this IRoutingInputs destination, IRoutingOutputs source,
-			RoutingOutputPort outputPortToUse, List<IRoutingInputsOutputs> alreadyCheckedDevices, 
-				eRoutingSignalType signalType, int cycle, RouteDescriptor routeTable)
-		{
-			cycle++;
-			Debug.LogMessage(LogEventLevel.Verbose, "GetRouteToSource: {0} {1}--> {2}", cycle, source.Key, destination.Key);
-
-			RoutingInputPort goodInputPort = null;
-			var destDevInputTies = TieLineCollection.Default.Where(t =>
-                t.DestinationPort.ParentDevice == destination && (t.Type == signalType || (t.Type & (eRoutingSignalType.Audio | eRoutingSignalType.Video)) == (eRoutingSignalType.Audio | eRoutingSignalType.Video)));
-
-			// find a direct tie
-			var directTie = destDevInputTies.FirstOrDefault(
-				t => t.DestinationPort.ParentDevice == destination 
-					&& t.SourcePort.ParentDevice == source);
-			if (directTie != null) // Found a tie directly to the source
-			{
-				goodInputPort = directTie.DestinationPort;
-			}
-			else // no direct-connect.  Walk back devices.
-			{
-				Debug.LogMessage(LogEventLevel.Verbose, destination, "is not directly connected to {0}. Walking down tie lines", source.Key);
-
-				// No direct tie? Run back out on the inputs' attached devices... 
-				// Only the ones that are routing devices
-				var attachedMidpoints = destDevInputTies.Where(t => t.SourcePort.ParentDevice is IRoutingInputsOutputs);
-
-                //Create a list for tracking already checked devices to avoid loops, if it doesn't already exist from previous iteration
-                if (alreadyCheckedDevices == null)
-                    alreadyCheckedDevices = new List<IRoutingInputsOutputs>();
-                alreadyCheckedDevices.Add(destination as IRoutingInputsOutputs);
-
-				foreach (var inputTieToTry in attachedMidpoints)
-				{
-					var upstreamDeviceOutputPort = inputTieToTry.SourcePort;
-					var upstreamRoutingDevice = upstreamDeviceOutputPort.ParentDevice as IRoutingInputsOutputs;
-                    Debug.LogMessage(LogEventLevel.Verbose, destination, "Trying to find route on {0}", upstreamRoutingDevice.Key);
-
-					// Check if this previous device has already been walked
-                    if (alreadyCheckedDevices.Contains(upstreamRoutingDevice))
-                    {
-                        Debug.LogMessage(LogEventLevel.Verbose, destination, "Skipping input {0} on {1}, this was already checked", upstreamRoutingDevice.Key, destination.Key);
-                        continue;
-                    }
-                    // haven't seen this device yet.  Do it.  Pass the output port to the next
-                    // level to enable switching on success
-                    var upstreamRoutingSuccess = upstreamRoutingDevice.GetRouteToSource(source, upstreamDeviceOutputPort,
-                        alreadyCheckedDevices, signalType, cycle, routeTable);
-                    if (upstreamRoutingSuccess)
-                    {
-                        Debug.LogMessage(LogEventLevel.Verbose, destination, "Upstream device route found");
-                        goodInputPort = inputTieToTry.DestinationPort;
-                        break; // Stop looping the inputs in this cycle
-                    }
-				}
-			}
-
-			// we have a route on corresponding inputPort. *** Do the route ***
-			if (goodInputPort != null) 
-			{
-                //Debug.LogMessage(LogEventLevel.Verbose, destination, "adding RouteDescriptor");
-				if (outputPortToUse == null)
-				{
-					// it's a sink device
-                        routeTable.Routes.Add(new RouteSwitchDescriptor(goodInputPort));
-				}
-				else if (destination is IRouting)
-				{
-					routeTable.Routes.Add(new RouteSwitchDescriptor (outputPortToUse, goodInputPort));
-				}
-				else // device is merely IRoutingInputOutputs
-					Debug.LogMessage(LogEventLevel.Verbose, destination, "    No routing. Passthrough device");
-                //Debug.LogMessage(LogEventLevel.Verbose, destination, "Exiting cycle {0}", cycle);
-				return true;
-			}
-
-			Debug.LogMessage(LogEventLevel.Verbose, destination, "No route found to {0}", source.Key);
-			return false;
-		}
-	}
-
-
-
-
-
-	// MOVE MOVE MOVE MOVE MOVE MOVE MOVE  MOVE MOVE MOVE MOVE MOVE MOVE MOVE  MOVE MOVE MOVE MOVE MOVE MOVE MOVE 
-
-
-	/// <summary>
-	/// A collection of RouteDescriptors - typically the static DefaultCollection is used
-	/// </summary>
-	public class RouteDescriptorCollection
-	{
-		public static RouteDescriptorCollection DefaultCollection
-		{
-			get
-			{
-				if (_DefaultCollection == null)
-					_DefaultCollection = new RouteDescriptorCollection();
-				return _DefaultCollection;
-			}
-		}
-		static RouteDescriptorCollection _DefaultCollection;
-
-		List<RouteDescriptor> RouteDescriptors = new List<RouteDescriptor>();
-
-		/// <summary>
-		/// Adds a RouteDescriptor to the list.  If an existing RouteDescriptor for the
-		/// destination exists already, it will not be added - in order to preserve
-		/// proper route releasing.
-		/// </summary>
-		/// <param name="descriptor"></param>
-		public void AddRouteDescriptor(RouteDescriptor descriptor)
-		{
-			if (RouteDescriptors.Any(t => t.Destination == descriptor.Destination))
-			{
-				Debug.LogMessage(LogEventLevel.Debug, descriptor.Destination, 
-					"Route to [{0}] already exists in global routes table", descriptor.Source.Key);
-				return;
-			}
-			RouteDescriptors.Add(descriptor);
-		}
-
-		/// <summary>
-		/// Gets the RouteDescriptor for a destination
-		/// </summary>
-		/// <returns>null if no RouteDescriptor for a destination exists</returns>
-		public RouteDescriptor GetRouteDescriptorForDestination(IRoutingInputs destination)
-		{
-			return RouteDescriptors.FirstOrDefault(rd => rd.Destination == destination);
-		}
-
-		/// <summary>
-		/// Returns the RouteDescriptor for a given destination AND removes it from collection.
-		/// Returns null if no route with the provided destination exists.
-		/// </summary>
-		public RouteDescriptor RemoveRouteDescriptor(IRoutingInputs destination)
-		{
-			var descr = GetRouteDescriptorForDestination(destination);
-			if (descr != null)
-				RouteDescriptors.Remove(descr);
-			return descr;
-		}
-	}
-
-	/// <summary>
-	/// Represents an collection of individual route steps between Source and Destination
-	/// </summary>
-	public class RouteDescriptor
-	{
-		public IRoutingInputs Destination { get; private set; }
-		public IRoutingOutputs Source { get; private set; }
-		public eRoutingSignalType SignalType { get; private set; }
-		public List<RouteSwitchDescriptor> Routes { get; private set; }
-
-
-		public RouteDescriptor(IRoutingOutputs source, IRoutingInputs destination, eRoutingSignalType signalType)
-		{
-			Destination = destination;
-			Source = source;
-			SignalType = signalType;
-			Routes = new List<RouteSwitchDescriptor>();
-		}
-
-		/// <summary>
-		/// Executes all routes described in this collection.  Typically called via
-		/// extension method IRoutingInputs.ReleaseAndMakeRoute()
-		/// </summary>
-		public void ExecuteRoutes()
-		{
-			foreach (var route in Routes)
-			{
-				Debug.LogMessage(LogEventLevel.Verbose, "ExecuteRoutes: {0}", route.ToString());
-                if (route.SwitchingDevice is IRoutingSink)
-                {
-                    var device = route.SwitchingDevice as IRoutingSinkWithSwitching;
-                    if (device == null)
-                        continue;
-
-                    device.ExecuteSwitch(route.InputPort.Selector);
-                }
-                else if (route.SwitchingDevice is IRouting)
-                {
-                    (route.SwitchingDevice as IRouting).ExecuteSwitch(route.InputPort.Selector, route.OutputPort.Selector, SignalType);
-                    route.OutputPort.InUseTracker.AddUser(Destination, "destination-" + SignalType);
-                    Debug.LogMessage(LogEventLevel.Verbose, "Output port {0} routing. Count={1}", route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
-                }
-			}
-		}
-
-		/// <summary>
-		/// Releases all routes in this collection. Typically called via
-		/// extension method IRoutingInputs.ReleaseAndMakeRoute()
-		/// </summary>
-		public void ReleaseRoutes()
-		{
-			foreach (var route in Routes)
-			{
-				if (route.SwitchingDevice is IRouting)
-				{
-					// Pull the route from the port.  Whatever is watching the output's in use tracker is
-					// responsible for responding appropriately.
-					route.OutputPort.InUseTracker.RemoveUser(Destination, "destination-" + SignalType);
-					Debug.LogMessage(LogEventLevel.Verbose, "Port {0} releasing. Count={1}", route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
-				}
-			}
-		}
-
-		public override string ToString()
-		{
-			var routesText = Routes.Select(r => r.ToString()).ToArray();
-			return string.Format("Route table from {0} to {1}:\r{2}", Source.Key, Destination.Key, string.Join("\r", routesText));
-		}
-	}
-
-	/// <summary>
-	/// Represents an individual link for a route
-	/// </summary>
-	public class RouteSwitchDescriptor
-	{
-		public IRoutingInputs SwitchingDevice { get { return InputPort.ParentDevice; } }
-		public RoutingOutputPort OutputPort { get; set; }
-		public RoutingInputPort InputPort { get; set; }
-
-		public RouteSwitchDescriptor(RoutingInputPort inputPort)
-		{
-			InputPort = inputPort;
-		}
-
-		public RouteSwitchDescriptor(RoutingOutputPort outputPort, RoutingInputPort inputPort)
-		{
-			InputPort = inputPort;
-			OutputPort = outputPort;
-		}
-
-		public override string ToString()
-		{
-			if(SwitchingDevice is IRouting)
-				return string.Format("{0} switches output '{1}' to input '{2}'", SwitchingDevice.Key, OutputPort.Selector, InputPort.Selector);
-			else
-				return string.Format("{0} switches to input '{1}'", SwitchingDevice.Key, InputPort.Selector);
-
-		}
-	}
-}

src/PepperDash.Essentials.Core/Routing/IRoutingInputsOutputs.cs

@@ -0,0 +1,16 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// For devices like RMCs, baluns, other devices with no switching.
+    /// </summary>
+    public interface IRoutingInputsOutputs : IRoutingInputs, IRoutingOutputs
+	{
+	}
+
+/*    /// <summary>
+    /// For devices like RMCs, baluns, other devices with no switching.
+    /// </summary>
+    public interface IRoutingInputsOutputs<TInputSelector, TOutputSelector> : IRoutingInputs<TInputSelector>, IRoutingOutputs<TOutputSelector>
+    {
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingNumeric.cs

@@ -0,0 +1,7 @@
+namespace PepperDash.Essentials.Core
+{
+    public interface IRoutingNumeric : IRouting
+    {
+        void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type);
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingNumericWithFeedback.cs

@@ -0,0 +1,9 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an IRoutingNumeric with a feedback event 
+    /// </summary>
+    public interface IRoutingNumericWithFeedback : IRoutingNumeric, IRoutingFeedback
+    {
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingOutputs.cs

@@ -0,0 +1,19 @@
+using PepperDash.Core;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines a class that has a collection of RoutingOutputPorts
+    /// </summary>
+
+    public interface IRoutingOutputs : IKeyed
+	{
+		RoutingPortCollection<RoutingOutputPort> OutputPorts { get; }
+	}
+
+/*    public interface IRoutingOutputs<TSelector> : IKeyed
+    {
+        RoutingPortCollection<RoutingOutputPort<TSelector>, TSelector> OutputPorts { get; }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingSink.cs

@@ -0,0 +1,23 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// For fixed-source endpoint devices
+    /// </summary>
+    public interface IRoutingSink : IRoutingInputs, IHasCurrentSourceInfoChange
+    {        
+    }
+
+    public interface IRoutingSinkWithInputPort :IRoutingSink
+    {
+        RoutingInputPort CurrentInputPort { get; }
+    }
+    /*/// <summary>
+    /// For fixed-source endpoint devices
+    /// </summary>
+    public interface IRoutingSink<TSelector> : IRoutingInputs<TSelector>, IHasCurrentSourceInfoChange
+    {
+        void UpdateRouteRequest<TOutputSelector>(RouteRequest<TSelector, TOutputSelector> request);
+
+        RouteRequest<TSelector, TOutputSelector> GetRouteRequest<TOutputSelector>();
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingSinkWithFeedback.cs

@@ -0,0 +1,25 @@
+using PepperDash.Essentials.Core.Routing;
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core
+{
+    
+    /// <summary>
+    /// For fixed-source endpoint devices
+    /// </summary>
+    public interface IRoutingSinkWithFeedback : IRoutingSinkWithSwitching
+    {
+        
+    }
+
+/*    /// <summary>
+    /// For fixed-source endpoint devices
+    /// </summary>
+    public interface IRoutingSinkWithFeedback<TSelector> : IRoutingSinkWithSwitching<TSelector>
+    {
+        RouteSwitchDescriptor CurrentRoute { get; }
+
+        event EventHandler InputChanged;
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingSinkWithSwitching.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace PepperDash.Essentials.Core
+{
+    public delegate void InputChangedEventHandler(IRoutingSinkWithSwitching destination, RoutingInputPort currentPort);
+
+    /// <summary>
+    /// Endpoint device like a display, that selects inputs
+    /// </summary>
+    public interface IRoutingSinkWithSwitching : IRoutingSink
+	{		
+		void ExecuteSwitch(object inputSelector);        
+    }
+
+    public interface IRoutingSinkWithSwitchingWithInputPort:IRoutingSinkWithSwitching, IRoutingSinkWithInputPort
+    {
+        event InputChangedEventHandler InputChanged;
+    }
+
+/*    /// <summary>
+    /// Endpoint device like a display, that selects inputs
+    /// </summary>
+    public interface IRoutingSinkWithSwitching<TSelector> : IRoutingSink<TSelector>
+    {
+        void ExecuteSwitch(TSelector inputSelector);
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/IRoutingSource.cs

@@ -0,0 +1,9 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an IRoutingOutputs devices as being a source - the start of the chain
+    /// </summary>
+    public interface IRoutingSource : IRoutingOutputs
+    {
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingWithClear.cs

@@ -0,0 +1,12 @@
+namespace PepperDash.Essentials.Core
+{
+    public interface IRoutingWithClear : IRouting
+    {
+        /// <summary>
+        /// Clears a route to an output, however a device needs to do that
+        /// </summary>
+        /// <param name="outputSelector">Output to clear</param>
+        /// <param name="signalType">signal type to clear</param>
+        void ClearRoute(object outputSelector, eRoutingSignalType signalType);
+    }
+}

src/PepperDash.Essentials.Core/Routing/IRoutingWithFeedback.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System;
+
+namespace PepperDash.Essentials.Core
+{
+    public delegate void RouteChangedEventHandler(IRoutingWithFeedback midpoint, RouteSwitchDescriptor newRoute);
+    /// <summary>
+    /// Defines an IRouting with a feedback event
+    /// </summary>
+    public interface IRoutingWithFeedback : IRouting
+    {
+        List<RouteSwitchDescriptor> CurrentRoutes { get; }
+
+        event RouteChangedEventHandler RouteChanged;
+    }
+}

src/PepperDash.Essentials.Core/Routing/ITxRouting.cs

@@ -0,0 +1,8 @@
+namespace PepperDash.Essentials.Core
+{
+    public interface ITxRouting : IRoutingNumeric
+    {
+        IntFeedback VideoSourceNumericFeedback { get; }
+        IntFeedback AudioSourceNumericFeedback { get; }
+    }
+}

src/PepperDash.Essentials.Core/Routing/ITxRoutingWithFeedback.cs

@@ -0,0 +1,9 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines an IRmcRouting with a feedback event 
+    /// </summary>
+    public interface ITxRoutingWithFeedback : ITxRouting
+    {
+    }
+}

src/PepperDash.Essentials.Core/Routing/RouteDescriptor.cs

@@ -0,0 +1,172 @@
+using System.Collections.Generic;
+using System.Linq;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Core;
+using Serilog.Events;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Represents an collection of individual route steps between Source and Destination
+    /// </summary>
+    public class RouteDescriptor
+	{
+		public IRoutingInputs Destination { get; private set; }
+
+        public RoutingInputPort InputPort { get; private set; }
+
+		public IRoutingOutputs Source { get; private set; }
+		public eRoutingSignalType SignalType { get; private set; }
+		public List<RouteSwitchDescriptor> Routes { get; private set; }
+
+
+		public RouteDescriptor(IRoutingOutputs source, IRoutingInputs destination, eRoutingSignalType signalType):this(source,destination, null, signalType)
+		{
+		}
+
+        public RouteDescriptor(IRoutingOutputs source, IRoutingInputs destination, RoutingInputPort inputPort, eRoutingSignalType signalType)
+        {
+            Destination = destination;
+            Source = source;
+            SignalType = signalType;
+            InputPort = inputPort;
+            Routes = new List<RouteSwitchDescriptor>();
+        }
+
+		/// <summary>
+		/// Executes all routes described in this collection.  Typically called via
+		/// extension method IRoutingInputs.ReleaseAndMakeRoute()
+		/// </summary>
+		public void ExecuteRoutes()
+		{
+			foreach (var route in Routes)
+			{
+				Debug.LogMessage(LogEventLevel.Verbose, "ExecuteRoutes: {0}",null, route.ToString());
+
+                if (route.SwitchingDevice is IRoutingSinkWithSwitching sink)
+                {                   
+                    sink.ExecuteSwitch(route.InputPort.Selector);
+                    continue; 
+                }
+
+                if (route.SwitchingDevice is IRouting switchingDevice)
+                {
+                    switchingDevice.ExecuteSwitch(route.InputPort.Selector, route.OutputPort.Selector, SignalType);
+
+                    route.OutputPort.InUseTracker.AddUser(Destination, "destination-" + SignalType);
+
+                    Debug.LogMessage(LogEventLevel.Verbose, "Output port {0} routing. Count={1}", null, route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
+                }
+			}
+		}
+
+		/// <summary>
+		/// Releases all routes in this collection. Typically called via
+		/// extension method IRoutingInputs.ReleaseAndMakeRoute()
+		/// </summary>
+		public void ReleaseRoutes()
+		{
+            foreach (var route in Routes.Where(r => r.SwitchingDevice is IRouting))
+            {
+                if (route.SwitchingDevice is IRouting switchingDevice)
+                {
+                    if (route.OutputPort == null)
+                    {
+                        continue;
+                    }
+
+                    switchingDevice.ExecuteSwitch(null, route.OutputPort.Selector, SignalType);
+
+                    if (route.OutputPort.InUseTracker != null)
+                    {
+                        route.OutputPort.InUseTracker.RemoveUser(Destination, "destination-" + SignalType);
+                        Debug.LogMessage(LogEventLevel.Verbose, "Port {0} releasing. Count={1}", null, route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
+                    }
+                    else
+                    {
+                        Debug.LogMessage(LogEventLevel.Error, "InUseTracker is null for OutputPort {0}", null, route.OutputPort.Key);
+                    }
+                }
+            }
+        }
+
+		public override string ToString()
+		{
+			var routesText = Routes.Select(r => r.ToString()).ToArray();
+			return string.Format("Route table from {0} to {1}:\r{2}", Source.Key, Destination.Key, string.Join("\r", routesText));
+		}
+	}
+
+    /*/// <summary>
+    /// Represents an collection of individual route steps between Source and Destination
+    /// </summary>
+    public class RouteDescriptor<TInputSelector, TOutputSelector>
+    {
+        public IRoutingInputs<TInputSelector> Destination { get; private set; }
+        public IRoutingOutputs<TOutputSelector> Source { get; private set; }
+        public eRoutingSignalType SignalType { get; private set; }
+        public List<RouteSwitchDescriptor<TInputSelector, TOutputSelector>> Routes { get; private set; }
+
+
+        public RouteDescriptor(IRoutingOutputs<TOutputSelector> source, IRoutingInputs<TInputSelector> destination, eRoutingSignalType signalType)
+        {
+            Destination = destination;
+            Source = source;
+            SignalType = signalType;
+            Routes = new List<RouteSwitchDescriptor<TInputSelector, TOutputSelector>>();
+        }
+
+        /// <summary>
+        /// Executes all routes described in this collection.  Typically called via
+        /// extension method IRoutingInputs.ReleaseAndMakeRoute()
+        /// </summary>
+        public void ExecuteRoutes()
+        {
+            foreach (var route in Routes)
+            {
+                Debug.LogMessage(LogEventLevel.Verbose, "ExecuteRoutes: {0}", null, route.ToString());
+
+                if (route.SwitchingDevice is IRoutingSinkWithSwitching<TInputSelector> sink)
+                {
+                    sink.ExecuteSwitch(route.InputPort.Selector);
+                    continue;
+                }
+
+                if (route.SwitchingDevice is IRouting switchingDevice)
+                {
+                    switchingDevice.ExecuteSwitch(route.InputPort.Selector, route.OutputPort.Selector, SignalType);
+
+                    route.OutputPort.InUseTracker.AddUser(Destination, "destination-" + SignalType);
+
+                    Debug.LogMessage(LogEventLevel.Verbose, "Output port {0} routing. Count={1}", null, route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Releases all routes in this collection. Typically called via
+        /// extension method IRoutingInputs.ReleaseAndMakeRoute()
+        /// </summary>
+        public void ReleaseRoutes()
+        {
+            foreach (var route in Routes)
+            {
+                if (route.SwitchingDevice is IRouting<TInputSelector, TOutputSelector>)
+                {
+                    // Pull the route from the port.  Whatever is watching the output's in use tracker is
+                    // responsible for responding appropriately.
+                    route.OutputPort.InUseTracker.RemoveUser(Destination, "destination-" + SignalType);
+                    Debug.LogMessage(LogEventLevel.Verbose, "Port {0} releasing. Count={1}", null, route.OutputPort.Key, route.OutputPort.InUseTracker.InUseCountFeedback.UShortValue);
+                }
+            }
+        }
+
+        public override string ToString()
+        {
+            var routesText = Routes.Select(r => r.ToString()).ToArray();
+            return string.Format("Route table from {0} to {1}:\r{2}", Source.Key, Destination.Key, string.Join("\r", routesText));
+        }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/RouteDescriptorCollection.cs

@@ -0,0 +1,143 @@
+using PepperDash.Core;
+using Serilog.Events;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// A collection of RouteDescriptors - typically the static DefaultCollection is used
+    /// </summary>
+    public class RouteDescriptorCollection
+    {
+        public static RouteDescriptorCollection DefaultCollection
+        {
+            get
+            {
+                if (_DefaultCollection == null)
+                    _DefaultCollection = new RouteDescriptorCollection();
+                return _DefaultCollection;
+            }
+        }
+        private static RouteDescriptorCollection _DefaultCollection;
+
+        private readonly List<RouteDescriptor> RouteDescriptors = new List<RouteDescriptor>();
+
+        /// <summary>
+        /// Adds a RouteDescriptor to the list.  If an existing RouteDescriptor for the
+        /// destination exists already, it will not be added - in order to preserve
+        /// proper route releasing.
+        /// </summary>
+        /// <param name="descriptor"></param>
+        public void AddRouteDescriptor(RouteDescriptor descriptor)
+        {
+            if (descriptor == null)
+            {
+                return;
+            }
+
+            if (RouteDescriptors.Any(t => t.Destination == descriptor.Destination)
+                && RouteDescriptors.Any(t => t.Destination == descriptor.Destination && t.InputPort != null && descriptor.InputPort != null && t.InputPort.Key == descriptor.InputPort.Key))
+            {
+                Debug.LogMessage(LogEventLevel.Debug, descriptor.Destination,
+                    "Route to [{0}] already exists in global routes table", descriptor.Source.Key);
+                return;
+            }
+            RouteDescriptors.Add(descriptor);
+        }
+
+        /// <summary>
+        /// Gets the RouteDescriptor for a destination
+        /// </summary>
+        /// <returns>null if no RouteDescriptor for a destination exists</returns>
+        public RouteDescriptor GetRouteDescriptorForDestination(IRoutingInputs destination)
+        {
+            Debug.LogMessage(LogEventLevel.Debug, "Getting route descriptor", destination);
+
+            return RouteDescriptors.FirstOrDefault(rd => rd.Destination == destination);
+        }
+
+        public RouteDescriptor GetRouteDescriptorForDestinationAndInputPort(IRoutingInputs destination, string inputPortKey)
+        {
+            Debug.LogMessage(LogEventLevel.Debug, "Getting route descriptor for {inputPortKey}", destination, string.IsNullOrEmpty(inputPortKey) ? "auto" : inputPortKey);
+            return RouteDescriptors.FirstOrDefault(rd => rd.Destination == destination && rd.InputPort != null && rd.InputPort.Key == inputPortKey);
+        }
+
+        /// <summary>
+        /// Returns the RouteDescriptor for a given destination AND removes it from collection.
+        /// Returns null if no route with the provided destination exists.
+        /// </summary>
+        public RouteDescriptor RemoveRouteDescriptor(IRoutingInputs destination, string inputPortKey = "")
+        {
+            Debug.LogMessage(LogEventLevel.Debug, "Removing route descriptor for {inputPortKey}", destination, string.IsNullOrEmpty(inputPortKey) ? "auto" : inputPortKey);
+
+            var descr = string.IsNullOrEmpty(inputPortKey) 
+                ? GetRouteDescriptorForDestination(destination)
+                : GetRouteDescriptorForDestinationAndInputPort(destination, inputPortKey);
+            if (descr != null)
+                RouteDescriptors.Remove(descr);
+
+            Debug.LogMessage(LogEventLevel.Debug, "Found route descriptor {routeDescriptor}", destination, descr);
+
+            return descr;
+        }
+    }
+
+    /*/// <summary>
+    /// A collection of RouteDescriptors - typically the static DefaultCollection is used
+    /// </summary>
+    public class RouteDescriptorCollection<TInputSelector, TOutputSelector>
+	{
+		public static RouteDescriptorCollection<TInputSelector, TOutputSelector> DefaultCollection
+		{
+			get
+			{
+				if (_DefaultCollection == null)
+					_DefaultCollection = new RouteDescriptorCollection<TInputSelector, TOutputSelector>();
+				return _DefaultCollection;
+			}
+		}
+		private static RouteDescriptorCollection<TInputSelector, TOutputSelector> _DefaultCollection;
+
+		private readonly List<RouteDescriptor> RouteDescriptors = new List<RouteDescriptor>();
+
+		/// <summary>
+		/// Adds a RouteDescriptor to the list.  If an existing RouteDescriptor for the
+		/// destination exists already, it will not be added - in order to preserve
+		/// proper route releasing.
+		/// </summary>
+		/// <param name="descriptor"></param>
+		public void AddRouteDescriptor(RouteDescriptor descriptor)
+		{
+			if (RouteDescriptors.Any(t => t.Destination == descriptor.Destination))
+			{
+				Debug.LogMessage(LogEventLevel.Debug, descriptor.Destination, 
+					"Route to [{0}] already exists in global routes table", descriptor.Source.Key);
+				return;
+			}
+			RouteDescriptors.Add(descriptor);
+		}
+
+		/// <summary>
+		/// Gets the RouteDescriptor for a destination
+		/// </summary>
+		/// <returns>null if no RouteDescriptor for a destination exists</returns>
+		public RouteDescriptor GetRouteDescriptorForDestination(IRoutingInputs<TInputSelector> destination)
+		{
+			return RouteDescriptors.FirstOrDefault(rd => rd.Destination == destination);
+		}
+
+		/// <summary>
+		/// Returns the RouteDescriptor for a given destination AND removes it from collection.
+		/// Returns null if no route with the provided destination exists.
+		/// </summary>
+		public RouteDescriptor RemoveRouteDescriptor(IRoutingInputs<TInputSelector> destination)
+		{
+			var descr = GetRouteDescriptorForDestination(destination);
+			if (descr != null)
+				RouteDescriptors.Remove(descr);
+			return descr;
+		}
+	}*/
+}

src/PepperDash.Essentials.Core/Routing/RouteRequest.cs

@@ -0,0 +1,42 @@
+using PepperDash.Core;
+using Serilog.Events;
+using System;
+
+namespace PepperDash.Essentials.Core
+{
+    public class RouteRequest
+    {
+        public RoutingInputPort DestinationPort { get; set; }
+
+        public RoutingOutputPort SourcePort { get; set; }
+        public IRoutingInputs Destination { get; set; }
+        public IRoutingOutputs Source { get; set; }
+        public eRoutingSignalType SignalType { get; set; }
+
+        public void HandleCooldown(object sender, FeedbackEventArgs args)
+        {
+            try
+            {
+                Debug.LogMessage(LogEventLevel.Information, "Handling cooldown route request: {destination}:{destinationPort} -> {source}:{sourcePort} {type}", null, Destination?.Key ?? "empty destination", DestinationPort?.Key ?? "no destination port", Source?.Key ?? "empty source", SourcePort?.Key ?? "empty source port", SignalType.ToString());
+
+                if (args.BoolValue == true)
+                {
+                    return;
+                }
+
+                Debug.LogMessage(LogEventLevel.Information, "Cooldown complete. Making route from {destination} to {source}", Destination?.Key, Source?.Key);
+
+                Destination.ReleaseAndMakeRoute(Source, SignalType, DestinationPort?.Key ?? string.Empty, SourcePort?.Key ?? string.Empty);
+
+                if (sender is IWarmingCooling coolingDevice)
+                {
+                    Debug.LogMessage(LogEventLevel.Debug, "Unsubscribing from cooling feedback for {destination}", null, Destination.Key);
+                    coolingDevice.IsCoolingDownFeedback.OutputChange -= HandleCooldown;
+                }
+            } catch(Exception ex)
+            {
+                Debug.LogMessage(ex, "Exception handling cooldown", Destination);
+            }
+        }
+    }
+}

src/PepperDash.Essentials.Core/Routing/RouteSwitchDescriptor.cs

@@ -0,0 +1,60 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Represents an individual link for a route
+    /// </summary>
+    public class RouteSwitchDescriptor
+	{
+		public IRoutingInputs SwitchingDevice { get { return InputPort?.ParentDevice; } }
+		public RoutingOutputPort OutputPort { get; set; }
+		public RoutingInputPort InputPort { get; set; }
+
+		public RouteSwitchDescriptor(RoutingInputPort inputPort)
+		{
+			InputPort = inputPort;
+		}
+
+		public RouteSwitchDescriptor(RoutingOutputPort outputPort, RoutingInputPort inputPort)
+		{
+			InputPort = inputPort;
+			OutputPort = outputPort;
+		}
+
+		public override string ToString()
+		{
+            if (SwitchingDevice is IRouting)
+                return $"{(SwitchingDevice != null ? SwitchingDevice.Key : "No Device")} switches output {(OutputPort != null ? OutputPort.Key : "No output port")} to input {(InputPort != null ? InputPort.Key : "No input port")}";
+            else
+                return $"{(SwitchingDevice != null ? SwitchingDevice.Key : "No Device")} switches to input {(InputPort != null ? InputPort.Key : "No input port")}";
+		}
+	}
+
+    /*/// <summary>
+    /// Represents an individual link for a route
+    /// </summary>
+    public class RouteSwitchDescriptor<TInputSelector, TOutputSelector>
+    {
+        public IRoutingInputs<TInputSelector> SwitchingDevice { get { return InputPort.ParentDevice; } }
+        public RoutingOutputPort<TOutputSelector> OutputPort { get; set; }
+        public RoutingInputPort<TInputSelector> InputPort { get; set; }
+
+        public RouteSwitchDescriptor(RoutingInputPort<TInputSelector> inputPort)
+        {
+            InputPort = inputPort;
+        }
+
+        public RouteSwitchDescriptor(RoutingOutputPort<TOutputSelector> outputPort, RoutingInputPort<TInputSelector> inputPort)
+        {
+            InputPort = inputPort;
+            OutputPort = outputPort;
+        }
+
+        public override string ToString()
+        {
+            if (SwitchingDevice is IRouting)
+                return string.Format("{0} switches output '{1}' to input '{2}'", SwitchingDevice.Key, OutputPort.Selector, InputPort.Selector);
+            else
+                return string.Format("{0} switches to input '{1}'", SwitchingDevice.Key, InputPort.Selector);
+        }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/RoutingFeedbackManager.cs

@@ -0,0 +1,271 @@
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+using System;
+using System.Linq;
+
+namespace PepperDash.Essentials.Core.Routing
+{
+    public class RoutingFeedbackManager:EssentialsDevice
+    {
+        public RoutingFeedbackManager(string key, string name): base(key, name)
+        {            
+            AddPreActivationAction(SubscribeForMidpointFeedback);
+            AddPreActivationAction(SubscribeForSinkFeedback);
+        }
+
+
+        private void SubscribeForMidpointFeedback()
+        {
+            var midpointDevices = DeviceManager.AllDevices.OfType<IRoutingWithFeedback>();
+
+            foreach (var device in midpointDevices)
+            {
+                device.RouteChanged += HandleMidpointUpdate;
+            }
+        }
+
+        private void SubscribeForSinkFeedback()
+        {
+                var sinkDevices = DeviceManager.AllDevices.OfType<IRoutingSinkWithSwitchingWithInputPort>();
+
+                foreach (var device in sinkDevices)
+                {
+                    device.InputChanged += HandleSinkUpdate;
+                }   
+        }
+
+        private void HandleMidpointUpdate(IRoutingWithFeedback midpoint, RouteSwitchDescriptor newRoute)
+        {
+            try
+            {
+                var devices = DeviceManager.AllDevices.OfType<IRoutingSinkWithSwitchingWithInputPort>();
+
+                foreach (var device in devices)
+                {
+                    UpdateDestination(device, device.CurrentInputPort);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error handling midpoint update from {midpointKey}:{Exception}", this, midpoint.Key, ex);
+            }
+        }
+
+        private void HandleSinkUpdate(IRoutingSinkWithSwitching sender, RoutingInputPort currentInputPort)
+        {
+            try
+            {
+                UpdateDestination(sender, currentInputPort);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error handling Sink update from {senderKey}:{Exception}", this, sender.Key, ex);
+            }
+        }
+
+        private void UpdateDestination(IRoutingSinkWithSwitching destination, RoutingInputPort inputPort)
+        {            
+            // Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Updating destination {destination} with inputPort {inputPort}", this,destination?.Key, inputPort?.Key);
+
+            if(inputPort == null)
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Warning, "Destination {destination} has not reported an input port yet", this,destination.Key);
+                return;
+            }
+
+            TieLine firstTieLine;
+            try
+            {
+                var tieLines = TieLineCollection.Default;
+
+                firstTieLine = tieLines.FirstOrDefault(tl => tl.DestinationPort.Key == inputPort.Key && tl.DestinationPort.ParentDevice.Key == inputPort.ParentDevice.Key);
+
+                if (firstTieLine == null)
+                {
+                    Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "No tieline found for inputPort {inputPort}. Clearing current source", this, inputPort);
+
+                    var tempSourceListItem = new SourceListItem
+                    {
+                        SourceKey = "$transient",
+                        Name = inputPort.Key,
+                    };
+
+
+                    destination.CurrentSourceInfo = tempSourceListItem;                        ;
+                    destination.CurrentSourceInfoKey = "$transient";
+                    return;
+                }
+            } catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error getting first tieline: {Exception}", this, ex);
+                return;
+            }
+
+            // Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Getting source for first TieLine {tieLine}", this, firstTieLine);
+
+            TieLine sourceTieLine;
+            try
+            {
+                sourceTieLine = GetRootTieLine(firstTieLine);
+
+                if (sourceTieLine == null)
+                {
+                    Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "No route found to source for inputPort {inputPort}. Clearing current source", this, inputPort);
+
+                    var tempSourceListItem = new SourceListItem
+                    {
+                        SourceKey = "$transient",
+                        Name = "None",
+                    };
+
+                    destination.CurrentSourceInfo = tempSourceListItem;
+                    destination.CurrentSourceInfoKey = string.Empty;
+                    return;
+                }
+            } catch(Exception ex)
+            {
+                Debug.LogMessage(ex, "Error getting sourceTieLine: {Exception}", this, ex);
+                return;
+            }
+
+            // Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found root TieLine {tieLine}", this, sourceTieLine);           
+
+            // Does not handle combinable scenarios or other scenarios where a display might be part of multiple rooms yet.
+            var room = DeviceManager.AllDevices.OfType<IEssentialsRoom>().FirstOrDefault((r) => {
+                if(r is IHasMultipleDisplays roomMultipleDisplays)
+                {
+                    return roomMultipleDisplays.Displays.Any(d => d.Value.Key == destination.Key);
+                }
+
+                if(r is IHasDefaultDisplay roomDefaultDisplay)
+                {
+                    return roomDefaultDisplay.DefaultDisplay.Key == destination.Key;
+                }
+
+                return false;
+            });
+            
+            if(room == null)
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Warning, "No room found for display {destination}", this, destination.Key);
+                return;
+            }
+
+            // Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found room {room} for destination {destination}", this, room.Key, destination.Key);
+
+            var sourceList = ConfigReader.ConfigObject.GetSourceListForKey(room.SourceListKey);
+
+            if (sourceList == null)
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Warning, "No source list found for source list key {key}. Unable to find source for tieLine {sourceTieLine}", this, room.SourceListKey, sourceTieLine);
+                return;
+            }
+
+            // Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found sourceList for room {room}", this, room.Key);
+
+            var sourceListItem = sourceList.FirstOrDefault(sli => {
+                 //// Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose,
+                 //   "SourceListItem {sourceListItem}:{sourceKey} tieLine sourceport device key {sourcePortDeviceKey}",
+                 //   this,
+                 //   sli.Key,
+                 //   sli.Value.SourceKey,
+                 //   sourceTieLine.SourcePort.ParentDevice.Key);
+
+                return sli.Value.SourceKey.Equals(sourceTieLine.SourcePort.ParentDevice.Key,StringComparison.InvariantCultureIgnoreCase);
+            });            
+
+            var source = sourceListItem.Value;
+            var sourceKey = sourceListItem.Key;
+
+            if (source == null)
+            {
+                Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "No source found for device {key}. Creating transient source for {destination}", this, sourceTieLine.SourcePort.ParentDevice.Key, destination);
+
+                var tempSourceListItem = new SourceListItem
+                {
+                    SourceKey = "$transient",
+                    Name = sourceTieLine.SourcePort.Key,
+                };
+
+                destination.CurrentSourceInfoKey = "$transient";
+                destination.CurrentSourceInfo = tempSourceListItem;                
+                return;
+            }
+
+            //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Got Source {@source} with key {sourceKey}", this, source, sourceKey);
+
+            destination.CurrentSourceInfoKey = sourceKey;
+            destination.CurrentSourceInfo = source;
+            
+        }
+
+        private TieLine GetRootTieLine(TieLine tieLine)
+        {
+            TieLine nextTieLine = null;
+            try
+            {
+                //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "**Following tieLine {tieLine}**", this, tieLine);
+
+                if (tieLine.SourcePort.ParentDevice is IRoutingWithFeedback midpoint)
+                {
+                    // Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "TieLine Source device {sourceDevice} is midpoint", this, midpoint);
+
+                    if(midpoint.CurrentRoutes == null || midpoint.CurrentRoutes.Count == 0)
+                    {
+                        Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "Midpoint {midpointKey} has no routes",this, midpoint.Key);
+                        return null;
+                    }
+
+                    var currentRoute = midpoint.CurrentRoutes.FirstOrDefault(route => {
+                        //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Checking {route} against {tieLine}", this, route, tieLine);
+
+                        return route.OutputPort != null && route.InputPort != null && route.OutputPort?.Key == tieLine.SourcePort.Key && route.OutputPort?.ParentDevice.Key == tieLine.SourcePort.ParentDevice.Key;
+                    });
+
+                    if (currentRoute == null)
+                    {
+                        Debug.LogMessage(Serilog.Events.LogEventLevel.Information, "No route through midpoint {midpoint} for outputPort {outputPort}", this, midpoint.Key, tieLine.SourcePort);
+                        return null;
+                    }
+
+                    //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found currentRoute {currentRoute} through {midpoint}", this, currentRoute, midpoint);
+
+                    nextTieLine = TieLineCollection.Default.FirstOrDefault(tl => { 
+                        //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Checking {route} against {tieLine}", tl.DestinationPort.Key, currentRoute.InputPort.Key);
+                        return tl.DestinationPort.Key == currentRoute.InputPort.Key && tl.DestinationPort.ParentDevice.Key == currentRoute.InputPort.ParentDevice.Key; });
+
+                    if (nextTieLine != null)
+                    {
+                        //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found next tieLine {tieLine}. Walking the chain", this, nextTieLine);
+                        return GetRootTieLine(nextTieLine);
+                    }
+
+                    //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found root tieLine {tieLine}", this,nextTieLine);
+                    return nextTieLine;
+                }
+
+                //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "TieLIne Source Device {sourceDeviceKey} is IRoutingSource: {isIRoutingSource}", this, tieLine.SourcePort.ParentDevice.Key, tieLine.SourcePort.ParentDevice is IRoutingSource);
+                //Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "TieLine Source Device interfaces: {typeFullName}:{interfaces}", this, tieLine.SourcePort.ParentDevice.GetType().FullName, tieLine.SourcePort.ParentDevice.GetType().GetInterfaces().Select(i => i.Name));
+
+                if (tieLine.SourcePort.ParentDevice is IRoutingSource || tieLine.SourcePort.ParentDevice is IRoutingOutputs) //end of the chain
+                {
+                    // Debug.LogMessage(Serilog.Events.LogEventLevel.Verbose, "Found root: {tieLine}", this, tieLine);
+                    return tieLine;
+                }
+
+                nextTieLine = TieLineCollection.Default.FirstOrDefault(tl => tl.DestinationPort.Key == tieLine.SourcePort.Key && tl.DestinationPort.ParentDevice.Key == tieLine.SourcePort.ParentDevice.Key );
+
+                if (nextTieLine != null)
+                {
+                    return GetRootTieLine(nextTieLine);
+                }
+            } catch (Exception ex)
+            {
+                Debug.LogMessage(ex, "Error walking tieLines: {Exception}", this, ex);
+                return null;
+            }
+
+            return null;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Routing/RoutingInputPort.cs

@@ -0,0 +1,82 @@
+using System;
+
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Basic RoutingInput with no statuses.
+    /// </summary>
+    public class RoutingInputPort : RoutingPort
+	{
+		/// <summary>
+		/// The IRoutingInputs object this lives on
+		/// </summary>
+		public IRoutingInputs ParentDevice { get; private set; }
+
+		/// <summary>
+		/// Constructor for a basic RoutingInputPort
+		/// </summary>
+		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+		/// May be string, number, whatever</param>
+		/// <param name="parent">The IRoutingInputs object this lives on</param>
+		public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+			object selector, IRoutingInputs parent)
+			: this (key, type, connType, selector, parent, false)
+		{
+		}
+
+		/// <summary>
+		/// Constructor for a virtual routing input port that lives inside a device. For example
+		/// the ports that link a DM card to a DM matrix bus
+		/// </summary>
+		/// <param name="isInternal">true for internal ports</param>
+		public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+			object selector, IRoutingInputs parent, bool isInternal)
+			: base(key, type, connType, selector, isInternal)
+		{
+			if (parent == null)
+				throw new ArgumentNullException(nameof(parent));
+			ParentDevice = parent;
+		}
+
+        public override string ToString()
+        {
+            return $"{ParentDevice.Key}|{Key}|{Type}|{ConnectionType}";
+        }
+    }
+
+    /*/// <summary>
+    /// Basic RoutingInput with no statuses.
+    /// </summary>
+    public class RoutingInputPort<TSelector> : RoutingPort<TSelector>
+    {
+        /// <summary>
+        /// The IRoutingInputs object this lives on
+        /// </summary>
+        public IRoutingInputs<TSelector> ParentDevice { get; private set; }
+
+        /// <summary>
+        /// Constructor for a basic RoutingInputPort
+        /// </summary>
+        /// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+        /// May be string, number, whatever</param>
+        /// <param name="parent">The IRoutingInputs object this lives on</param>
+        public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+            TSelector selector, IRoutingInputs<TSelector> parent)
+            : this(key, type, connType, selector, parent, false)
+        {
+        }
+
+        /// <summary>
+        /// Constructor for a virtual routing input port that lives inside a device. For example
+        /// the ports that link a DM card to a DM matrix bus
+        /// </summary>
+        /// <param name="isInternal">true for internal ports</param>
+        public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+            TSelector selector, IRoutingInputs<TSelector> parent, bool isInternal)
+            : base(key, type, connType, selector, isInternal)
+        {
+            ParentDevice = parent ?? throw new ArgumentNullException(nameof(parent));
+        }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/RoutingInputPortWithVideoStatuses.cs

@@ -0,0 +1,30 @@
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// A RoutingInputPort for devices like DM-TX and DM input cards. 
+    /// Will provide video statistics on connected signals
+    /// </summary>
+    public class RoutingInputPortWithVideoStatuses : RoutingInputPort
+	{
+		/// <summary>
+		/// Video statuses attached to this port
+		/// </summary>
+		public VideoStatusOutputs VideoStatus { get; private set; }
+
+		/// <summary>
+		/// Constructor 
+		/// </summary>
+		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+		/// May be string, number, whatever</param>
+		/// <param name="parent">The IRoutingInputs object this lives on</param>
+		/// <param name="funcs">A VideoStatusFuncsWrapper used to assign the callback funcs that will get 
+		/// the values for the various stats</param>
+		public RoutingInputPortWithVideoStatuses(string key, 
+			eRoutingSignalType type, eRoutingPortConnectionType connType, object selector, 
+			IRoutingInputs parent, VideoStatusFuncsWrapper funcs) :
+			base(key, type, connType, selector, parent)
+		{
+			VideoStatus = new VideoStatusOutputs(funcs);		
+		}
+	}
+}

src/PepperDash.Essentials.Core/Routing/RoutingInterfaces.cs

@@ -1,203 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DM;
-
-using PepperDash.Core;
-
-
-namespace PepperDash.Essentials.Core
-{
-
-    /// <summary>
-    /// The handler type for a Room's SourceInfoChange
-    /// </summary>
-    public delegate void SourceInfoChangeHandler(/*EssentialsRoomBase room,*/ SourceListItem info, ChangeType type);
-
-
-	//*******************************************************************************************
-	// Interfaces
-
-    /// <summary>
-    /// For rooms with a single presentation source, change event
-    /// </summary>
-    public interface IHasCurrentSourceInfoChange
-    {
-        string CurrentSourceInfoKey { get; set; }
-        SourceListItem CurrentSourceInfo { get; set; }
-        event SourceInfoChangeHandler CurrentSourceChange;
-    }
-
-	/// <summary>
-	/// Defines a class that has a collection of RoutingInputPorts
-	/// </summary>
-	public interface IRoutingInputs : IKeyed
-	{
-		RoutingPortCollection<RoutingInputPort> InputPorts { get; }
-	}
-
-	/// <summary>
-	/// Defines a class that has a collection of RoutingOutputPorts
-	/// </summary>
-
-	public interface IRoutingOutputs : IKeyed
-	{
-		RoutingPortCollection<RoutingOutputPort> OutputPorts { get; }
-	}
-
-    /// <summary>
-    /// For fixed-source endpoint devices
-    /// </summary>
-    public interface IRoutingSink : IRoutingInputs, IHasCurrentSourceInfoChange
-    {
-
-    }
-
-	/// <summary>
-	/// Endpoint device like a display, that selects inputs
-	/// </summary>
-    public interface IRoutingSinkWithSwitching : IRoutingSink
-	{
-		//void ClearRoute();
-		void ExecuteSwitch(object inputSelector);
-	}
-
-	/// <summary>
-	/// For devices like RMCs, baluns, other devices with no switching.
-	/// </summary>
-	public interface IRoutingInputsOutputs : IRoutingInputs, IRoutingOutputs
-	{
-	}
-
-	/// <summary>
-	/// Defines a midpoint device as have internal routing.  Any devices in the middle of the
-	/// signal chain, that do switching, must implement this for routing to work otherwise
-	/// the routing algorithm will treat the IRoutingInputsOutputs device as a passthrough
-	/// device.
-	/// </summary>
-	public interface IRouting : IRoutingInputsOutputs
-	{
-		void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType);
-    }
-
-    public interface IRoutingWithClear : IRouting
-    {
-        /// <summary>
-        /// Clears a route to an output, however a device needs to do that
-        /// </summary>
-        /// <param name="outputSelector">Output to clear</param>
-        /// <param name="signalType">signal type to clear</param>
-        void ClearRoute(object outputSelector, eRoutingSignalType signalType);
-    }
-
-    public interface IRoutingNumeric : IRouting
-    {
-        void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type);
-    }
-
-    public interface ITxRouting : IRoutingNumeric
-    {
-        IntFeedback VideoSourceNumericFeedback { get; }
-        IntFeedback AudioSourceNumericFeedback { get; }
-    }
-
-    /// <summary>
-    /// Defines a receiver that has internal routing (DM-RMC-4K-Z-SCALER-C)
-    /// </summary>
-    public interface IRmcRouting : IRoutingNumeric
-    {
-        IntFeedback AudioVideoSourceNumericFeedback { get; }
-    }
-
-
-    /// <summary>
-    /// Defines an IRmcRouting with a feedback event 
-    /// </summary>
-    public interface ITxRoutingWithFeedback : ITxRouting
-    {
-    }
-
-    /// <summary>
-    /// Defines an IRmcRouting with a feedback event 
-    /// </summary>
-    public interface IRmcRoutingWithFeedback : IRmcRouting
-    {
-    }
-
-    /// <summary>
-	/// Defines an IRoutingOutputs devices as being a source - the start of the chain
-	/// </summary>
-	public interface IRoutingSource : IRoutingOutputs
-	{
-	}
-
-    /// <summary>
-    /// Defines an event structure for reporting output route data
-    /// </summary>
-    public interface IRoutingFeedback : IKeyName
-    {
-        event EventHandler<RoutingNumericEventArgs> NumericSwitchChange;
-        //void OnSwitchChange(RoutingNumericEventArgs e);
-    }
-
-    /// <summary>
-    /// Defines an IRoutingNumeric with a feedback event 
-    /// </summary>
-    public interface IRoutingNumericWithFeedback : IRoutingNumeric, IRoutingFeedback
-    {
-    }
-
-    /// <summary>
-    /// Defines an IRouting with a feedback event
-    /// </summary>
-    public interface IRoutingWithFeedback : IRouting, IRoutingFeedback
-    {
-        
-    }
-
-    public class RoutingNumericEventArgs : EventArgs
-    {
-
-        public uint? Output { get; set; }
-        public uint? Input { get; set; }
-
-        public eRoutingSignalType SigType { get; set; }
-        public RoutingInputPort InputPort { get; set; }
-        public RoutingOutputPort OutputPort { get; set; }
-
-        public RoutingNumericEventArgs(uint output, uint input, eRoutingSignalType sigType) : this(output, input, null, null, sigType)
-        {
-        }
-
-        public RoutingNumericEventArgs(RoutingOutputPort outputPort, RoutingInputPort inputPort,
-            eRoutingSignalType sigType)
-            : this(null, null, outputPort, inputPort, sigType)
-        {
-        }
-
-        public RoutingNumericEventArgs()
-            : this(null, null, null, null, 0)
-        {
- 
-        }
-
-        public RoutingNumericEventArgs(uint? output, uint? input, RoutingOutputPort outputPort,
-            RoutingInputPort inputPort, eRoutingSignalType sigType)
-        {
-            OutputPort = outputPort;
-            InputPort = inputPort;
-
-            Output = output;
-            Input = input;
-            SigType = sigType;
-        }
-    }
-
-	public interface IRoutingHasVideoInputSyncFeedbacks
-	{
-		FeedbackCollection<BoolFeedback> VideoInputSyncFeedbacks { get; }
-	}	
-}

src/PepperDash.Essentials.Core/Routing/RoutingNumericEventArgs.cs

@@ -0,0 +1,43 @@
+using System;
+
+
+namespace PepperDash.Essentials.Core
+{
+    public class RoutingNumericEventArgs : EventArgs
+    {
+
+        public uint? Output { get; set; }
+        public uint? Input { get; set; }
+
+        public eRoutingSignalType SigType { get; set; }
+        public RoutingInputPort InputPort { get; set; }
+        public RoutingOutputPort OutputPort { get; set; }
+
+        public RoutingNumericEventArgs(uint output, uint input, eRoutingSignalType sigType) : this(output, input, null, null, sigType)
+        {
+        }
+
+        public RoutingNumericEventArgs(RoutingOutputPort outputPort, RoutingInputPort inputPort,
+            eRoutingSignalType sigType)
+            : this(null, null, outputPort, inputPort, sigType)
+        {
+        }
+
+        public RoutingNumericEventArgs()
+            : this(null, null, null, null, 0)
+        {
+ 
+        }
+
+        public RoutingNumericEventArgs(uint? output, uint? input, RoutingOutputPort outputPort,
+            RoutingInputPort inputPort, eRoutingSignalType sigType)
+        {
+            OutputPort = outputPort;
+            InputPort = inputPort;
+
+            Output = output;
+            Input = input;
+            SigType = sigType;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Routing/RoutingOutputPort.cs

@@ -0,0 +1,75 @@
+using System;
+
+
+namespace PepperDash.Essentials.Core
+{
+    public class RoutingOutputPort : RoutingPort
+	{
+		/// <summary>
+		/// The IRoutingOutputs object this port lives on
+		/// </summary>
+		public IRoutingOutputs ParentDevice { get; private set; }
+
+		public InUseTracking InUseTracker { get; private set; }
+
+
+		/// <summary>
+		/// </summary>
+		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+		/// May be string, number, whatever</param>
+		/// <param name="parent">The IRoutingOutputs object this port lives on</param>
+		public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+			object selector, IRoutingOutputs parent)
+			: this(key, type, connType, selector, parent, false)
+		{
+		}
+
+		public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+			object selector, IRoutingOutputs parent, bool isInternal)
+			: base(key, type, connType, selector, isInternal)
+		{
+            ParentDevice = parent ?? throw new ArgumentNullException(nameof(parent));
+			InUseTracker = new InUseTracking();
+		}
+
+        public override string ToString()
+        {
+            return $"{ParentDevice.Key}|{Key}|{Type}|{ConnectionType}";
+        }
+	}
+
+    /*public class RoutingOutputPort<TSelector> : RoutingPort<TSelector>
+    {
+        /// <summary>
+        /// The IRoutingOutputs object this port lives on
+        /// </summary>
+        public IRoutingOutputs ParentDevice { get; private set; }
+
+        public InUseTracking InUseTracker { get; private set; }
+
+
+        /// <summary>
+        /// </summary>
+        /// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
+        /// May be string, number, whatever</param>
+        /// <param name="parent">The IRoutingOutputs object this port lives on</param>
+        public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+            TSelector selector, IRoutingOutputs parent)
+            : this(key, type, connType, selector, parent, false)
+        {
+        }
+
+        public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
+            TSelector selector, IRoutingOutputs parent, bool isInternal)
+            : base(key, type, connType, selector, isInternal)
+        {
+            ParentDevice = parent ?? throw new ArgumentNullException(nameof(parent));
+            InUseTracker = new InUseTracking();
+        }
+
+        public override string ToString()
+        {
+            return ParentDevice.Key + ":" + Key;
+        }
+    }*/
+}

src/PepperDash.Essentials.Core/Routing/RoutingPort.cs

@@ -1,15 +1,12 @@
-using System;
-using System.Collections.Generic;
-
-using PepperDash.Core;
+using PepperDash.Core;
 
 
 namespace PepperDash.Essentials.Core
 {
-	/// <summary>
-	/// Base class for RoutingInput and Output ports
-	/// </summary>
-	public abstract class RoutingPort : IKeyed
+    /// <summary>
+    /// Base class for RoutingInput and Output ports
+    /// </summary>
+    public abstract class RoutingPort : IKeyed
 	{
 		public string Key { get; private set; }
 		public eRoutingSignalType Type { get; private set; }
@@ -26,183 +23,26 @@ namespace PepperDash.Essentials.Core
 			ConnectionType = connType;
 			Selector = selector;
 			IsInternal = isInternal;
-		}
-	}
+		}        
+    }
 
-    [Flags]
-	public enum eRoutingSignalType
-	{
-		Audio = 1,
-		Video = 2,     
-		AudioVideo = Audio | Video,
-        UsbOutput = 8,
-        UsbInput = 16,
-        SecondaryAudio = 32
-	}
+    /*public abstract class RoutingPort<TSelector>:IKeyed
+    {
+        public string Key { get; private set; }
+        public eRoutingSignalType Type { get; private set; }
+        public eRoutingPortConnectionType ConnectionType { get; private set; }
+        public readonly TSelector Selector;
+        public bool IsInternal { get; private set; }
+        public object FeedbackMatchObject { get; set; }
+        public object Port { get; set; }
 
-	public enum eRoutingPortConnectionType
-	{
-		None, BackplaneOnly, DisplayPort, Dvi, Hdmi, Rgb, Vga, LineAudio, DigitalAudio, Sdi, 
-		Composite, Component, DmCat, DmMmFiber, DmSmFiber, Speaker, Streaming, UsbC, HdBaseT
-	}
-
-	/// <summary>
-	/// Basic RoutingInput with no statuses.
-	/// </summary>
-	public class RoutingInputPort : RoutingPort
-	{
-		/// <summary>
-		/// The IRoutingInputs object this lives on
-		/// </summary>
-		public IRoutingInputs ParentDevice { get; private set; }
-
-		/// <summary>
-		/// Constructor for a basic RoutingInputPort
-		/// </summary>
-		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
-		/// May be string, number, whatever</param>
-		/// <param name="parent">The IRoutingInputs object this lives on</param>
-		public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
-			object selector, IRoutingInputs parent)
-			: this (key, type, connType, selector, parent, false)
-		{
-		}
-
-		/// <summary>
-		/// Constructor for a virtual routing input port that lives inside a device. For example
-		/// the ports that link a DM card to a DM matrix bus
-		/// </summary>
-		/// <param name="isInternal">true for internal ports</param>
-		public RoutingInputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
-			object selector, IRoutingInputs parent, bool isInternal)
-			: base(key, type, connType, selector, isInternal)
-		{
-			if (parent == null)
-				throw new ArgumentNullException("parent");
-			ParentDevice = parent;
-		}
-
-
-
-
-		///// <summary>
-		///// Static method to get a named port from a named device
-		///// </summary>
-		///// <returns>Returns null if device or port doesn't exist</returns>
-		//public static RoutingInputPort GetDevicePort(string deviceKey, string portKey)
-		//{
-		//    var sourceDev = DeviceManager.GetDeviceForKey(deviceKey) as IRoutingInputs;
-		//    if (sourceDev == null)
-		//        return null;
-		//    return sourceDev.InputPorts[portKey];
-		//}
-
-		///// <summary>
-		///// Static method to get a named port from a card in a named ICardPortsDevice device
-		///// Uses ICardPortsDevice.GetChildInputPort 
-		///// </summary>
-		///// <param name="cardKey">'input-N'</param>
-		///// <returns>null if device, card or port doesn't exist</returns>
-		//public static RoutingInputPort GetDeviceCardPort(string deviceKey, string cardKey, string portKey)
-		//{
-		//    var sourceDev = DeviceManager.GetDeviceForKey(deviceKey) as ICardPortsDevice;
-		//    if (sourceDev == null)
-		//        return null;
-		//    return sourceDev.GetChildInputPort(cardKey, portKey);
-		//}
-	}
-
-	/// <summary>
-	/// A RoutingInputPort for devices like DM-TX and DM input cards. 
-	/// Will provide video statistics on connected signals
-	/// </summary>
-	public class RoutingInputPortWithVideoStatuses : RoutingInputPort
-	{
-		/// <summary>
-		/// Video statuses attached to this port
-		/// </summary>
-		public VideoStatusOutputs VideoStatus { get; private set; }
-
-		/// <summary>
-		/// Constructor 
-		/// </summary>
-		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
-		/// May be string, number, whatever</param>
-		/// <param name="parent">The IRoutingInputs object this lives on</param>
-		/// <param name="funcs">A VideoStatusFuncsWrapper used to assign the callback funcs that will get 
-		/// the values for the various stats</param>
-		public RoutingInputPortWithVideoStatuses(string key, 
-			eRoutingSignalType type, eRoutingPortConnectionType connType, object selector, 
-			IRoutingInputs parent, VideoStatusFuncsWrapper funcs) :
-			base(key, type, connType, selector, parent)
-		{
-			VideoStatus = new VideoStatusOutputs(funcs);		
-		}
-	}
-
-	public class RoutingOutputPort : RoutingPort
-	{
-		/// <summary>
-		/// The IRoutingOutputs object this port lives on
-		/// </summary>
-		public IRoutingOutputs ParentDevice { get; private set; }
-
-		public InUseTracking InUseTracker { get; private set; }
-
-
-		/// <summary>
-		/// </summary>
-		/// <param name="selector">An object used to refer to this port in the IRouting device's ExecuteSwitch method.
-		/// May be string, number, whatever</param>
-		/// <param name="parent">The IRoutingOutputs object this port lives on</param>
-		public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
-			object selector, IRoutingOutputs parent)
-			: this(key, type, connType, selector, parent, false)
-		{
-		}
-
-		public RoutingOutputPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType,
-			object selector, IRoutingOutputs parent, bool isInternal)
-			: base(key, type, connType, selector, isInternal)
-		{
-			if (parent == null)
-				throw new ArgumentNullException("parent");
-			ParentDevice = parent;
-			InUseTracker = new InUseTracking();
-		}
-
-		public override string ToString()
-		{
-			return ParentDevice.Key + ":" + Key;
-		}
-
-		///// <summary>
-		///// Static method to get a named port from a named device
-		///// </summary>
-		///// <returns>Returns null if device or port doesn't exist</returns>
-		//public static RoutingOutputPort GetDevicePort(string deviceKey, string portKey)
-		//{
-		//    var sourceDev = DeviceManager.GetDeviceForKey(deviceKey) as IRoutingOutputs;
-		//    if (sourceDev == null)
-		//        return null;
-		//    var port = sourceDev.OutputPorts[portKey];
-		//    if (port == null)
-		//        Debug.LogMessage(LogEventLevel.Information, "WARNING: Device '{0}' does does not contain output port '{1}'", deviceKey, portKey);
-		//    return port;
-		//}
-
-		///// <summary>
-		///// Static method to get a named port from a card in a named ICardPortsDevice device
-		///// Uses ICardPortsDevice.GetChildOutputPort on that device
-		///// </summary>
-		///// <param name="cardKey">'input-N' or 'output-N'</param>
-		///// <returns>null if device, card or port doesn't exist</returns>
-		//public static RoutingOutputPort GetDeviceCardPort(string deviceKey, string cardKey, string portKey)
-		//{
-		//    var sourceDev = DeviceManager.GetDeviceForKey(deviceKey) as ICardPortsDevice;
-		//    if (sourceDev == null)
-		//        return null;
-		//    var port = sourceDev.GetChildOutputPort(cardKey, portKey);
-		//}
-	}
+        public RoutingPort(string key, eRoutingSignalType type, eRoutingPortConnectionType connType, TSelector selector, bool isInternal)
+        {
+            Key = key;
+            Type = type;
+            ConnectionType = connType;
+            Selector = selector;
+            IsInternal = isInternal;
+        }
+    }*/
 }

src/PepperDash.Essentials.Core/Routing/RoutingPortCollection.cs

@@ -23,4 +23,21 @@ namespace PepperDash.Essentials.Core
 			}
 		}
 	}
+
+/*    /// <summary>
+	/// Basically a List , with an indexer to find ports by key name
+	/// </summary>
+	public class RoutingPortCollection<T, TSelector> : List<T> where T : RoutingPort<TSelector>
+    {
+        /// <summary>
+        /// Case-insensitive port lookup linked to ports' keys
+        /// </summary>
+        public T this[string key]
+        {
+            get
+            {
+                return this.FirstOrDefault(i => i.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+            }
+        }
+    }*/
 }

src/PepperDash.Essentials.Core/Routing/RoutingPortNames.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 
-namespace PepperDash.Essentials.Core.Routing
+namespace PepperDash.Essentials.Core
 {
 	/// <summary>
 	/// These should correspond directly with the portNames var in the config tool.
@@ -239,5 +239,13 @@ namespace PepperDash.Essentials.Core.Routing
         /// HdBaseTOut
         /// </summary>
         public const string HdBaseTOut = "hdBaseTOut";
+        /// <summary>
+        /// SdiIn
+        /// </summary>
+        public const string SdiIn = "sdiIn";
+        /// <summary>
+        /// SdiOut
+        /// </summary>
+        public const string SdiOut = "sdiOut";
     }
 }

src/PepperDash.Essentials.Core/Routing/TieLine.cs

@@ -1,111 +1,107 @@
-using System;
+using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DM;
-
-using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core
 {
-	public class TieLine
-	{
-		public RoutingOutputPort SourcePort { get; private set; }
-		public RoutingInputPort DestinationPort { get; private set; }
-		//public int InUseCount { get { return DestinationUsingThis.Count; } }
+    public class TieLine
+    {
+        public RoutingOutputPort SourcePort { get; private set; }
+        public RoutingInputPort DestinationPort { get; private set; }
+        //public int InUseCount { get { return DestinationUsingThis.Count; } }
 
-		/// <summary>
-		/// Gets the type of this tie line.  Will either be the type of the desination port
-		/// or the type of OverrideType when it is set.
-		/// </summary>
-		public eRoutingSignalType Type
-		{
-			get
-			{
-				if (OverrideType.HasValue) return OverrideType.Value;
-				return DestinationPort.Type;
-			}
-		}
+        /// <summary>
+        /// Gets the type of this tie line.  Will either be the type of the desination port
+        /// or the type of OverrideType when it is set.
+        /// </summary>
+        public eRoutingSignalType Type
+        {
+            get
+            {
+                if (OverrideType.HasValue) return OverrideType.Value;
+                return DestinationPort.Type;
+            }
+        }
 
-		/// <summary>
-		/// Use this to override the Type property for the destination port. For example,
-		/// when the tie line is type AudioVideo, and the signal flow should be limited to
-		/// Audio-only or Video only, changing this type will alter the signal paths
-		/// available to the routing algorithm without affecting the actual Type
-		/// of the destination port.
-		/// </summary>
-		public eRoutingSignalType? OverrideType { get; set; }
+        /// <summary>
+        /// Use this to override the Type property for the destination port. For example,
+        /// when the tie line is type AudioVideo, and the signal flow should be limited to
+        /// Audio-only or Video only, changing this type will alter the signal paths
+        /// available to the routing algorithm without affecting the actual Type
+        /// of the destination port.
+        /// </summary>
+        public eRoutingSignalType? OverrideType { get; set; }
 
-		//List<IRoutingInputs> DestinationUsingThis = new List<IRoutingInputs>();
+        //List<IRoutingInputs> DestinationUsingThis = new List<IRoutingInputs>();
 
-		/// <summary>
-		/// For tie lines that represent internal links, like from cards to the matrix in a DM.
-		/// This property is true if SourcePort and DestinationPort IsInternal
-		/// property are both true
-		/// </summary>
-		public bool IsInternal { get { return SourcePort.IsInternal && DestinationPort.IsInternal; } }
-		public bool TypeMismatch { get { return SourcePort.Type != DestinationPort.Type; } }
-		public bool ConnectionTypeMismatch { get { return SourcePort.ConnectionType != DestinationPort.ConnectionType; } }
-		public string TypeMismatchNote { get; set; }
+        /// <summary>
+        /// For tie lines that represent internal links, like from cards to the matrix in a DM.
+        /// This property is true if SourcePort and DestinationPort IsInternal
+        /// property are both true
+        /// </summary>
+        public bool IsInternal { get { return SourcePort.IsInternal && DestinationPort.IsInternal; } }
+        public bool TypeMismatch { get { return SourcePort.Type != DestinationPort.Type; } }
+        public bool ConnectionTypeMismatch { get { return SourcePort.ConnectionType != DestinationPort.ConnectionType; } }
+        public string TypeMismatchNote { get; set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="sourcePort"></param>
-		/// <param name="destinationPort"></param>
-		public TieLine(RoutingOutputPort sourcePort, RoutingInputPort destinationPort)
-		{
-			if (sourcePort == null || destinationPort == null)
-				throw new ArgumentNullException("source or destination port");
-			SourcePort = sourcePort;
-			DestinationPort = destinationPort;
-		}
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="sourcePort"></param>
+        /// <param name="destinationPort"></param>
+        public TieLine(RoutingOutputPort sourcePort, RoutingInputPort destinationPort)
+        {
+            if (sourcePort == null || destinationPort == null)
+                throw new ArgumentNullException("source or destination port");
+            SourcePort = sourcePort;
+            DestinationPort = destinationPort;
+        }
 
-		/// <summary>
-		/// Creates a tie line with an overriding Type.  See help for OverrideType property for info
-		/// </summary>
-		/// <param name="overrideType">The signal type to limit the link to. Overrides DestinationPort.Type</param>
-		public TieLine(RoutingOutputPort sourcePort, RoutingInputPort destinationPort, eRoutingSignalType overrideType) :
-			this(sourcePort, destinationPort)
-		{
-			OverrideType = overrideType;
-		}
+        /// <summary>
+        /// Creates a tie line with an overriding Type.  See help for OverrideType property for info
+        /// </summary>
+        /// <param name="overrideType">The signal type to limit the link to. Overrides DestinationPort.Type</param>
+        public TieLine(RoutingOutputPort sourcePort, RoutingInputPort destinationPort, eRoutingSignalType overrideType) :
+            this(sourcePort, destinationPort)
+        {
+            OverrideType = overrideType;
+        }
 
-		/// <summary>
-		/// Will link up video status from supporting inputs to connected outputs
-		/// </summary>
-		public void Activate()
-		{
-			// Now does nothing
-		}
+        /// <summary>
+        /// Will link up video status from supporting inputs to connected outputs
+        /// </summary>
+        public void Activate()
+        {
+            // Now does nothing
+        }
 
-		public void Deactivate()
-		{
-			// Now does nothing
-		}
+        public void Deactivate()
+        {
+            // Now does nothing
+        }
 
-		public override string ToString()
-		{
-			return string.Format("Tie line: [{0}]{1} --> [{2}]{3}", SourcePort.ParentDevice.Key, SourcePort.Key,
-				DestinationPort.ParentDevice.Key, DestinationPort.Key);
-		}
-	}
+        public override string ToString()
+        {
+            return string.Format("Tie line: {0}:{1} --> {2}:{3} {4}", SourcePort.ParentDevice.Key, SourcePort.Key,
+                DestinationPort.ParentDevice.Key, DestinationPort.Key, Type.ToString());
+        }
+    }
 
-	//********************************************************************************
+    //********************************************************************************
 
-	public class TieLineCollection : List<TieLine>
-	{
-		public static TieLineCollection Default
-		{
-			get
-			{
-				if (_Default == null)
-					_Default = new TieLineCollection();
-				return _Default;
-			}
-		}
-		static TieLineCollection _Default;
-	}
+    public class TieLineCollection : List<TieLine>
+    {
+        public static TieLineCollection Default
+        {
+            get
+            {
+                if (_Default == null)
+                    _Default = new TieLineCollection();
+                return _Default;
+            }
+        }
+
+        [JsonIgnore]
+        private static TieLineCollection _Default;
+    }
 }

src/PepperDash.Essentials.Core/Routing/TieLineConfig.cs

@@ -30,7 +30,7 @@ namespace PepperDash.Essentials.Core.Config
 		/// <returns>null if config data does not match ports, cards or devices</returns>
 		public TieLine GetTieLine()
 		{
-			Debug.LogMessage(LogEventLevel.Information, "Build TieLine: {0}", this);
+			Debug.LogMessage(LogEventLevel.Information, "Build TieLine: {0}",null, this);
 			// Get the source device
 			var sourceDev = DeviceManager.GetDeviceForKey(SourceKey) as IRoutingOutputs;
 			if (sourceDev == null)
@@ -48,68 +48,29 @@ namespace PepperDash.Essentials.Core.Config
 			}
 
             //Get the source port
-            RoutingOutputPort sourceOutputPort = null;
-            //// If it's a card-based device, get the card and then the source port
-            //if (sourceDev is ICardPortsDevice)
-            //{
-            //    if (SourceCard == null)
-            //    {
-            //        LogError("Card missing from source device config");
-            //        return null;
-            //    }
-            //    sourceOutputPort = (sourceDev as ICardPortsDevice).GetChildOutputPort(SourceCard, SourcePort);
-            //    if (sourceOutputPort == null)
-            //    {
-            //        LogError("Source card does not contain port");
-            //        return null;
-            //    }
-            //}
-            //// otherwise it's a normal port device, get the source port
-            //else
-            //{
-				sourceOutputPort = sourceDev.OutputPorts[SourcePort];
-				if (sourceOutputPort == null)
-				{
-					LogError("Source does not contain port");
-					return null;
-				}
-            //}
+            var sourceOutputPort = sourceDev.OutputPorts[SourcePort];
 
+            if (sourceOutputPort == null)
+			{
+				LogError("Source does not contain port");
+				return null;
+			}
 
-			//Get the Destination port
-			RoutingInputPort destinationInputPort = null;
-            //// If it's a card-based device, get the card and then the Destination port
-            //if (destDev is ICardPortsDevice)
-            //{
-            //    if (DestinationCard == null)
-            //    {
-            //        LogError("Card missing from destination device config");
-            //        return null;
-            //    }
-            //    destinationInputPort = (destDev as ICardPortsDevice).GetChildInputPort(DestinationCard, DestinationPort);
-            //    if (destinationInputPort == null)
-            //    {
-            //        LogError("Destination card does not contain port");
-            //        return null;
-            //    }
-            //}
-            //// otherwise it's a normal port device, get the Destination port
-            //else
-            //{
-				destinationInputPort = destDev.InputPorts[DestinationPort];
-				if (destinationInputPort == null)
+            //Get the Destination port
+            var destinationInputPort = destDev.InputPorts[DestinationPort];
+
+            if (destinationInputPort == null)
 				{
 					LogError("Destination does not contain port");
 					return null;
-				}
-            //}
+				}            
 
 			return new TieLine(sourceOutputPort, destinationInputPort);
 		}
 
 		void LogError(string msg)
 		{
-			Debug.LogMessage(LogEventLevel.Debug, "WARNING: Cannot create tie line: {0}:\r   {1}", msg, this);
+			Debug.LogMessage(LogEventLevel.Error, "WARNING: Cannot create tie line: {message}:\r   {tieLineConfig}",null, msg, this);
 		}
 
 		public override string ToString()

src/PepperDash.Essentials.Core/Routing/eRoutingPortConnectionType.cs

@@ -0,0 +1,8 @@
+namespace PepperDash.Essentials.Core
+{
+    public enum eRoutingPortConnectionType
+	{
+		None, BackplaneOnly, DisplayPort, Dvi, Hdmi, Rgb, Vga, LineAudio, DigitalAudio, Sdi, 
+		Composite, Component, DmCat, DmMmFiber, DmSmFiber, Speaker, Streaming, UsbC, HdBaseT
+	}
+}

src/PepperDash.Essentials.Core/Routing/eRoutingSignalType.cs

@@ -0,0 +1,16 @@
+using System;
+
+
+namespace PepperDash.Essentials.Core
+{
+    [Flags]
+	public enum eRoutingSignalType
+	{
+		Audio = 1,
+		Video = 2,     
+		AudioVideo = Audio | Video,
+        UsbOutput = 8,
+        UsbInput = 16,
+        SecondaryAudio = 32
+	}
+}

src/PepperDash.Essentials.Core/Touchpanels/CrestronTouchpanelPropertiesConfig.cs

@@ -1,38 +1,74 @@
-namespace PepperDash.Essentials.Core
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core
 {
     public class CrestronTouchpanelPropertiesConfig
     {
+        [JsonProperty("control")]
+        public EssentialsControlPropertiesConfig ControlProperties { get; set; }
+
+        [JsonProperty("ipId", NullValueHandling = NullValueHandling.Ignore)]
         public string IpId { get; set; }
+
+        [JsonProperty("defaultRoomKey", NullValueHandling = NullValueHandling.Ignore)]
         public string DefaultRoomKey { get; set; }
+        
+        [JsonProperty("roomListKey", NullValueHandling = NullValueHandling.Ignore)]
         public string RoomListKey { get; set; }
+
+        [JsonProperty("sgdFile", NullValueHandling = NullValueHandling.Ignore)]
         public string SgdFile { get; set; }
+
+        [JsonProperty("projectName", NullValueHandling = NullValueHandling.Ignore)]
         public string ProjectName { get; set; }
-        public bool ShowVolumeGauge { get; set; }
-        public bool UsesSplashPage { get; set; }
-        public bool ShowDate { get; set; }
-        public bool ShowTime { get; set; }
+
+        [JsonProperty("showVolumeGauge", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? ShowVolumeGauge { get; set; }
+
+        [JsonProperty("usesSplashPage", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? UsesSplashPage { get; set; }
+
+        [JsonProperty("showDate", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? ShowDate { get; set; }
+
+        [JsonProperty("showTime", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? ShowTime { get; set; }
+
+        [JsonProperty("setup", NullValueHandling = NullValueHandling.Ignore)]
         public UiSetupPropertiesConfig Setup { get; set; }
+
+        [JsonProperty("headerStyle", NullValueHandling = NullValueHandling.Ignore)]
         public string HeaderStyle { get; set; }
-        public bool IncludeInFusionRoomHealth { get; set; }
-        public uint ScreenSaverTimeoutMin { get; set; }
-        public uint ScreenSaverMovePositionIntervalMs { get; set; }
+
+        [JsonProperty("includeInFusionRoomHealth", NullValueHandling = NullValueHandling.Ignore)]
+        public bool? IncludeInFusionRoomHealth { get; set; }
+
+        [JsonProperty("screenSaverTimeoutMin", NullValueHandling = NullValueHandling.Ignore)]
+        public uint? ScreenSaverTimeoutMin { get; set; }
+
+        [JsonProperty("screenSaverMovePositionIntervalMs", NullValueHandling = NullValueHandling.Ignore)]
+        public uint? ScreenSaverMovePositionIntervalMs { get; set; }
 
 
         /// <summary>
         /// The count of sources that will trigger the "additional" arrows to show on the SRL.
         /// Defaults to 5
         /// </summary>
-        public int SourcesOverflowCount { get; set; }
+        [JsonProperty("sourcesOverflowCount", NullValueHandling = NullValueHandling.Ignore)]
+        public int? SourcesOverflowCount { get; set; }
 
-        public CrestronTouchpanelPropertiesConfig()
+        public CrestronTouchpanelPropertiesConfig() : this(false) { }        
+
+        public CrestronTouchpanelPropertiesConfig(bool setDefaultValues = false)
         {
+            if(!setDefaultValues) { return; }
             SourcesOverflowCount = 5;
-            HeaderStyle = CrestronTouchpanelPropertiesConfig.Habanero;
+            HeaderStyle = Habanero;
 
             // Default values
             ScreenSaverTimeoutMin = 5;
             ScreenSaverMovePositionIntervalMs = 15000;
-        }
+        }        
 
         /// <summary>
         /// "habanero"
@@ -49,6 +85,7 @@
     /// </summary>
     public class UiSetupPropertiesConfig
     {
+        [JsonProperty("isVisible", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsVisible { get; set; }
     }
 }

src/PepperDash.Essentials.Core/Web/EssentialsWebApi.cs

@@ -89,7 +89,7 @@ namespace PepperDash.Essentials.Core.Web
                     Name = "DevList",
                     RouteHandler = new DevListRequestHandler()
                 },
-                new HttpCwsRoute("deviceCommands")
+                new HttpCwsRoute("deviceCommands/{deviceKey}")
                 {
                     Name = "DevJson",
                     RouteHandler = new DevJsonRequestHandler()
@@ -163,6 +163,11 @@ namespace PepperDash.Essentials.Core.Web
                 {
                     Name = "Load Config",
                     RouteHandler = new LoadConfigRequestHandler()
+                },
+                new HttpCwsRoute("getTielines")
+                {
+                    Name = "Get TieLines",
+                    RouteHandler = new GetTieLinesRequestHandler()
                 }
 
             };
@@ -233,32 +238,32 @@ namespace PepperDash.Essentials.Core.Web
 		/// </example>
 		public void GetPaths()
 		{
-			Debug.LogMessage(LogEventLevel.Verbose, this, "{0}", new String('-', 50));
+			Debug.LogMessage(LogEventLevel.Information, this, new string('-', 50));
 
 			var currentIp = CrestronEthernetHelper.GetEthernetParameter(
 				CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_IP_ADDRESS, 0);
 			
 			var hostname = CrestronEthernetHelper.GetEthernetParameter(
                     CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_HOSTNAME, 0);
+
+            var path = CrestronEnvironment.DevicePlatform == eDevicePlatform.Server
+                ? $"http(s)://{hostname}/VirtualControl/Rooms/{InitialParametersClass.RoomId}/cws{BasePath}"
+                : $"http(s)://{currentIp}/cws{BasePath}";
 			
-			var path = CrestronEnvironment.DevicePlatform == eDevicePlatform.Server 
-				? string.Format("http(s)://{0}/VirtualControl/Rooms/{1}/cws{2}", hostname, InitialParametersClass.RoomId, BasePath)
-				: string.Format("http(s)://{0}/cws{1}", currentIp, BasePath);
-			
-			Debug.LogMessage(LogEventLevel.Verbose, this, "Server:{0}", path);
+			Debug.LogMessage(LogEventLevel.Information, this, "Server:{path:l}", path);
 
 			var routeCollection = _server.GetRouteCollection();
 			if (routeCollection == null)
 			{
-				Debug.LogMessage(LogEventLevel.Verbose, this, "Server route collection is null");
+				Debug.LogMessage(LogEventLevel.Information, this, "Server route collection is null");
 				return;
 			}
-			Debug.LogMessage(LogEventLevel.Verbose, this, "Configured Routes:");
+			Debug.LogMessage(LogEventLevel.Information, this, "Configured Routes:");
 			foreach (var route in routeCollection)
 			{
-				Debug.LogMessage(LogEventLevel.Verbose, this, "{0}: {1}/{2}", route.Name, path, route.Url);
+				Debug.LogMessage(LogEventLevel.Information, this, "{routeName:l}: {routePath:l}/{routeUrl:l}", route.Name, path, route.Url);
 			}
-			Debug.LogMessage(LogEventLevel.Verbose, this, "{0}", new String('-', 50));
+			Debug.LogMessage(LogEventLevel.Information, this, new string('-', 50));
 		}
 	}
 }

src/PepperDash.Essentials.Core/Web/EssentialsWebApiHelpers.cs

@@ -7,11 +7,11 @@ using PepperDash.Core;
 
 namespace PepperDash.Essentials.Core.Web
 {
-	public class EssentialsWebApiHelpers
+	public static class EssentialsWebApiHelpers
 	{
-		public static string GetRequestBody(HttpCwsRequest request)
+		public static string GetRequestBody(this HttpCwsRequest request)
 		{
-			var bytes = new Byte[request.ContentLength];
+			var bytes = new byte[request.ContentLength];
 
 			request.InputStream.Read(bytes, 0, request.ContentLength);
 
@@ -22,8 +22,8 @@ namespace PepperDash.Essentials.Core.Web
 		{
 			return new
 			{
-				Name = assembly.Name,
-				Version = assembly.Version
+                assembly.Name,
+                assembly.Version
 			};
 		}
 
@@ -31,7 +31,7 @@ namespace PepperDash.Essentials.Core.Web
 		{
 			return new
 			{
-				Key = device.Key,
+                device.Key,
 				Name = (device is IKeyName)
 					? (device as IKeyName).Name
 					: "---"
@@ -80,7 +80,7 @@ namespace PepperDash.Essentials.Core.Web
 			{
 				Type = device.Key,
 				Description = device.Value.Description,
-				CType = device.Value.CType == null ? "---": device.Value.CType.ToString()
+				CType = device.Value.Type == null ? "---": device.Value.Type.ToString()
 			};
 		}
 	}

src/PepperDash.Essentials.Core/Web/RequestHandlers/AppDebugRequestHandler.cs

@@ -52,7 +52,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 				return;
 			}
 
-			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			var data = context.Request.GetRequestBody();
 			if (string.IsNullOrEmpty(data))
 			{
 				context.Response.StatusCode = 400;

src/PepperDash.Essentials.Core/Web/RequestHandlers/DevJsonRequestHandler.cs

@@ -1,5 +1,6 @@
 using System;
 using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Core.Web.RequestHandlers;
 using Serilog.Events;
@@ -25,28 +26,55 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 		/// <param name="context"></param>
 		protected override void HandlePost(HttpCwsContext context)
 		{
+            var routeData = context.Request.RouteData;
+
+            if(routeData == null)
+            {
+                context.Response.StatusCode = 400;
+                context.Response.StatusDescription = "Bad Request";
+                context.Response.End();
+
+                return;
+            }
+
+            if(!routeData.Values.TryGetValue("deviceKey", out var deviceKey))
+            {
+                context.Response.StatusCode = 400;
+                context.Response.StatusDescription = "Bad Request";
+                context.Response.End();
+
+                return;
+            }
+
 			if (context.Request.ContentLength < 0)
 			{
 				context.Response.StatusCode = 400;
-				context.Response.StatusDescription = "Bad Request";
+				context.Response.StatusDescription = "Bad Request: no body";
 				context.Response.End();
 
 				return;
 			}
 
-			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			var data = context.Request.GetRequestBody();
+
 			if (string.IsNullOrEmpty(data))
 			{
 				context.Response.StatusCode = 400;
-				context.Response.StatusDescription = "Bad Request";
+				context.Response.StatusDescription = "Bad Request: no body";
 				context.Response.End();
 
 				return;
 			}
 			
 			try
-			{
-				DeviceJsonApi.DoDeviceActionWithJson(data);
+			{                
+                var daw = new DeviceActionWrapper { DeviceKey = (string) deviceKey};
+
+                JsonConvert.PopulateObject(data, daw);
+
+                Debug.LogMessage(LogEventLevel.Verbose, "Device Action Wrapper: {@wrapper}", null, daw);
+
+				DeviceJsonApi.DoDeviceAction(daw);
 
 				context.Response.StatusCode = 200;
 				context.Response.StatusDescription = "OK";
@@ -54,12 +82,11 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 			}
 			catch (Exception ex)
 			{
-				Debug.LogMessage(LogEventLevel.Error, "Exception Message: {0}", ex.Message);
-				Debug.LogMessage(LogEventLevel.Verbose, "Exception Stack Trace: {0}", ex.StackTrace);
-				if(ex.InnerException != null) Debug.LogMessage(LogEventLevel.Error, "Exception Inner: {0}", ex.InnerException);
+				Debug.LogMessage(ex, "Error handling device command: {Exception}");				
 
 				context.Response.StatusCode = 400;
 				context.Response.StatusDescription = "Bad Request";
+                context.Response.Write(JsonConvert.SerializeObject(new { error = ex.Message }), false);
 				context.Response.End();
 			}
 		}

src/PepperDash.Essentials.Core/Web/RequestHandlers/DevListRequestHandler.cs

@@ -34,7 +34,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 				return;
 			}
 
-			allDevices.Sort((a, b) => System.String.Compare(a.Key, b.Key, System.StringComparison.Ordinal));
+			allDevices.Sort((a, b) => string.Compare(a.Key, b.Key, System.StringComparison.Ordinal));
 
 			var deviceList = allDevices.Select(d => EssentialsWebApiHelpers.MapToDeviceListObject(d)).ToList();
 

src/PepperDash.Essentials.Core/Web/RequestHandlers/DevMethodsRequestHandler.cs

@@ -1,6 +1,7 @@
 using System.Text;
 using Crestron.SimplSharp.WebScripting;
 using Newtonsoft.Json;
+using PepperDash.Core;
 using PepperDash.Core.Web.RequestHandlers;
 
 namespace PepperDash.Essentials.Core.Web.RequestHandlers
@@ -25,6 +26,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 		protected override void HandleGet(HttpCwsContext context)
 		{
             var routeData = context.Request.RouteData;
+            Debug.LogMessage(Serilog.Events.LogEventLevel.Debug, "Getting DevMethods: {@routeData}", routeData);
             if (routeData == null)
             {
                 context.Response.StatusCode = 400;

src/PepperDash.Essentials.Core/Web/RequestHandlers/DoNotLoadConfigOnNextBootRequestHandler.cs

@@ -52,7 +52,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 				return;
 			}
 
-			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			var data = context.Request.GetRequestBody();
 			if (string.IsNullOrEmpty(data))
 			{
 				context.Response.StatusCode = 400;

src/PepperDash.Essentials.Core/Web/RequestHandlers/GetTieLinesRequestHandler.cs

@@ -0,0 +1,33 @@
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+using System.Linq;
+using System.Text;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+    public class GetTieLinesRequestHandler : WebApiBaseRequestHandler
+    {
+        public GetTieLinesRequestHandler() : base(true) { }
+
+        protected override void HandleGet(HttpCwsContext context)
+        {
+            var tieLineString = JsonConvert.SerializeObject(TieLineCollection.Default.Select((tl) => new
+            {
+                sourceKey = tl.SourcePort.ParentDevice.Key,
+                sourcePort = tl.SourcePort.Key,
+                destinationKey = tl.DestinationPort.ParentDevice.Key,
+                destinationPort = tl.DestinationPort.Key,
+                type = tl.Type.ToString(),
+            }));
+
+            context.Response.StatusCode = 200;
+            context.Response.StatusDescription = "OK";
+            context.Response.ContentType = "application/json";
+            context.Response.ContentEncoding = Encoding.UTF8;
+            context.Response.Write(tieLineString, false);
+            context.Response.End();
+
+        }
+    }
+}

src/PepperDash.Essentials.Core/Web/RequestHandlers/SetDeviceStreamDebugRequestHandler.cs

@@ -89,7 +89,7 @@ namespace PepperDash.Essentials.Core.Web.RequestHandlers
 				return;
 			}
 
-			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			var data = context.Request.GetRequestBody();
 			if (data == null)
 			{
 				context.Response.StatusCode = 500;

src/PepperDash.Essentials.Devices.Common/Audio/GenericAudioOut.cs

@@ -8,7 +8,6 @@ using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 
-using PepperDash.Essentials.Core.Routing;
 using Serilog.Events;
 
 namespace PepperDash.Essentials.Devices.Common
@@ -18,6 +17,8 @@ namespace PepperDash.Essentials.Devices.Common
 	/// </summary>
 	public class GenericAudioOut : EssentialsDevice, IRoutingSink
 	{
+        public RoutingInputPort CurrentInputPort => AnyAudioIn;
+
         public event SourceInfoChangeHandler CurrentSourceChange;
 
         public string CurrentSourceInfoKey { get; set; }