Merge branch 'development' into feature/GenericHttpClientOptions

Feature: Add constructor to set client options

feature: Add overloaded methods to set Request Types for Client Requests

PepperDashEssentials/Audio/EssentialsVolumeLevelConfig.cs

@@ -55,7 +55,7 @@ namespace PepperDash.Essentials
                 return null;
             }
 
-            // DSP format: deviceKey--levelName, biampTesira-1--master
+            // DSP/DMPS format: deviceKey--levelName, biampTesira-1--master
             match = Regex.Match(DeviceKey, @"([-_\w]+)--(.+)");
             if (match.Success)
             {
@@ -67,6 +67,27 @@ namespace PepperDash.Essentials
                     if (dsp.LevelControlPoints.ContainsKey(levelTag)) // should always...
                         return dsp.LevelControlPoints[levelTag];
                 }
+
+                var dmps = DeviceManager.GetDeviceForKey(devKey) as DmpsAudioOutputController;
+                if (dmps != null)
+                {
+                    var levelTag = match.Groups[2].Value;
+                    switch (levelTag)
+                    {
+                        case "master":
+                            return dmps.MasterVolumeLevel;
+                        case "source":
+                            return dmps.SourceVolumeLevel;
+                        case "micsmaster":
+                            return dmps.MicsMasterVolumeLevel;
+                        case "codec1":
+                            return dmps.Codec1VolumeLevel;
+                        case "codec2":
+                            return dmps.Codec2VolumeLevel;
+                        default:
+                            return dmps.MasterVolumeLevel;
+                    }
+                }
                 // No volume for some reason. We have failed as developers
                 return null;
             }

PepperDashEssentials/ControlSystem.cs

@@ -13,6 +13,7 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.Fusion;
+using PepperDash.Essentials.Core.Web;
 using PepperDash.Essentials.Devices.Common;
 using PepperDash.Essentials.DM;
 using PepperDash.Essentials.Fusion;
@@ -46,28 +47,29 @@ namespace PepperDash.Essentials
         /// </summary>
         public override void InitializeSystem()
         {
-            _startTimer = new CTimer(StartSystem,StartupTime);
-
-
             // If the control system is a DMPS type, we need to wait to exit this method until all devices have had time to activate
             // to allow any HD-BaseT DM endpoints to register first.
-            if (Global.ControlSystemIsDmpsType)
+            bool preventInitializationComplete = Global.ControlSystemIsDmpsType;
+            if (preventInitializationComplete)
             {
                 Debug.Console(1, "******************* InitializeSystem() Entering **********************");
-
-                _initializeEvent = new CEvent();
-
+                _startTimer = new CTimer(StartSystem, preventInitializationComplete, StartupTime);
+                _initializeEvent = new CEvent(true, false);
                 DeviceManager.AllDevicesRegistered += (o, a) =>
                 {
                     _initializeEvent.Set();
-                    Debug.Console(1, "******************* InitializeSystem() Exiting **********************");
                 };
-
                 _initializeEvent.Wait(30000);
+                Debug.Console(1, "******************* InitializeSystem() Exiting **********************");
+                SystemMonitor.ProgramInitialization.ProgramInitializationComplete = true;
+            }
+            else
+            {
+                _startTimer = new CTimer(StartSystem, preventInitializationComplete, StartupTime);
             }
         }
 
-        private void StartSystem(object obj)
+        private void StartSystem(object preventInitialization)
         {
             DeterminePlatform();
 
@@ -79,36 +81,41 @@ namespace PepperDash.Essentials
 
             CrestronConsole.AddNewConsoleCommand(PluginLoader.ReportAssemblyVersions, "reportversions", "Reports the versions of the loaded assemblies", ConsoleAccessLevelEnum.AccessOperator);
 
-            CrestronConsole.AddNewConsoleCommand(PepperDash.Essentials.Core.DeviceFactory.GetDeviceFactoryTypes, "gettypes", "Gets the device types that can be built. Accepts a filter string.", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(Core.DeviceFactory.GetDeviceFactoryTypes, "gettypes", "Gets the device types that can be built. Accepts a filter string.", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(BridgeHelper.PrintJoinMap, "getjoinmap", "map(s) for bridge or device on bridge [brKey [devKey]]", ConsoleAccessLevelEnum.AccessOperator);
 
-            CrestronConsole.AddNewConsoleCommand(s =>
-            {
-                Debug.Console(0, Debug.ErrorLogLevel.Notice, "CONSOLE MESSAGE: {0}", s);
-            }, "appdebugmessage", "Writes message to log", ConsoleAccessLevelEnum.AccessOperator);
+            CrestronConsole.AddNewConsoleCommand(BridgeHelper.JoinmapMarkdown, "getjoinmapmarkdown"
+                , "generate markdown of map(s) for bridge or device on bridge [brKey [devKey]]", ConsoleAccessLevelEnum.AccessOperator);
+
+            CrestronConsole.AddNewConsoleCommand(s => Debug.Console(0, Debug.ErrorLogLevel.Notice, "CONSOLE MESSAGE: {0}", s), "appdebugmessage", "Writes message to log", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(s =>
             {
                 foreach (var tl in TieLineCollection.Default)
-                    CrestronConsole.ConsoleCommandResponse("  {0}\r\n", tl);
+                    CrestronConsole.ConsoleCommandResponse("  {0}{1}", tl, CrestronEnvironment.NewLine);
             },
             "listtielines", "Prints out all tie lines", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(s =>
             {
                 CrestronConsole.ConsoleCommandResponse
-                    ("Current running configuration. This is the merged system and template configuration");
+                    ("Current running configuration. This is the merged system and template configuration" + CrestronEnvironment.NewLine);
                 CrestronConsole.ConsoleCommandResponse(Newtonsoft.Json.JsonConvert.SerializeObject
                     (ConfigReader.ConfigObject, Newtonsoft.Json.Formatting.Indented));
             }, "showconfig", "Shows the current running merged config", ConsoleAccessLevelEnum.AccessOperator);
 
             CrestronConsole.AddNewConsoleCommand(s =>
-            {
-                CrestronConsole.ConsoleCommandResponse("This system can be found at the following URLs:\r\n" +
-                    "System URL:   {0}\r\n" +
-                    "Template URL: {1}", ConfigReader.ConfigObject.SystemUrl, ConfigReader.ConfigObject.TemplateUrl);
-            }, "portalinfo", "Shows portal URLS from configuration", ConsoleAccessLevelEnum.AccessOperator);
+                CrestronConsole.ConsoleCommandResponse(
+                "This system can be found at the following URLs:{2}" +
+                "System URL:   {0}{2}" +
+                "Template URL: {1}{2}",
+                ConfigReader.ConfigObject.SystemUrl,
+                ConfigReader.ConfigObject.TemplateUrl,
+                CrestronEnvironment.NewLine),
+                "portalinfo",
+                "Shows portal URLS from configuration",
+                ConsoleAccessLevelEnum.AccessOperator);
 
 
             CrestronConsole.AddNewConsoleCommand(DeviceManager.GetRoutingPorts,
@@ -120,7 +127,10 @@ namespace PepperDash.Essentials
                 return;
             }
 
-            SystemMonitor.ProgramInitialization.ProgramInitializationComplete = true;
+            if (!(bool)preventInitialization)
+            {
+                SystemMonitor.ProgramInitialization.ProgramInitializationComplete = true;
+            }
         }
 
         /// <summary>
@@ -195,6 +205,8 @@ namespace PepperDash.Essentials
                 }
                 else   // Handles Linux OS (Virtual Control)
                 {
+                    Debug.SetDebugLevel(2);
+
                     Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on Virtual Control Server", Global.AssemblyVersion);
 
                     // Set path to User/
@@ -296,6 +308,10 @@ namespace PepperDash.Essentials
             if (!Directory.Exists(pluginDir))
                 Directory.Create(pluginDir);
 
+            var joinmapDir = Global.FilePathPrefix + "joinmaps";
+            if(!Directory.Exists(joinmapDir))
+                Directory.Create(joinmapDir);
+
 			return configExists;
 		}
 
@@ -343,6 +359,7 @@ namespace PepperDash.Essentials
 
             // Build the processor wrapper class
             DeviceManager.AddDevice(new PepperDash.Essentials.Core.Devices.CrestronProcessor("processor"));
+			DeviceManager.AddDevice(new EssemtialsWebApi("essentialsWebApi","Essentials Web API"));
 
             // Add global System Monitor device
             if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance)

PepperDashEssentials/Room/Types/EssentialsHuddleVtc1Room.cs

@@ -745,6 +745,28 @@ namespace PepperDash.Essentials
         {
             //Implement this
         }
+
+        protected override bool AllowVacancyTimerToStart()
+        {
+            bool allowVideo = true;
+            bool allowAudio = true;
+
+            if (VideoCodec != null)
+            {
+                Debug.Console(2,this, Debug.ErrorLogLevel.Notice, "Room {0} {1} in a video call", Key, VideoCodec.IsInCall ? "is" : "is not");
+                allowVideo = !VideoCodec.IsInCall;
+            }
+
+            if (AudioCodec != null)
+            {
+                Debug.Console(2,this, Debug.ErrorLogLevel.Notice, "Room {0} {1} in an audio call", Key, AudioCodec.IsInCall ? "is" : "is not");
+                allowAudio = !AudioCodec.IsInCall;
+            }
+
+            Debug.Console(2, this, "Room {0} allowing vacancy timer to start: {1}", Key, allowVideo && allowAudio);
+
+            return allowVideo && allowAudio;
+        }
         
         /// <summary>
         /// Does what it says

PepperDashEssentials/Room/Types/EssentialsTechRoom.cs

@@ -272,7 +272,7 @@ namespace PepperDash.Essentials
                 {
                     Debug.Console(2, this, 
 @"Attempting to run action:
-DeviceKey: {0}
+Key: {0}
 MethodName: {1}
 Params: {2}"
                     , a.DeviceKey, a.MethodName, a.Params);

PepperDashEssentials/Room/Types/IEssentialsHuddleSpaceRoom.cs

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

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

@@ -46,6 +46,33 @@ namespace PepperDash.Essentials.Core.Bridges
                 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.Console(0, "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);
+
+            }
+        }
     }
 
 
@@ -82,7 +109,7 @@ namespace PepperDash.Essentials.Core.Bridges
     {
         public EiscApiPropertiesConfig PropertiesConfig { get; private set; }
 
-        protected Dictionary<string, JoinMapBaseAdvanced> JoinMaps { get; private set; }
+        public Dictionary<string, JoinMapBaseAdvanced> JoinMaps { get; private set; }
 
         public BasicTriList Eisc { get; private set; }
 
@@ -138,7 +165,7 @@ namespace PepperDash.Essentials.Core.Bridges
 
                 Debug.Console(1, this, "Linking Device: '{0}'", device.Key);
 
-                if (!typeof (IBridgeAdvanced).IsAssignableFrom(device.GetType().GetCType()))
+                if (!typeof(IBridgeAdvanced).IsAssignableFrom(device.GetType().GetCType()))
                 {
                     Debug.Console(0, this, Debug.ErrorLogLevel.Notice,
                         "{0} is not compatible with this bridge type. Please use 'eiscapi' instead, or updae the device.",
@@ -227,6 +254,19 @@ namespace PepperDash.Essentials.Core.Bridges
                 joinMap.Value.PrintJoinMapInfo();
             }
         }
+        /// <summary>
+        /// Generates markdown for all join maps on this bridge
+        /// </summary>
+        public virtual void MarkdownForBridge(string bridgeKey)
+        {
+            Debug.Console(0, this, "Writing Joinmaps to files for EISC IPID: {0}", Eisc.ID.ToString("X"));
+
+            foreach (var joinMap in JoinMaps)
+            {
+                Debug.Console(0, "Generating markdown for device '{0}':", joinMap.Key);
+                joinMap.Value.MarkdownJoinMapInfo(joinMap.Key, bridgeKey);
+            }
+        }
 
         /// <summary>
         /// Prints the join map for a device by key
@@ -242,9 +282,26 @@ namespace PepperDash.Essentials.Core.Bridges
                 return;
             }
 
-            Debug.Console(0, "Join map for device '{0}' on EISC '{1}':", deviceKey, Key); 
+            Debug.Console(0, "Join map for device '{0}' on EISC '{1}':", deviceKey, Key);
             joinMap.PrintJoinMapInfo();
         }
+        /// <summary>
+        /// Prints the join map for a device by key
+        /// </summary>
+        /// <param name="deviceKey"></param>
+        public void MarkdownJoinMapForDevice(string deviceKey, string bridgeKey)
+        {
+            var joinMap = JoinMaps[deviceKey];
+
+            if (joinMap == null)
+            {
+                Debug.Console(0, this, "Unable to find joinMap for device with key: '{0}'", deviceKey);
+                return;
+            }
+
+            Debug.Console(0, "Join map for device '{0}' on EISC '{1}':", deviceKey, Key);
+            joinMap.MarkdownJoinMapInfo(deviceKey, bridgeKey);
+        }
 
         /// <summary>
         /// Used for debugging to trigger an action based on a join number and type
@@ -352,7 +409,7 @@ namespace PepperDash.Essentials.Core.Bridges
         public List<ApiDevicePropertiesConfig> Devices { get; set; }
 
         [JsonProperty("rooms")]
-        public List<ApiRoomPropertiesConfig> Rooms { get; set; } 
+        public List<ApiRoomPropertiesConfig> Rooms { get; set; }
 
 
         public class ApiDevicePropertiesConfig
@@ -385,7 +442,7 @@ namespace PepperDash.Essentials.Core.Bridges
     {
         public EiscApiAdvancedFactory()
         {
-            TypeNames = new List<string> { "eiscapiadv", "eiscapiadvanced", "eiscapiadvancedserver", "eiscapiadvancedclient",  "vceiscapiadv", "vceiscapiadvanced" };
+            TypeNames = new List<string> { "eiscapiadv", "eiscapiadvanced", "eiscapiadvancedserver", "eiscapiadvancedclient", "vceiscapiadv", "vceiscapiadvanced" };
         }
 
         public override EssentialsDevice BuildDevice(DeviceConfig dc)
@@ -394,35 +451,51 @@ namespace PepperDash.Essentials.Core.Bridges
 
             var controlProperties = CommFactory.GetControlPropertiesConfig(dc);
 
+            BasicTriList eisc;
+
             switch (dc.Type.ToLower())
             {
                 case "eiscapiadv":
                 case "eiscapiadvanced":
-                {
-                    var eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(controlProperties.IpIdInt,
-                        controlProperties.TcpSshProperties.Address, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
-                }
+                    {
+                        eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(controlProperties.IpIdInt,
+                            controlProperties.TcpSshProperties.Address, Global.ControlSystem);
+                        break;
+                    }
                 case "eiscapiadvancedserver":
-                {
-                    var eisc = new EISCServer(controlProperties.IpIdInt, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
-                }
+                    {
+                        eisc = new EISCServer(controlProperties.IpIdInt, Global.ControlSystem);
+                        break;
+                    }
                 case "eiscapiadvancedclient":
-                {
-                    var eisc = new EISCClient(controlProperties.IpIdInt, controlProperties.TcpSshProperties.Address, Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
-                }
+                    {
+                        eisc = new EISCClient(controlProperties.IpIdInt, controlProperties.TcpSshProperties.Address, Global.ControlSystem);
+                        break;
+                    }
                 case "vceiscapiadv":
                 case "vceiscapiadvanced":
-                {
-                    var eisc = new VirtualControlEISCClient(controlProperties.IpIdInt, InitialParametersClass.RoomId,
-                        Global.ControlSystem);
-                    return new EiscApiAdvanced(dc, eisc);
-                }
+                    {
+                        if (string.IsNullOrEmpty(controlProperties.RoomId))
+                        {
+                            Debug.Console(0, Debug.ErrorLogLevel.Error, "Unable to build VC-4 EISC Client for device {0}. Room ID is missing or empty", dc.Key);
+                            eisc = null;
+                            break;
+                        }
+                        eisc = new VirtualControlEISCClient(controlProperties.IpIdInt, controlProperties.RoomId,
+                            Global.ControlSystem);
+                        break;
+                    }
                 default:
-                    return null;
+                    eisc = null;
+                    break;
             }
+
+            if (eisc == null)
+            {
+                return null;
+            }
+
+            return new EiscApiAdvanced(dc, eisc);
         }
     }
 

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

@@ -36,6 +36,28 @@ namespace PepperDash.Essentials.Core.Bridges
         public JoinDataComplete AudioVideoSource = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
             new JoinMetadata { Description = "DM RMC Audio Video Source Set / Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
 
+        [JoinName("HdcpSupportCapability")]
+        public JoinDataComplete HdcpSupportCapability = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM RMC HDCP Support Capability", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("Port1HdcpState")]
+        public JoinDataComplete Port1HdcpState = new JoinDataComplete(new JoinData { JoinNumber = 3, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM RMC Port 1 (DM) HDCP State Set / Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("Port2HdcpState")]
+        public JoinDataComplete Port2HdcpState = new JoinDataComplete(new JoinData { JoinNumber = 4, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM TX Port 2 (HDMI) HDCP State Set / Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("HdmiInputSync")]
+        public JoinDataComplete HdmiInputSync = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM RMC HDMI Input Sync", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdcpInputPortCount")]
+        public JoinDataComplete HdcpInputPortCount = new JoinDataComplete(new JoinData { JoinNumber = 5, JoinSpan = 1 },
+            new JoinMetadata { Description = "Number of Input Ports that support HDCP", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Analog });
+
+
+
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it
         /// </summary>
@@ -50,7 +72,8 @@ namespace PepperDash.Essentials.Core.Bridges
         /// </summary>
         /// <param name="joinStart">Join this join map will start at</param>
         /// <param name="type">Type of the child join map</param>
-        protected DmRmcControllerJoinMap(uint joinStart, Type type) : base(joinStart, type)
+        protected DmRmcControllerJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
         {
         }
     }

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

@@ -64,6 +64,16 @@ namespace PepperDash.Essentials.Core.Bridges
         public JoinDataComplete VgaContrast = new JoinDataComplete(new JoinData { JoinNumber = 7, JoinSpan = 1 },
             new JoinMetadata { Description = "DM TX Online", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
 
+        [JoinName("Port3HdcpState")]
+        public JoinDataComplete Port3HdcpState = new JoinDataComplete(new JoinData { JoinNumber = 8, JoinSpan = 1 },
+            new JoinMetadata { Description = "DM TX Port 3 HDCP State Set / Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("HdcpInputPortCount")]
+        public JoinDataComplete HdcpInputPortCount = new JoinDataComplete(new JoinData { JoinNumber = 9, JoinSpan = 1 },
+            new JoinMetadata { Description = "Number of Input Ports that support HDCP", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Analog });
+
+
+
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it
         /// </summary>
@@ -78,7 +88,8 @@ namespace PepperDash.Essentials.Core.Bridges
         /// </summary>
         /// <param name="joinStart">Join this join map will start at</param>
         /// <param name="type">Type of the child join map</param>
-        protected DmTxControllerJoinMap(uint joinStart, Type type) : base(joinStart, type)
+        protected DmTxControllerJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
         {
         }
     }

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

@@ -0,0 +1,34 @@
+using System;
+
+namespace PepperDash.Essentials.Core.Bridges
+{
+    public class IAnalogInputJoinMap : JoinMapBaseAdvanced
+    {
+
+        [JoinName("InputValue")]
+        public JoinDataComplete InputValue = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "Input Value", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Analog });
+        [JoinName("MinimumChange")]
+        public JoinDataComplete MinimumChange = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+            new JoinMetadata { Description = "Minimum voltage change required to reflect a change", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        /// <summary>
+        /// Constructor to use when instantiating this Join Map without inheriting from it
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        public IAnalogInputJoinMap(uint joinStart)
+            : this(joinStart, typeof(IAnalogInputJoinMap))
+        {
+        }
+
+        /// <summary>
+        /// Constructor to use when extending this Join map
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        /// <param name="type">Type of the child join map</param>
+        protected IAnalogInputJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
+        {
+        }
+    }
+}

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

@@ -1,13 +1,13 @@
 using System;
 
-namespace PepperDash.Essentials.Core.Bridges
-{
-    public class IDigitalInputJoinMap : JoinMapBaseAdvanced
-    {
-
+namespace PepperDash.Essentials.Core.Bridges
+{
+    public class IDigitalInputJoinMap : JoinMapBaseAdvanced
+    {
+
         [JoinName("InputState")]
         public JoinDataComplete InputState = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
-            new JoinMetadata { Description = "Room Email Url", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+            new JoinMetadata { Description = "Input State", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
 
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it
@@ -26,6 +26,6 @@ namespace PepperDash.Essentials.Core.Bridges
         protected IDigitalInputJoinMap(uint joinStart, Type type)
             : base(joinStart, type)
         {
-        }
-    }
+        }
+    }
 }

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

@@ -0,0 +1,31 @@
+using System;
+
+namespace PepperDash.Essentials.Core.Bridges
+{
+    public class IDigitalOutputJoinMap : JoinMapBaseAdvanced
+    {
+
+        [JoinName("OutputState")]
+        public JoinDataComplete OutputState = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "Get / Set state of Digital Input", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        /// <summary>
+        /// Constructor to use when instantiating this Join Map without inheriting from it
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        public IDigitalOutputJoinMap(uint joinStart)
+            : this(joinStart, typeof(IDigitalOutputJoinMap))
+        {
+        }
+
+        /// <summary>
+        /// Constructor to use when extending this Join map
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        /// <param name="type">Type of the child join map</param>
+        protected IDigitalOutputJoinMap(uint joinStart, Type type)
+            : base(joinStart, type)
+        {
+        }
+    }
+}

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

@@ -47,7 +47,7 @@ namespace PepperDash.Essentials.Core.Bridges
         [JoinName("ProgramOffsetJoin")]
         public JoinDataComplete ProgramOffsetJoin = new JoinDataComplete(new JoinData { JoinNumber = 5, JoinSpan = 5 },
             new JoinMetadata { Description = "All Program Data is offset between slots by 5 - First Joins Start at 11", JoinCapabilities = eJoinCapabilities.None, JoinType = eJoinType.None });
-
+		
         [JoinName("ProgramStart")]
         public JoinDataComplete ProgramStart = new JoinDataComplete(new JoinData { JoinNumber = 11, JoinSpan = 1 },
             new JoinMetadata { Description = "Processor Program Start / Fb", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
@@ -132,6 +132,23 @@ namespace PepperDash.Essentials.Core.Bridges
         public JoinDataComplete DhcpStatus = new JoinDataComplete(new JoinData { JoinNumber = 86, JoinSpan = 1 },
             new JoinMetadata { Description = "Processor Ethernet Dhcp Status", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
 
+		[JoinName("ProcessorRebot")]
+		public JoinDataComplete ProcessorReboot = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+			new JoinMetadata { Description = "Reboot processor", JoinCapabilities = eJoinCapabilities.FromSIMPL, JoinType = eJoinType.Digital });
+
+		[JoinName("IsAppliance")]
+		public JoinDataComplete IsAppliance = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+			new JoinMetadata { Description = "Is appliance Fb", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+		[JoinName("IsServer")]
+		public JoinDataComplete IsServer = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+			new JoinMetadata { Description = "Is server Fb", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+		[JoinName("ProgramReset")]
+		public JoinDataComplete ProgramReset = new JoinDataComplete(new JoinData { JoinNumber = 15, JoinSpan = 1 },
+			new JoinMetadata { Description = "Resets the program", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+
         /// <summary>
         /// Constructor to use when instantiating this Join Map without inheriting from it
         /// </summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/CommFactory.cs

@@ -183,6 +183,8 @@ namespace PepperDash.Essentials.Core
         [JsonConverter(typeof(ComSpecJsonConverter))]
         public ComPort.ComPortSpec ComParams { get; set; }
 
+		public string RoomId { get; set; }
+
 		public string CresnetId { get; set; }
 
         /// <summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/GenericHttpClient.cs

@@ -1,11 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
+using System.ComponentModel;
 using Crestron.SimplSharp.Net.Http;
+using Crestron.SimplSharp.Ssh;
+using Crestron.SimplSharpPro.EthernetCommunication;
 using PepperDash.Core;
-using PepperDash.Core.DebugThings;
 
 namespace PepperDash.Essentials.Core
 {
@@ -17,52 +16,130 @@ namespace PepperDash.Essentials.Core
 		public GenericHttpClient(string key, string name, string hostname)
 			: base(key, name)
 		{
-			Client = new HttpClient();
-			Client.HostName = hostname;
-			
-			
+			Client = new HttpClient {HostName = hostname};
 		}
 
-		/// <summary>
-		/// 
+	    public GenericHttpClient(string key, string name, string hostname, GenericHttpClientConnectionOptions options)
+	        : base(key, name)
+	    {
+	        Client = new HttpClient
+	        {
+	            HostName = hostname,
+	            Accept = options.Accept,
+	            KeepAlive = options.KeepAlive,
+	            Password = options.Password,
+	            Timeout = options.Timeout,
+	            TimeoutEnabled = options.TimeoutEnabled,
+	            UserAgent = options.UserAgent,
+	            UserName = options.UserName,
+	            Version = options.Version
+	        };
+	        if (options.Port > 0) Client.Port = options.Port;
+	    }
+
+	    /// <summary>
+		/// Send a HTTP Get Request to a client
 		/// </summary>
-		/// <param name="path"></param>
-		public void SendText(string path)
-		{
-			HttpClientRequest request = new HttpClientRequest();
-			string url = string.Format("http://{0}/{1}", Client.HostName, path);
-			request.Url = new UrlParser(url);
-			HttpClient.DISPATCHASYNC_ERROR error = Client.DispatchAsyncEx(request, Response, request); 
-		}
-		public void SendText(string format, params object[] items)
-		{
-			HttpClientRequest request = new HttpClientRequest();
-			string url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
-			request.Url = new UrlParser(url);
-			HttpClient.DISPATCHASYNC_ERROR error = Client.DispatchAsyncEx(request, Response, request);
-		}
+		/// <param name="path">Path to request node</param>
+        public void SendText(string path)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, path);
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
 
-		public void SendTextNoResponse(string format, params object[] items)
-		{
-			HttpClientRequest request = new HttpClientRequest();
-			string url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
-			request.Url = new UrlParser(url);
-			Client.Dispatch(request);
-		}
+        /// <summary>
+        /// Send a HTTP Get Request to a client using a formatted string
+        /// </summary>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendText(string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send a unidirectional HTTP Get Request to a client using a formatted string
+        /// </summary>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendTextNoResponse(string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            Client.Dispatch(request);
+        }
+
+        /// <summary>
+        /// Send an HTTP Request of a specific request type
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="path">Path to request node</param>
+        public void SendText(RequestType requestType, string path)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, path);
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url),
+                RequestType = requestType
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send an HTTP Request of a specific request type using a formatted string
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendText(RequestType requestType, string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url),
+                RequestType = requestType
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send a unidirectional HTTP Request of a specific request type using a formatted string
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendTextNoResponse(RequestType requestType, string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            Client.Dispatch(request);
+        }
 
 		private void Response(HttpClientResponse response, HTTP_CALLBACK_ERROR error, object request)
 		{
-			if (error == HTTP_CALLBACK_ERROR.COMPLETED)
-			{
-				var responseReceived = response;
-
-				if (responseReceived.ContentString.Length > 0)
-				{
-					if (ResponseRecived != null)
-						ResponseRecived(this, new GenericHttpClientEventArgs(responseReceived.ContentString, (request as HttpClientRequest).Url.ToString(), error));
-				}
-			}
+		    if (error != HTTP_CALLBACK_ERROR.COMPLETED) return;
+		    var responseReceived = response;
 
+		    if (responseReceived.ContentString.Length <= 0) return;
+		    if (ResponseRecived == null) return;
+		    var httpClientRequest = request as HttpClientRequest;
+		    if (httpClientRequest != null)
+		        ResponseRecived(this, new GenericHttpClientEventArgs(responseReceived.ContentString, httpClientRequest.Url.ToString(), error));
 		}
 
 
@@ -100,6 +177,8 @@ namespace PepperDash.Essentials.Core
 
 		#endregion
 	}
+
+
 	public class GenericHttpClientEventArgs : EventArgs
 	{
 		public string ResponseText { get; private set; }
@@ -112,4 +191,84 @@ namespace PepperDash.Essentials.Core
 			Error = error;
 		}
 	}
+
+    /// <summary>
+    /// Objedct to set parameters for HTTP Requests
+    /// </summary>
+    public class GenericHttpClientConnectionOptions
+    {
+        /// <summary>
+        ///     Gets or sets content types that are acceptable for the response. The default
+        ///     value is "text/html, image/gif, image/jpeg, image/png, */*".
+        /// </summary>
+        [DefaultValue("text/html, image/gif, image/jpeg, image/png")]
+        public string Accept { get; set; }
+
+        /// <summary>
+        ///     Controls whether to use HTTP Keep-Alive to keep the connection alive between
+        ///     requests. If enabled (true) , once a request is made and a connection is
+        ///     established, this connection is kept open and used for future requests. If
+        ///     disabled, the connection is closed, and a new connection is created for future
+        ///     requests.
+        /// </summary>
+        [DefaultValue(true)]
+        public bool KeepAlive { get; set; }
+
+        /// <summary>
+        ///     This property controls whether the request operation will do an automatic
+        ///     timeout checking. If timeout handling is turned on (i.e. this property is
+        ///     set to true) and a request takes longer than Timeout, it will be terminated.
+        /// </summary>
+        [DefaultValue(true)]
+        public bool TimeoutEnabled { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the maximum amount of time (in seconds) that a client will wait
+        ///     for a server response within a single request. The default value is 60 seconds
+        ///     (1 minute).  The timeout handling can be activated via the TimeoutEnabled
+        ///     property.
+        /// </summary>
+        [DefaultValue(60)]
+        public int Timeout { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the version identifier of the UserAgent. Can be used to mimic
+        ///     particular browsers like Internet Explorer 6.0
+        /// </summary>
+        [DefaultValue("1.1")]
+        public string Version { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the identifier of the software being used to retrieve data via
+        ///     the URL. Some custom HTTP servers check this HTTP header to provide content
+        ///     optimized for particular HTTP browsers.
+        /// </summary>
+        [DefaultValue("Crestron SimplSharp HTTP Client")]
+        public string UserAgent { get; set; }
+
+        /// <summary>
+        ///    Name that will be inserted into the Authorization HTTP header in the request
+        ///    to the server.
+        /// </summary>
+        public string UserName { get; set; }
+
+        /// <summary>
+        ///     Password that will be inserted into the Authorization HTTP header in the
+        ///     request to the server.
+        /// </summary>
+        public string Password { get; set; }
+
+        /// <summary>
+        ///     The server Port that you intend the client to connect to.  If you do not
+        ///     assign a port number on this property, the port number in the parsed URL
+        ///     will be used. If a port number is assigned in the parsed URL, it will take
+        ///     precedence over this property.
+        /// </summary>
+        /// <remarks>
+        ///     If you do not assign a port number on this property, the port number in the
+        ///     parsed URL will be used.
+        /// </remarks>
+        /// 
+        public int Port { get; set; }
+    }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/DinIo8/DinIo8Controller.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    public class DinIo8Controller:CrestronGenericBaseDevice, IIOPorts
+    {
+        private DinIo8 _device;
+
+        public DinIo8Controller(string key, Func<DeviceConfig, DinIo8> preActivationFunc, DeviceConfig config):base(key, config.Name)
+        {
+            AddPreActivationAction(() =>
+            {
+                _device = preActivationFunc(config);
+
+                RegisterCrestronGenericBase(_device);
+            });
+        }
+
+        #region Implementation of IIOPorts
+
+        public CrestronCollection<Versiport> VersiPorts
+        {
+            get { return _device.VersiPorts; }
+        }
+
+        public int NumberOfVersiPorts
+        {
+            get { return _device.NumberOfVersiPorts; }
+        }
+
+        #endregion
+
+
+    }
+
+    public class DinIo8ControllerFactory : EssentialsDeviceFactory<DinIo8Controller>
+    {
+        public DinIo8ControllerFactory()
+        {
+            TypeNames = new List<string>() { "DinIo8" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new DinIo8 Device");
+
+            return new DinIo8Controller(dc.Key, GetDinIo8Device, dc);
+        }
+
+        static DinIo8 GetDinIo8Device(DeviceConfig dc)
+        {
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+            var cresnetId = control.CresnetIdInt;
+            var branchId = control.ControlPortNumber;
+            var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
+
+            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new DinIo8", parentKey);
+                return new DinIo8(cresnetId, Global.ControlSystem);
+            }
+            var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as IHasCresnetBranches;
+
+            if (cresnetBridge != null)
+            {
+                Debug.Console(0, "Device {0} is a valid cresnet master - creating new DinIo8", parentKey);
+                return new DinIo8(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+            }
+            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+            return null;
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/IOPortConfig.cs

@@ -15,5 +15,7 @@ namespace PepperDash.Essentials.Core.CrestronIO
         public uint PortNumber { get; set; }
         [JsonProperty("disablePullUpResistor")]
         public bool DisablePullUpResistor { get; set; }
+        [JsonProperty("minimumChange")]
+        public int MinimumChange { get; set; }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Inputs/GenericVersiportAnalogInputDevice.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Bridges;
+
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a generic digital input deviced tied to a versiport
+    /// </summary>
+    public class GenericVersiportAnalogInputDevice : EssentialsBridgeableDevice, IAnalogInput
+    {
+        public Versiport InputPort { get; private set; }
+
+        public IntFeedback InputValueFeedback { get; private set; }
+        public IntFeedback InputMinimumChangeFeedback { get; private set; }
+
+        Func<int> InputValueFeedbackFunc
+        {
+            get
+            {
+                return () => InputPort.AnalogIn;
+            }
+        }
+
+        Func<int> InputMinimumChangeFeedbackFunc
+        {
+            get { return () => InputPort.AnalogMinChange; }
+        } 
+
+        public GenericVersiportAnalogInputDevice(string key, string name, Func<IOPortConfig, Versiport> postActivationFunc, IOPortConfig config) :
+            base(key, name)
+        {
+            InputValueFeedback = new IntFeedback(InputValueFeedbackFunc);
+            InputMinimumChangeFeedback = new IntFeedback(InputMinimumChangeFeedbackFunc);
+
+            AddPostActivationAction(() =>
+            {
+                InputPort = postActivationFunc(config);
+
+                InputPort.Register();
+
+                InputPort.SetVersiportConfiguration(eVersiportConfiguration.AnalogInput);
+                InputPort.AnalogMinChange = (ushort)(config.MinimumChange > 0 ? config.MinimumChange : 655);
+                if (config.DisablePullUpResistor)
+                    InputPort.DisablePullUpResistor = true;
+
+                InputPort.VersiportChange += InputPort_VersiportChange;
+
+                Debug.Console(1, this, "Created GenericVersiportAnalogInputDevice on port '{0}'.  DisablePullUpResistor: '{1}'", config.PortNumber, InputPort.DisablePullUpResistor);
+
+            });
+
+        }
+
+        /// <summary>
+        /// Set minimum voltage change for device to update voltage changed method
+        /// </summary>
+        /// <param name="value">valid values range from 0 - 65535, representing the full 100% range of the processor voltage source.  Check processor documentation for details</param>
+        public void SetMinimumChange(ushort value)
+        {
+            InputPort.AnalogMinChange = value;
+        }
+
+        void InputPort_VersiportChange(Versiport port, VersiportEventArgs args)
+        {
+			Debug.Console(1, this, "Versiport change: {0}", args.Event);
+
+            if(args.Event == eVersiportEvent.AnalogInChange)
+                InputValueFeedback.FireUpdate();
+            if (args.Event == eVersiportEvent.AnalogMinChangeChange)
+                InputMinimumChangeFeedback.FireUpdate();
+        }
+
+
+        #region Bridge Linking
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new IAnalogInputJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<IAnalogInputJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            try
+            {
+                Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+                // Link feedback for input state
+                InputValueFeedback.LinkInputSig(trilist.UShortInput[joinMap.InputValue.JoinNumber]);
+                InputMinimumChangeFeedback.LinkInputSig(trilist.UShortInput[joinMap.MinimumChange.JoinNumber]);
+                trilist.SetUShortSigAction(joinMap.MinimumChange.JoinNumber, SetMinimumChange);
+
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, this, "Unable to link device '{0}'.  Input is null", Key);
+                Debug.Console(1, this, "Error: {0}", e);
+            }
+
+            trilist.OnlineStatusChange += (d, args) =>
+            {
+                if (!args.DeviceOnLine) return;
+                InputValueFeedback.FireUpdate();
+                InputMinimumChangeFeedback.FireUpdate();
+            };
+
+        }
+
+        void trilist_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+
+        public static Versiport GetVersiportDigitalInput(IOPortConfig dc)
+        {
+         
+            IIOPorts ioPortDevice;
+
+            if (dc.PortDeviceKey.Equals("processor"))
+            {
+                if (!Global.ControlSystem.SupportsVersiport)
+                {
+                    Debug.Console(0, "GetVersiportAnalogInput: Processor does not support Versiports");
+                    return null;
+                }
+                ioPortDevice = Global.ControlSystem;
+            }
+            else
+            {
+                var ioPortDev = DeviceManager.GetDeviceForKey(dc.PortDeviceKey) as IIOPorts;
+                if (ioPortDev == null)
+                {
+                    Debug.Console(0, "GetVersiportAnalogInput: Device {0} is not a valid device", dc.PortDeviceKey);
+                    return null;
+                }
+                ioPortDevice = ioPortDev;
+            }
+            if (ioPortDevice == null)
+            {
+                Debug.Console(0, "GetVersiportAnalogInput: Device '0' is not a valid IIOPorts Device", dc.PortDeviceKey);
+                return null;
+            }
+
+            if (dc.PortNumber > ioPortDevice.NumberOfVersiPorts)
+            {
+                Debug.Console(0, "GetVersiportAnalogInput: Device {0} does not contain a port {1}", dc.PortDeviceKey, dc.PortNumber);
+                return null;
+            }
+            if(!ioPortDevice.VersiPorts[dc.PortNumber].SupportsAnalogInput)
+            {
+                Debug.Console(0, "GetVersiportAnalogInput: Device {0} does not support AnalogInput on port {1}", dc.PortDeviceKey, dc.PortNumber);
+                return null;
+            }
+
+
+            return ioPortDevice.VersiPorts[dc.PortNumber];
+
+
+        }
+    }
+
+
+    public class GenericVersiportAbalogInputDeviceFactory : EssentialsDeviceFactory<GenericVersiportAnalogInputDevice>
+    {
+        public GenericVersiportAbalogInputDeviceFactory()
+        {
+            TypeNames = new List<string>() { "versiportanaloginput" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new Generic Versiport Device");
+
+            var props = JsonConvert.DeserializeObject<IOPortConfig>(dc.Properties.ToString());
+
+            if (props == null) return null;
+
+            var portDevice = new GenericVersiportAnalogInputDevice(dc.Key, dc.Name, GenericVersiportAnalogInputDevice.GetVersiportDigitalInput, props);
+
+            return portDevice;
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Inputs/IAnalogInput.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    public interface IAnalogInput
+    {
+        IntFeedback InputValueFeedback { get; }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Outputs/GenericVersiportOutputDevice.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.Bridges;
+
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a generic digital input deviced tied to a versiport
+    /// </summary>
+    public class GenericVersiportDigitalOutputDevice : EssentialsBridgeableDevice, IDigitalOutput
+    {
+        public Versiport OutputPort { get; private set; }
+
+        public BoolFeedback OutputStateFeedback { get; private set; }
+
+        Func<bool> OutputStateFeedbackFunc
+        {
+            get
+            {
+                return () => OutputPort.DigitalOut;
+            }
+        }
+
+        public GenericVersiportDigitalOutputDevice(string key, string name, Func<IOPortConfig, Versiport> postActivationFunc, IOPortConfig config) :
+            base(key, name)
+        {
+            OutputStateFeedback = new BoolFeedback(OutputStateFeedbackFunc);
+
+            AddPostActivationAction(() =>
+            {
+                OutputPort = postActivationFunc(config);
+
+                OutputPort.Register();
+
+
+                if (!OutputPort.SupportsDigitalOutput)
+                {
+                    Debug.Console(0, this, "Device does not support configuration as a Digital Output");
+                    return;
+                }
+
+                OutputPort.SetVersiportConfiguration(eVersiportConfiguration.DigitalOutput);
+
+
+                OutputPort.VersiportChange += OutputPort_VersiportChange;
+
+            });
+
+        }
+
+        void OutputPort_VersiportChange(Versiport port, VersiportEventArgs args)
+        {
+			Debug.Console(1, this, "Versiport change: {0}", args.Event);
+
+            if(args.Event == eVersiportEvent.DigitalOutChange)
+                OutputStateFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// Set value of the versiport digital output
+        /// </summary>
+        /// <param name="state">value to set the output to</param>
+        public void SetOutput(bool state)
+        {
+                if (OutputPort.SupportsDigitalOutput)
+                {
+                    Debug.Console(0, this, "Passed the Check");
+
+                    OutputPort.DigitalOut = state;
+
+                }
+                else
+                {
+                    Debug.Console(0, this, "Versiport does not support Digital Output Mode");
+                }
+
+        }
+
+        #region Bridge Linking
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new IDigitalOutputJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<IDigitalOutputJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            try
+            {
+                Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+                // Link feedback for input state
+                OutputStateFeedback.LinkInputSig(trilist.BooleanInput[joinMap.OutputState.JoinNumber]);
+                trilist.SetBoolSigAction(joinMap.OutputState.JoinNumber, SetOutput);
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, this, "Unable to link device '{0}'.  Input is null", Key);
+                Debug.Console(1, this, "Error: {0}", e);
+            }
+        }
+
+        #endregion
+
+
+        public static Versiport GetVersiportDigitalOutput(IOPortConfig dc)
+        {
+
+                IIOPorts ioPortDevice;
+
+                if (dc.PortDeviceKey.Equals("processor"))
+                {
+                    if (!Global.ControlSystem.SupportsVersiport)
+                    {
+                        Debug.Console(0, "GetVersiportDigitalOuptut: Processor does not support Versiports");
+                        return null;
+                    }
+                    ioPortDevice = Global.ControlSystem;
+                }
+                else
+                {
+                    var ioPortDev = DeviceManager.GetDeviceForKey(dc.PortDeviceKey) as IIOPorts;
+                    if (ioPortDev == null)
+                    {
+                        Debug.Console(0, "GetVersiportDigitalOuptut: Device {0} is not a valid device", dc.PortDeviceKey);
+                        return null;
+                    }
+                    ioPortDevice = ioPortDev;
+                }
+                if (ioPortDevice == null)
+                {
+                    Debug.Console(0, "GetVersiportDigitalOuptut: Device '0' is not a valid IOPorts Device", dc.PortDeviceKey);
+                    return null;
+                }
+
+                if (dc.PortNumber > ioPortDevice.NumberOfVersiPorts)
+                {
+                    Debug.Console(0, "GetVersiportDigitalOuptut: Device {0} does not contain a port {1}", dc.PortDeviceKey, dc.PortNumber);
+                }
+                var port = ioPortDevice.VersiPorts[dc.PortNumber];
+                return port;
+
+        }
+    }
+
+
+    public class GenericVersiportDigitalOutputDeviceFactory : EssentialsDeviceFactory<GenericVersiportDigitalInputDevice>
+    {
+        public GenericVersiportDigitalOutputDeviceFactory()
+        {
+            TypeNames = new List<string>() { "versiportoutput" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new Generic Versiport Device");
+
+            var props = JsonConvert.DeserializeObject<IOPortConfig>(dc.Properties.ToString());
+
+            if (props == null) return null;
+
+            var portDevice = new GenericVersiportDigitalOutputDevice(dc.Key, dc.Name, GenericVersiportDigitalOutputDevice.GetVersiportDigitalOutput, props);
+
+            return portDevice;
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Outputs/IDigitalOutput.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    /// <summary>
+    /// Represents a device that provides digital input
+    /// </summary>
+    public interface IDigitalOutput
+    {
+        BoolFeedback OutputStateFeedback { get; }
+        void SetOutput(bool state);
+    }
+}

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

@@ -379,30 +379,28 @@ namespace PepperDash.Essentials.Core
         /// Prints a list of routing inputs and outputs by device key.
         /// </summary>
         /// <param name="s">Device key from which to report data</param>
-	    public static void GetRoutingPorts(string s)
-	    {
-	        var device = GetDeviceForKey(s);
+        public static void GetRoutingPorts(string s)
+        {
+            var device = GetDeviceForKey(s);
 
             if (device == null) return;
             var inputPorts = ((device as IRoutingInputs) != null) ? (device as IRoutingInputs).InputPorts : null;
             var outputPorts = ((device as IRoutingOutputs) != null) ? (device as IRoutingOutputs).OutputPorts : null;
-	        if (inputPorts != null)
-	        {
-	            Debug.Console(0, "Device {0} has {1} Input Ports:", s, inputPorts.Count);
-	            foreach (var routingInputPort in inputPorts)
-	            {
-	                Debug.Console(0, "{0}", routingInputPort.Key);
-	            }
-	        }
-	        if (outputPorts != null)
-	        {
-	            Debug.Console(0, "Device {0} has {1} Output Ports:", s, outputPorts.Count);
-	            foreach (var routingOutputPort in outputPorts)
-	            {
-	                Debug.Console(0, "{0}", routingOutputPort.Key);
-	            }
-	        }
-	    }
+            if (inputPorts != null)
+            {
+                CrestronConsole.ConsoleCommandResponse("Device {0} has {1} Input Ports:{2}", s, inputPorts.Count, CrestronEnvironment.NewLine);
+                foreach (var routingInputPort in inputPorts)
+                {
+                    CrestronConsole.ConsoleCommandResponse("{0}{1}", routingInputPort.Key, CrestronEnvironment.NewLine);
+                }
+            }
+            if (outputPorts == null) return;
+            CrestronConsole.ConsoleCommandResponse("Device {0} has {1} Output Ports:{2}", s, outputPorts.Count, CrestronEnvironment.NewLine);
+            foreach (var routingOutputPort in outputPorts)
+            {
+                CrestronConsole.ConsoleCommandResponse("{0}{1}", routingOutputPort.Key, CrestronEnvironment.NewLine);
+            }
+        }
 
         /// <summary>
         /// Attempts to set the debug level of a device
@@ -435,7 +433,7 @@ namespace PepperDash.Essentials.Core
 
             if (device == null)
             {
-                Debug.Console(0, "Unable to get device with key: {0}", deviceKey);
+                CrestronConsole.ConsoleCommandResponse("Unable to get device with key: {0}", deviceKey);
                 return;
             }
 
@@ -447,7 +445,7 @@ namespace PepperDash.Essentials.Core
             }
             catch
             {
-                Debug.Console(0, "Unable to convert setting value.  Please use off/rx/tx/both");
+                CrestronConsole.ConsoleCommandResponse("Unable to convert setting value.  Please use off/rx/tx/both");
                 return;
             }
 
@@ -458,18 +456,18 @@ namespace PepperDash.Essentials.Core
                     var min = Convert.ToUInt32(timeout);
 
                     device.StreamDebugging.SetDebuggingWithSpecificTimeout(debugSetting, min);
-                    Debug.Console(0, "Device: '{0}' debug level set to {1} for {2} minutes", deviceKey, debugSetting, min);
+                    CrestronConsole.ConsoleCommandResponse("Device: '{0}' debug level set to {1} for {2} minutes", deviceKey, debugSetting, min);
 
                 }
                 catch (Exception e)
                 {
-                    Debug.Console(0, "Unable to convert minutes or settings value.  Please use an integer value for minutes. Errro: {0}", e);
+                    CrestronConsole.ConsoleCommandResponse("Unable to convert minutes or settings value.  Please use an integer value for minutes. Error: {0}", e);
                 }
             }
             else
             {
                 device.StreamDebugging.SetDebuggingWithDefaultTimeout(debugSetting);
-                Debug.Console(0, "Device: '{0}' debug level set to {1} for default time (30 minutes)", deviceKey, debugSetting);
+                CrestronConsole.ConsoleCommandResponse("Device: '{0}' debug level set to {1} for default time (30 minutes)", deviceKey, debugSetting);
             }
         }
 

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

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Crestron.SimplSharp;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
@@ -8,6 +9,7 @@ namespace PepperDash_Essentials_Core.Devices
     /// <summary>
     /// Interface for any device that is able to control it'spower and has a configurable reboot time
     /// </summary>
+    [Obsolete("PepperDash_Essentials_Core.Devices is Deprecated - use PepperDash.Essentials.Core")]
     public interface IHasPowerCycle : IKeyName, IHasPowerControlWithFeedback
     {
         /// <summary>
@@ -24,6 +26,7 @@ namespace PepperDash_Essentials_Core.Devices
     /// <summary>
     /// Interface for any device that contains a collection of IHasPowerReboot Devices
     /// </summary>
+    [Obsolete("PepperDash_Essentials_Core.Devices is Deprecated - use PepperDash.Essentials.Core")]
     public interface IHasControlledPowerOutlets : IKeyName
     {
         /// <summary>

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

@@ -0,0 +1,87 @@
+using Crestron.SimplSharp;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Interface for any device that has a battery that can be monitored
+    /// </summary>
+    public interface IHasBatteryStats : IKeyName
+    {
+        int BatteryPercentage { get; }
+        int BatteryCautionThresholdPercentage { get;  }
+        int BatteryWarningThresholdPercentage { get; }
+        BoolFeedback BatteryIsWarningFeedback { get; }
+        BoolFeedback BatteryIsCautionFeedback { get; }
+        BoolFeedback BatteryIsOkFeedback { get; }
+        IntFeedback BatteryPercentageFeedback { get; }
+    }
+
+    /// <summary>
+    /// Interface for any device that has a battery that can be monitored and the ability to charge and discharge
+    /// </summary>
+    public interface IHasBatteryCharging : IHasBatteryStats
+    {
+        BoolFeedback BatteryIsCharging { get; }
+    }
+
+    /// <summary>
+    /// Interface for any device that has multiple batteries that can be monitored
+    /// </summary>
+    public interface IHasBatteries : IKeyName
+    {
+        ReadOnlyDictionary<string, IHasBatteryStats> Batteries { get; }   
+    }
+
+    public interface IHasBatteryStatsExtended : IHasBatteryStats
+    {
+        int InputVoltage { get; }
+        int OutputVoltage { get; }
+        int InptuCurrent { get; }
+        int OutputCurrent { get; }
+
+        IntFeedback InputVoltageFeedback { get; }
+        IntFeedback OutputVoltageFeedback { get; }
+        IntFeedback InputCurrentFeedback { get; }
+        IntFeedback OutputCurrentFeedback { get; }
+    }
+
+    /// <summary>
+    /// Interface for any device that is able to control its power, has a configurable reboot time, and has batteries that can be monitored
+    /// </summary>
+    public interface IHasPowerCycleWithBattery : IHasPowerCycle, IHasBatteryStats
+    {
+        
+    }
+
+    /// <summary>
+    /// Interface for any device that is able to control it's power and has a configurable reboot time
+    /// </summary>
+    public interface IHasPowerCycle : IKeyName, IHasPowerControlWithFeedback
+    {
+        /// <summary>
+        /// Delay between power off and power on for reboot
+        /// </summary>
+        int PowerCycleTimeMs { get; }
+
+        /// <summary>
+        /// Reboot outlet
+        /// </summary>
+        void PowerCycle();
+    }
+
+    /// <summary>
+    /// Interface for any device that contains a collection of IHasPowerReboot Devices
+    /// </summary>
+    public interface IHasControlledPowerOutlets : IKeyName
+    {
+        /// <summary>
+        /// Collection of IPduOutlets
+        /// </summary>
+        ReadOnlyDictionary<int, IHasPowerCycle> PduOutlets { get; }
+
+    }
+
+
+
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Extensions/StringExtensions.cs

@@ -16,5 +16,9 @@ namespace PepperDash.Essentials.Core
         {
             return string.IsNullOrEmpty(s.Trim()) ? null : s;
         }
+        public static string ReplaceIfNullOrEmpty(this string s, string newString)
+        {
+            return string.IsNullOrEmpty(s) ? newString : s;
+        }
     }
 }

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

@@ -172,37 +172,42 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Prints the type names and associated metadata from the FactoryMethods collection.
         /// </summary>
-        /// <param name="command"></param>
+        /// <param name="filter"></param>
         public static void GetDeviceFactoryTypes(string filter)
         {
-            Dictionary<string, DeviceFactoryWrapper> types = new Dictionary<string, DeviceFactoryWrapper>();
+            var types = !string.IsNullOrEmpty(filter)
+                ? FactoryMethods.Where(k => k.Key.Contains(filter)).ToDictionary(k => k.Key, k => k.Value)
+                : FactoryMethods;
 
-            if (!string.IsNullOrEmpty(filter))
-            {
-                types = FactoryMethods.Where(k => k.Key.Contains(filter)).ToDictionary(k => k.Key, k => k.Value);
-            }
-            else
-            {
-                types = FactoryMethods;
-            }
-
-            Debug.Console(0, "Device Types:");
+            CrestronConsole.ConsoleCommandResponse("Device Types:");
 
             foreach (var type in types.OrderBy(t => t.Key))
             {
                 var description = type.Value.Description;
                 var cType = "Not Specified by Plugin";
 
-                if(type.Value.CType != null)
+                if (type.Value.CType != null)
                 {
                     cType = type.Value.CType.FullName;
                 }
 
-                Debug.Console(0, 
+                CrestronConsole.ConsoleCommandResponse(
                     @"Type: '{0}' 
                     CType: '{1}' 
                     Description: {2}", type.Key, cType, description);
             }
         }
+
+		/// <summary>
+		/// Returns the device factory dictionary
+		/// </summary>
+		/// <param name="filter"></param>
+		/// <returns></returns>
+	    public static Dictionary<string, DeviceFactoryWrapper> GetDeviceFactoryDictionary(string filter)
+		{
+			return string.IsNullOrEmpty(filter) 
+				? FactoryMethods
+				: FactoryMethods.Where(k => k.Key.Contains(filter)).ToDictionary(k => k.Key, k => k.Value);
+		}
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/File/FileIO.cs

@@ -21,35 +21,37 @@ namespace PepperDash.Essentials.Core
 		/// </summary>
 		/// <param name="fileName"></param>
 		/// <returns></returns>
-		public static FileInfo[] GetFiles(string fileName)
-		{
-			DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(fileName));
-			var files = dirInfo.GetFiles(Path.GetFileName(fileName));
-			Debug.Console(0, "FileIO found: {0}, {1}", files.Count(), fileName);
-			if (files.Count() > 0)
-			{
-				return files;
-			}
-			else
-			{
-				return null;
-			}
-		}
+        public static FileInfo[] GetFiles(string fileName)
+        {
+            string fullFilePath = Global.FilePathPrefix + fileName;
+            DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(fullFilePath));
+            var files = dirInfo.GetFiles(Path.GetFileName(fullFilePath));
+            Debug.Console(0, "FileIO found: {0}, {1}", files.Count(), fullFilePath);
+            if (files.Count() > 0)
+            {
+                return files;
+            }
+            else
+            {
+                return null;
+            }
+        }
 
-		public static FileInfo GetFile(string fileName)
-		{
-			DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(fileName));
-			var files = dirInfo.GetFiles(Path.GetFileName(fileName));
-			Debug.Console(0, "FileIO found: {0}, {1}", files.Count(), fileName);
-			if (files.Count() > 0)
-			{
-				return files.FirstOrDefault();
-			}
-			else
-			{
-				return null;
-			}
-		}
+        public static FileInfo GetFile(string fileName)
+        {
+            string fullFilePath = Global.FilePathPrefix + fileName;
+            DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(fullFilePath));
+            var files = dirInfo.GetFiles(Path.GetFileName(fullFilePath));
+            Debug.Console(0, "FileIO found: {0}, {1}", files.Count(), fullFilePath);
+            if (files.Count() > 0)
+            {
+                return files.FirstOrDefault();
+            }
+            else
+            {
+                return null;
+            }
+        }
 
 
 		/// <summary>
@@ -81,7 +83,7 @@ namespace PepperDash.Essentials.Core
 			{
 				if (fileLock.TryEnter())
 				{
-					DirectoryInfo dirInfo = new DirectoryInfo(file.Name);
+					DirectoryInfo dirInfo = new DirectoryInfo(file.DirectoryName);
 					Debug.Console(2, "FileIO Getting Data {0}", file.FullName);
 
 					if (File.Exists(file.FullName))
@@ -202,7 +204,7 @@ namespace PepperDash.Essentials.Core
 		public static void WriteDataToFile(string data, string filePath)
 		{
 			Thread _WriteFileThread;
-			_WriteFileThread = new Thread((O) => _WriteFileMethod(data, filePath), null, Thread.eThreadStartOptions.CreateSuspended);
+            _WriteFileThread = new Thread((O) => _WriteFileMethod(data, Global.FilePathPrefix + "/" + filePath), null, Thread.eThreadStartOptions.CreateSuspended);
 			_WriteFileThread.Priority = Thread.eThreadPriority.LowestPriority;
 			_WriteFileThread.Start();
 			Debug.Console(0, Debug.ErrorLogLevel.Notice, "New WriteFile Thread");
@@ -217,7 +219,8 @@ namespace PepperDash.Essentials.Core
 			{
 				if (fileLock.TryEnter())
 				{
-					using (StreamWriter sw = new StreamWriter(filePath))
+
+                    using (StreamWriter sw = new StreamWriter(filePath))
 					{
 						sw.Write(data);
 						sw.Flush();

essentials-framework/Essentials Core/PepperDashEssentialsBase/JoinMaps/JoinMapBase.cs

@@ -1,8 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
-using System.Runtime.InteropServices;
+using System.Text;
 using Crestron.SimplSharp.Reflection;
+using Crestron.SimplSharp.CrestronIO;
+using Crestron.SimplSharp;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core.Config;
@@ -98,22 +101,22 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         public void PrintJoinMapInfo()
         {
-            Debug.Console(0, "{0}:\n", GetType().Name);
+            CrestronConsole.ConsoleCommandResponse("{0}:\n", GetType().Name);
 
             // Get the joins of each type and print them
-            Debug.Console(0, "Digitals:");
+            CrestronConsole.ConsoleCommandResponse("Digitals:");
             var digitals = Joins.Where(j => (j.Value.JoinType & eJoinType.Digital) == eJoinType.Digital).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Digital Joins", digitals.Count); 
+            CrestronConsole.ConsoleCommandResponse("Found {0} Digital Joins", digitals.Count); 
             PrintJoinList(GetSortedJoins(digitals));
 
-            Debug.Console(0, "Analogs:");
+            CrestronConsole.ConsoleCommandResponse("Analogs:");
             var analogs = Joins.Where(j => (j.Value.JoinType & eJoinType.Analog) == eJoinType.Analog).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Analog Joins", analogs.Count); 
+            CrestronConsole.ConsoleCommandResponse("Found {0} Analog Joins", analogs.Count); 
             PrintJoinList(GetSortedJoins(analogs));
 
-            Debug.Console(0, "Serials:");
+            CrestronConsole.ConsoleCommandResponse("Serials:");
             var serials = Joins.Where(j => (j.Value.JoinType & eJoinType.Serial) == eJoinType.Serial).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Serial Joins", serials.Count);
+            CrestronConsole.ConsoleCommandResponse("Found {0} Serial Joins", serials.Count);
             PrintJoinList(GetSortedJoins(serials));
 
         }
@@ -136,7 +139,7 @@ namespace PepperDash.Essentials.Core
         {
             foreach (var join in joins)
             {
-                Debug.Console(0,
+                CrestronConsole.ConsoleCommandResponse(
                     @"Join Number: {0} | Label: '{1}' | JoinSpan: '{2}' | Type: '{3}' | Capabilities: '{4}'",
                         join.Value.JoinNumber,
                         join.Value.Label,
@@ -193,19 +196,6 @@ namespace PepperDash.Essentials.Core
 
         protected void AddJoins(Type type)
         {
-            // Add all the JoinDataComplete properties to the Joins Dictionary and pass in the offset 
-            //Joins = this.GetType()
-            //    .GetCType()
-            //    .GetFields(BindingFlags.Public | BindingFlags.Instance)
-            //    .Where(field => field.IsDefined(typeof(JoinNameAttribute), true))
-            //    .Select(field => (JoinDataComplete)field.GetValue(this))
-            //    .ToDictionary(join => join.GetNameAttribute(), join =>
-            //        {
-            //            join.SetJoinOffset(_joinOffset);
-            //            return join;
-            //        });
-
-            //type = this.GetType(); <- this wasn't working because 'this' was always the base class, never the derived class
             var fields =
                 type.GetCType()
                     .GetFields(BindingFlags.Public | BindingFlags.Instance)
@@ -219,7 +209,7 @@ namespace PepperDash.Essentials.Core
 
                 if (value == null)
                 {
-                    Debug.Console(0, "Unable to caset base class to {0}", type.Name);
+                    Debug.Console(0, "Unable to cast base class to {0}", type.Name);
                     continue;
                 }
 
@@ -244,23 +234,69 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         public void PrintJoinMapInfo()
         {
-            Debug.Console(0, "{0}:\n", GetType().Name);
+            var sb = JoinmapStringBuilder();
+
+            CrestronConsole.ConsoleCommandResponse(sb.ToString());
+        }
+
+        private StringBuilder JoinmapStringBuilder()
+        {
+            var sb = new StringBuilder();
 
             // Get the joins of each type and print them
-            Debug.Console(0, "Digitals:");
-            var digitals = Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Digital) == eJoinType.Digital).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Digital Joins", digitals.Count);
-            PrintJoinList(GetSortedJoins(digitals));
+            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();
 
-            Debug.Console(0, "Analogs:");
-            var analogs = Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Analog) == eJoinType.Analog).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Analog Joins", analogs.Count);
-            PrintJoinList(GetSortedJoins(analogs));
-            
-            Debug.Console(0, "Serials:");
-            var serials = Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Serial) == eJoinType.Serial).ToDictionary(j => j.Key, j => j.Value);
-            Debug.Console(2, "Found {0} Serial Joins", serials.Count);
-            PrintJoinList(GetSortedJoins(serials));
+            var analogs =
+                Joins.Where(j => (j.Value.Metadata.JoinType & eJoinType.Analog) == 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)
+                    .ToDictionary(j => j.Key, j => j.Value);
+            var serialSb = AppendJoinList(GetSortedJoins(serials));
+
+            sb.EnsureCapacity(sb.Length + digitalSb.Length + analogSb.Length + serialSb.Length);
+            sb.Append(digitalSb).Append(analogSb).Append(serialSb);
+            return sb;
+        }
+
+        /// <summary>
+        /// Prints the join information to console
+        /// </summary>
+        public void MarkdownJoinMapInfo(string deviceKey, string bridgeKey)
+        {
+            var pluginType = GetType().Name;
+
+            CrestronConsole.ConsoleCommandResponse("{0}:\n", pluginType);
+
+
+
+            WriteJoinmapMarkdown(JoinmapStringBuilder(), pluginType, bridgeKey, deviceKey);
+
+        }
+
+        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);
+
+            using (var sw = new StreamWriter(fileName))
+            {
+                sw.WriteLine(stringBuilder.ToString());
+                CrestronConsole.ConsoleCommandResponse("Joinmap Readme generated and written to {0}", fileName);
+            }
 
         }
 
@@ -269,7 +305,7 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         /// <param name="joins"></param>
         /// <returns></returns>
-        List<KeyValuePair<string, JoinDataComplete>> GetSortedJoins(Dictionary<string, JoinDataComplete> joins)
+        static List<KeyValuePair<string, JoinDataComplete>> GetSortedJoins(Dictionary<string, JoinDataComplete> joins)
         {
             var sortedJoins = joins.ToList();
 
@@ -278,19 +314,38 @@ namespace PepperDash.Essentials.Core
             return sortedJoins;
         }
 
-        void PrintJoinList(List<KeyValuePair<string, JoinDataComplete>> joins)
+
+        static StringBuilder AppendJoinList(List<KeyValuePair<string, JoinDataComplete>> joins)
         {
+            var sb = new StringBuilder();
+            const string stringFormatter = "| {0} | {1} | {2} | {3} | {4} |";
+            const int joinNumberLen = 11;
+            const int joinSpanLen = 9;
+            const int typeLen = 19;
+            const int capabilitiesLen = 12;
+            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, ' ')));
+            //build table seperator
+            sb.AppendLine(String.Format(stringFormatter,
+                new String('-', joinNumberLen),
+                new String('-', joinSpanLen),
+                new String('-', descriptionLen),
+                new String('-', typeLen),
+                new String('-', capabilitiesLen)));
+
             foreach (var join in joins)
             {
-                Debug.Console(0,
-                    @"Join Number: {0} | JoinSpan: '{1}' | JoinName: {2} | Description: '{3}' | Type: '{4}' | Capabilities: '{5}'",
-                        join.Value.JoinNumber,
-                        join.Value.JoinSpan,
-                        join.Key,
-                        String.IsNullOrEmpty(join.Value.AttributeName) ? join.Value.Metadata.Label : join.Value.AttributeName,
-                        join.Value.Metadata.JoinType.ToString(),
-                        join.Value.Metadata.JoinCapabilities.ToString());
+                sb.AppendLine(join.Value.GetMarkdownFormattedData(stringFormatter, descriptionLen));
             }
+            sb.AppendLine();
+            return sb;
         }
 
         /// <summary>
@@ -459,6 +514,64 @@ namespace PepperDash.Essentials.Core
             Metadata = metadata;
         }
 
+        public string GetMarkdownFormattedData(string stringFormatter, int descriptionLen)
+        {
+
+            //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;
+
+            //Track which one failed, if it did
+            const string placeholder = "unknown";
+            var dataArray = new Dictionary<string, string>
+            {
+                {"joinNumber", placeholder.PadRight(joinNumberLen, ' ')},
+                {"joinSpan", placeholder.PadRight(joinSpanLen, ' ')},
+                {"description", placeholder.PadRight(descriptionLen, ' ')},
+                {"joinType", placeholder.PadRight(typeLen, ' ')},
+                {"capabilities", placeholder.PadRight(capabilitiesLen, ' ')}
+            };
+
+
+            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, ' ');
+
+                return String.Format(stringFormatter,
+                    dataArray["joinNumber"],
+                    dataArray["joinSpan"],
+                    dataArray["description"],
+                    dataArray["joinType"],
+                    dataArray["capabilities"]);
+
+            }
+            catch (Exception e)
+            {
+                //Don't Throw - we don't want to kill the system if this falls over - it's not mission critical. Print the error, use placeholder data
+                var errorKey = string.Empty;
+                foreach (var item in dataArray)
+                {
+                    if (item.Value.TrimEnd() == placeholder) continue;
+                    errorKey = item.Key;
+                    break;
+                }
+                Debug.Console(0, "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"],
+                    dataArray["joinType"],
+                    dataArray["capabilities"]);
+            }
+        }
+
+
         /// <summary>
         /// Sets the join offset value
         /// </summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Monitoring/SystemMonitorController.cs

@@ -43,7 +43,20 @@ namespace PepperDash.Essentials.Core.Monitoring
         public StringFeedback UptimeFeedback { get; set; }
         public StringFeedback LastStartFeedback { get; set; }
 
-        public SystemMonitorController(string key)
+		public BoolFeedback IsApplianceFeedback { get; protected set; }
+	    private bool _isApplianceFb
+	    {
+			get { return CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance; }
+	    }
+
+		public BoolFeedback IsServerFeedback { get; protected set; }
+	    private bool _isServerFb
+	    {
+			get { return CrestronEnvironment.DevicePlatform == eDevicePlatform.Server; }
+	    }
+
+
+	    public SystemMonitorController(string key)
             : base(key)
         {
             Debug.Console(2, this, "Adding SystemMonitorController.");
@@ -63,6 +76,9 @@ namespace PepperDash.Essentials.Core.Monitoring
             UptimeFeedback = new StringFeedback(() => _uptime);
             LastStartFeedback = new StringFeedback(()=> _lastStart);
 
+			IsApplianceFeedback = new BoolFeedback(() => _isApplianceFb);
+			IsServerFeedback = new BoolFeedback(() => _isServerFb);
+
             ProgramStatusFeedbackCollection = new Dictionary<uint, ProgramStatusFeedbacks>();
 
             foreach (var prog in SystemMonitor.ProgramCollection)
@@ -123,6 +139,26 @@ namespace PepperDash.Essentials.Core.Monitoring
             _uptime = uptimeRaw.Substring(forIndex + 4);
         }
 
+	    private static void ProcessorReboot()
+	    {
+		    if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server) return;
+
+		    var response = string.Empty;
+		    CrestronConsole.SendControlSystemCommand("reboot", ref response);
+	    }
+
+		private static void ProgramReset(uint index)
+		{
+			if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server) return;
+
+			if (index <= 0 || index > 10) return;
+
+			var cmd = string.Format("progreset -p:{0}", index);
+
+			var response = string.Empty;
+			CrestronConsole.SendControlSystemCommand(cmd, ref response);
+		}
+
         private void CrestronEnvironmentOnEthernetEventHandler(EthernetEventArgs ethernetEventArgs)
         {
             if (ethernetEventArgs.EthernetEventType != eEthernetEventType.LinkUp) return;
@@ -185,6 +221,9 @@ namespace PepperDash.Essentials.Core.Monitoring
             SerialNumberFeedback.FireUpdate();
             ModelFeedback.FireUpdate();
 
+			IsApplianceFeedback.FireUpdate();
+			IsServerFeedback.FireUpdate();
+
             OnSystemMonitorPropertiesChanged();
         }
 
@@ -237,6 +276,11 @@ namespace PepperDash.Essentials.Core.Monitoring
             UptimeFeedback.LinkInputSig(trilist.StringInput[joinMap.Uptime.JoinNumber]);
             LastStartFeedback.LinkInputSig(trilist.StringInput[joinMap.LastBoot.JoinNumber]);
 
+	        trilist.SetSigHeldAction(joinMap.ProcessorReboot.JoinNumber, 10000, ProcessorReboot);
+
+			IsApplianceFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsAppliance.JoinNumber]);
+			IsServerFeedback.LinkInputSig(trilist.BooleanInput[joinMap.IsServer.JoinNumber]);
+
             // iterate the program status feedback collection and map all the joins
             LinkProgramInfoJoins(this, trilist, joinMap);
 
@@ -301,11 +345,13 @@ namespace PepperDash.Essentials.Core.Monitoring
                 p.Value.AggregatedProgramInfoFeedback.LinkInputSig(
                     trilist.StringInput[programSlotJoinStart + joinMap.AggregatedProgramInfo.JoinNumber]);
 
+				trilist.SetSigHeldAction(programSlotJoinStart + joinMap.ProgramReset.JoinNumber, 10000, () => ProgramReset(programNumber));
+
                 programSlotJoinStart = programSlotJoinStart + joinMap.ProgramOffsetJoin.JoinSpan;
             }
-        }
+        }	    
 
-        //// Sets the time zone
+	    //// Sets the time zone
         //public void SetTimeZone(int timeZone)
         //{
         //    SystemMonitor.TimeZoneInformation.TimeZoneNumber = timeZone;

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

@@ -92,6 +92,10 @@
       <HintPath>..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCustomAttributesInterface.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="SimplSharpCWSHelperInterface, Version=2.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCWSHelperInterface.dll</HintPath>
+    </Reference>
     <Reference Include="SimplSharpHelperInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpHelperInterface.dll</HintPath>
@@ -123,6 +127,8 @@
     <Compile Include="Bridges\IBridge.cs" />
     <Compile Include="Bridges\JoinMaps\AirMediaControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\AppleTvJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\IAnalogInputJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\IDigitalOutputJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\PduJoinMapBase.cs" />
     <Compile Include="Bridges\JoinMaps\C2nRthsControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\CameraControllerJoinMap.cs" />
@@ -179,16 +185,40 @@
     <Compile Include="Crestron IO\Cards\InternalCardCageController.cs" />
     <Compile Include="Crestron IO\DinCenCn\DinCenCnController.cs" />
     <Compile Include="Crestron IO\DinCenCn\IHasCresnetBranches.cs" />
+    <Compile Include="Crestron IO\DinIo8\DinIo8Controller.cs" />
     <Compile Include="Crestron IO\Inputs\CenIoDigIn104Controller.cs" />
+    <Compile Include="Crestron IO\Inputs\GenericVersiportAnalogInputDevice.cs" />
     <Compile Include="Crestron IO\Inputs\GenericDigitalInputDevice.cs" />
     <Compile Include="Crestron IO\Inputs\GenericVersiportInputDevice.cs" />
+    <Compile Include="Crestron IO\Inputs\IAnalogInput.cs" />
     <Compile Include="Crestron IO\Inputs\IDigitalInput.cs" />
     <Compile Include="Crestron IO\IOPortConfig.cs" />
     <Compile Include="Crestron IO\Ir\CenIoIr104Controller.cs" />
+    <Compile Include="Crestron IO\Outputs\GenericVersiportOutputDevice.cs" />
+    <Compile Include="Crestron IO\Outputs\IDigitalOutput.cs" />
     <Compile Include="Crestron IO\Relay\CenIoRy104Controller.cs" />
     <Compile Include="Crestron IO\Relay\GenericRelayDevice.cs" />
     <Compile Include="Crestron IO\Relay\ISwitchedOutput.cs" />
     <Compile Include="Crestron IO\StatusSign\StatusSignController.cs" />
+    <Compile Include="Devices\PowerInterfaces.cs" />
+    <Compile Include="Web\RequestHandlers\AppDebugRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\GetFeedbacksForDeviceRequestHandler.cs" />
+    <Compile Include="Web\EssentialsWebApiHelpers.cs" />
+    <Compile Include="Web\RequestHandlers\GetTypesByFilterRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\GetJoinMapForDeviceKeyRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DefaultRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DevListRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DevPropsRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DevJsonRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\SetDeviceStreamDebugRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\DisableAllStreamDebugRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\ShowConfigRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\GetTypesRequestHandler.cs" />
+    <Compile Include="Web\RequestHandlers\GetJoinMapForBridgeKeyRequestHandler.cs" />
+    <Compile Include="Web\EssemtialsWebApi.cs" />
+    <Compile Include="Web\EssentialsWebApiFactory.cs" />
+    <Compile Include="Web\EssentialsWebApiPropertiesConfig.cs" />
+    <Compile Include="Web\RequestHandlers\ReportVersionsRequestHandler.cs" />
     <Compile Include="Device Info\DeviceInfo.cs" />
     <Compile Include="Device Info\DeviceInfoEventArgs.cs" />
     <Compile Include="Device Info\IDeviceInfoProvider.cs" />

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

@@ -0,0 +1,3 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Crestron_0020Web_0020Server/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Web/@EntryIndexedValue">False</s:Boolean></wpf:ResourceDictionary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Plugins/PluginLoader.cs

@@ -194,13 +194,13 @@ namespace PepperDash.Essentials
         /// <param name="command"></param>
         public static void ReportAssemblyVersions(string command)
         {
-            Debug.Console(0, "Loaded Assemblies:");
+
+            CrestronConsole.ConsoleCommandResponse("Loaded Assemblies:" + CrestronEnvironment.NewLine);
             foreach (var assembly in LoadedAssemblies)
             {
-                Debug.Console(0, "{0} Version: {1}", assembly.Name, assembly.Version);
+                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
         /// </summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Queues/GenericQueue.cs

@@ -1,5 +1,6 @@
 using System;
 using Crestron.SimplSharp;
+using Crestron.SimplSharp.Reflection;
 using Crestron.SimplSharpPro.CrestronThread;
 using PepperDash.Core;
 
@@ -187,9 +188,20 @@ namespace PepperDash.Essentials.Core.Queues
                         if (_delayEnabled)
                             Thread.Sleep(_delayTime);
                     }
+                    catch (System.Threading.ThreadAbortException)
+                    {
+                        //swallowing this exception, as it should only happen on shut down
+                    }
                     catch (Exception ex)
                     {
-                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}\r{1}\r{2}", ex.Message, ex.InnerException, ex.StackTrace);
+                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue: {1}:{0}", ex.Message, ex);
+                        Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Stack Trace: {0}", ex.StackTrace);
+
+                        if (ex.InnerException != null)
+                        {
+                            Debug.Console(0, this, Debug.ErrorLogLevel.Error, "---\r\n{0}", ex.InnerException.Message);
+                            Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Stack Trace: {0}", ex.InnerException.StackTrace);
+                        }
                     }
                 }
                 else _waitHandle.Wait();
@@ -202,7 +214,7 @@ namespace PepperDash.Essentials.Core.Queues
         {
             if (Disposed)
             {
-                Debug.Console(1, this, "I've been disposed so you can't enqueue any messages.  Are you trying to dispatch a message while the program is stopping?");
+                Debug.Console(1, this, "Queue has been disposed. Enqueuing messages not allowed while program is stopping.");
                 return;
             }
 
@@ -446,7 +458,14 @@ namespace PepperDash_Essentials_Core.Queues
                     }
                     catch (Exception ex)
                     {
-                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}\r{1}\r{2}", ex.Message, ex.InnerException, ex.StackTrace);
+                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}", ex.Message);
+                        Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Stack Trace: {0}", ex.StackTrace);
+
+                        if (ex.InnerException != null)
+                        {
+                            Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}", ex.InnerException.Message);
+                            Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Stack Trace: {0}", ex.InnerException.StackTrace);
+                        }
                     }
                 }
                 else _waitHandle.Wait();

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/EssentialsRoomBase.cs

@@ -343,7 +343,7 @@ namespace PepperDash.Essentials.Core
 
         void RoomIsOccupiedFeedback_OutputChange(object sender, EventArgs e)
         {
-            if (RoomOccupancy.RoomIsOccupiedFeedback.BoolValue == false)
+            if (RoomOccupancy.RoomIsOccupiedFeedback.BoolValue == false  && AllowVacancyTimerToStart())
             {
                 Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Notice: Vacancy Detected");
                 // Trigger the timer when the room is vacant
@@ -362,6 +362,15 @@ namespace PepperDash.Essentials.Core
         /// </summary>
         /// <param name="o"></param>
         public abstract void RoomVacatedForTimeoutPeriod(object o);
+
+        /// <summary>
+        /// Allow the vacancy event from an occupancy sensor to turn the room off.
+        /// </summary>
+        /// <returns>If the timer should be allowed. Defaults to true</returns>
+        protected virtual bool AllowVacancyTimerToStart()
+        {
+            return true;
+        }
     }
         
     /// <summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Routing/IRoutingInputsExtensions.cs

@@ -1,425 +1,425 @@
-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 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;
-
+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 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.Console(2, "******************************************************** 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;
-
+                Debug.Console(2, "******************************************************** 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.Console(2, "******************************************************** 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)
-            {
+                return;
+            }
+
+            if (RouteRequests.ContainsKey(destination.Key) && coolingDevice != null && coolingDevice.IsCoolingDownFeedback.BoolValue == false)
+            {
                 RouteRequests.Remove(destination.Key);
                 Debug.Console(2, "******************************************************** 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.Console(2, 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.Console(1, 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.Console(1, 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.Console(1, 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.Console(1, destination, "Cannot find audio route to {0}", source.Key);
-				var videoSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Video, 0, routeDescr);
-				if (!videoSuccess)
-					Debug.Console(1, destination, "Cannot find video route to {0}", source.Key);
-				if (!audioSuccess && !videoSuccess)
-					routeDescr = null;
-			}
-
-            //Debug.Console(1, 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.Console(2, "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.Console(2, 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.Console(2, destination, "Trying to find route on {0}", upstreamRoutingDevice.Key);
-
-					// Check if this previous device has already been walked
-                    if (alreadyCheckedDevices.Contains(upstreamRoutingDevice))
-                    {
-                        Debug.Console(2, 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.Console(2, 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.Console(2, 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.Console(2, destination, "    No routing. Passthrough device");
-                //Debug.Console(2, destination, "Exiting cycle {0}", cycle);
-				return true;
-			}
-
-			Debug.Console(2, 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.Console(1, 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.Console(2, "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.Console(2, "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.Console(2, "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);
-
-		}
-	}
+            }
+
+            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.Console(2, 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.Console(1, 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.Console(1, 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.Console(1, 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.Console(1, destination, "Cannot find audio route to {0}", source.Key);
+				var videoSuccess = destination.GetRouteToSource(source, null, null, eRoutingSignalType.Video, 0, routeDescr);
+				if (!videoSuccess)
+					Debug.Console(1, destination, "Cannot find video route to {0}", source.Key);
+				if (!audioSuccess && !videoSuccess)
+					routeDescr = null;
+			}
+
+            //Debug.Console(1, 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.Console(2, "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.Console(2, 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.Console(2, destination, "Trying to find route on {0}", upstreamRoutingDevice.Key);
+
+					// Check if this previous device has already been walked
+                    if (alreadyCheckedDevices.Contains(upstreamRoutingDevice))
+                    {
+                        Debug.Console(2, 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.Console(2, 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.Console(2, 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.Console(2, destination, "    No routing. Passthrough device");
+                //Debug.Console(2, destination, "Exiting cycle {0}", cycle);
+				return true;
+			}
+
+			Debug.Console(2, 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.Console(1, 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.Console(2, "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.Console(2, "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.Console(2, "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);
+
+		}
+	}
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Secrets/SecretsManager.cs

@@ -148,6 +148,7 @@ namespace PepperDash.Essentials.Core
             {
                 Secrets.Add(key, provider);
                 Debug.Console(1, "Secrets provider '{0}' added to SecretsManager", key);
+                return;
             }
             Debug.Console(0, Debug.ErrorLogLevel.Notice, "Unable to add Provider '{0}' to Secrets.  Provider with that key already exists", key );
         }
@@ -164,13 +165,13 @@ namespace PepperDash.Essentials.Core
             {
                 Secrets.Add(key, provider);
                 Debug.Console(1, "Secrets provider '{0}' added to SecretsManager", key);
-
+                return;
             }
             if (overwrite)
             {
                 Secrets.Add(key, provider);
                 Debug.Console(1, Debug.ErrorLogLevel.Notice, "Provider with the key '{0}' already exists in secrets.  Overwriting with new secrets provider.", key);
-
+                return;
             }
             Debug.Console(0, Debug.ErrorLogLevel.Notice, "Unable to add Provider '{0}' to Secrets.  Provider with that key already exists", key);
         }

essentials-framework/Essentials Core/PepperDashEssentialsBase/UI/TouchpanelBase.cs

@@ -31,7 +31,7 @@ namespace PepperDash.Essentials.Core.UI
             :base(key, name)
         {
 
-            if (Panel == null)
+            if (panel == null)
             {
                 Debug.Console(0, this, "Panel is not valid. Touchpanel class WILL NOT work correctly");
                 return;
@@ -71,6 +71,8 @@ namespace PepperDash.Essentials.Core.UI
                         return;
                     }
                 }
+
+                Panel.LoadSmartObjects(sgdName);
             });
 
             AddPostActivationAction(() =>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/EssemtialsWebApi.cs

@@ -0,0 +1,224 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core;
+using PepperDash.Core.Web;
+using PepperDash.Essentials.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web
+{
+	public class EssemtialsWebApi : EssentialsDevice
+	{
+		private readonly WebApiServer _server;
+
+		///<example>
+		/// http(s)://{ipaddress}/cws/{basePath}
+		/// http(s)://{ipaddress}/VirtualControl/Rooms/{roomId}/cws/{basePath}
+		/// </example>
+		private readonly string _defaultBasePath = CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance 
+			? string.Format("/app{0:00}/api", InitialParametersClass.ApplicationNumber) 
+			: "/api";
+
+		private const int DebugTrace = 0;
+		private const int DebugInfo = 1;
+		private const int DebugVerbose = 2;
+
+		/// <summary>
+		/// CWS base path
+		/// </summary>
+		public string BasePath { get; private set; }
+
+		/// <summary>
+		/// Tracks if CWS is registered
+		/// </summary>
+		public bool IsRegistered
+		{
+			get { return _server.IsRegistered; }
+		}
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>		
+		public EssemtialsWebApi(string key, string name)
+			: this(key, name, null)
+		{
+		}
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="config"></param>
+		public EssemtialsWebApi(string key, string name, EssentialsWebApiPropertiesConfig config)
+			: base(key, name)
+		{
+			Key = key;
+
+			if (config == null)
+				BasePath = _defaultBasePath;
+			else
+				BasePath = string.IsNullOrEmpty(config.BasePath) ? _defaultBasePath : config.BasePath;
+
+			_server = new WebApiServer(Key, Name, BasePath);
+		}
+
+		/// <summary>
+		/// Custom activate, add routes
+		/// </summary>
+		/// <returns></returns>
+		public override bool CustomActivate()
+		{
+			var routes = new List<HttpCwsRoute>
+			{
+				new HttpCwsRoute("reportversions")
+				{
+					Name = "ReportVersions",
+					RouteHandler = new ReportVersionsRequestHandler()
+				},
+				new HttpCwsRoute("appdebug")
+				{
+					Name = "AppDebug",
+					RouteHandler = new AppDebugRequestHandler()
+				},
+				new HttpCwsRoute("devlist")
+				{
+					Name = "DevList",
+					RouteHandler = new DevListRequestHandler()
+				},
+				new HttpCwsRoute("devprops")
+				{
+					Name = "DevProps",
+					RouteHandler = new DevPropsRequestHandler()
+				},
+				new HttpCwsRoute("devjson")
+				{
+					Name = "DevJson",
+					RouteHandler = new DevJsonRequestHandler()
+				},
+				new HttpCwsRoute("setdevicestreamdebug")
+				{
+				    Name = "SetDeviceStreamDebug",
+				    RouteHandler = new SetDeviceStreamDebugRequestHandler()
+				},
+				new HttpCwsRoute("disableallstreamdebug")
+				{
+					Name = "DisableAllStreamDebug",
+					RouteHandler = new DisableAllStreamDebugRequestHandler()
+				},
+				new HttpCwsRoute("showconfig")
+				{
+					Name = "ShowConfig",
+					RouteHandler = new ShowConfigRequestHandler()
+				},
+				new HttpCwsRoute("gettypes")
+				{
+					Name = "GetTypes",
+					RouteHandler = new GetTypesRequestHandler()
+				},
+				new HttpCwsRoute("gettypes/{filter}")
+				{
+					Name = "GetTypesByFilter",
+					RouteHandler = new GetTypesByFilterRequestHandler()
+				},
+				new HttpCwsRoute("getjoinmap/{bridgeKey}")
+				{
+					Name = "GetJoinMapsForBridgeKey",
+					RouteHandler = new GetJoinMapForBridgeKeyRequestHandler()
+				},
+				new HttpCwsRoute("getjoinmap/{bridgeKey}/{deviceKey}")
+				{
+					Name = "GetJoinMapsForDeviceKey",
+					RouteHandler = new GetJoinMapForDeviceKeyRequestHandler()
+				},
+				new HttpCwsRoute("feedbacks/{deviceKey}")
+				{
+					Name = "GetFeedbacksForDeviceKey",
+					RouteHandler = new GetFeedbacksForDeviceRequestHandler()
+				}
+			};
+
+			foreach (var route in routes.Where(route => route != null))
+			{
+				var r = route;
+				_server.AddRoute(r);
+			}
+
+			return base.CustomActivate();
+		}
+
+		/// <summary>
+		/// Initializes the CWS class
+		/// </summary>
+		public override void Initialize()
+		{
+			// If running on an appliance
+			if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance)
+			{
+				/*
+					WEBSERVER [ON | OFF | TIMEOUT <VALUE IN SECONDS> | MAXSESSIONSPERUSER <Number of sessions>]
+				*/
+				var response = string.Empty;
+				CrestronConsole.SendControlSystemCommand("webserver", ref response);
+				if (response.Contains("OFF")) return;
+
+				var is4Series = eCrestronSeries.Series4 == (Global.ProcessorSeries & eCrestronSeries.Series4);
+				Debug.Console(DebugTrace, Debug.ErrorLogLevel.Notice, "Starting Essentials Web API on {0} Appliance", is4Series ? "4-series" : "3-series");
+
+				_server.Start();
+
+				GetPaths();
+
+				return;
+			}
+
+			// Automatically start CWS when running on a server (Linux OS, Virtual Control)
+			Debug.Console(DebugTrace, Debug.ErrorLogLevel.Notice, "Starting Essentials Web API on Virtual Control Server");
+
+			_server.Start();
+
+			GetPaths();
+		}
+
+		/// <summary>
+		/// Print the available pahts
+		/// </summary>
+		/// <example>
+		/// http(s)://{ipaddress}/cws/{basePath}
+		/// http(s)://{ipaddress}/VirtualControl/Rooms/{roomId}/cws/{basePath}
+		/// </example>
+		public void GetPaths()
+		{
+			Debug.Console(DebugTrace, this, "{0}", 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 
+				? string.Format("http(s)://{0}/VirtualControl/Rooms/{1}/cws{2}", hostname, InitialParametersClass.RoomId, BasePath)
+				: string.Format("http(s)://{0}/cws{1}", currentIp, BasePath);
+			
+			Debug.Console(DebugTrace, this, "Server:{0}", path);
+
+			var routeCollection = _server.GetRouteCollection();
+			if (routeCollection == null)
+			{
+				Debug.Console(DebugTrace, this, "Server route collection is null");
+				return;
+			}
+			Debug.Console(DebugTrace, this, "Configured Routes:");
+			foreach (var route in routeCollection)
+			{
+				Debug.Console(DebugTrace, this, "{0}: {1}/{2}", route.Name, path, route.Url);
+			}
+			Debug.Console(DebugTrace, this, "{0}", new String('-', 50));
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/EssentialsWebApiFactory.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.Web
+{
+	public class EssentialsWebApiFactory : EssentialsDeviceFactory<EssemtialsWebApi>
+	{
+		public EssentialsWebApiFactory()
+		{
+			TypeNames = new List<string> { "EssentialsWebApi" };
+		}
+
+		public override EssentialsDevice BuildDevice(DeviceConfig dc)
+		{
+			Debug.Console(1, "Factory Attempting to create new Essentials Web API Server");
+
+			var props = dc.Properties.ToObject<EssentialsWebApiPropertiesConfig>();
+			if (props != null) return new EssemtialsWebApi(dc.Key, dc.Name, props);
+
+			Debug.Console(1, "Factory failed to create new Essentials Web API Server");
+			return null;
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/EssentialsWebApiHelpers.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core.Web
+{
+	public class EssentialsWebApiHelpers
+	{
+		public static string GetRequestBody(HttpCwsRequest request)
+		{
+			var bytes = new Byte[request.ContentLength];
+
+			request.InputStream.Read(bytes, 0, request.ContentLength);
+
+			return Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+		}
+
+		public static object MapToAssemblyObject(LoadedAssembly assembly)
+		{
+			return new
+			{
+				Name = assembly.Name,
+				Version = assembly.Version
+			};
+		}
+
+		public static object MapToDeviceListObject(IKeyed device)
+		{
+			return new
+			{
+				Key = device.Key,
+				Name = (device is IKeyName)
+					? (device as IKeyName).Name
+					: "---"
+			};
+		}
+
+		public static object MapJoinToObject(string key, JoinMapBaseAdvanced join)
+		{
+			var kp = new KeyValuePair<string, JoinMapBaseAdvanced>(key, join);
+
+			return MapJoinToObject(kp);
+		}
+
+		public static object MapJoinToObject(KeyValuePair<string, JoinMapBaseAdvanced> join)
+		{
+			return new
+			{
+				DeviceKey = join.Key,
+				Joins = join.Value.Joins.Select(j => MapJoinDataCompleteToObject(j))
+			};
+		}
+
+		public static object MapJoinDataCompleteToObject(KeyValuePair<string, JoinDataComplete> joinData)
+		{
+			return new
+			{
+				Signal = joinData.Key,
+				Description = joinData.Value.Metadata.Description,
+				JoinNumber = joinData.Value.JoinNumber,
+				JoinSpan = joinData.Value.JoinSpan,
+				JoinType = joinData.Value.Metadata.JoinType.ToString(),
+				JoinCapabilities = joinData.Value.Metadata.JoinCapabilities.ToString()
+			};
+		}
+
+		public static object MapDeviceTypeToObject(string key, DeviceFactoryWrapper device)
+		{
+			var kp = new KeyValuePair<string, DeviceFactoryWrapper>(key, device);
+
+			return MapDeviceTypeToObject(kp);
+		}
+
+		public static object MapDeviceTypeToObject(KeyValuePair<string, DeviceFactoryWrapper> device)
+		{
+			return new
+			{
+				Type = device.Key,
+				Description = device.Value.Description,
+				CType = device.Value.CType == null ? "---": device.Value.CType.ToString()
+			};
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/EssentialsWebApiPropertiesConfig.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core.Web
+{
+	public class EssentialsWebApiPropertiesConfig
+	{
+		[JsonProperty("basePath")]
+		public string BasePath { get; set; }
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/AppDebugRequestHandler.cs

@@ -0,0 +1,82 @@
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class AppDebugRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>		
+		public AppDebugRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var appDebug = new AppDebug { Level = Debug.Level };
+
+			var body = JsonConvert.SerializeObject(appDebug, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.Write(body, false);
+			context.Response.End();
+		}
+		
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			if (context.Request.ContentLength < 0)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			if (string.IsNullOrEmpty(data))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var appDebug = new AppDebug();
+			var requestBody = JsonConvert.DeserializeAnonymousType(data, appDebug);
+
+			Debug.SetDebugLevel(requestBody.Level);
+
+			appDebug.Level = Debug.Level;
+			var responseBody = JsonConvert.SerializeObject(appDebug, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.Write(responseBody, false);
+			context.Response.End();
+		}
+	}
+
+	public class AppDebug
+	{
+		[JsonProperty("level", NullValueHandling = NullValueHandling.Ignore)]
+		public int Level { get; set; }
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DefaultRequestHandler.cs

@@ -0,0 +1,118 @@
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DefaultRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>		
+		public DefaultRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles CONNECT method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleConnect(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles DELETE method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleDelete(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles HEAD method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleHead(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles OPTIONS method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleOptions(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles PATCH method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePatch(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles PUT method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePut(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles TRACE method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleTrace(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 418;
+			context.Response.StatusDescription = "I'm a teapot";
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DevJsonRequestHandler.cs

@@ -0,0 +1,66 @@
+using System;
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DevJsonRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public DevJsonRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			if (context.Request.ContentLength < 0)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			if (string.IsNullOrEmpty(data))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+			
+			try
+			{
+				DeviceJsonApi.DoDeviceActionWithJson(data);
+
+				context.Response.StatusCode = 200;
+				context.Response.StatusDescription = "OK";
+				context.Response.End();
+			}
+			catch (Exception ex)
+			{
+				Debug.Console(1, "Exception Message: {0}", ex.Message);
+				Debug.Console(2, "Exception Stack Trace: {0}", ex.StackTrace);
+				if(ex.InnerException != null) Debug.Console(2, "Exception Inner: {0}", ex.InnerException);
+
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+			}
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DevListRequestHandler.cs

@@ -0,0 +1,51 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DevListRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public DevListRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var allDevices = DeviceManager.AllDevices;
+			if (allDevices == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			allDevices.Sort((a, b) => System.String.Compare(a.Key, b.Key, System.StringComparison.Ordinal));
+
+			var deviceList = allDevices.Select(d => EssentialsWebApiHelpers.MapToDeviceListObject(d)).ToList();
+
+			var js = JsonConvert.SerializeObject(deviceList, Formatting.Indented);			
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DevPropsRequestHandler.cs

@@ -0,0 +1,76 @@
+using System.Text;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DevPropsRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public DevPropsRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			if (context.Request.ContentLength < 0)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			if (string.IsNullOrEmpty(data))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var o = new DeviceActionWrapper();
+			var body = JsonConvert.DeserializeAnonymousType(data, o);			
+			
+			if (string.IsNullOrEmpty(body.DeviceKey))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceProps = DeviceJsonApi.GetProperties(body.DeviceKey);
+			if (deviceProps == null || deviceProps.ToLower().Contains("no device"))
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";			
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = Encoding.UTF8;
+			context.Response.Write(deviceProps, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/DisableAllStreamDebugRequestHandler.cs

@@ -0,0 +1,32 @@
+using Crestron.SimplSharp.WebScripting;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class DisableAllStreamDebugRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public DisableAllStreamDebugRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			DeviceManager.DisableAllDeviceStreamDebugging();
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetFeedbacksForDeviceRequestHandler.cs

@@ -0,0 +1,102 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetFeedbacksForDeviceRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetFeedbacksForDeviceRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object deviceObj;
+			if (!routeData.Values.TryGetValue("deviceKey", out deviceObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+
+			var device = DeviceManager.GetDeviceForKey(deviceObj.ToString()) as IHasFeedback;
+			if (device == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			var boolFeedback =
+				from feedback in device.Feedbacks.OfType<BoolFeedback>()
+				where !string.IsNullOrEmpty(feedback.Key)
+				select new
+				{
+					FeedbackKey = feedback.Key,
+					Value = feedback.BoolValue
+				};
+
+			var intFeedback =
+				from feedback in device.Feedbacks.OfType<IntFeedback>()
+				where !string.IsNullOrEmpty(feedback.Key)
+				select new
+				{
+					FeedbackKey = feedback.Key,
+					Value = feedback.IntValue
+				};
+
+			var stringFeedback = 
+				from feedback in device.Feedbacks.OfType<StringFeedback>()
+				where !string.IsNullOrEmpty(feedback.Key)
+				select new
+				{
+					FeedbackKey = feedback.Key,
+					Value = feedback.StringValue ?? string.Empty
+				};
+
+			var responseObj = new
+			{
+				BoolValues = boolFeedback,
+				IntValues = intFeedback,
+				SerialValues = stringFeedback
+			};
+
+			var js = JsonConvert.SerializeObject(responseObj, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetJoinMapForBridgeKeyRequestHandler.cs

@@ -0,0 +1,78 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetJoinMapForBridgeKeyRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetJoinMapForBridgeKeyRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object bridgeObj;			
+			if (!routeData.Values.TryGetValue("bridgeKey", out bridgeObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var bridge = DeviceManager.GetDeviceForKey(bridgeObj.ToString()) as EiscApiAdvanced;
+			if (bridge == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var joinMap = bridge.JoinMaps.Select(j => EssentialsWebApiHelpers.MapJoinToObject(j)).ToList();			
+			if (joinMap == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			var js = JsonConvert.SerializeObject(joinMap, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}		
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetJoinMapForDeviceKeyRequestHandler.cs

@@ -0,0 +1,95 @@
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetJoinMapForDeviceKeyRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetJoinMapForDeviceKeyRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object bridgeObj;
+			if (!routeData.Values.TryGetValue("bridgeKey", out bridgeObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object deviceObj;
+			if (!routeData.Values.TryGetValue("deviceKey", out deviceObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var bridge = DeviceManager.GetDeviceForKey(bridgeObj.ToString()) as EiscApiAdvanced;
+			if (bridge == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			JoinMapBaseAdvanced deviceJoinMap;
+			if (!bridge.JoinMaps.TryGetValue(deviceObj.ToString(), out deviceJoinMap))
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			var joinMap = EssentialsWebApiHelpers.MapJoinToObject(deviceObj.ToString(), deviceJoinMap);
+			var js = JsonConvert.SerializeObject(joinMap, Formatting.Indented, new JsonSerializerSettings
+			{
+				ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
+				NullValueHandling = NullValueHandling.Ignore,
+				MissingMemberHandling = MissingMemberHandling.Ignore,
+				DefaultValueHandling = DefaultValueHandling.Ignore,
+				TypeNameHandling = TypeNameHandling.None
+			});
+			
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetTypesByFilterRequestHandler.cs

@@ -0,0 +1,68 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetTypesByFilterRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetTypesByFilterRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			object filterObj;
+			if (!routeData.Values.TryGetValue("filter", out filterObj))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceFactory = DeviceFactory.GetDeviceFactoryDictionary(filterObj.ToString());
+			if (deviceFactory == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceTypes = deviceFactory.Select(t => EssentialsWebApiHelpers.MapDeviceTypeToObject(t)).ToList();
+			var js = JsonConvert.SerializeObject(deviceTypes, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/GetTypesRequestHandler.cs

@@ -0,0 +1,58 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class GetTypesRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public GetTypesRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var routeData = context.Request.RouteData;
+			if (routeData == null)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceFactory = DeviceFactory.GetDeviceFactoryDictionary(null);
+			if (deviceFactory == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+
+			var deviceTypes = deviceFactory.Select(t => EssentialsWebApiHelpers.MapDeviceTypeToObject(t)).ToList();
+			var js = JsonConvert.SerializeObject(deviceTypes, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/ReportVersionsRequestHandler.cs

@@ -0,0 +1,49 @@
+using System.Linq;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class ReportVersionsRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public ReportVersionsRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var loadAssemblies = PluginLoader.LoadedAssemblies;
+			if (loadAssemblies == null)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			var assemblies = loadAssemblies.Select(a => EssentialsWebApiHelpers.MapToAssemblyObject(a)).ToList();
+
+			var js = JsonConvert.SerializeObject(assemblies, Formatting.Indented);
+			
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(js, false);			
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/SetDeviceStreamDebugRequestHandler.cs

@@ -0,0 +1,212 @@
+using System;
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Core.Web.RequestHandlers;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class SetDeviceStreamDebugRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Handles CONNECT method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleConnect(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles DELETE method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleDelete(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles HEAD method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleHead(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles OPTIONS method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleOptions(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles PATCH method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePatch(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles POST method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePost(HttpCwsContext context)
+		{
+			if (context.Request.ContentLength < 0)
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var data = EssentialsWebApiHelpers.GetRequestBody(context.Request);
+			if (data == null)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			var config = new SetDeviceStreamDebugConfig();
+			var body = JsonConvert.DeserializeAnonymousType(data, config);
+			if (body == null)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			if (string.IsNullOrEmpty(body.DeviceKey) || string.IsNullOrEmpty(body.Setting))
+			{
+				context.Response.StatusCode = 400;
+				context.Response.StatusDescription = "Bad Request";
+				context.Response.End();
+
+				return;
+			}
+
+			var device = DeviceManager.GetDeviceForKey(body.DeviceKey) as IStreamDebugging;
+			if (device == null)
+			{
+				context.Response.StatusCode = 404;
+				context.Response.StatusDescription = "Not Found";
+				context.Response.End();
+
+				return;
+			}
+			
+			eStreamDebuggingSetting debugSetting;
+			try
+			{
+				debugSetting = (eStreamDebuggingSetting) Enum.Parse(typeof (eStreamDebuggingSetting), body.Setting, true);				
+			}
+			catch (Exception ex)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+
+				return;
+			}
+
+			try
+			{
+				var mins = Convert.ToUInt32(body.Timeout);
+				if (mins > 0)
+				{
+					device.StreamDebugging.SetDebuggingWithSpecificTimeout(debugSetting, mins);
+				}
+				else
+				{
+					device.StreamDebugging.SetDebuggingWithDefaultTimeout(debugSetting);
+				}
+
+				context.Response.StatusCode = 200;
+				context.Response.StatusDescription = "OK";
+				context.Response.End();
+			}
+			catch (Exception ex)
+			{
+				context.Response.StatusCode = 500;
+				context.Response.StatusDescription = "Internal Server Error";
+				context.Response.End();
+			}
+		}
+
+		/// <summary>
+		/// Handles PUT method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandlePut(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+
+		/// <summary>
+		/// Handles TRACE method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleTrace(HttpCwsContext context)
+		{
+			context.Response.StatusCode = 501;
+			context.Response.StatusDescription = "Not Implemented";
+			context.Response.End();
+		}
+	}
+
+
+	public class SetDeviceStreamDebugConfig
+	{
+		[JsonProperty("deviceKey", NullValueHandling = NullValueHandling.Include)]
+		public string DeviceKey { get; set; }
+
+		[JsonProperty("setting", NullValueHandling = NullValueHandling.Include)]
+		public string Setting { get; set; }
+
+		[JsonProperty("timeout")]
+		public int Timeout { get; set; }
+
+		public SetDeviceStreamDebugConfig()
+		{
+			DeviceKey = null;
+			Setting = null;
+			Timeout = 15;
+		}
+	}
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Web/RequestHandlers/ShowConfigRequestHandler.cs

@@ -0,0 +1,37 @@
+using Crestron.SimplSharp.WebScripting;
+using Newtonsoft.Json;
+using PepperDash.Core.Web.RequestHandlers;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.Web.RequestHandlers
+{
+	public class ShowConfigRequestHandler : WebApiBaseRequestHandler
+	{
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <remarks>
+		/// base(true) enables CORS support by default
+		/// </remarks>
+		public ShowConfigRequestHandler()
+			: base(true)
+		{
+		}
+
+		/// <summary>
+		/// Handles GET method requests
+		/// </summary>
+		/// <param name="context"></param>
+		protected override void HandleGet(HttpCwsContext context)
+		{
+			var config = JsonConvert.SerializeObject(ConfigReader.ConfigObject, Formatting.Indented);
+
+			context.Response.StatusCode = 200;
+			context.Response.StatusDescription = "OK";
+			context.Response.ContentType = "application/json";
+			context.Response.ContentEncoding = System.Text.Encoding.UTF8;
+			context.Response.Write(config, false);
+			context.Response.End();
+		}
+	}
+}

essentials-framework/Essentials DM/Essentials_DM/AirMedia/AirMediaController.cs

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.DM.AirMedia
     [Description("Wrapper class for an AM-200 or AM-300")]
     public class AirMediaController : CrestronGenericBridgeableBaseDevice, IRoutingNumericWithFeedback, IIROutputPorts, IComPorts
     {
-        public AmX00 AirMedia { get; private set; }
+        public Am3x00 AirMedia { get; private set; }
 
         public DeviceConfig DeviceConfig { get; private set; }
 
@@ -44,7 +44,7 @@ namespace PepperDash.Essentials.DM.AirMedia
         public StringFeedback SerialNumberFeedback { get; private set; }
         public BoolFeedback AutomaticInputRoutingEnabledFeedback { get; private set; }
 
-        public AirMediaController(string key, string name, AmX00 device, DeviceConfig dc, AirMediaPropertiesConfig props)
+        public AirMediaController(string key, string name, Am3x00 device, DeviceConfig dc, AirMediaPropertiesConfig props)
             : base(key, name, device)
         {
 
@@ -95,24 +95,31 @@ namespace PepperDash.Essentials.DM.AirMedia
 
             AirMedia.AirMedia.AirMediaChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(AirMedia_AirMediaChange);
 
-            IsInSessionFeedback = new BoolFeedback(new Func<bool>(() => AirMedia.AirMedia.StatusFeedback.UShortValue == 0));
-            ErrorFeedback = new IntFeedback(new Func<int>(() => AirMedia.AirMedia.ErrorFeedback.UShortValue));
-            NumberOfUsersConnectedFeedback = new IntFeedback(new Func<int>(() => AirMedia.AirMedia.NumberOfUsersConnectedFeedback.UShortValue));
-            LoginCodeFeedback = new IntFeedback(new Func<int>(() => AirMedia.AirMedia.LoginCodeFeedback.UShortValue));
-            ConnectionAddressFeedback = new StringFeedback(new Func<string>(() => AirMedia.AirMedia.ConnectionAddressFeedback.StringValue));
-            HostnameFeedback = new StringFeedback(new Func<string>(() => AirMedia.AirMedia.HostNameFeedback.StringValue));
+            IsInSessionFeedback = new BoolFeedback(() => AirMedia.AirMedia.StatusFeedback.UShortValue == 0);
+            ErrorFeedback = new IntFeedback(() => AirMedia.AirMedia.ErrorFeedback.UShortValue);
+            NumberOfUsersConnectedFeedback = new IntFeedback(() => AirMedia.AirMedia.NumberOfUsersConnectedFeedback.UShortValue);
+            LoginCodeFeedback = new IntFeedback(() => AirMedia.AirMedia.LoginCodeFeedback.UShortValue);
+            ConnectionAddressFeedback = new StringFeedback(() => AirMedia.AirMedia.ConnectionAddressFeedback.StringValue);
+            HostnameFeedback = new StringFeedback(() => AirMedia.AirMedia.HostNameFeedback.StringValue);
 
             // TODO: Figure out if we can actually get the TSID/Serial
-            SerialNumberFeedback = new StringFeedback(new Func<string>(() => "unknown"));
+            SerialNumberFeedback = new StringFeedback(() => "unknown");
 
-            AirMedia.DisplayControl.DisplayControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(DisplayControl_DisplayControlChange);
+            AirMedia.DisplayControl.DisplayControlChange += DisplayControl_DisplayControlChange;
 
-            VideoOutFeedback = new IntFeedback(new Func<int>(() => Convert.ToInt16(AirMedia.DisplayControl.VideoOutFeedback)));
-            AutomaticInputRoutingEnabledFeedback = new BoolFeedback(new Func<bool>(() => AirMedia.DisplayControl.EnableAutomaticRoutingFeedback.BoolValue));
+            VideoOutFeedback = new IntFeedback(() => Convert.ToInt16(AirMedia.DisplayControl.VideoOutFeedback));
+            AutomaticInputRoutingEnabledFeedback = new BoolFeedback(() => AirMedia.DisplayControl.EnableAutomaticRoutingFeedback.BoolValue);
 
-            AirMedia.HdmiIn.StreamChange += new Crestron.SimplSharpPro.DeviceSupport.StreamEventHandler(HdmiIn_StreamChange);
+            // Not all AirMedia versions support HDMI In like the 3200
+            if (AirMedia.HdmiIn != null)
+            {
+                AirMedia.HdmiIn.StreamChange += HdmiIn_StreamChange;
+                HdmiVideoSyncDetectedFeedback = new BoolFeedback(() => AirMedia.HdmiIn.SyncDetectedFeedback.BoolValue);
+                return;
+            }
 
-            HdmiVideoSyncDetectedFeedback = new BoolFeedback(new Func<bool>(() => AirMedia.HdmiIn.SyncDetectedFeedback.BoolValue));
+            // Return false if the AirMedia device doesn't support HDMI Input
+            HdmiVideoSyncDetectedFeedback = new BoolFeedback(() => false);
         }
 
         public override bool CustomActivate()
@@ -122,7 +129,7 @@ namespace PepperDash.Essentials.DM.AirMedia
             else
                 AirMedia.DisplayControl.DisableAutomaticRouting();
 
-            return base.CustomActivate();
+            return true;
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
@@ -179,31 +186,53 @@ namespace PepperDash.Essentials.DM.AirMedia
         /// <param name="e">Arguments defined as IKeyName sender, output, input, and eRoutingSignalType</param>
         private void OnSwitchChange(RoutingNumericEventArgs e)
         {
-            var newEvent = NumericSwitchChange;
-            if (newEvent != null) newEvent(this, e);
-        }
+            var handler = NumericSwitchChange;
+
+            if (handler == null) return;
+                
+            handler(this, e);
+        }
 
 
         void AirMedia_AirMediaChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
         {
-            if (args.EventId == AirMediaInputSlot.AirMediaStatusFeedbackEventId)
-                IsInSessionFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaErrorFeedbackEventId)
-                ErrorFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaNumberOfUserConnectedEventId)
-                NumberOfUsersConnectedFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaLoginCodeEventId)
-                LoginCodeFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaConnectionAddressFeedbackEventId)
-                ConnectionAddressFeedback.FireUpdate();
-            else if (args.EventId == AirMediaInputSlot.AirMediaHostNameFeedbackEventId)
-                HostnameFeedback.FireUpdate();
+            switch (args.EventId)
+            {
+                case AirMediaInputSlot.AirMediaStatusFeedbackEventId:
+                    {
+                        IsInSessionFeedback.FireUpdate();
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaErrorFeedbackEventId:
+                    {
+                        ErrorFeedback.FireUpdate();
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaNumberOfUserConnectedEventId:
+                    {
+                        NumberOfUsersConnectedFeedback.FireUpdate();
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaLoginCodeEventId:
+                    {
+                        LoginCodeFeedback.FireUpdate();
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaConnectionAddressFeedbackEventId:
+                    {
+                        ConnectionAddressFeedback.FireUpdate();
+                        break;
+                    }
+                case AirMediaInputSlot.AirMediaHostNameFeedbackEventId:
+                    {
+                        HostnameFeedback.FireUpdate();
+                        break;
+                    }
+            }
         }
 
         void DisplayControl_DisplayControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
         {
-            if (args.EventId == AmX00.VideoOutFeedbackEventId)
-            {
                 VideoOutFeedback.FireUpdate();
 
                 var localInputPort =
@@ -211,8 +240,7 @@ namespace PepperDash.Essentials.DM.AirMedia
 
                 OnSwitchChange(new RoutingNumericEventArgs(1, VideoOutFeedback.UShortValue, OutputPorts.First(),
                     localInputPort, eRoutingSignalType.AudioVideo));
-            }
-            else if (args.EventId == AmX00.EnableAutomaticRoutingFeedbackEventId)
+            
                 AutomaticInputRoutingEnabledFeedback.FireUpdate();
         }
 
@@ -342,7 +370,7 @@ namespace PepperDash.Essentials.DM.AirMedia
     {
         public AirMediaControllerFactory()
         {
-            TypeNames = new List<string>() { "am200", "am300" };
+            TypeNames = new List<string>() { "am200", "am300", "am3200" };
         }
 
         public override EssentialsDevice BuildDevice(DeviceConfig dc)
@@ -351,12 +379,26 @@ namespace PepperDash.Essentials.DM.AirMedia
 
             Debug.Console(1, "Factory Attempting to create new AirMedia Device");
 
-            var props = JsonConvert.DeserializeObject<AirMediaPropertiesConfig>(dc.Properties.ToString());
-            AmX00 amDevice = null;
-            if (type == "am200")
-                amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am200(props.Control.IpIdInt, Global.ControlSystem);
-            else if (type == "am300")
-                amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am300(props.Control.IpIdInt, Global.ControlSystem);
+            var props = dc.Properties.ToObject<AirMediaPropertiesConfig>();
+            Am3x00 amDevice = null;
+            switch (type)
+            {
+                case "am200" :
+                {
+                    amDevice = new Am200(props.Control.IpIdInt, Global.ControlSystem);
+                    break;
+                }
+                case "am300" :
+                {
+                    amDevice = new Am300(props.Control.IpIdInt, Global.ControlSystem);
+                    break;
+                }
+                case "am3200" :
+                {
+                    amDevice = new Am3200(props.Control.IpIdInt, Global.ControlSystem);
+                    break;
+                }
+            }
 
             return new AirMediaController(dc.Key, dc.Name, amDevice, dc, props);
 

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

@@ -22,7 +22,7 @@ namespace PepperDash.Essentials.DM
     /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
     /// 
     /// </summary>
-    public class DmBladeChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitch, IRoutingNumericWithFeedback
+	public class DmBladeChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitchWithEndpointOnlineFeedback, IRoutingNumericWithFeedback
     {
         private const string NonePortKey = "inputCard0--None";
 

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

@@ -23,7 +23,7 @@ namespace PepperDash.Essentials.DM
     /// 
     /// </summary>
     [Description("Wrapper class for all DM-MD chassis variants from 8x8 to 32x32")]
-    public class DmChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitch, IRoutingNumericWithFeedback
+    public class DmChassisController : CrestronGenericBridgeableBaseDevice, IDmSwitchWithEndpointOnlineFeedback, IRoutingNumericWithFeedback
     {
         private const string NonePortKey = "inputCard0--None";
         public DMChassisPropertiesConfig PropertiesConfig { get; set; }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/DGEs/Dge100Controller.cs

@@ -17,11 +17,12 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using Crestron.SimplSharpPro.DeviceSupport;
 using PepperDash.Essentials.Core.DeviceInfo;
+using PepperDash.Essentials.Core.Bridges;
 
 namespace PepperDash.Essentials.DM.Endpoints.DGEs
 {
     [Description("Wrapper class for DGE-100")]    
-    public class Dge100Controller : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject, ICec, IDeviceInfoProvider
+    public class Dge100Controller : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject, ICec, IDeviceInfoProvider, IBridgeAdvanced
     {
         private const int CtpPort = 41795;
         private readonly Dge100 _dge;
@@ -30,9 +31,12 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
 
         public BasicTriListWithSmartObject Panel { get { return _dge; } }
 
-        private DeviceConfig _dc;
+        private DeviceConfig _dc;
+
+		public VideoStatusOutputs VideoStatusFeedbacks { get; private set;  }
+
+        CrestronTouchpanelPropertiesConfig PropertiesConfig;        
 
-        CrestronTouchpanelPropertiesConfig PropertiesConfig;
 
         public Dge100Controller(string key, string name, Dge100 device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
             :base(key, name, device)
@@ -48,8 +52,20 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
 
             _dc = dc;
 
-            PropertiesConfig = props;
-        }
+            PropertiesConfig = props;
+
+            var videoStatusFuncs = new VideoStatusFuncsWrapper
+            {
+                HdcpActiveFeedbackFunc = () => _dge.HdmiIn.HdcpSupportOnFeedback.BoolValue,
+                VideoResolutionFeedbackFunc = () => _dge.HdmiIn.VideoAttributes.GetVideoResolutionString(),
+                VideoSyncFeedbackFunc = () => _dge.HdmiIn.SyncDetectedFeedback.BoolValue, 
+            };
+
+			VideoStatusFeedbacks = new VideoStatusOutputs(videoStatusFuncs);
+
+			_dge.HdmiIn.StreamChange += (s,a) => VideoStatusFeedbacks.FireAll();
+			_dge.HdmiIn.VideoAttributes.AttributeChange += (o, a) => VideoStatusFeedbacks.FireAll();
+        }		
 
         #region IComPorts Members
 
@@ -187,6 +203,63 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             handler(this, new DeviceInfoEventArgs(DeviceInfo));
         }
 
+        #endregion
+
+        #region IBridgeAdvanced Members
+
+        public void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new DgeJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DgeJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+			//Presses
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpOn.JoinNumber, () => _dge.HdmiIn.HdcpSupportOn());
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpOff.JoinNumber,() => _dge.HdmiIn.HdcpSupportOff());
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpToggle.JoinNumber, () => {
+				if(_dge.HdmiIn.HdcpSupportOnFeedback.BoolValue)
+				{
+					_dge.HdmiIn.HdcpSupportOff();
+					return;
+				}
+			
+				_dge.HdmiIn.HdcpSupportOn();
+			});
+
+
+			// Feedbacks
+			VideoStatusFeedbacks.HdcpActiveFeedback.LinkInputSig(trilist.BooleanInput[joinMap.HdmiInHdcpOn.JoinNumber]);
+			VideoStatusFeedbacks.HdcpActiveFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.HdmiInHdcpOff.JoinNumber]);
+
+			VideoStatusFeedbacks.VideoResolutionFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentInputResolution.JoinNumber]);
+			VideoStatusFeedbacks.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.SyncDetected.JoinNumber]);
+
+			IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+
+			trilist.OnlineStatusChange += (o, a) =>
+			{
+				if (!a.DeviceOnLine) return;
+
+				VideoStatusFeedbacks.FireAll();
+			};
+        }
+
+        
+
         #endregion
     }
 

essentials-framework/Essentials DM/Essentials_DM/Endpoints/DGEs/DgeJoinMap.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM.Endpoints.DGEs
+{
+    public class DgeJoinMap : JoinMapBaseAdvanced
+    {
+        [JoinName("IsOnline")]
+        public JoinDataComplete IsOnline = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE Online", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });        
+
+        [JoinName("CurrentInputResolution")]
+        public JoinDataComplete CurrentInputResolution = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE Current Input Resolution", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+		[JoinName("SyncDetected")]
+		public JoinDataComplete SyncDetected = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+			new JoinMetadata { Description = "DGE Sync Detected", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpOn")]
+        public JoinDataComplete HdmiInHdcpOn = new JoinDataComplete(new JoinData { JoinNumber = 3, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State On", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpOff")]
+        public JoinDataComplete HdmiInHdcpOff = new JoinDataComplete(new JoinData { JoinNumber = 4, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State Off", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpToggle")]
+        public JoinDataComplete HdmiInHdcpToggle = new JoinDataComplete(new JoinData { JoinNumber = 5, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State Toggle", JoinCapabilities = eJoinCapabilities.FromSIMPL, JoinType = eJoinType.Digital });
+
+        public DgeJoinMap(uint joinStart)
+            : this(joinStart, typeof(DgeJoinMap))
+        {
+        }
+
+        /// <summary>
+        /// Constructor to use when extending this Join map
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        /// <param name="type">Type of the child join map</param>
+        protected DgeJoinMap(uint joinStart, Type type) : base(joinStart, type)
+        {
+        }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/DGEs/DmDge200CController.cs

@@ -58,37 +58,37 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             HdmiOut.Port = _dge.HdmiOut; ;
 
         }
-
-        public class DmDge200CControllerFactory : EssentialsDeviceFactory<DmDge200CController>
-        {
-            public DmDge200CControllerFactory()
-            {
-                TypeNames = new List<string>() { "dmdge200c" };
-            }
-
-            public override EssentialsDevice BuildDevice(DeviceConfig dc)
-            {
-                var typeName = dc.Type.ToLower();
-                var comm = CommFactory.GetControlPropertiesConfig(dc);
-                var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
-
-                Debug.Console(1, "Factory Attempting to create new DgeController  Device");
-
-                DmDge200C dgeDevice = null;
-
-                if (typeName == "dmdge200c")
-                    dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
-
-                if (dgeDevice == null)
-                {
-                    Debug.Console(1, "Unable to create DGE device");
-                    return null;
-                }
-
-                var dgeController = new DmDge200CController(dc.Key , dc.Name, dgeDevice, dc, props);
-
-                return dgeController;
-            }
-        }
     }
+
+	public class DmDge200CControllerFactory : EssentialsDeviceFactory<DmDge200CController>
+	{
+		public DmDge200CControllerFactory()
+		{
+			TypeNames = new List<string>() { "dmdge200c" };
+		}
+
+		public override EssentialsDevice BuildDevice(DeviceConfig dc)
+		{
+			var typeName = dc.Type.ToLower();
+			var comm = CommFactory.GetControlPropertiesConfig(dc);
+			var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
+
+			Debug.Console(1, "Factory Attempting to create new DgeController  Device");
+
+			DmDge200C dgeDevice = null;
+
+			if (typeName == "dmdge200c")
+				dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
+
+			if (dgeDevice == null)
+			{
+				Debug.Console(1, "Unable to create DGE device");
+				return null;
+			}
+
+			var dgeController = new DmDge200CController(dc.Key, dc.Name, dgeDevice, dc, props);
+
+			return dgeController;
+		}
+	}
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/EndpointInterfaces.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash_Essentials_DM
+{
+    public interface IHasDmInHdcpSet
+    {
+        void SetDmInHdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasDmInHdcpGet
+    {
+        IntFeedback DmInHdcpStateFeedback { get; }
+    }
+
+    public interface IHasDmInHdcp : IHasDmInHdcpGet, IHasDmInHdcpSet
+    {
+        eHdcpCapabilityType DmInHdcpCapability { get; }
+    }
+
+
+    public interface IHasHdmiInHdcpSet
+    {
+        void SetHdmiInHdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasHdmiInHdcpGet
+    {
+        IntFeedback HdmiInHdcpStateFeedback { get; }
+    }
+
+    public interface IHasHdmiInHdcp : IHasHdmiInHdcpGet, IHasHdmiInHdcpSet
+    {
+        eHdcpCapabilityType HdmiInHdcpCapability { get; }
+    }
+
+
+    public interface IHasHdmiIn1HdcpSet
+    {
+        void SetHdmiIn1HdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasHdmiIn1HdcpGet
+    {
+        IntFeedback HdmiIn1HdcpStateFeedback { get; }
+    }
+
+    public interface IHasHdmiIn1Hdcp : IHasHdmiIn1HdcpGet, IHasHdmiIn1HdcpSet
+    {
+        eHdcpCapabilityType HdmiIn1HdcpCapability { get; }
+    }
+
+
+    public interface IHasHdmiIn2HdcpSet
+    {
+        void SetHdmiIn2HdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasHdmiIn2HdcpGet
+    {
+        IntFeedback HdmiInIn2HdcpStateFeedback { get; }
+    }
+
+    public interface IHasHdmi2InHdcp : IHasHdmiIn2HdcpGet, IHasHdmiIn2HdcpSet
+    {
+        eHdcpCapabilityType Hdmi2InHdcpCapability { get; }
+    }
+
+
+
+    public interface IHasDisplayPortInHdcpGet
+    {
+        IntFeedback DisplayPortInHdcpStateFeedback { get; }
+    }
+
+    public interface IHasDisplayPortInHdcpSet
+    {
+        void SetDisplayPortInHdcpState(eHdcpCapabilityType hdcpState);
+    }
+
+    public interface IHasDisplayPortInHdcp : IHasDisplayPortInHdcpGet, IHasDisplayPortInHdcpSet
+    {
+        eHdcpCapabilityType DisplayPortInHdcpCapability { get; }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmHdBaseTEndpointController.cs

@@ -28,6 +28,8 @@ namespace PepperDash.Essentials.DM
 
             InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
             OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HDBaseTSink};
+            PreventRegistration = true;
+            rmc.Register();
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc150SController.cs

@@ -1,99 +1,99 @@
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
-
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Bridges;
-
-namespace PepperDash.Essentials.DM
-{
-    /// <summary>
-    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
-    /// 
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
     /// </summary>
-    [Description("Wrapper Class for DM-RMC-150-S")]
-    public class DmRmc150SController : DmRmcControllerBase, IRoutingInputsOutputs,
-        IIROutputPorts, IComPorts, ICec
-    {
-        private readonly DmRmc150S _rmc;
-
-        public RoutingInputPort DmIn { get; private set; }
-        public RoutingOutputPort HdmiOut { get; private set; }
-
-        public RoutingPortCollection<RoutingInputPort> InputPorts
-        {
-            get; private set;
-        }
-
-        public RoutingPortCollection<RoutingOutputPort> OutputPorts
-        {
-            get;
-            private set ;
-        }
-
-        /// <summary>
-        ///  Make a Crestron RMC and put it in here
-        /// </summary>
-        public DmRmc150SController(string key, string name, DmRmc150S rmc)
-            : base(key, name, rmc)
-        {
-            _rmc = rmc;
-            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
-                eRoutingPortConnectionType.DmCat, 0, this);
-            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
-                eRoutingPortConnectionType.Hdmi, null, this);
-
-            EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
-            EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
-            EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
-            EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
-
-            InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
-            OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut};
-
-            _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
-
-            // Set Ports for CEC
-            HdmiOut.Port = _rmc.HdmiOutput;
-        }
-
-        void ConnectedDevice_DeviceInformationChange(ConnectedDeviceInformation connectedDevice, ConnectedDeviceEventArgs args)
-        {
-            switch (args.EventId)
-            {
-                case ConnectedDeviceEventIds.ManufacturerEventId:
-                    EdidManufacturerFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.NameEventId:
-                    EdidNameFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.PreferredTimingEventId:
-                    EdidPreferredTimingFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.SerialNumberEventId:
-                    EdidSerialNumberFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-        {
-            LinkDmRmcToApi(this, trilist, joinStart, joinMapKey, bridge);
-        }
-
-        #region IIROutputPorts Members
-        public CrestronCollection<IROutputPort> IROutputPorts { get { return _rmc.IROutputPorts; } }
-        public int NumberOfIROutputPorts { get { return _rmc.NumberOfIROutputPorts; } }
-        #endregion
-
-        #region IComPorts Members
-        public CrestronCollection<ComPort> ComPorts { get { return _rmc.ComPorts; } }
-        public int NumberOfComPorts { get { return _rmc.NumberOfComPorts; } }
-        #endregion
-
-        #region ICec Members
-        public Cec StreamCec { get { return _rmc.HdmiOutput.StreamCec; } }
-        #endregion
-    }
+    [Description("Wrapper Class for DM-RMC-150-S")]
+    public class DmRmc150SController : DmRmcControllerBase, IRoutingInputsOutputs,
+        IIROutputPorts, IComPorts, ICec
+    {
+        private readonly DmRmc150S _rmc;
+
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get; private set;
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get;
+            private set ;
+        }
+
+        /// <summary>
+        ///  Make a Crestron RMC and put it in here
+        /// </summary>
+        public DmRmc150SController(string key, string name, DmRmc150S rmc)
+            : base(key, name, rmc)
+        {
+            _rmc = rmc;
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DmCat, 0, this);
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, null, this);
+
+            EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
+            EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
+            EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
+            EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
+
+            InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut};
+
+            _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
+
+            // Set Ports for CEC
+            HdmiOut.Port = _rmc.HdmiOutput;
+        }
+
+        void ConnectedDevice_DeviceInformationChange(ConnectedDeviceInformation connectedDevice, ConnectedDeviceEventArgs args)
+        {
+            switch (args.EventId)
+            {
+                case ConnectedDeviceEventIds.ManufacturerEventId:
+                    EdidManufacturerFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.NameEventId:
+                    EdidNameFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.PreferredTimingEventId:
+                    EdidPreferredTimingFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.SerialNumberEventId:
+                    EdidSerialNumberFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            LinkDmRmcToApi(this, trilist, joinStart, joinMapKey, bridge);
+        }
+
+        #region IIROutputPorts Members
+        public CrestronCollection<IROutputPort> IROutputPorts { get { return _rmc.IROutputPorts; } }
+        public int NumberOfIROutputPorts { get { return _rmc.NumberOfIROutputPorts; } }
+        #endregion
+
+        #region IComPorts Members
+        public CrestronCollection<ComPort> ComPorts { get { return _rmc.ComPorts; } }
+        public int NumberOfComPorts { get { return _rmc.NumberOfComPorts; } }
+        #endregion
+
+        #region ICec Members
+        public Cec StreamCec { get { return _rmc.HdmiOutput.StreamCec; } }
+        #endregion
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc200CController.cs

@@ -1,111 +1,111 @@
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
-
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Bridges;
-
-namespace PepperDash.Essentials.DM
-{
-	/// <summary>
-	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
-	/// 
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
 	/// </summary>
     [Description("Wrapper Class for DM-RMC-200-C")]
-    public class DmRmc200CController : DmRmcControllerBase, IRoutingInputsOutputs,
-		IIROutputPorts, IComPorts, ICec
-	{
-	    private readonly DmRmc200C _rmc;
-
-		public RoutingInputPort DmIn { get; private set; }
+    public class DmRmc200CController : DmRmcControllerBase, IRoutingInputsOutputs,
+		IIROutputPorts, IComPorts, ICec
+	{
+	    private readonly DmRmc200C _rmc;
+
+		public RoutingInputPort DmIn { get; private set; }
 		public RoutingOutputPort HdmiOut { get; private set; }
-
-		public RoutingPortCollection<RoutingInputPort> InputPorts
-		{
-			get; private set;
-		}
-
-		public RoutingPortCollection<RoutingOutputPort> OutputPorts
-		{
-			get; private set;
-		}
-
-		/// <summary>
-		///  Make a Crestron RMC and put it in here
-		/// </summary>
-		public DmRmc200CController(string key, string name, DmRmc200C rmc)
-			: base(key, name, rmc)
-		{
-			_rmc = rmc;
-			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
-				eRoutingPortConnectionType.DmCat, 0, this);
-			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
-				eRoutingPortConnectionType.Hdmi, null, this);
-
-            EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
-            EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
-            EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
-            EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
-
-            VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
-
-            _rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
-            _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
-
-		    InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
-		    OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut};
-
-            // Set Ports for CEC
-            HdmiOut.Port = _rmc.HdmiOutput;
-        }
-
-        void HdmiOutput_OutputStreamChange(EndpointOutputStream outputStream, EndpointOutputStreamEventArgs args)
-        {
-            if (args.EventId == EndpointOutputStreamEventIds.HorizontalResolutionFeedbackEventId || args.EventId == EndpointOutputStreamEventIds.VerticalResolutionFeedbackEventId ||
-                args.EventId == EndpointOutputStreamEventIds.FramesPerSecondFeedbackEventId)
-            {
-                VideoOutputResolutionFeedback.FireUpdate();
-            }
-        }
-
-        void ConnectedDevice_DeviceInformationChange(ConnectedDeviceInformation connectedDevice, ConnectedDeviceEventArgs args)
-        {
-            switch (args.EventId)
-            {
-                case ConnectedDeviceEventIds.ManufacturerEventId:
-                    EdidManufacturerFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.NameEventId:
-                    EdidNameFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.PreferredTimingEventId:
-                    EdidPreferredTimingFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.SerialNumberEventId:
-                    EdidSerialNumberFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-	    public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-	    {
-	        LinkDmRmcToApi(this, trilist, joinStart, joinMapKey, bridge);
-	    }
-
-	    #region IIROutputPorts Members
-		public CrestronCollection<IROutputPort> IROutputPorts { get { return _rmc.IROutputPorts; } }
-		public int NumberOfIROutputPorts { get { return _rmc.NumberOfIROutputPorts; } }
-		#endregion
-
-		#region IComPorts Members
-		public CrestronCollection<ComPort> ComPorts { get { return _rmc.ComPorts; } }
-		public int NumberOfComPorts { get { return _rmc.NumberOfComPorts; } }
-		#endregion
-
-		#region ICec Members
-		public Cec StreamCec { get { return _rmc.HdmiOutput.StreamCec; } }
-		#endregion
-	}
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get; private set;
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get; private set;
+		}
+
+		/// <summary>
+		///  Make a Crestron RMC and put it in here
+		/// </summary>
+		public DmRmc200CController(string key, string name, DmRmc200C rmc)
+			: base(key, name, rmc)
+		{
+			_rmc = rmc;
+			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.DmCat, 0, this);
+			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, null, this);
+
+            EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
+            EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
+            EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
+            EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
+
+            VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
+
+            _rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
+            _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
+
+		    InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
+		    OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut};
+
+            // Set Ports for CEC
+            HdmiOut.Port = _rmc.HdmiOutput;
+        }
+
+        void HdmiOutput_OutputStreamChange(EndpointOutputStream outputStream, EndpointOutputStreamEventArgs args)
+        {
+            if (args.EventId == EndpointOutputStreamEventIds.HorizontalResolutionFeedbackEventId || args.EventId == EndpointOutputStreamEventIds.VerticalResolutionFeedbackEventId ||
+                args.EventId == EndpointOutputStreamEventIds.FramesPerSecondFeedbackEventId)
+            {
+                VideoOutputResolutionFeedback.FireUpdate();
+            }
+        }
+
+        void ConnectedDevice_DeviceInformationChange(ConnectedDeviceInformation connectedDevice, ConnectedDeviceEventArgs args)
+        {
+            switch (args.EventId)
+            {
+                case ConnectedDeviceEventIds.ManufacturerEventId:
+                    EdidManufacturerFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.NameEventId:
+                    EdidNameFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.PreferredTimingEventId:
+                    EdidPreferredTimingFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.SerialNumberEventId:
+                    EdidSerialNumberFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+	    public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+	    {
+	        LinkDmRmcToApi(this, trilist, joinStart, joinMapKey, bridge);
+	    }
+
+	    #region IIROutputPorts Members
+		public CrestronCollection<IROutputPort> IROutputPorts { get { return _rmc.IROutputPorts; } }
+		public int NumberOfIROutputPorts { get { return _rmc.NumberOfIROutputPorts; } }
+		#endregion
+
+		#region IComPorts Members
+		public CrestronCollection<ComPort> ComPorts { get { return _rmc.ComPorts; } }
+		public int NumberOfComPorts { get { return _rmc.NumberOfComPorts; } }
+		#endregion
+
+		#region ICec Members
+		public Cec StreamCec { get { return _rmc.HdmiOutput.StreamCec; } }
+		#endregion
+	}
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc4KScalerCController.cs

@@ -1,196 +1,220 @@
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Bridges;
-
-namespace PepperDash.Essentials.DM
-{
-	/// <summary>
-	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
-	/// 
-	/// </summary>
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash_Essentials_DM;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
+    /// </summary>
     [Description("Wrapper Class for DM-RMC-4K-SCALER-C")]
-    public class DmRmc4kScalerCController : DmRmcControllerBase, IRoutingInputsOutputs, IBasicVolumeWithFeedback,
-		IIROutputPorts, IComPorts, ICec, IRelayPorts
-	{
-	    private readonly DmRmc4kScalerC _rmc;
-
-		public RoutingInputPort DmIn { get; private set; }
-		public RoutingOutputPort HdmiOut { get; private set; }
-		public RoutingOutputPort BalancedAudioOut { get; private set; }
-
-		public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
-
-		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
-
-		/// <summary>
-		///  Make a Crestron RMC and put it in here
-		/// </summary>
-		public DmRmc4kScalerCController(string key, string name, DmRmc4kScalerC rmc)
-			: base(key, name, rmc)
-		{
-			_rmc = rmc;
-
-			DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo, 
-				eRoutingPortConnectionType.DmCat, 0, this);
-			HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo, 
-				eRoutingPortConnectionType.Hdmi, null, this);
-			BalancedAudioOut = new RoutingOutputPort(DmPortName.BalancedAudioOut, eRoutingSignalType.Audio,
-				eRoutingPortConnectionType.LineAudio, null, this);
-
-			MuteFeedback = new BoolFeedback(() => false);
-
-			VolumeLevelFeedback = new IntFeedback("MainVolumeLevelFeedback", () => 
-				rmc.AudioOutput.VolumeFeedback.UShortValue);
-
-            EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
-            EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
-            EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
-            EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
-
-		    InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
-		    OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut, BalancedAudioOut};
-
-            VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
-
-            _rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
-            _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
-
-            // Set Ports for CEC
-            HdmiOut.Port = _rmc.HdmiOutput;
-        }
-
-        void HdmiOutput_OutputStreamChange(EndpointOutputStream outputStream, EndpointOutputStreamEventArgs args)
-        {
-            if (args.EventId == EndpointOutputStreamEventIds.HorizontalResolutionFeedbackEventId || args.EventId == EndpointOutputStreamEventIds.VerticalResolutionFeedbackEventId ||
-                args.EventId == EndpointOutputStreamEventIds.FramesPerSecondFeedbackEventId)
-            {
-                VideoOutputResolutionFeedback.FireUpdate();
-            }
-        }
-
-        void ConnectedDevice_DeviceInformationChange(ConnectedDeviceInformation connectedDevice, ConnectedDeviceEventArgs args)
-        {
-            switch (args.EventId)
-            {
-                case ConnectedDeviceEventIds.ManufacturerEventId:
-                    EdidManufacturerFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.NameEventId:
-                    EdidNameFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.PreferredTimingEventId:
-                    EdidPreferredTimingFeedback.FireUpdate();
-                    break;
-                case ConnectedDeviceEventIds.SerialNumberEventId:
-                    EdidSerialNumberFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-	    public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-	    {
-	        LinkDmRmcToApi(this, trilist, joinStart, joinMapKey, bridge);
-	    }
-
-	    #region IIROutputPorts Members
-		public CrestronCollection<IROutputPort> IROutputPorts { get { return _rmc.IROutputPorts; } }
-		public int NumberOfIROutputPorts { get { return _rmc.NumberOfIROutputPorts; } }
-		#endregion
-
-		#region IComPorts Members
-		public CrestronCollection<ComPort> ComPorts { get { return _rmc.ComPorts; } }
-		public int NumberOfComPorts { get { return _rmc.NumberOfComPorts; } }
-		#endregion
-
-		#region ICec Members
-		/// <summary>
-		/// Gets the CEC stream directly from the HDMI port.
-		/// </summary>
-		public Cec StreamCec { get { return _rmc.HdmiOutput.StreamCec; } }
-		#endregion
-
-		#region IRelayPorts Members
-
-		public int NumberOfRelayPorts
-		{
-			get { return _rmc.NumberOfRelayPorts; }
-		}
-
-		public CrestronCollection<Relay> RelayPorts
-		{
-			get { return _rmc.RelayPorts; }
-		}
-
-		#endregion
-
-		#region IBasicVolumeWithFeedback Members
-
-		public BoolFeedback MuteFeedback
-		{
-			get;
-			private set;
-		}
-
-		/// <summary>
-		/// Not implemented
-		/// </summary>
-		public void MuteOff()
-		{	
-            Debug.Console(2, this, "DM Endpoint {0} does not have a mute function", Key);
-		}
-
-		/// <summary>
-		/// Not implemented
-		/// </summary>
-		public void MuteOn()
-		{
-            Debug.Console(2, this, "DM Endpoint {0} does not have a mute function", Key);
-		}
-
-		public void SetVolume(ushort level)
-		{
-			_rmc.AudioOutput.Volume.UShortValue = level;
-		}
-
-		public IntFeedback VolumeLevelFeedback
-		{
-			get;
-			private set;
-		}
-
-		#endregion
-
-		#region IBasicVolumeControls Members
-
-		/// <summary>
-		/// Not implemented
-		/// </summary>
-		public void MuteToggle()
-		{
-            Debug.Console(2, this, "DM Endpoint {0} does not have a mute function", Key);
-		}
-
-		public void VolumeDown(bool pressRelease)
-		{
-			if (pressRelease)
-				SigHelper.RampTimeScaled(_rmc.AudioOutput.Volume, 0, 4000);
-			else
-				_rmc.AudioOutput.Volume.StopRamp();
-		}
-
-		public void VolumeUp(bool pressRelease)
-		{
-			if (pressRelease)
-				SigHelper.RampTimeScaled(_rmc.AudioOutput.Volume, 65535, 4000);
-			else
-				_rmc.AudioOutput.Volume.StopRamp();
-		}
-
-		#endregion
-	}
+    public class DmRmc4kScalerCController : DmRmcControllerBase, IRoutingInputsOutputs, IBasicVolumeWithFeedback,
+        IIROutputPorts, IComPorts, ICec, IRelayPorts, IHasDmInHdcp
+    {
+        private readonly DmRmc4kScalerC _rmc;
+
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+        public RoutingOutputPort BalancedAudioOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+        public EndpointDmInputStreamWithCec DmInput { get; private set; }
+
+        public IntFeedback DmInHdcpStateFeedback { get; private set; }
+
+
+
+        /// <summary>
+        ///  Make a Crestron RMC and put it in here
+        /// </summary>
+        public DmRmc4kScalerCController(string key, string name, DmRmc4kScalerC rmc)
+            : base(key, name, rmc)
+        {
+            _rmc = rmc;
+
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DmCat, 0, this);
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, null, this);
+            BalancedAudioOut = new RoutingOutputPort(DmPortName.BalancedAudioOut, eRoutingSignalType.Audio,
+                eRoutingPortConnectionType.LineAudio, null, this);
+
+            MuteFeedback = new BoolFeedback(() => false);
+
+            VolumeLevelFeedback = new IntFeedback("MainVolumeLevelFeedback", () =>
+                rmc.AudioOutput.VolumeFeedback.UShortValue);
+
+            EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
+            EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
+            EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
+            EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
+
+            InputPorts = new RoutingPortCollection<RoutingInputPort> { DmIn };
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut, BalancedAudioOut };
+
+            VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
+            DmInHdcpStateFeedback = new IntFeedback("DmInHdcpCapability",
+                () => (int)_rmc.DmInput.HdcpCapabilityFeedback);
+
+            AddToFeedbackList(DmInHdcpStateFeedback);
+
+
+            _rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
+            _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
+
+            // Set Ports for CEC
+            HdmiOut.Port = _rmc.HdmiOutput;
+        }
+
+        void HdmiOutput_OutputStreamChange(EndpointOutputStream outputStream, EndpointOutputStreamEventArgs args)
+        {
+            if (args.EventId == EndpointOutputStreamEventIds.HorizontalResolutionFeedbackEventId || args.EventId == EndpointOutputStreamEventIds.VerticalResolutionFeedbackEventId ||
+                args.EventId == EndpointOutputStreamEventIds.FramesPerSecondFeedbackEventId)
+            {
+                VideoOutputResolutionFeedback.FireUpdate();
+            }
+        }
+
+        void ConnectedDevice_DeviceInformationChange(ConnectedDeviceInformation connectedDevice, ConnectedDeviceEventArgs args)
+        {
+            switch (args.EventId)
+            {
+                case ConnectedDeviceEventIds.ManufacturerEventId:
+                    EdidManufacturerFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.NameEventId:
+                    EdidNameFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.PreferredTimingEventId:
+                    EdidPreferredTimingFeedback.FireUpdate();
+                    break;
+                case ConnectedDeviceEventIds.SerialNumberEventId:
+                    EdidSerialNumberFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            LinkDmRmcToApi(this, trilist, joinStart, joinMapKey, bridge);
+        }
+
+        #region IIROutputPorts Members
+        public CrestronCollection<IROutputPort> IROutputPorts { get { return _rmc.IROutputPorts; } }
+        public int NumberOfIROutputPorts { get { return _rmc.NumberOfIROutputPorts; } }
+        #endregion
+
+        #region IComPorts Members
+        public CrestronCollection<ComPort> ComPorts { get { return _rmc.ComPorts; } }
+        public int NumberOfComPorts { get { return _rmc.NumberOfComPorts; } }
+        #endregion
+
+        #region ICec Members
+        /// <summary>
+        /// Gets the CEC stream directly from the HDMI port.
+        /// </summary>
+        public Cec StreamCec { get { return _rmc.HdmiOutput.StreamCec; } }
+        #endregion
+
+        #region IRelayPorts Members
+
+        public int NumberOfRelayPorts
+        {
+            get { return _rmc.NumberOfRelayPorts; }
+        }
+
+        public CrestronCollection<Relay> RelayPorts
+        {
+            get { return _rmc.RelayPorts; }
+        }
+
+        #endregion
+
+        #region IBasicVolumeWithFeedback Members
+
+        public BoolFeedback MuteFeedback
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Not implemented
+        /// </summary>
+        public void MuteOff()
+        {
+            Debug.Console(2, this, "DM Endpoint {0} does not have a mute function", Key);
+        }
+
+        /// <summary>
+        /// Not implemented
+        /// </summary>
+        public void MuteOn()
+        {
+            Debug.Console(2, this, "DM Endpoint {0} does not have a mute function", Key);
+        }
+
+        public void SetVolume(ushort level)
+        {
+            _rmc.AudioOutput.Volume.UShortValue = level;
+        }
+
+        public IntFeedback VolumeLevelFeedback
+        {
+            get;
+            private set;
+        }
+
+        #endregion
+
+        #region IBasicVolumeControls Members
+
+        /// <summary>
+        /// Not implemented
+        /// </summary>
+        public void MuteToggle()
+        {
+            Debug.Console(2, this, "DM Endpoint {0} does not have a mute function", Key);
+        }
+
+        public void VolumeDown(bool pressRelease)
+        {
+            if (pressRelease)
+                SigHelper.RampTimeScaled(_rmc.AudioOutput.Volume, 0, 4000);
+            else
+                _rmc.AudioOutput.Volume.StopRamp();
+        }
+
+        public void VolumeUp(bool pressRelease)
+        {
+            if (pressRelease)
+                SigHelper.RampTimeScaled(_rmc.AudioOutput.Volume, 65535, 4000);
+            else
+                _rmc.AudioOutput.Volume.StopRamp();
+        }
+
+        #endregion
+
+        public eHdcpCapabilityType DmInHdcpCapability
+        {
+            get { return eHdcpCapabilityType.Hdcp2_2Support; }
+        }
+
+        public void SetDmInHdcpState(eHdcpCapabilityType hdcpState)
+        {
+            if (_rmc == null) return;
+            _rmc.DmInput.HdcpCapability = hdcpState;
+        }
+
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc4k100C1GController.cs

@@ -32,7 +32,9 @@ namespace PepperDash.Essentials.DM
                 eRoutingPortConnectionType.Hdmi, null, this) {Port = _rmc};
 
             InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
-            OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut};
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut};
+            PreventRegistration = true;
+            rmc.Register();
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc4kScalerCDspController.cs

@@ -5,8 +5,9 @@ using Crestron.SimplSharpPro.DM.Endpoints;
 using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Bridges;
-
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash_Essentials_DM;
+
 namespace PepperDash.Essentials.DM
 {
     /// <summary>
@@ -15,7 +16,7 @@ namespace PepperDash.Essentials.DM
     /// </summary>
     [Description("Wrapper Class for DM-RMC-4K-SCALER-C-DSP")]
     public class DmRmc4kScalerCDspController : DmRmcControllerBase, IRoutingInputsOutputs, IBasicVolumeWithFeedback,
-        IIROutputPorts, IComPorts, ICec, IRelayPorts
+        IIROutputPorts, IComPorts, ICec, IRelayPorts, IHasDmInHdcp
     {
         private readonly DmRmc4kScalerCDsp _rmc;
 
@@ -25,7 +26,12 @@ namespace PepperDash.Essentials.DM
 
         public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
 
-        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+        public EndpointDmInputStreamWithCec DmInput { get; private set; }
+
+        public IntFeedback DmInHdcpStateFeedback { get; private set; }
+
 
         /// <summary>
         ///  Make a Crestron RMC and put it in here
@@ -51,7 +57,13 @@ namespace PepperDash.Essentials.DM
             EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
             EdidSerialNumberFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.SerialNumber.StringValue);
 
-            VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
+            VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
+
+            DmInHdcpStateFeedback = new IntFeedback("DmInHdcpCapability",
+                () => (int) _rmc.DmInput.HdcpCapabilityFeedback);
+
+            AddToFeedbackList(DmInHdcpStateFeedback);
+
 
             InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn};
             OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut, BalancedAudioOut};
@@ -190,6 +202,18 @@ namespace PepperDash.Essentials.DM
                 _rmc.AudioOutput.Volume.StopRamp();
         }
 
-        #endregion
+        #endregion
+
+        public eHdcpCapabilityType DmInHdcpCapability
+        {
+            get { return eHdcpCapabilityType.Hdcp2_2Support; }
+        }
+
+        public void SetDmInHdcpState(eHdcpCapabilityType hdcpState)
+        {
+            if (_rmc == null) return;
+            _rmc.DmInput.HdcpCapability = hdcpState;
+        }
+
     }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmc4kZScalerCController.cs

@@ -9,12 +9,13 @@ using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Core;
+using PepperDash_Essentials_DM;
 
 namespace PepperDash.Essentials.DM
 {
     [Description("Wrapper Class for DM-RMC-4K-Z-SCALER-C")]
     public class DmRmc4kZScalerCController : DmRmcControllerBase, IRmcRoutingWithFeedback,
-        IIROutputPorts, IComPorts, ICec, IRelayPorts
+        IIROutputPorts, IComPorts, ICec, IRelayPorts, IHasDmInHdcp, IHasHdmiInHdcp
     {
         private readonly DmRmc4kzScalerC _rmc;
 
@@ -22,6 +23,13 @@ namespace PepperDash.Essentials.DM
         public RoutingInputPort HdmiIn { get; private set; }
         public RoutingOutputPort HdmiOut { get; private set; }
 
+        public IntFeedback DmInHdcpStateFeedback { get; private set; }
+        public IntFeedback HdmiInHdcpStateFeedback { get; private set; }
+
+        public BoolFeedback HdmiVideoSyncFeedback { get; private set; }
+
+
+
         /// <summary>
         /// The value of the current video source for the HDMI output on the receiver
         /// </summary>
@@ -42,13 +50,13 @@ namespace PepperDash.Essentials.DM
         {
             var newEvent = NumericSwitchChange;
             if (newEvent != null) newEvent(this, e);
-        }
-
+        }
 
         public DmRmc4kZScalerCController(string key, string name, DmRmc4kzScalerC rmc)
             : base(key, name, rmc)
         {
             _rmc = rmc;
+
             DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
                 eRoutingPortConnectionType.DmCat, 0, this)
             {
@@ -62,6 +70,16 @@ namespace PepperDash.Essentials.DM
             HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
                 eRoutingPortConnectionType.Hdmi, null, this);
 
+            HdmiInHdcpStateFeedback = new IntFeedback("HdmiInHdcpCapability",
+                () => (int)_rmc.HdmiIn.HdcpCapabilityFeedback);
+            DmInHdcpStateFeedback = new IntFeedback("DmInHdcpCapability",
+                () => (int)_rmc.DmInput.HdcpCapabilityFeedback);
+            HdmiVideoSyncFeedback = new BoolFeedback("HdmiInVideoSync",
+                () => _rmc.HdmiIn.SyncDetectedFeedback.BoolValue);
+
+            AddToFeedbackList(HdmiInHdcpStateFeedback, DmInHdcpStateFeedback, HdmiVideoSyncFeedback);
+
+
             EdidManufacturerFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Manufacturer.StringValue);
             EdidNameFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.Name.StringValue);
             EdidPreferredTimingFeedback = new StringFeedback(() => _rmc.HdmiOutput.ConnectedDevice.PreferredTiming.StringValue);
@@ -69,11 +87,13 @@ namespace PepperDash.Essentials.DM
 
             VideoOutputResolutionFeedback = new StringFeedback(() => _rmc.HdmiOutput.GetVideoResolutionString());
 
-            InputPorts = new RoutingPortCollection<RoutingInputPort> {DmIn, HdmiIn};
-            OutputPorts = new RoutingPortCollection<RoutingOutputPort> {HdmiOut};
+            InputPorts = new RoutingPortCollection<RoutingInputPort> { DmIn, HdmiIn };
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut };
 
             _rmc.HdmiOutput.OutputStreamChange += HdmiOutput_OutputStreamChange;
             _rmc.HdmiOutput.ConnectedDevice.DeviceInformationChange += ConnectedDevice_DeviceInformationChange;
+            _rmc.HdmiIn.InputStreamChange += InputStreamChangeEvent;
+            _rmc.DmInput.InputStreamChange += InputStreamChangeEvent;
 
             _rmc.OnlineStatusChange += _rmc_OnlineStatusChange;
 
@@ -83,6 +103,20 @@ namespace PepperDash.Essentials.DM
             AudioVideoSourceNumericFeedback = new IntFeedback(() => (ushort)(_rmc.SelectedSourceFeedback));
         }
 
+        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
+        {
+            switch (args.EventId)
+            {
+                case EndpointInputStreamEventIds.HdcpCapabilityFeedbackEventId:
+                    if (inputStream == _rmc.HdmiIn) HdmiInHdcpStateFeedback.FireUpdate();
+                    if (inputStream == _rmc.DmInput) DmInHdcpStateFeedback.FireUpdate();
+                    break;
+                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
+                    if (inputStream == _rmc.HdmiIn) HdmiVideoSyncFeedback.FireUpdate();
+                    break;
+            }
+        }
+
         private void _rmc_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
         {
             AudioVideoSourceNumericFeedback.FireUpdate();
@@ -181,5 +215,31 @@ namespace PepperDash.Essentials.DM
         }
 
         #endregion
+
+
+        public eHdcpCapabilityType DmInHdcpCapability
+        {
+            get { return eHdcpCapabilityType.Hdcp2_2Support; }
+        }
+
+        public void SetDmInHdcpState(eHdcpCapabilityType hdcpState)
+        {
+
+            if (_rmc == null) return;
+            _rmc.DmInput.HdcpCapability = hdcpState;
+        }
+
+
+        public eHdcpCapabilityType HdmiInHdcpCapability
+        {
+            get { return eHdcpCapabilityType.Hdcp2_2Support; }
+        }
+
+        public void SetHdmiInHdcpState(eHdcpCapabilityType hdcpState)
+        {
+            if (_rmc == null) return;
+            _rmc.HdmiIn.HdcpCapability = hdcpState;
+        }
+
     }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Receivers/DmRmcHelper.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.DM;
 using Crestron.SimplSharpPro.DM.Cards;
@@ -11,11 +12,12 @@ using PepperDash.Essentials.Core.Bridges;
 using PepperDash.Essentials.Core.DeviceInfo;
 using PepperDash.Essentials.DM.Config;
 using PepperDash.Essentials.Core.Config;
+using PepperDash_Essentials_DM;
 
 namespace PepperDash.Essentials.DM
 {
     [Description("Wrapper class for all DM-RMC variants")]
-	public abstract class DmRmcControllerBase : CrestronGenericBridgeableBaseDevice, IDeviceInfoProvider
+    public abstract class DmRmcControllerBase : CrestronGenericBridgeableBaseDevice, IDeviceInfoProvider
     {
         private const int CtpPort = 41795;
         private readonly EndpointReceiverBase _rmc; //kept here just in case. Only property or method on this class that's not device-specific is the DMOutput that it's attached to.
@@ -27,15 +29,15 @@ namespace PepperDash.Essentials.DM
         public StringFeedback EdidSerialNumberFeedback { get; protected set; }
 
         protected DmRmcControllerBase(string key, string name, EndpointReceiverBase device)
-			: base(key, name, device)
+            : base(key, name, device)
         {
             _rmc = device;
 
-			// if wired to a chassis, skip registration step in base class
+            // if wired to a chassis, skip registration step in base class
             PreventRegistration = _rmc.DMOutput != null;
-			
+
             AddToFeedbackList(VideoOutputResolutionFeedback, EdidManufacturerFeedback, EdidSerialNumberFeedback, EdidNameFeedback, EdidPreferredTimingFeedback);
-            
+
             DeviceInfo = new DeviceInfo();
 
             IsOnline.OutputChange += (currentDevice, args) => { if (args.BoolValue) UpdateDeviceInfo(); };
@@ -73,19 +75,80 @@ namespace PepperDash.Essentials.DM
                 rmc.EdidPreferredTimingFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidPrefferedTiming.JoinNumber]);
             if (rmc.EdidSerialNumberFeedback != null)
                 rmc.EdidSerialNumberFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidSerialNumber.JoinNumber]);
-            
+
+
             //If the device is an DM-RMC-4K-Z-SCALER-C
-            var routing = rmc as IRmcRouting;
+            var routing = rmc as IRoutingInputsOutputs;
+
+            trilist.UShortInput[joinMap.HdcpInputPortCount.JoinNumber].UShortValue = (ushort)(routing == null
+                ? 1
+                : routing.InputPorts.Count);
 
             if (routing == null)
             {
                 return;
             }
+            var hdcpCapability = eHdcpCapabilityType.HdcpSupportOff;
+            if (routing.InputPorts[DmPortName.HdmiIn] != null)
+            {
+                var hdmiInHdcp = routing as IHasHdmiInHdcp;
+                if (hdmiInHdcp != null)
+                {
+                    if (rmc.Feedbacks["HdmiInHdcpCapability"] != null)
+                    {
+                        var intFeedback = rmc.Feedbacks["HdmiInHdcpCapability"] as IntFeedback;
+                        if (intFeedback != null)
+                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState.JoinNumber]);
+                    }
+                    if (rmc.Feedbacks["HdmiInVideoSync"] != null)
+                    {
+                        var boolFeedback = rmc.Feedbacks["HdmiInVideoSync"] as BoolFeedback;
+                        if (boolFeedback != null)
+                            boolFeedback.LinkInputSig(trilist.BooleanInput[joinMap.HdmiInputSync.JoinNumber]);
+                    }
+                    hdcpCapability = hdmiInHdcp.HdmiInHdcpCapability > hdcpCapability
+                        ? hdmiInHdcp.HdmiInHdcpCapability
+                        : hdcpCapability;
 
-            if (routing.AudioVideoSourceNumericFeedback != null)
-                routing.AudioVideoSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.AudioVideoSource.JoinNumber]);
+                    trilist.SetUShortSigAction(joinMap.Port1HdcpState.JoinNumber, a => hdmiInHdcp.SetHdmiInHdcpState((eHdcpCapabilityType)a));
+                }
+            }
+            if (routing.InputPorts[DmPortName.DmIn] != null)
+            {
+                var dmInHdcp = rmc as IHasDmInHdcp;
 
-            trilist.SetUShortSigAction(joinMap.AudioVideoSource.JoinNumber, a => routing.ExecuteNumericSwitch(a, 1, eRoutingSignalType.AudioVideo));
+                if (dmInHdcp != null)
+                {
+                    if (rmc.Feedbacks["DmInHdcpCapability"] != null)
+                    {
+                        var intFeedback = rmc.Feedbacks["DmInHdcpCapability"] as IntFeedback;
+                        if (intFeedback != null)
+                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port2HdcpState.JoinNumber]);
+                    }
+
+                    hdcpCapability = dmInHdcp.DmInHdcpCapability > hdcpCapability
+                        ? dmInHdcp.DmInHdcpCapability
+                        : hdcpCapability;
+
+
+                    trilist.SetUShortSigAction(joinMap.Port2HdcpState.JoinNumber, a => dmInHdcp.SetDmInHdcpState((eHdcpCapabilityType)a));
+                }
+            }
+
+            trilist.UShortInput[joinMap.HdcpSupportCapability.JoinNumber].UShortValue = (ushort)hdcpCapability;
+
+            trilist.UShortInput[joinMap.HdcpInputPortCount.JoinNumber].UShortValue = (ushort)routing.InputPorts.Count;
+
+            var routingWithFeedback = routing as IRmcRouting;
+            if (routingWithFeedback == null) return;
+
+            if (routingWithFeedback.AudioVideoSourceNumericFeedback != null)
+                routingWithFeedback.AudioVideoSourceNumericFeedback.LinkInputSig(
+                    trilist.UShortInput[joinMap.AudioVideoSource.JoinNumber]);
+
+
+            trilist.SetUShortSigAction(joinMap.AudioVideoSource.JoinNumber,
+                a => routingWithFeedback.ExecuteNumericSwitch(a, 1, eRoutingSignalType.AudioVideo));
         }
 
         #region Implementation of IDeviceInfoProvider
@@ -143,13 +206,13 @@ namespace PepperDash.Essentials.DM
                     return;
                 }
 
-                
+
                 if (args.Text.ToLower().Contains("host"))
                 {
                     DeviceInfo.HostName = args.Text.Split(':')[1].Trim();
 
                     tcpClient.SendText("maca\r\n");
-                    
+
                     return;
                 }
 
@@ -202,17 +265,17 @@ namespace PepperDash.Essentials.DM
         }
     }
 
-	public class DmRmcHelper
-	{
-	    private static readonly Dictionary<string, Func<string, string, uint, CrestronGenericBaseDevice>> ProcessorFactoryDict;
-	    private static readonly Dictionary<string, Func<string, string, DMOutput, CrestronGenericBaseDevice>> ChassisCpu3Dict;
+    public class DmRmcHelper
+    {
+        private static readonly Dictionary<string, Func<string, string, uint, CrestronGenericBaseDevice>> ProcessorFactoryDict;
+        private static readonly Dictionary<string, Func<string, string, DMOutput, CrestronGenericBaseDevice>> ChassisCpu3Dict;
 
-	    private static readonly Dictionary<string, Func<string, string, uint, DMOutput, CrestronGenericBaseDevice>>
-	        ChassisDict; 
+        private static readonly Dictionary<string, Func<string, string, uint, DMOutput, CrestronGenericBaseDevice>>
+            ChassisDict;
 
-	    static DmRmcHelper()
-	    {
-	        ProcessorFactoryDict = new Dictionary<string, Func<string, string, uint, CrestronGenericBaseDevice>>
+        static DmRmcHelper()
+        {
+            ProcessorFactoryDict = new Dictionary<string, Func<string, string, uint, CrestronGenericBaseDevice>>
 	        {
 	            {"dmrmc100c", (k, n, i) => new DmRmcX100CController(k, n, new DmRmc100C(i, Global.ControlSystem))},
 	            {"dmrmc100s", (k, n, i) => new DmRmc100SController(k, n, new DmRmc100S(i, Global.ControlSystem))},
@@ -306,31 +369,34 @@ namespace PepperDash.Essentials.DM
                 {"dmrmc4k100c1g", (k,n,i,d) => new DmRmc4k100C1GController(k,n, new DmRmc4K100C1G(i, d))}
 	        };
         }
-	    /// <summary>
-	    /// A factory method for various DmRmcControllers
-	    /// </summary>
-	    /// <param name="key">device key. Used to uniquely identify device</param>
-	    /// <param name="name">device name</param>
-	    /// <param name="typeName">device type name. Used to retrived the correct device</param>
-	    /// <param name="props">Config from config file</param>
-	    /// <returns></returns>
-	    public static CrestronGenericBaseDevice GetDmRmcController(string key, string name, string typeName, DmRmcPropertiesConfig props)
-		{
-			typeName = typeName.ToLower();
-			var ipid = props.Control.IpIdInt;
+        /// <summary>
+        /// A factory method for various DmRmcControllers
+        /// </summary>
+        /// <param name="key">device key. Used to uniquely identify device</param>
+        /// <param name="name">device name</param>
+        /// <param name="typeName">device type name. Used to retrived the correct device</param>
+        /// <param name="props">Config from config file</param>
+        /// <returns></returns>
+        public static CrestronGenericBaseDevice GetDmRmcController(string key, string name, string typeName, DmRmcPropertiesConfig props)
+        {
+            typeName = typeName.ToLower();
+            var ipid = props.Control.IpIdInt;
 
-			var pKey = props.ParentDeviceKey.ToLower();
+            var pKey = props.ParentDeviceKey.ToLower();
 
-			// Non-DM-chassis endpoints
-			return pKey == "processor" ? GetDmRmcControllerForProcessor(key, name, typeName, ipid) : GetDmRmcControllerForChassis(key, name, typeName, props, pKey, ipid);
-		}
+            // Non-DM-chassis endpoints
+            return pKey == "processor" ? GetDmRmcControllerForProcessor(key, name, typeName, ipid) : GetDmRmcControllerForChassis(key, name, typeName, props, pKey, ipid);
+        }
 
-	    private static CrestronGenericBaseDevice GetDmRmcControllerForChassis(string key, string name, string typeName,
-	        DmRmcPropertiesConfig props, string pKey, uint ipid)
-	    {
-	        var parentDev = DeviceManager.GetDeviceForKey(pKey);
-	        if (parentDev is DmpsRoutingController)
-	        {
+        private static CrestronGenericBaseDevice GetDmRmcControllerForChassis(string key, string name, string typeName,
+            DmRmcPropertiesConfig props, string pKey, uint ipid)
+        {
+            var parentDev = DeviceManager.GetDeviceForKey(pKey);
+            CrestronGenericBaseDevice rx;
+            bool useChassisForOfflineFeedback = false;
+
+            if (parentDev is DmpsRoutingController)
+            {
                 var dmps = parentDev as DmpsRoutingController;
                 //Check that the input is within range of this chassis' possible inputs
                 var num = props.ParentOutputNumber;
@@ -342,26 +408,37 @@ namespace PepperDash.Essentials.DM
                     return null;
                 }
                 // Must use different constructor for DMPS4K types. No IPID
-                if (Global.ControlSystemIsDmps4kType || typeName == "hdbasetrx" || typeName == "dmrmc4k100c1g")
+                if (Global.ControlSystemIsDmps4kType)
                 {
-                    var rmc = GetDmRmcControllerForDmps4k(key, name, typeName, dmps, props.ParentOutputNumber);
-                    Debug.Console(0, "DM endpoint output {0} is for Dmps4k, changing online feedback to chassis", num);
-                    rmc.IsOnline.SetValueFunc(() => dmps.OutputEndpointOnlineFeedbacks[num].BoolValue);
+                    rx = GetDmRmcControllerForDmps4k(key, name, typeName, dmps, props.ParentOutputNumber);
+                    useChassisForOfflineFeedback = true;
+                }
+                else
+                {
+                    rx = GetDmRmcControllerForDmps(key, name, typeName, ipid, dmps, props.ParentOutputNumber);
+                    if (typeName == "hdbasetrx" || typeName == "dmrmc4k100c1g")
+                    {
+                        useChassisForOfflineFeedback = true;
+                    }
+                }
+                if (useChassisForOfflineFeedback)
+                {
+                    Debug.Console(0, "DM endpoint output {0} does not have direct online feedback, changing online feedback to chassis", num);
+                    rx.IsOnline.SetValueFunc(() => dmps.OutputEndpointOnlineFeedbacks[num].BoolValue);
                     dmps.OutputEndpointOnlineFeedbacks[num].OutputChange += (o, a) =>
                     {
-                        foreach (var feedback in rmc.Feedbacks)
+                        foreach (var feedback in rx.Feedbacks)
                         {
                             if (feedback != null)
                                 feedback.FireUpdate();
                         }
                     };
-                    return rmc;
                 }
-                return GetDmRmcControllerForDmps(key, name, typeName, ipid, dmps, props.ParentOutputNumber);
-	        }
-            else if (parentDev is DmChassisController)
+                return rx;
+            }
+            else if (parentDev is IDmSwitchWithEndpointOnlineFeedback)
             {
-                var controller = parentDev as DmChassisController;
+                var controller = parentDev as IDmSwitchWithEndpointOnlineFeedback;
                 var chassis = controller.Chassis;
                 var num = props.ParentOutputNumber;
                 Debug.Console(1, "Creating DM Chassis device '{0}'. Output number '{1}'.", key, num);
@@ -371,7 +448,7 @@ namespace PepperDash.Essentials.DM
                     Debug.Console(0, "Cannot create DM device '{0}'. Output number '{1}' is out of range",
                         key, num);
                     return null;
-                }                
+                }
                 controller.RxDictionary.Add(num, key);
                 // Catch constructor failures, mainly dues to IPID
                 try
@@ -380,23 +457,33 @@ namespace PepperDash.Essentials.DM
                     if (chassis is DmMd8x8Cpu3 || chassis is DmMd16x16Cpu3 ||
                         chassis is DmMd32x32Cpu3 || chassis is DmMd8x8Cpu3rps ||
                         chassis is DmMd16x16Cpu3rps || chassis is DmMd32x32Cpu3rps ||
-                        chassis is DmMd128x128 || chassis is DmMd64x64
-                        || typeName == "hdbasetrx" || typeName == "dmrmc4k100c1g")
+                        chassis is DmMd128x128 || chassis is DmMd64x64)
                     {
-                        var rmc = GetDmRmcControllerForCpu3Chassis(key, name, typeName, chassis, num, parentDev);
-                        Debug.Console(0, "DM endpoint output {0} is for Cpu3, changing online feedback to chassis", num);
-                        rmc.IsOnline.SetValueFunc(() => controller.OutputEndpointOnlineFeedbacks[num].BoolValue);
-                        controller.OutputEndpointOnlineFeedbacks[num].OutputChange += (o, a) =>
-                            {
-                                foreach (var feedback in rmc.Feedbacks)
-                                {
-                                    if (feedback != null)
-                                        feedback.FireUpdate();
-                                }
-                            };
-                        return rmc;
+                        rx = GetDmRmcControllerForCpu3Chassis(key, name, typeName, chassis, num, parentDev);
+                        useChassisForOfflineFeedback = true;
                     }
-                    return GetDmRmcControllerForCpu2Chassis(key, name, typeName, ipid, chassis, num, parentDev);
+                    else
+                    {
+                        rx = GetDmRmcControllerForCpu2Chassis(key, name, typeName, ipid, chassis, num, parentDev);
+                        if (typeName == "hdbasetrx" || typeName == "dmrmc4k100c1g")
+                        {
+                            useChassisForOfflineFeedback = true;
+                        }
+                    }
+                    if (useChassisForOfflineFeedback)
+                    {
+                        Debug.Console(0, "DM endpoint output {0} does not have direct online feedback, changing online feedback to chassis", num);
+                        rx.IsOnline.SetValueFunc(() => controller.OutputEndpointOnlineFeedbacks[num].BoolValue);
+                        controller.OutputEndpointOnlineFeedbacks[num].OutputChange += (o, a) =>
+                        {
+                            foreach (var feedback in rx.Feedbacks)
+                            {
+                                if (feedback != null)
+                                    feedback.FireUpdate();
+                            }
+                        };
+                    }
+                    return rx;
                 }
                 catch (Exception e)
                 {
@@ -410,31 +497,31 @@ namespace PepperDash.Essentials.DM
                     key, pKey);
                 return null;
             }
-	    }
+        }
 
-	    private static CrestronGenericBaseDevice GetDmRmcControllerForCpu2Chassis(string key, string name, string typeName,
-	        uint ipid, Switch chassis, uint num, IKeyed parentDev)
-	    {
-	        Func<string, string, uint, DMOutput, CrestronGenericBaseDevice> handler;
-	        if (ChassisDict.TryGetValue(typeName.ToLower(), out handler))
-	        {
-	            return handler(key, name, ipid, chassis.Outputs[num]);
-	        }
-	        Debug.Console(0, "Cannot create DM-RMC of type '{0}' with parent device {1}", typeName, parentDev.Key);
-	        return null;
-	    }
+        private static CrestronGenericBaseDevice GetDmRmcControllerForCpu2Chassis(string key, string name, string typeName,
+            uint ipid, Switch chassis, uint num, IKeyed parentDev)
+        {
+            Func<string, string, uint, DMOutput, CrestronGenericBaseDevice> handler;
+            if (ChassisDict.TryGetValue(typeName.ToLower(), out handler))
+            {
+                return handler(key, name, ipid, chassis.Outputs[num]);
+            }
+            Debug.Console(0, "Cannot create DM-RMC of type '{0}' with parent device {1}", typeName, parentDev.Key);
+            return null;
+        }
 
-	    private static CrestronGenericBaseDevice GetDmRmcControllerForCpu3Chassis(string key, string name, string typeName,
-	        Switch chassis, uint num, IKeyed parentDev)
-	    {
-	        Func<string, string, DMOutput, CrestronGenericBaseDevice> cpu3Handler;
-	        if (ChassisCpu3Dict.TryGetValue(typeName.ToLower(), out cpu3Handler))
-	        {
-	            return cpu3Handler(key, name, chassis.Outputs[num]);
-	        }
-	        Debug.Console(0, "Cannot create DM-RMC of type '{0}' with parent device {1}", typeName, parentDev.Key);
-	        return null;
-	    }
+        private static CrestronGenericBaseDevice GetDmRmcControllerForCpu3Chassis(string key, string name, string typeName,
+            Switch chassis, uint num, IKeyed parentDev)
+        {
+            Func<string, string, DMOutput, CrestronGenericBaseDevice> cpu3Handler;
+            if (ChassisCpu3Dict.TryGetValue(typeName.ToLower(), out cpu3Handler))
+            {
+                return cpu3Handler(key, name, chassis.Outputs[num]);
+            }
+            Debug.Console(0, "Cannot create DM-RMC of type '{0}' with parent device {1}", typeName, parentDev.Key);
+            return null;
+        }
 
         private static CrestronGenericBaseDevice GetDmRmcControllerForDmps(string key, string name, string typeName,
             uint ipid, DmpsRoutingController controller, uint num)
@@ -458,51 +545,49 @@ namespace PepperDash.Essentials.DM
             return null;
         }
 
-	    private static CrestronGenericBaseDevice GetDmRmcControllerForDmps4k(string key, string name, string typeName,
-	        DmpsRoutingController controller, uint num)
-	    {
-	        Func<string, string, DMOutput, CrestronGenericBaseDevice> dmps4kHandler;
-	        if (ChassisCpu3Dict.TryGetValue(typeName.ToLower(), out dmps4kHandler))
-	        {
-	            var output = controller.Dmps.SwitcherOutputs[num] as DMOutput;
+        private static CrestronGenericBaseDevice GetDmRmcControllerForDmps4k(string key, string name, string typeName,
+            DmpsRoutingController controller, uint num)
+        {
+            Func<string, string, DMOutput, CrestronGenericBaseDevice> dmps4kHandler;
+            if (ChassisCpu3Dict.TryGetValue(typeName.ToLower(), out dmps4kHandler))
+            {
+                var output = controller.Dmps.SwitcherOutputs[num] as DMOutput;
 
-	            if (output != null)
-	            {
-	                return dmps4kHandler(key, name, output);
-	            }
-	            Debug.Console(0, Debug.ErrorLogLevel.Error,
-	                "Cannot attach DM-RMC of type '{0}' to output {1} on DMPS-4K chassis. Output is not a DM Output.",
-	                typeName, num);
-	            return null;
-	        }
+                if (output != null)
+                {
+                    return dmps4kHandler(key, name, output);
+                }
+                Debug.Console(0, Debug.ErrorLogLevel.Error,
+                    "Cannot attach DM-RMC of type '{0}' to output {1} on DMPS-4K chassis. Output is not a DM Output.",
+                    typeName, num);
+                return null;
+            }
 
             Debug.Console(0, Debug.ErrorLogLevel.Error, "Cannot create DM-RMC of type '{0}' to output {1} on DMPS-4K chassis", typeName, num);
-	        return null;
-	    }
+            return null;
+        }
 
-	    private static CrestronGenericBaseDevice GetDmRmcControllerForProcessor(string key, string name, string typeName, uint ipid)
-	    {
-	        try
-	        {
-	            Func<string, string, uint, CrestronGenericBaseDevice> handler;
+        private static CrestronGenericBaseDevice GetDmRmcControllerForProcessor(string key, string name, string typeName, uint ipid)
+        {
+            try
+            {
+                Func<string, string, uint, CrestronGenericBaseDevice> handler;
 
-	            if (ProcessorFactoryDict.TryGetValue(typeName.ToLower(), out handler))
-	            {
-	                return handler(key, name, ipid);
-	            }
-	            Debug.Console(0, "Cannot create DM-RMC of type: '{0}'", typeName);
+                if (ProcessorFactoryDict.TryGetValue(typeName.ToLower(), out handler))
+                {
+                    return handler(key, name, ipid);
+                }
+                Debug.Console(0, "Cannot create DM-RMC of type: '{0}'", typeName);
 
-	            return null;
-	        }
-	        catch (Exception e)
-	        {
-	            Debug.Console(0, "[{0}] WARNING: Cannot create DM-RMC device: {1}", key, e.Message);
                 return null;
-	        }
-	    }
-
-        
-	}
+            }
+            catch (Exception e)
+            {
+                Debug.Console(0, "[{0}] WARNING: Cannot create DM-RMC device: {1}", key, e.Message);
+                return null;
+            }
+        }
+    }
 
     public class DmRmcControllerFactory : EssentialsDeviceFactory<DmRmcControllerBase>
     {
@@ -522,7 +607,7 @@ namespace PepperDash.Essentials.DM
 
             var props = JsonConvert.DeserializeObject
                 <DmRmcPropertiesConfig>(dc.Properties.ToString());
-            return DmRmcHelper.GetDmRmcController(dc.Key, dc.Name, type, props);            
+            return DmRmcHelper.GetDmRmcController(dc.Key, dc.Name, type, props);
         }
     }
 

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx200Controller.cs

@@ -1,41 +1,41 @@
 using System;
 using System.Linq;
-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;
-using PepperDash.Essentials.Core.Bridges;
-
-namespace PepperDash.Essentials.DM
-{
-    // using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
-
-    /// <summary>
-    /// Controller class for all DM-TX-201C/S/F transmitters
+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;
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.DM
+{
+    // using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+
+    /// <summary>
+    /// Controller class for all DM-TX-201C/S/F transmitters
     /// </summary>
     [Description("Wrapper class for DM-TX-200-C")]
-    public class DmTx200Controller : DmTxControllerBase, ITxRoutingWithFeedback, IHasFreeRun, IVgaBrightnessContrastControls
-    {
-        public DmTx200C2G Tx { get; private set; }
-
-        public RoutingInputPortWithVideoStatuses HdmiInput { get; private set; }
-        public RoutingInputPortWithVideoStatuses VgaInput { get; private set; }
-        public RoutingOutputPort DmOutput { get; private set; }
-
-        public override StringFeedback ActiveVideoInputFeedback { get; protected set; }
-        public IntFeedback VideoSourceNumericFeedback { get; protected set; }
-        public IntFeedback AudioSourceNumericFeedback { get; protected set; }
-        public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; } //actually state
-        public BoolFeedback HdmiVideoSyncFeedback { get; protected set; }
-        public BoolFeedback VgaVideoSyncFeedback { get; protected set; }
-
-        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
-
-        public IntFeedback VgaBrightnessFeedback { get; protected set; }
+    public class DmTx200Controller : DmTxControllerBase, ITxRoutingWithFeedback, IHasFreeRun, IVgaBrightnessContrastControls
+    {
+        public DmTx200C2G Tx { get; private set; }
+
+        public RoutingInputPortWithVideoStatuses HdmiInput { get; private set; }
+        public RoutingInputPortWithVideoStatuses VgaInput { get; private set; }
+        public RoutingOutputPort DmOutput { get; private set; }
+
+        public override StringFeedback ActiveVideoInputFeedback { get; protected set; }
+        public IntFeedback VideoSourceNumericFeedback { get; protected set; }
+        public IntFeedback AudioSourceNumericFeedback { get; protected set; }
+        public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; } //actually state
+        public BoolFeedback HdmiVideoSyncFeedback { get; protected set; }
+        public BoolFeedback VgaVideoSyncFeedback { get; protected set; }
+
+        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
+
+        public IntFeedback VgaBrightnessFeedback { get; protected set; }
         public IntFeedback VgaContrastFeedback { get; protected set; }
 
         //IroutingNumericEvent
@@ -49,57 +49,57 @@ namespace PepperDash.Essentials.DM
         {
             var newEvent = NumericSwitchChange;
             if (newEvent != null) newEvent(this, e);
-        }
-
-
-        /// <summary>
-        /// Helps get the "real" inputs, including when in Auto
-        /// </summary>
-        public DmTx200Base.eSourceSelection ActualActiveVideoInput
-        {
-            get
-            {
-                if (Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Digital ||
-                        Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Analog ||
-                        Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Disable)
-                    return Tx.VideoSourceFeedback;
-                if (Tx.HdmiInput.SyncDetectedFeedback.BoolValue)
-                    return DmTx200Base.eSourceSelection.Digital;
-
-                return Tx.VgaInput.SyncDetectedFeedback.BoolValue ? DmTx200Base.eSourceSelection.Analog : DmTx200Base.eSourceSelection.Disable;
-            }
-        }
-
-        public RoutingPortCollection<RoutingInputPort> InputPorts
-        {
-            get
-            {
-                return new RoutingPortCollection<RoutingInputPort> 
-				{ 
-					HdmiInput, 
-					VgaInput, 
-					AnyVideoInput 
-				};
-            }
-        }
-
-        public RoutingPortCollection<RoutingOutputPort> OutputPorts
-        {
-            get
-            {
-                return new RoutingPortCollection<RoutingOutputPort> { DmOutput };
-            }
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="name"></param>
-        /// <param name="tx"></param>
-        public DmTx200Controller(string key, string name, DmTx200C2G tx, bool preventRegistration)
-            : base(key, name, tx)
-        {
+        }
+
+
+        /// <summary>
+        /// Helps get the "real" inputs, including when in Auto
+        /// </summary>
+        public DmTx200Base.eSourceSelection ActualActiveVideoInput
+        {
+            get
+            {
+                if (Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Digital ||
+                        Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Analog ||
+                        Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Disable)
+                    return Tx.VideoSourceFeedback;
+                if (Tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+                    return DmTx200Base.eSourceSelection.Digital;
+
+                return Tx.VgaInput.SyncDetectedFeedback.BoolValue ? DmTx200Base.eSourceSelection.Analog : DmTx200Base.eSourceSelection.Disable;
+            }
+        }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiInput, 
+					VgaInput, 
+					AnyVideoInput 
+				};
+            }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingOutputPort> { DmOutput };
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="tx"></param>
+        public DmTx200Controller(string key, string name, DmTx200C2G tx, bool preventRegistration)
+            : base(key, name, tx)
+        {
             Tx = tx;
             PreventRegistration = preventRegistration;
 
@@ -116,300 +116,300 @@ namespace PepperDash.Essentials.DM
                 VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput))
             {
                 FeedbackMatchObject = DmTx200Base.eSourceSelection.Analog
-            };
-
-            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
-                () => ActualActiveVideoInput.ToString());
-
-            Tx.HdmiInput.InputStreamChange += InputStreamChangeEvent;
-            Tx.VgaInput.InputStreamChange += VgaInputOnInputStreamChange;
-            Tx.BaseEvent += Tx_BaseEvent;
-            Tx.OnlineStatusChange += Tx_OnlineStatusChange;
-
-            VideoSourceNumericFeedback = new IntFeedback(() => (int)Tx.VideoSourceFeedback);
-            AudioSourceNumericFeedback = new IntFeedback(() => (int)Tx.AudioSourceFeedback);
-
+            };
+
+            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+                () => ActualActiveVideoInput.ToString());
+
+            Tx.HdmiInput.InputStreamChange += InputStreamChangeEvent;
+            Tx.VgaInput.InputStreamChange += VgaInputOnInputStreamChange;
+            Tx.BaseEvent += Tx_BaseEvent;
+            Tx.OnlineStatusChange += Tx_OnlineStatusChange;
+
+            VideoSourceNumericFeedback = new IntFeedback(() => (int)Tx.VideoSourceFeedback);
+            AudioSourceNumericFeedback = new IntFeedback(() => (int)Tx.AudioSourceFeedback);
+
             HdmiInHdcpCapabilityFeedback = new IntFeedback("HdmiInHdcpCapability", () => tx.HdmiInput.HdcpSupportOnFeedback.BoolValue ? 1 : 0);
 
             //setting this on the base class so that we can get it easily on the chassis.
-            HdcpStateFeedback = HdmiInHdcpCapabilityFeedback;
-
-            HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
-
-            HdmiVideoSyncFeedback = new BoolFeedback(() => tx.HdmiInput.SyncDetectedFeedback.BoolValue);
-
-            VgaVideoSyncFeedback = new BoolFeedback(() => tx.VgaInput.SyncDetectedFeedback.BoolValue);
-
-            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
-
-            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
-            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
-
-            tx.VgaInput.VideoControls.ControlChange += VideoControls_ControlChange;
-
-
-            var combinedFuncs = new VideoStatusFuncsWrapper
-            {
-                HdcpActiveFeedbackFunc = () =>
-                    (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
-                    && tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
-
-                HdcpStateFeedbackFunc = () => ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital ? tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString() : "",
-
-                VideoResolutionFeedbackFunc = () =>
-                {
-                    if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital)
-                        return tx.HdmiInput.VideoAttributes.GetVideoResolutionString();
-                    return ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog ? tx.VgaInput.VideoAttributes.GetVideoResolutionString() : "";
-                },
-                VideoSyncFeedbackFunc = () =>
-                (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
-                && tx.HdmiInput.SyncDetectedFeedback.BoolValue)
-                || (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog
-                && tx.VgaInput.SyncDetectedFeedback.BoolValue)
-                || (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Auto
-                && (tx.VgaInput.SyncDetectedFeedback.BoolValue || tx.HdmiInput.SyncDetectedFeedback.BoolValue))
-
-            };
-
-            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
-
-            DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
-                eRoutingPortConnectionType.DmCat, null, this);
-
-            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
-                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
-                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
-                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiInHdcpCapabilityFeedback, HdmiVideoSyncFeedback,
-                VgaVideoSyncFeedback);
-
-            // Set Ports for CEC
-            HdmiInput.Port = Tx.HdmiInput;
-            VgaInput.Port = Tx.VgaInput;
-            DmOutput.Port = Tx.DmOutput;
-        }
-
-        private void VgaInputOnInputStreamChange(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
-        {
-            switch (args.EventId)
-            {
-                case EndpointInputStreamEventIds.FreeRunFeedbackEventId:
-                    FreeRunEnabledFeedback.FireUpdate();
-                    break;
-                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
-                    VgaVideoSyncFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-        void VideoControls_ControlChange(object sender, GenericEventArgs args)
-        {
-            var id = args.EventId;
-            Debug.Console(2, this, "EventId {0}", args.EventId);
-
-            switch (id)
-            {
-                case VideoControlsEventIds.BrightnessFeedbackEventId:
-                    VgaBrightnessFeedback.FireUpdate();
-                    break;
-                case VideoControlsEventIds.ContrastFeedbackEventId:
-                    VgaContrastFeedback.FireUpdate();
-                    break;
-            }
-        }
-
+            HdcpStateFeedback = HdmiInHdcpCapabilityFeedback;
+
+            HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
+
+            HdmiVideoSyncFeedback = new BoolFeedback(() => tx.HdmiInput.SyncDetectedFeedback.BoolValue);
+
+            VgaVideoSyncFeedback = new BoolFeedback(() => tx.VgaInput.SyncDetectedFeedback.BoolValue);
+
+            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
+
+            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
+            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
+
+            tx.VgaInput.VideoControls.ControlChange += VideoControls_ControlChange;
+
+
+            var combinedFuncs = new VideoStatusFuncsWrapper
+            {
+                HdcpActiveFeedbackFunc = () =>
+                    (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
+                    && tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
+
+                HdcpStateFeedbackFunc = () => ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital ? tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString() : "",
+
+                VideoResolutionFeedbackFunc = () =>
+                {
+                    if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital)
+                        return tx.HdmiInput.VideoAttributes.GetVideoResolutionString();
+                    return ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog ? tx.VgaInput.VideoAttributes.GetVideoResolutionString() : "";
+                },
+                VideoSyncFeedbackFunc = () =>
+                (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
+                && tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+                || (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog
+                && tx.VgaInput.SyncDetectedFeedback.BoolValue)
+                || (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Auto
+                && (tx.VgaInput.SyncDetectedFeedback.BoolValue || tx.HdmiInput.SyncDetectedFeedback.BoolValue))
+
+            };
+
+            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+            DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
+                eRoutingPortConnectionType.DmCat, null, this);
+
+            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
+                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
+                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
+                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiInHdcpCapabilityFeedback, HdmiVideoSyncFeedback,
+                VgaVideoSyncFeedback);
+
+            // Set Ports for CEC
+            HdmiInput.Port = Tx.HdmiInput;
+            VgaInput.Port = Tx.VgaInput;
+            DmOutput.Port = Tx.DmOutput;
+        }
+
+        private void VgaInputOnInputStreamChange(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
+        {
+            switch (args.EventId)
+            {
+                case EndpointInputStreamEventIds.FreeRunFeedbackEventId:
+                    FreeRunEnabledFeedback.FireUpdate();
+                    break;
+                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
+                    VgaVideoSyncFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+        void VideoControls_ControlChange(object sender, GenericEventArgs args)
+        {
+            var id = args.EventId;
+            Debug.Console(2, this, "EventId {0}", args.EventId);
+
+            switch (id)
+            {
+                case VideoControlsEventIds.BrightnessFeedbackEventId:
+                    VgaBrightnessFeedback.FireUpdate();
+                    break;
+                case VideoControlsEventIds.ContrastFeedbackEventId:
+                    VgaContrastFeedback.FireUpdate();
+                    break;
+            }
+        }
+
         void Tx_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
         {
             var localVideoInputPort =
                 InputPorts.FirstOrDefault(p => (DmTx200Base.eSourceSelection) p.Selector == Tx.VideoSourceFeedback);
             var localAudioInputPort =
-                InputPorts.FirstOrDefault(p => (DmTx200Base.eSourceSelection) p.Selector == Tx.AudioSourceFeedback);
-
-
-            ActiveVideoInputFeedback.FireUpdate();
-            VideoSourceNumericFeedback.FireUpdate();
+                InputPorts.FirstOrDefault(p => (DmTx200Base.eSourceSelection) p.Selector == Tx.AudioSourceFeedback);
+
+
+            ActiveVideoInputFeedback.FireUpdate();
+            VideoSourceNumericFeedback.FireUpdate();
             AudioSourceNumericFeedback.FireUpdate();
             OnSwitchChange(new RoutingNumericEventArgs(1, VideoSourceNumericFeedback.UShortValue, OutputPorts.First(), localVideoInputPort, eRoutingSignalType.Video));
-            OnSwitchChange(new RoutingNumericEventArgs(1, AudioSourceNumericFeedback.UShortValue, OutputPorts.First(), localAudioInputPort, eRoutingSignalType.Audio));
-        }
-
-        public override bool CustomActivate()
-        {
-
-            Tx.HdmiInput.InputStreamChange += (o, a) => FowardInputStreamChange(HdmiInput, a.EventId);
-            Tx.HdmiInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(HdmiInput, a.EventId);
-
-            Tx.VgaInput.InputStreamChange += (o, a) => FowardInputStreamChange(VgaInput, a.EventId);
-            Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(VgaInput, a.EventId);
-
-            // Base does register and sets up comm monitoring.
-            return base.CustomActivate();
-        }
-
-        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-        {
-            var joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
-
-            if (HdmiVideoSyncFeedback != null)
-            {
-                HdmiVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
-            }
-            if (VgaVideoSyncFeedback != null)
-            {
-                VgaVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
-            }
-
-            LinkDmTxToApi(this, trilist, joinMap, bridge);
-        }
-
-        /// <summary>
-        /// Enables or disables free run
-        /// </summary>
-        /// <param name="enable"></param>
-        public void SetFreeRunEnabled(bool enable)
-        {
-            Tx.VgaInput.FreeRun = enable ? eDmFreeRunSetting.Enabled : eDmFreeRunSetting.Disabled;
-        }
-
-        /// <summary>
-        /// Sets the VGA brightness level
-        /// </summary>
-        /// <param name="level"></param>
-        public void SetVgaBrightness(ushort level)
-        {
-            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
-        }
-
-        /// <summary>
-        /// Sets the VGA contrast level
-        /// </summary>
-        /// <param name="level"></param>
-        public void SetVgaContrast(ushort level)
-        {
-            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
-        }
-
-        public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
-        {
-            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
-
-            switch (input)
-            {
-                case 0:
-                    {
-                        ExecuteSwitch(DmTx200Base.eSourceSelection.Auto, null, type);
-                        break;
-                    }
-                case 1:
-                    {
-                        ExecuteSwitch(HdmiInput.Selector, null, type);
-                        break;
-                    }
-                case 2:
-                    {
-                        ExecuteSwitch(VgaInput.Selector, null, type);
-                        break;
-                    }
-                case 3:
-                    {
-                        ExecuteSwitch(DmTx200Base.eSourceSelection.Disable, null, type);
-                        break;
-                    }
-            }
-        }
-
-        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
-        {
-            if ((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
-                Tx.VideoSource = (DmTx200Base.eSourceSelection)inputSelector;
-            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
-                Tx.AudioSource = (DmTx200Base.eSourceSelection)inputSelector;
-        }
-
-        void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
-        {
-            var id = args.EventId;
-            Debug.Console(2, this, "EventId {0}", args.EventId);
-
-            switch (id)
-            {
+            OnSwitchChange(new RoutingNumericEventArgs(1, AudioSourceNumericFeedback.UShortValue, OutputPorts.First(), localAudioInputPort, eRoutingSignalType.Audio));
+        }
+
+        public override bool CustomActivate()
+        {
+
+            Tx.HdmiInput.InputStreamChange += (o, a) => FowardInputStreamChange(HdmiInput, a.EventId);
+            Tx.HdmiInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(HdmiInput, a.EventId);
+
+            Tx.VgaInput.InputStreamChange += (o, a) => FowardInputStreamChange(VgaInput, a.EventId);
+            Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(VgaInput, a.EventId);
+
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
+
+            if (HdmiVideoSyncFeedback != null)
+            {
+                HdmiVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
+            }
+            if (VgaVideoSyncFeedback != null)
+            {
+                VgaVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
+            }
+
+            LinkDmTxToApi(this, trilist, joinMap, bridge);
+        }
+
+        /// <summary>
+        /// Enables or disables free run
+        /// </summary>
+        /// <param name="enable"></param>
+        public void SetFreeRunEnabled(bool enable)
+        {
+            Tx.VgaInput.FreeRun = enable ? eDmFreeRunSetting.Enabled : eDmFreeRunSetting.Disabled;
+        }
+
+        /// <summary>
+        /// Sets the VGA brightness level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaBrightness(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Sets the VGA contrast level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaContrast(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
+        }
+
+        public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
+        {
+            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
+
+            switch (input)
+            {
+                case 0:
+                    {
+                        ExecuteSwitch(DmTx200Base.eSourceSelection.Auto, null, type);
+                        break;
+                    }
+                case 1:
+                    {
+                        ExecuteSwitch(HdmiInput.Selector, null, type);
+                        break;
+                    }
+                case 2:
+                    {
+                        ExecuteSwitch(VgaInput.Selector, null, type);
+                        break;
+                    }
+                case 3:
+                    {
+                        ExecuteSwitch(DmTx200Base.eSourceSelection.Disable, null, type);
+                        break;
+                    }
+            }
+        }
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            if ((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
+                Tx.VideoSource = (DmTx200Base.eSourceSelection)inputSelector;
+            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
+                Tx.AudioSource = (DmTx200Base.eSourceSelection)inputSelector;
+        }
+
+        void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+        {
+            var id = args.EventId;
+            Debug.Console(2, this, "EventId {0}", args.EventId);
+
+            switch (id)
+            {
                 case EndpointTransmitterBase.VideoSourceFeedbackEventId:
-                    var localVideoInputPort = InputPorts.FirstOrDefault(p => (DmTx200Base.eSourceSelection)p.Selector == Tx.VideoSourceFeedback);
-                    Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
-                    VideoSourceNumericFeedback.FireUpdate();
+                    var localVideoInputPort = InputPorts.FirstOrDefault(p => (DmTx200Base.eSourceSelection)p.Selector == Tx.VideoSourceFeedback);
+                    Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+                    VideoSourceNumericFeedback.FireUpdate();
                     ActiveVideoInputFeedback.FireUpdate();
                     OnSwitchChange(new RoutingNumericEventArgs(1, VideoSourceNumericFeedback.UShortValue, OutputPorts.First(), localVideoInputPort, eRoutingSignalType.Video));
-                    break;
+                    break;
                 case EndpointTransmitterBase.AudioSourceFeedbackEventId:
-                    var localInputAudioPort = InputPorts.FirstOrDefault(p => (DmTx200Base.eSourceSelection)p.Selector == Tx.AudioSourceFeedback);
-                    Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+                    var localInputAudioPort = InputPorts.FirstOrDefault(p => (DmTx200Base.eSourceSelection)p.Selector == Tx.AudioSourceFeedback);
+                    Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
                     AudioSourceNumericFeedback.FireUpdate();
-                    OnSwitchChange(new RoutingNumericEventArgs(1, AudioSourceNumericFeedback.UShortValue, OutputPorts.First(), localInputAudioPort, eRoutingSignalType.Audio));
-                    break;
-            }
-        }
-
-        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
-        {
-            Debug.Console(2, "{0} event {1} stream {2}", Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
-
-            switch (args.EventId)
-            {
-                case EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId:
-                    HdmiInHdcpCapabilityFeedback.FireUpdate();
-                    break;
-                case EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId:
-                    HdmiInHdcpCapabilityFeedback.FireUpdate();
-                    break;
-                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
-                    HdmiVideoSyncFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-        /// <summary>
-        /// Relays the input stream change to the appropriate RoutingInputPort.
-        /// </summary>
-        void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
-        {
-            if (eventId != EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
-            {
-                return;
-            }
-            inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
-            AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
-        }
-
-        /// <summary>
-        /// Relays the VideoAttributes change to a RoutingInputPort
-        /// </summary>
-        void FireVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
-        {
-            //// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
-            //Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
-            //    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
-            switch (eventId)
-            {
-                case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
-                    inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
-                    break;
-                case VideoAttributeEventIds.HdcpStateFeedbackEventId:
-                    inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
-                    break;
-                case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
-                case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
-                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    break;
-                case VideoAttributeEventIds.FramesPerSecondFeedbackEventId:
-                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-    }
+                    OnSwitchChange(new RoutingNumericEventArgs(1, AudioSourceNumericFeedback.UShortValue, OutputPorts.First(), localInputAudioPort, eRoutingSignalType.Audio));
+                    break;
+            }
+        }
+
+        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
+        {
+            Debug.Console(2, "{0} event {1} stream {2}", Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
+
+            switch (args.EventId)
+            {
+                case EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId:
+                    HdmiInHdcpCapabilityFeedback.FireUpdate();
+                    break;
+                case EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId:
+                    HdmiInHdcpCapabilityFeedback.FireUpdate();
+                    break;
+                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
+                    HdmiVideoSyncFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Relays the input stream change to the appropriate RoutingInputPort.
+        /// </summary>
+        void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
+            if (eventId != EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+            {
+                return;
+            }
+            inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
+            AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// Relays the VideoAttributes change to a RoutingInputPort
+        /// </summary>
+        void FireVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
+            //// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
+            //Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
+            //    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
+            switch (eventId)
+            {
+                case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
+                    inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.HdcpStateFeedbackEventId:
+                    inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
+                case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
+                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.FramesPerSecondFeedbackEventId:
+                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx201CController.cs

@@ -8,33 +8,33 @@ using System.Linq;
 
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Bridges;
-
-namespace PepperDash.Essentials.DM
-{
-    /// <summary>
-    /// Controller class for all DM-TX-201C/S/F transmitters
+using PepperDash.Essentials.Core.Bridges;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Controller class for all DM-TX-201C/S/F transmitters
     /// </summary>
     [Description("Wrapper class for DM-TX-201-C")]
-    public class DmTx201CController : DmTxControllerBase, ITxRoutingWithFeedback, IHasFreeRun, IVgaBrightnessContrastControls
-	{
-		public DmTx201C Tx { get; private set; }
-
-		public RoutingInputPortWithVideoStatuses HdmiInput { get; private set; }
-		public RoutingInputPortWithVideoStatuses VgaInput { get; private set; }
-		public RoutingOutputPort DmOutput { get; private set; }
-        public RoutingOutputPort HdmiLoopOut { get; private set; }
-
-        public override StringFeedback ActiveVideoInputFeedback { get; protected set; }
-        public IntFeedback VideoSourceNumericFeedback { get; protected set; }
-        public IntFeedback AudioSourceNumericFeedback { get; protected set; }
-        public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; }
-        public BoolFeedback HdmiVideoSyncFeedback { get; protected set; }
-        public BoolFeedback VgaVideoSyncFeedback { get; protected set; }
-
-        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
-
-        public IntFeedback VgaBrightnessFeedback { get; protected set; }
+    public class DmTx201CController : DmTxControllerBase, ITxRoutingWithFeedback, IHasFreeRun, IVgaBrightnessContrastControls
+	{
+		public DmTx201C Tx { get; private set; }
+
+		public RoutingInputPortWithVideoStatuses HdmiInput { get; private set; }
+		public RoutingInputPortWithVideoStatuses VgaInput { get; private set; }
+		public RoutingOutputPort DmOutput { get; private set; }
+        public RoutingOutputPort HdmiLoopOut { get; private set; }
+
+        public override StringFeedback ActiveVideoInputFeedback { get; protected set; }
+        public IntFeedback VideoSourceNumericFeedback { get; protected set; }
+        public IntFeedback AudioSourceNumericFeedback { get; protected set; }
+        public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; }
+        public BoolFeedback HdmiVideoSyncFeedback { get; protected set; }
+        public BoolFeedback VgaVideoSyncFeedback { get; protected set; }
+
+        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
+
+        public IntFeedback VgaBrightnessFeedback { get; protected set; }
         public IntFeedback VgaContrastFeedback { get; protected set; }
 
         //IroutingNumericEvent
@@ -48,61 +48,61 @@ namespace PepperDash.Essentials.DM
         {
             var newEvent = NumericSwitchChange;
             if (newEvent != null) newEvent(this, e);
-        }
-
-		/// <summary>
-		/// Helps get the "real" inputs, including when in Auto
-		/// </summary>
-		public DmTx200Base.eSourceSelection ActualActiveVideoInput
-		{
-			get
-			{
-				if (Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Digital ||
-						Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Analog ||
-						Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Disable)
-					return Tx.VideoSourceFeedback;
-				else // auto
-				{
-					if (Tx.HdmiInput.SyncDetectedFeedback.BoolValue)
-						return DmTx200Base.eSourceSelection.Digital;
-					else if (Tx.VgaInput.SyncDetectedFeedback.BoolValue)
-						return DmTx200Base.eSourceSelection.Analog;
-					else
-						return DmTx200Base.eSourceSelection.Disable;
-				}
-			}
-		}
-
-		public RoutingPortCollection<RoutingInputPort> InputPorts
-		{
-			get
-			{
-				return new RoutingPortCollection<RoutingInputPort> 
-				{ 
-					HdmiInput, 
-					VgaInput, 
-					AnyVideoInput 
-				};
-			}
-		}
-
-		public RoutingPortCollection<RoutingOutputPort> OutputPorts
-		{
-			get
-			{
-				return new RoutingPortCollection<RoutingOutputPort> { DmOutput, HdmiLoopOut };
-			}
-		}
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
+        }
+
+		/// <summary>
+		/// Helps get the "real" inputs, including when in Auto
+		/// </summary>
+		public DmTx200Base.eSourceSelection ActualActiveVideoInput
+		{
+			get
+			{
+				if (Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Digital ||
+						Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Analog ||
+						Tx.VideoSourceFeedback == DmTx200Base.eSourceSelection.Disable)
+					return Tx.VideoSourceFeedback;
+				else // auto
+				{
+					if (Tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+						return DmTx200Base.eSourceSelection.Digital;
+					else if (Tx.VgaInput.SyncDetectedFeedback.BoolValue)
+						return DmTx200Base.eSourceSelection.Analog;
+					else
+						return DmTx200Base.eSourceSelection.Disable;
+				}
+			}
+		}
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiInput, 
+					VgaInput, 
+					AnyVideoInput 
+				};
+			}
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingOutputPort> { DmOutput, HdmiLoopOut };
+			}
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
 		/// <param name="tx"></param>
-        public DmTx201CController(string key, string name, DmTx201C tx, bool preventRegistration)
-			: base(key, name, tx)
-		{
+        public DmTx201CController(string key, string name, DmTx201C tx, bool preventRegistration)
+			: base(key, name, tx)
+		{
 			Tx = tx;
             PreventRegistration = preventRegistration;
 
@@ -119,89 +119,89 @@ namespace PepperDash.Essentials.DM
                 VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput))
             {
                 FeedbackMatchObject = DmTx200Base.eSourceSelection.Analog
-            };
-
-			ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
-				() => ActualActiveVideoInput.ToString());
-
+            };
+
+			ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+				() => ActualActiveVideoInput.ToString());
+
             Tx.HdmiInput.InputStreamChange += InputStreamChangeEvent;
-            Tx.VgaInput.InputStreamChange += VgaInputOnInputStreamChange;
-            Tx.BaseEvent += Tx_BaseEvent;
-            Tx.OnlineStatusChange += new OnlineStatusChangeEventHandler(Tx_OnlineStatusChange);
-
-            VideoSourceNumericFeedback = new IntFeedback(() => (int)Tx.VideoSourceFeedback);
-
+            Tx.VgaInput.InputStreamChange += VgaInputOnInputStreamChange;
+            Tx.BaseEvent += Tx_BaseEvent;
+            Tx.OnlineStatusChange += new OnlineStatusChangeEventHandler(Tx_OnlineStatusChange);
+
+            VideoSourceNumericFeedback = new IntFeedback(() => (int)Tx.VideoSourceFeedback);
+
             AudioSourceNumericFeedback = new IntFeedback(() => (int)Tx.AudioSourceFeedback);
 
             HdmiInHdcpCapabilityFeedback = new IntFeedback("HdmiInHdcpCapability", () =>
                 (tx.HdmiInput.HdcpSupportOnFeedback.BoolValue ? 1 : 0));
 
-		    HdcpStateFeedback = HdmiInHdcpCapabilityFeedback;
-
-            HdmiVideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInput.SyncDetectedFeedback.BoolValue);
-
-            VgaVideoSyncFeedback = new BoolFeedback(() => (bool)tx.VgaInput.SyncDetectedFeedback.BoolValue);
-
-            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
-
-            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
-
-            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
-
-            tx.VgaInput.VideoControls.ControlChange += VideoControls_ControlChange;
-
-            HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
-
-			var combinedFuncs = new VideoStatusFuncsWrapper
-			{
-				HdcpActiveFeedbackFunc = () =>
-					(ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
-					&& tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
+		    HdcpStateFeedback = HdmiInHdcpCapabilityFeedback;
 
-                HdcpStateFeedbackFunc = () => ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital ? 
-                    tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString() : "",
-
-				VideoResolutionFeedbackFunc = () =>
-				{
-					if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital)
-						return tx.HdmiInput.VideoAttributes.GetVideoResolutionString();
-					return ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog ?
-                        tx.VgaInput.VideoAttributes.GetVideoResolutionString() : "";						
-				},
-
-				VideoSyncFeedbackFunc = () => 			
-				(ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
-				&& tx.HdmiInput.SyncDetectedFeedback.BoolValue)
-				|| (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog
-				&& tx.VgaInput.SyncDetectedFeedback.BoolValue)
-				|| (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Auto
-				&& (tx.VgaInput.SyncDetectedFeedback.BoolValue || tx.HdmiInput.SyncDetectedFeedback.BoolValue))
-				
-			};
-
-			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-	            eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
-
-			DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, null, this);
-			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-
-            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
-                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
-                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
-                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiInHdcpCapabilityFeedback, HdmiVideoSyncFeedback,
-                VgaVideoSyncFeedback);
-
-            // Set Ports for CEC
-            HdmiInput.Port = Tx.HdmiInput;
-            VgaInput.Port = Tx.VgaInput;
-            HdmiLoopOut.Port = Tx.HdmiOutput;
-            DmOutput.Port = Tx.DmOutput;
-		}
-
-        void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
-        {
-            var id = args.EventId;
+            HdmiVideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInput.SyncDetectedFeedback.BoolValue);
+
+            VgaVideoSyncFeedback = new BoolFeedback(() => (bool)tx.VgaInput.SyncDetectedFeedback.BoolValue);
+
+            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
+
+            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
+
+            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
+
+            tx.VgaInput.VideoControls.ControlChange += VideoControls_ControlChange;
+
+            HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
+
+			var combinedFuncs = new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () =>
+					(ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
+					&& tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
+
+                HdcpStateFeedbackFunc = () => ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital ? 
+                    tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString() : "",
+
+				VideoResolutionFeedbackFunc = () =>
+				{
+					if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital)
+						return tx.HdmiInput.VideoAttributes.GetVideoResolutionString();
+					return ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog ?
+                        tx.VgaInput.VideoAttributes.GetVideoResolutionString() : "";						
+				},
+
+				VideoSyncFeedbackFunc = () => 			
+				(ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
+				&& tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+				|| (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog
+				&& tx.VgaInput.SyncDetectedFeedback.BoolValue)
+				|| (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Auto
+				&& (tx.VgaInput.SyncDetectedFeedback.BoolValue || tx.HdmiInput.SyncDetectedFeedback.BoolValue))
+				
+			};
+
+			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+	            eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+			DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, null, this);
+			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
+				eRoutingPortConnectionType.Hdmi, null, this);
+
+            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
+                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
+                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
+                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiInHdcpCapabilityFeedback, HdmiVideoSyncFeedback,
+                VgaVideoSyncFeedback);
+
+            // Set Ports for CEC
+            HdmiInput.Port = Tx.HdmiInput;
+            VgaInput.Port = Tx.VgaInput;
+            HdmiLoopOut.Port = Tx.HdmiOutput;
+            DmOutput.Port = Tx.DmOutput;
+		}
+
+        void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
+        {
+            var id = args.EventId;
             Debug.Console(2, this, "EventId {0}", args.EventId);
 
             switch (id)
@@ -212,7 +212,7 @@ namespace PepperDash.Essentials.DM
                 case VideoControlsEventIds.ContrastFeedbackEventId:
                     VgaContrastFeedback.FireUpdate();
                     break;
-            }
+            }
         }
 
         void Tx_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
@@ -228,7 +228,7 @@ namespace PepperDash.Essentials.DM
             AudioSourceNumericFeedback.FireUpdate();
             OnSwitchChange(new RoutingNumericEventArgs(1, VideoSourceNumericFeedback.UShortValue, OutputPorts.First(), localVideoInputPort, eRoutingSignalType.Video));
             OnSwitchChange(new RoutingNumericEventArgs(1, AudioSourceNumericFeedback.UShortValue, OutputPorts.First(), localAudioInputPort, eRoutingSignalType.Audio));
-        }
+        }
 
         private void VgaInputOnInputStreamChange(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
         {
@@ -241,107 +241,107 @@ namespace PepperDash.Essentials.DM
                     VgaVideoSyncFeedback.FireUpdate();
                     break;
             }
-        }
-
-		public override bool CustomActivate()
-		{		
-			Tx.HdmiInput.InputStreamChange += (o, a) => FowardInputStreamChange(HdmiInput, a.EventId);
-			Tx.HdmiInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(HdmiInput, a.EventId);
-
-			Tx.VgaInput.InputStreamChange += (o, a) => FowardInputStreamChange(VgaInput, a.EventId);
-			Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(VgaInput, a.EventId);
-
-			// Base does register and sets up comm monitoring.
-			return base.CustomActivate();
-		}
-
-        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-        {
-            var joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
-
-            if (HdmiVideoSyncFeedback != null)
-            {
-                HdmiVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
-            }
-            if (VgaVideoSyncFeedback != null)
-            {
-                VgaVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
-            }
-
-            LinkDmTxToApi(this, trilist, joinMap, bridge);
-        }
-
-        /// <summary>
-        /// Enables or disables free run
-        /// </summary>
-        /// <param name="enable"></param>
-        public void SetFreeRunEnabled(bool enable)
+        }
+
+		public override bool CustomActivate()
+		{		
+			Tx.HdmiInput.InputStreamChange += (o, a) => FowardInputStreamChange(HdmiInput, a.EventId);
+			Tx.HdmiInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(HdmiInput, a.EventId);
+
+			Tx.VgaInput.InputStreamChange += (o, a) => FowardInputStreamChange(VgaInput, a.EventId);
+			Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(VgaInput, a.EventId);
+
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
         {
-            Tx.VgaInput.FreeRun = enable ? eDmFreeRunSetting.Enabled : eDmFreeRunSetting.Disabled;
-        }
-
-        /// <summary>
-        /// Sets the VGA brightness level
-        /// </summary>
-        /// <param name="level"></param>
-        public void SetVgaBrightness(ushort level)
-        {
-            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
-        }
-
-        /// <summary>
-        /// Sets the VGA contrast level
-        /// </summary>
-        /// <param name="level"></param>
-        public void SetVgaContrast(ushort level)
-        {
-            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
-        }
-
-        /// <summary>
-        /// Switches the audio/video source based on the integer value (0-Auto, 1-HDMI, 2-VGA, 3-Disable)
-        /// </summary>
-        /// <param name="input"></param>
-        /// <param name="output"></param>
-        /// <param name="type"></param>
-        public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
-        {
-            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
-
-            switch (input)
-            {
-                case 0:
-                    {
-                        ExecuteSwitch(DmTx200Base.eSourceSelection.Auto, null, type);
-                        break;
-                    }
-                case 1:
-                    {
-                        ExecuteSwitch(HdmiInput.Selector, null, type);
-                        break;
-                    }
-                case 2:
-                    {
-                        ExecuteSwitch(VgaInput.Selector, null, type);
-                        break;
-                    }
-                case 3:
-                    {
-                        ExecuteSwitch(DmTx200Base.eSourceSelection.Disable, null, type);
-                        break;
-                    }
-            }
-        }
-
-        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
-        {
-            if((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
-                Tx.VideoSource = (DmTx200Base.eSourceSelection)inputSelector;
-            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
-                Tx.AudioSource = (DmTx200Base.eSourceSelection)inputSelector;
-        }
-
-		void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+            var joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
+
+            if (HdmiVideoSyncFeedback != null)
+            {
+                HdmiVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
+            }
+            if (VgaVideoSyncFeedback != null)
+            {
+                VgaVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
+            }
+
+            LinkDmTxToApi(this, trilist, joinMap, bridge);
+        }
+
+        /// <summary>
+        /// Enables or disables free run
+        /// </summary>
+        /// <param name="enable"></param>
+        public void SetFreeRunEnabled(bool enable)
+        {
+            Tx.VgaInput.FreeRun = enable ? eDmFreeRunSetting.Enabled : eDmFreeRunSetting.Disabled;
+        }
+
+        /// <summary>
+        /// Sets the VGA brightness level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaBrightness(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Sets the VGA contrast level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaContrast(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Switches the audio/video source based on the integer value (0-Auto, 1-HDMI, 2-VGA, 3-Disable)
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="output"></param>
+        /// <param name="type"></param>
+        public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
+        {
+            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
+
+            switch (input)
+            {
+                case 0:
+                    {
+                        ExecuteSwitch(DmTx200Base.eSourceSelection.Auto, null, type);
+                        break;
+                    }
+                case 1:
+                    {
+                        ExecuteSwitch(HdmiInput.Selector, null, type);
+                        break;
+                    }
+                case 2:
+                    {
+                        ExecuteSwitch(VgaInput.Selector, null, type);
+                        break;
+                    }
+                case 3:
+                    {
+                        ExecuteSwitch(DmTx200Base.eSourceSelection.Disable, null, type);
+                        break;
+                    }
+            }
+        }
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            if((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
+                Tx.VideoSource = (DmTx200Base.eSourceSelection)inputSelector;
+            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
+                Tx.AudioSource = (DmTx200Base.eSourceSelection)inputSelector;
+        }
+
+		void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
 		{
             var id = args.EventId;
             Debug.Console(2, this, "EventId {0}", args.EventId);
@@ -361,11 +361,11 @@ namespace PepperDash.Essentials.DM
                     AudioSourceNumericFeedback.FireUpdate();
                     OnSwitchChange(new RoutingNumericEventArgs(1, AudioSourceNumericFeedback.UShortValue, OutputPorts.First(), localInputAudioPort, eRoutingSignalType.Audio));
                     break;
-            }        
-		}
-
-        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
-        {
+            }        
+		}
+
+        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
+        {
             Debug.Console(2, "{0} event {1} stream {2}", Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
 
             switch (args.EventId)
@@ -379,52 +379,52 @@ namespace PepperDash.Essentials.DM
                 case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
                     HdmiVideoSyncFeedback.FireUpdate();
                     break;
-            }
-
-        }
-
-		/// <summary>
-		/// Relays the input stream change to the appropriate RoutingInputPort.
-		/// </summary>
-		void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
-		{
-			if (eventId != EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+            }
+
+        }
+
+		/// <summary>
+		/// Relays the input stream change to the appropriate RoutingInputPort.
+		/// </summary>
+		void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			if (eventId != EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
 			{
-                return;
+                return;
 			}
             inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
-            AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
-		}
-		
-		/// <summary>
-		/// Relays the VideoAttributes change to a RoutingInputPort
-		/// </summary>
-		void FireVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
-		{
-			//// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
-			//Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
-			//    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
-			switch (eventId)
-			{
-				case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
-					inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
-					AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
-					break;
-				case VideoAttributeEventIds.HdcpStateFeedbackEventId:
-					inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
-					AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
-					break;
-				case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
-				case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
-					inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
-					AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
-					break;
-                case VideoAttributeEventIds.FramesPerSecondFeedbackEventId:
-                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    break;
-			}
-		}
-
-	}
+            AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
+		}
+		
+		/// <summary>
+		/// Relays the VideoAttributes change to a RoutingInputPort
+		/// </summary>
+		void FireVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			//// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
+			//Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
+			//    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
+			switch (eventId)
+			{
+				case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
+					inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
+					break;
+				case VideoAttributeEventIds.HdcpStateFeedbackEventId:
+					inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
+					break;
+				case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
+				case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
+					inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+					AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+					break;
+                case VideoAttributeEventIds.FramesPerSecondFeedbackEventId:
+                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    break;
+			}
+		}
+
+	}
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4k100Controller.cs

@@ -78,6 +78,8 @@ namespace PepperDash.Essentials.DM
                 IsOnline.SetValueFunc(() => controller.InputEndpointOnlineFeedbacks[num].BoolValue);
                 controller.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => IsOnline.FireUpdate();
             }
+            PreventRegistration = true;
+            tx.Register();
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4k202CController.cs

@@ -1,42 +1,42 @@
-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.DeviceSupport;
-using Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Bridges;
-using PepperDash.Essentials.DM.Config;
-
-namespace PepperDash.Essentials.DM
-{
-    using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
-    using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
-
+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.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+    using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+    using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
+
     [Description("Wrapper class for DM-TX-4K-202-C")]
-    public class DmTx4k202CController : DmTxControllerBase, ITxRoutingWithFeedback, IHasFeedback,
-        IIROutputPorts, IComPorts
-    {
-        public DmTx4k202C Tx { get; private set; }
-
-        public RoutingInputPortWithVideoStatuses HdmiIn1 { get; private set; }
-        public RoutingInputPortWithVideoStatuses HdmiIn2 { get; private set; }
-        public RoutingOutputPort DmOut { get; private set; }
-        public RoutingOutputPort HdmiLoopOut { get; private set; }
-
-        public override StringFeedback ActiveVideoInputFeedback { get; protected set; }
-        public IntFeedback VideoSourceNumericFeedback { get; protected set; }
-        public IntFeedback AudioSourceNumericFeedback { get; protected set; }
-        public IntFeedback HdmiIn1HdcpCapabilityFeedback { get; protected set; }
-        public IntFeedback HdmiIn2HdcpCapabilityFeedback { get; protected set; }
-        public BoolFeedback Hdmi1VideoSyncFeedback { get; protected set; }
+    public class DmTx4k202CController : DmTxControllerBase, ITxRoutingWithFeedback, IHasFeedback,
+        IIROutputPorts, IComPorts
+    {
+        public DmTx4k202C Tx { get; private set; }
+
+        public RoutingInputPortWithVideoStatuses HdmiIn1 { get; private set; }
+        public RoutingInputPortWithVideoStatuses HdmiIn2 { get; private set; }
+        public RoutingOutputPort DmOut { get; private set; }
+        public RoutingOutputPort HdmiLoopOut { get; private set; }
+
+        public override StringFeedback ActiveVideoInputFeedback { get; protected set; }
+        public IntFeedback VideoSourceNumericFeedback { get; protected set; }
+        public IntFeedback AudioSourceNumericFeedback { get; protected set; }
+        public IntFeedback HdmiIn1HdcpCapabilityFeedback { get; protected set; }
+        public IntFeedback HdmiIn2HdcpCapabilityFeedback { get; protected set; }
+        public BoolFeedback Hdmi1VideoSyncFeedback { get; protected set; }
         public BoolFeedback Hdmi2VideoSyncFeedback { get; protected set; }
 
         //IroutingNumericEvent
@@ -50,50 +50,50 @@ namespace PepperDash.Essentials.DM
         {
             var newEvent = NumericSwitchChange;
             if (newEvent != null) newEvent(this, e);
-        }
-
-
-        //public override IntFeedback HdcpSupportAllFeedback { get; protected set; }
-        //public override ushort HdcpSupportCapability { get; protected set; }
-
-        /// <summary>
-        /// Helps get the "real" inputs, including when in Auto
-        /// </summary>
-        public Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType ActualActiveVideoInput
-        {
-            get
-            {
-                if (Tx.VideoSourceFeedback != eVst.Auto)
-                    return Tx.VideoSourceFeedback;
-                else // auto
-                {
-                    if (Tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
-                        return eVst.Hdmi1;
-                    else if (Tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
-                        return eVst.Hdmi2;
-                    else
-                        return eVst.AllDisabled;
-                }
-            }
-        }
-        public RoutingPortCollection<RoutingInputPort> InputPorts
-        {
-            get
-            {
+        }
+
+
+        //public override IntFeedback HdcpSupportAllFeedback { get; protected set; }
+        //public override ushort HdcpSupportCapability { get; protected set; }
+
+        /// <summary>
+        /// Helps get the "real" inputs, including when in Auto
+        /// </summary>
+        public Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType ActualActiveVideoInput
+        {
+            get
+            {
+                if (Tx.VideoSourceFeedback != eVst.Auto)
+                    return Tx.VideoSourceFeedback;
+                else // auto
+                {
+                    if (Tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
+                        return eVst.Hdmi1;
+                    else if (Tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+                        return eVst.Hdmi2;
+                    else
+                        return eVst.AllDisabled;
+                }
+            }
+        }
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get
+            {
                 return new RoutingPortCollection<RoutingInputPort> 
 				{ 
 					HdmiIn1,
 					HdmiIn2,
 					AnyVideoInput 
-				};
-            }
-        }
-        public RoutingPortCollection<RoutingOutputPort> OutputPorts
-        {
-            get
-            {
-                return new RoutingPortCollection<RoutingOutputPort> { DmOut, HdmiLoopOut };
-            }
+				};
+            }
+        }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingOutputPort> { DmOut, HdmiLoopOut };
+            }
         }
 
         public DmTx4k202CController(string key, string name, DmTx4k202C tx, bool preventRegistration)
@@ -127,28 +127,23 @@ namespace PepperDash.Essentials.DM
 
             Tx.OnlineStatusChange += Tx_OnlineStatusChange;
 
-            VideoSourceNumericFeedback = new IntFeedback(() => (int) Tx.VideoSourceFeedback);
+            VideoSourceNumericFeedback = new IntFeedback(() => (int)Tx.VideoSourceFeedback);
 
-            AudioSourceNumericFeedback = new IntFeedback(() => (int) Tx.AudioSourceFeedback);
+            AudioSourceNumericFeedback = new IntFeedback(() => (int)Tx.AudioSourceFeedback);
 
             HdmiIn1HdcpCapabilityFeedback = new IntFeedback("HdmiIn1HdcpCapability",
-                () => (int) tx.HdmiInputs[1].HdcpCapabilityFeedback);
+                () => (int)tx.HdmiInputs[1].HdcpCapabilityFeedback);
 
             HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability",
-                () => (int) tx.HdmiInputs[2].HdcpCapabilityFeedback);
-
-            HdcpStateFeedback =
-                new IntFeedback(
-                    () =>
-                        tx.HdmiInputs[1].HdcpCapabilityFeedback > tx.HdmiInputs[2].HdcpCapabilityFeedback
-                            ? (int) tx.HdmiInputs[1].HdcpCapabilityFeedback
-                            : (int) tx.HdmiInputs[2].HdcpCapabilityFeedback);
+                () => (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
 
             HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
 
-            Hdmi1VideoSyncFeedback = new BoolFeedback(() => (bool) tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue);
+            HdcpStateFeedback = new IntFeedback(() => (int)HdcpSupportCapability);
 
-            Hdmi2VideoSyncFeedback = new BoolFeedback(() => (bool) tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue);
+            Hdmi1VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue);
+
+            Hdmi2VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue);
 
             var combinedFuncs = new VideoStatusFuncsWrapper
             {
@@ -210,120 +205,120 @@ namespace PepperDash.Essentials.DM
 
 
 
-        public override bool CustomActivate()
-        {
-            // Link up all of these damned events to the various RoutingPorts via a helper handler
-            Tx.HdmiInputs[1].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn1, a.EventId);
-            Tx.HdmiInputs[1].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn1, a.EventId);
-
-            Tx.HdmiInputs[2].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn2, a.EventId);
-            Tx.HdmiInputs[2].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn2, a.EventId);
-
-            // Base does register and sets up comm monitoring.
-            return base.CustomActivate();
-        }
-
-        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-        {
-            var joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
-
-            if (Hdmi1VideoSyncFeedback != null)
-            {
-                Hdmi1VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
-            }
-            if (Hdmi2VideoSyncFeedback != null)
-            {
-                Hdmi2VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
-            }
-
-            LinkDmTxToApi(this, trilist, joinMap, bridge);
-        }
-
-        public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
-        {
-            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
-
-            switch (type)
-            {
-                case eRoutingSignalType.Video:
-                    switch (input)
-                    {
-                        case 0:
-                        {
-                            ExecuteSwitch(eVst.Auto, null, type);
-                            break;
-                        }
-                        case 1:
-                        {
-                            ExecuteSwitch(HdmiIn1.Selector, null, type);
-                            break;
-                        }
-                        case 2:
-                        {
-                            ExecuteSwitch(HdmiIn2.Selector, null, type);
-                            break;
-                        }
-                        case 3:
-                        {
-                            ExecuteSwitch(eVst.AllDisabled, null, type);
-                            break;
-                        }
-                    }
-                    break;
-                case eRoutingSignalType.Audio:
-                    switch (input)
-                    {
-                        case 0:
-                        {
-                            ExecuteSwitch(eAst.Auto, null, type);
-                            break;
-                        }
-                        case 1:
-                        {
-                            ExecuteSwitch(eAst.Hdmi1, null, type);
-                            break;
-                        }
-                        case 2:
-                        {
-                            ExecuteSwitch(eAst.Hdmi2, null, type);
-                            break;
-                        }
-                        case 3:
-                        {
-                            ExecuteSwitch(eAst.AllDisabled, null, type);
-                            break;
-                        }
-                    }
-                    break;
-            }
-        }
-
-        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
-        {
-            if ((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
-                Tx.VideoSource = (eVst)inputSelector;
-            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
-                Tx.AudioSource = (eAst)inputSelector;
-        }
-
-        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
-        {
-            Debug.Console(2, "{0} event {1} stream {2}", this.Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
-
-            switch (args.EventId)
-            {
-                case EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId:
-                case EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId:
-                case EndpointInputStreamEventIds.HdcpCapabilityFeedbackEventId:
-                    if (inputStream == Tx.HdmiInputs[1]) HdmiIn1HdcpCapabilityFeedback.FireUpdate();
-                    if (inputStream == Tx.HdmiInputs[2]) HdmiIn2HdcpCapabilityFeedback.FireUpdate();
-                    HdcpStateFeedback.FireUpdate();
-                    break;
-                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
-                    if (inputStream == Tx.HdmiInputs[1]) Hdmi1VideoSyncFeedback.FireUpdate();
-                    if (inputStream == Tx.HdmiInputs[2]) Hdmi2VideoSyncFeedback.FireUpdate();
-                    break;
-            }
+        public override bool CustomActivate()
+        {
+            // Link up all of these damned events to the various RoutingPorts via a helper handler
+            Tx.HdmiInputs[1].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn1, a.EventId);
+            Tx.HdmiInputs[1].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn1, a.EventId);
+
+            Tx.HdmiInputs[2].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn2, a.EventId);
+            Tx.HdmiInputs[2].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn2, a.EventId);
+
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
+
+            if (Hdmi1VideoSyncFeedback != null)
+            {
+                Hdmi1VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
+            }
+            if (Hdmi2VideoSyncFeedback != null)
+            {
+                Hdmi2VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
+            }
+
+            LinkDmTxToApi(this, trilist, joinMap, bridge);
+        }
+
+        public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
+        {
+            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
+
+            switch (type)
+            {
+                case eRoutingSignalType.Video:
+                    switch (input)
+                    {
+                        case 0:
+                            {
+                                ExecuteSwitch(eVst.Auto, null, type);
+                                break;
+                            }
+                        case 1:
+                            {
+                                ExecuteSwitch(HdmiIn1.Selector, null, type);
+                                break;
+                            }
+                        case 2:
+                            {
+                                ExecuteSwitch(HdmiIn2.Selector, null, type);
+                                break;
+                            }
+                        case 3:
+                            {
+                                ExecuteSwitch(eVst.AllDisabled, null, type);
+                                break;
+                            }
+                    }
+                    break;
+                case eRoutingSignalType.Audio:
+                    switch (input)
+                    {
+                        case 0:
+                            {
+                                ExecuteSwitch(eAst.Auto, null, type);
+                                break;
+                            }
+                        case 1:
+                            {
+                                ExecuteSwitch(eAst.Hdmi1, null, type);
+                                break;
+                            }
+                        case 2:
+                            {
+                                ExecuteSwitch(eAst.Hdmi2, null, type);
+                                break;
+                            }
+                        case 3:
+                            {
+                                ExecuteSwitch(eAst.AllDisabled, null, type);
+                                break;
+                            }
+                    }
+                    break;
+            }
+        }
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            if ((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
+                Tx.VideoSource = (eVst)inputSelector;
+            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
+                Tx.AudioSource = (eAst)inputSelector;
+        }
+
+        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
+        {
+            Debug.Console(2, "{0} event {1} stream {2}", this.Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
+
+            switch (args.EventId)
+            {
+                case EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId:
+                case EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId:
+                case EndpointInputStreamEventIds.HdcpCapabilityFeedbackEventId:
+                    if (inputStream == Tx.HdmiInputs[1]) HdmiIn1HdcpCapabilityFeedback.FireUpdate();
+                    if (inputStream == Tx.HdmiInputs[2]) HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+                    HdcpStateFeedback.FireUpdate();
+                    break;
+                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
+                    if (inputStream == Tx.HdmiInputs[1]) Hdmi1VideoSyncFeedback.FireUpdate();
+                    if (inputStream == Tx.HdmiInputs[2]) Hdmi2VideoSyncFeedback.FireUpdate();
+                    break;
+            }
         }
 
         void Tx_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
@@ -361,62 +356,62 @@ namespace PepperDash.Essentials.DM
                     OnSwitchChange(new RoutingNumericEventArgs(1, AudioSourceNumericFeedback.UShortValue, OutputPorts.First(), localInputAudioPort, eRoutingSignalType.Audio));
                     break;
             }
-        }
-
-        /// <summary>
-        /// Relays the input stream change to the appropriate RoutingInputPort.
-        /// </summary>
-        void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
-        {
-            if (eventId != EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
-            {
-                return;
-            }
-            inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
-            AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
-        }
-
-        /// <summary>
-        /// Relays the VideoAttributes change to a RoutingInputPort
-        /// </summary>
-        void ForwardVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
-        {
-            //// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
-            //Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
-            //    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
-            switch (eventId)
-            {
-                case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
-                    inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
-                    break;
-                case VideoAttributeEventIds.HdcpStateFeedbackEventId:
-                    inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
-                    break;
-                case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
-                case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
-                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    break;
-                case VideoAttributeEventIds.FramesPerSecondFeedbackEventId:
-                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-
-
-
-        #region IIROutputPorts Members
-        public CrestronCollection<IROutputPort> IROutputPorts { get { return Tx.IROutputPorts; } }
-        public int NumberOfIROutputPorts { get { return Tx.NumberOfIROutputPorts; } }
-        #endregion
-
-        #region IComPorts Members
-        public CrestronCollection<ComPort> ComPorts { get { return Tx.ComPorts; } }
-        public int NumberOfComPorts { get { return Tx.NumberOfComPorts; } }
-        #endregion
-    }
+        }
+
+        /// <summary>
+        /// Relays the input stream change to the appropriate RoutingInputPort.
+        /// </summary>
+        void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
+            if (eventId != EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+            {
+                return;
+            }
+            inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
+            AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// Relays the VideoAttributes change to a RoutingInputPort
+        /// </summary>
+        void ForwardVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
+            //// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
+            //Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
+            //    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
+            switch (eventId)
+            {
+                case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
+                    inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.HdcpStateFeedbackEventId:
+                    inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
+                case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
+                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.FramesPerSecondFeedbackEventId:
+                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+
+
+
+        #region IIROutputPorts Members
+        public CrestronCollection<IROutputPort> IROutputPorts { get { return Tx.IROutputPorts; } }
+        public int NumberOfIROutputPorts { get { return Tx.NumberOfIROutputPorts; } }
+        #endregion
+
+        #region IComPorts Members
+        public CrestronCollection<ComPort> ComPorts { get { return Tx.ComPorts; } }
+        public int NumberOfComPorts { get { return Tx.NumberOfComPorts; } }
+        #endregion
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4k302CController.cs

@@ -1,49 +1,49 @@
-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.DeviceSupport;
-using Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.Core.Bridges;
-using PepperDash.Essentials.DM.Config;
-
-namespace PepperDash.Essentials.DM
-{
-	using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+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.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+    using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
     using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
 
     [Description("Wrapper class for DM-TX-4K-302-C")]
-    public class DmTx4k302CController : DmTxControllerBase, ITxRoutingWithFeedback, IHasFeedback, 
-		IIROutputPorts, IComPorts, IHasFreeRun, IVgaBrightnessContrastControls
-	{
-		public DmTx4k302C Tx { get; private set; }
-
-		public RoutingInputPortWithVideoStatuses HdmiIn1 { get; private set; }
-		public RoutingInputPortWithVideoStatuses HdmiIn2 { get; private set; }
-		public RoutingInputPortWithVideoStatuses VgaIn { get; private set; }
-		public RoutingOutputPort DmOut { get; private set; }
-		public RoutingOutputPort HdmiLoopOut { get; private set; }
-
-		public override StringFeedback ActiveVideoInputFeedback { get; protected set; }
-        public IntFeedback VideoSourceNumericFeedback { get; protected set; }
-        public IntFeedback AudioSourceNumericFeedback { get; protected set; }
-        public IntFeedback HdmiIn1HdcpCapabilityFeedback { get; protected set; }
-        public IntFeedback HdmiIn2HdcpCapabilityFeedback { get; protected set; }
-        public BoolFeedback Hdmi1VideoSyncFeedback { get; protected set; }
-        public BoolFeedback Hdmi2VideoSyncFeedback { get; protected set; }
-        public BoolFeedback VgaVideoSyncFeedback { get; protected set; }
-
-        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
-
-        public IntFeedback VgaBrightnessFeedback { get; protected set; }
+    public class DmTx4k302CController : DmTxControllerBase, ITxRoutingWithFeedback, IHasFeedback,
+        IIROutputPorts, IComPorts, IHasFreeRun, IVgaBrightnessContrastControls
+    {
+        public DmTx4k302C Tx { get; private set; }
+
+        public RoutingInputPortWithVideoStatuses HdmiIn1 { get; private set; }
+        public RoutingInputPortWithVideoStatuses HdmiIn2 { get; private set; }
+        public RoutingInputPortWithVideoStatuses VgaIn { get; private set; }
+        public RoutingOutputPort DmOut { get; private set; }
+        public RoutingOutputPort HdmiLoopOut { get; private set; }
+
+        public override StringFeedback ActiveVideoInputFeedback { get; protected set; }
+        public IntFeedback VideoSourceNumericFeedback { get; protected set; }
+        public IntFeedback AudioSourceNumericFeedback { get; protected set; }
+        public IntFeedback HdmiIn1HdcpCapabilityFeedback { get; protected set; }
+        public IntFeedback HdmiIn2HdcpCapabilityFeedback { get; protected set; }
+        public BoolFeedback Hdmi1VideoSyncFeedback { get; protected set; }
+        public BoolFeedback Hdmi2VideoSyncFeedback { get; protected set; }
+        public BoolFeedback VgaVideoSyncFeedback { get; protected set; }
+
+        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
+
+        public IntFeedback VgaBrightnessFeedback { get; protected set; }
         public IntFeedback VgaContrastFeedback { get; protected set; }
 
         //IroutingNumericEvent
@@ -57,171 +57,166 @@ namespace PepperDash.Essentials.DM
         {
             var newEvent = NumericSwitchChange;
             if (newEvent != null) newEvent(this, e);
-        }
-
-
-		/// <summary>
-		/// Helps get the "real" inputs, including when in Auto
-		/// </summary>
-		public Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType ActualActiveVideoInput
-		{
-			get
-			{
-				if (Tx.VideoSourceFeedback != eVst.Auto)
-					return Tx.VideoSourceFeedback;
-				else // auto
-				{
-					if (Tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
-						return eVst.Hdmi1;
-					else if (Tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
-						return eVst.Hdmi2;
-					else if (Tx.VgaInput.SyncDetectedFeedback.BoolValue)
-						return eVst.Vga;
-					else
-						return eVst.AllDisabled;
-				}
-			}
-		}
-		public RoutingPortCollection<RoutingInputPort> InputPorts
-		{
-			get
-			{
-				return new RoutingPortCollection<RoutingInputPort> 
-				{ 
-					HdmiIn1,
-					HdmiIn2,
-					VgaIn, 
-					AnyVideoInput 
-				};
-			}
-		}
-		public RoutingPortCollection<RoutingOutputPort> OutputPorts
-		{
-			get
-			{
-				return new RoutingPortCollection<RoutingOutputPort> { DmOut, HdmiLoopOut };
-			}
-		}
-        public DmTx4k302CController(string key, string name, DmTx4k302C tx, bool preventRegistration)
-			: base(key, name, tx)
-		{
-			Tx = tx;
-            PreventRegistration = preventRegistration;
-
-			HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
-                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
-				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]))
-			{
-			    FeedbackMatchObject = eVst.Hdmi1
-			};
-			HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
-                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
-				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]))
+        }
+
+
+        /// <summary>
+        /// Helps get the "real" inputs, including when in Auto
+        /// </summary>
+        public Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType ActualActiveVideoInput
+        {
+            get
+            {
+                if (Tx.VideoSourceFeedback != eVst.Auto)
+                    return Tx.VideoSourceFeedback;
+                else // auto
+                {
+                    if (Tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
+                        return eVst.Hdmi1;
+                    else if (Tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+                        return eVst.Hdmi2;
+                    else if (Tx.VgaInput.SyncDetectedFeedback.BoolValue)
+                        return eVst.Vga;
+                    else
+                        return eVst.AllDisabled;
+                }
+            }
+        }
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiIn1,
+					HdmiIn2,
+					VgaIn, 
+					AnyVideoInput 
+				};
+            }
+        }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingOutputPort> { DmOut, HdmiLoopOut };
+            }
+        }
+        public DmTx4k302CController(string key, string name, DmTx4k302C tx, bool preventRegistration)
+            : base(key, name, tx)
+        {
+            Tx = tx;
+            PreventRegistration = preventRegistration;
+
+            HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
+                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]))
+            {
+                FeedbackMatchObject = eVst.Hdmi1
+            };
+            HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
+                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]))
             {
                 FeedbackMatchObject = eVst.Hdmi2
             };
-            
-			VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
-                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, eVst.Vga, this, 
-				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput))
+
+            VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, eVst.Vga, this,
+                VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput))
             {
                 FeedbackMatchObject = eVst.Vga
             };
-
-			ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
-				() => ActualActiveVideoInput.ToString());
-
-			Tx.HdmiInputs[1].InputStreamChange += InputStreamChangeEvent;
+
+            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+                () => ActualActiveVideoInput.ToString());
+
+            Tx.HdmiInputs[1].InputStreamChange += InputStreamChangeEvent;
             Tx.HdmiInputs[2].InputStreamChange += InputStreamChangeEvent;
-            Tx.VgaInput.InputStreamChange += VgaInputOnInputStreamChange;
-            Tx.BaseEvent += Tx_BaseEvent;
-
-            Tx.OnlineStatusChange += Tx_OnlineStatusChange;
-
-            VideoSourceNumericFeedback = new IntFeedback(() => (int)Tx.VideoSourceFeedback);
-            AudioSourceNumericFeedback = new IntFeedback(() => (int)Tx.AudioSourceFeedback);
-
-            HdmiIn1HdcpCapabilityFeedback = new IntFeedback("HdmiIn1HdcpCapability", () => (int)tx.HdmiInputs[1].HdcpCapabilityFeedback);
-
+            Tx.VgaInput.InputStreamChange += VgaInputOnInputStreamChange;
+            Tx.BaseEvent += Tx_BaseEvent;
+
+            Tx.OnlineStatusChange += Tx_OnlineStatusChange;
+
+            VideoSourceNumericFeedback = new IntFeedback(() => (int)Tx.VideoSourceFeedback);
+            AudioSourceNumericFeedback = new IntFeedback(() => (int)Tx.AudioSourceFeedback);
+
+            HdmiIn1HdcpCapabilityFeedback = new IntFeedback("HdmiIn1HdcpCapability", () => (int)tx.HdmiInputs[1].HdcpCapabilityFeedback);
+
             HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability", () => (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
 
-            HdcpStateFeedback =
-                new IntFeedback(
-                    () =>
-                        tx.HdmiInputs[1].HdcpCapabilityFeedback > tx.HdmiInputs[2].HdcpCapabilityFeedback
-                            ? (int)tx.HdmiInputs[1].HdcpCapabilityFeedback
-                            : (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
-
-            HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
-
-            Hdmi1VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue);
-
-            Hdmi2VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue);
-
-            VgaVideoSyncFeedback = new BoolFeedback(() => (bool)tx.VgaInput.SyncDetectedFeedback.BoolValue);
-
-            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
-
-            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
-            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
-
-            tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
-
-
-			var combinedFuncs = new VideoStatusFuncsWrapper
-			{
-				HdcpActiveFeedbackFunc = () =>
-					(ActualActiveVideoInput == eVst.Hdmi1
-					&& tx.HdmiInputs[1].VideoAttributes.HdcpActiveFeedback.BoolValue)
-					|| (ActualActiveVideoInput == eVst.Hdmi2
-					&& tx.HdmiInputs[2].VideoAttributes.HdcpActiveFeedback.BoolValue),
-
-				HdcpStateFeedbackFunc = () =>
-					{
-						if (ActualActiveVideoInput == eVst.Hdmi1)
-							return tx.HdmiInputs[1].VideoAttributes.HdcpStateFeedback.ToString();
-						return ActualActiveVideoInput == eVst.Hdmi2 ? tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString() : "";
-					},
-
-				VideoResolutionFeedbackFunc = () =>
-					{
-						if (ActualActiveVideoInput == eVst.Hdmi1)
-							return tx.HdmiInputs[1].VideoAttributes.GetVideoResolutionString();
-						if (ActualActiveVideoInput == eVst.Hdmi2)
-							return tx.HdmiInputs[2].VideoAttributes.GetVideoResolutionString();
-						return ActualActiveVideoInput == eVst.Vga ? tx.VgaInput.VideoAttributes.GetVideoResolutionString() : "";
-					},
-				VideoSyncFeedbackFunc = () =>
-					(ActualActiveVideoInput == eVst.Hdmi1
-					&& tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
-					|| (ActualActiveVideoInput == eVst.Hdmi2
-					&& tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
-					|| (ActualActiveVideoInput == eVst.Vga
-					&& tx.VgaInput.SyncDetectedFeedback.BoolValue)
-				
-			};
-
-			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
-				eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
-
-			DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, 
-				eRoutingPortConnectionType.DmCat, null, this);
-			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this);
-
-
-            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
-                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
-                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
-                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiIn1HdcpCapabilityFeedback, HdmiIn2HdcpCapabilityFeedback,
-                Hdmi1VideoSyncFeedback, Hdmi2VideoSyncFeedback, VgaVideoSyncFeedback);
-
-            // Set Ports for CEC
-            HdmiIn1.Port = Tx.HdmiInputs[1];
-            HdmiIn2.Port = Tx.HdmiInputs[2];
-            HdmiLoopOut.Port = Tx.HdmiOutput;
-            DmOut.Port = Tx.DmOutput;
-		}
+            HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
+
+            HdcpStateFeedback = new IntFeedback(() => (int)HdcpSupportCapability);
+
+            Hdmi1VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue);
+
+            Hdmi2VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue);
+
+            VgaVideoSyncFeedback = new BoolFeedback(() => (bool)tx.VgaInput.SyncDetectedFeedback.BoolValue);
+
+            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
+
+            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
+            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
+
+            tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
+
+
+            var combinedFuncs = new VideoStatusFuncsWrapper
+            {
+                HdcpActiveFeedbackFunc = () =>
+                    (ActualActiveVideoInput == eVst.Hdmi1
+                    && tx.HdmiInputs[1].VideoAttributes.HdcpActiveFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.Hdmi2
+                    && tx.HdmiInputs[2].VideoAttributes.HdcpActiveFeedback.BoolValue),
+
+                HdcpStateFeedbackFunc = () =>
+                {
+                    if (ActualActiveVideoInput == eVst.Hdmi1)
+                        return tx.HdmiInputs[1].VideoAttributes.HdcpStateFeedback.ToString();
+                    return ActualActiveVideoInput == eVst.Hdmi2 ? tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString() : "";
+                },
+
+                VideoResolutionFeedbackFunc = () =>
+                {
+                    if (ActualActiveVideoInput == eVst.Hdmi1)
+                        return tx.HdmiInputs[1].VideoAttributes.GetVideoResolutionString();
+                    if (ActualActiveVideoInput == eVst.Hdmi2)
+                        return tx.HdmiInputs[2].VideoAttributes.GetVideoResolutionString();
+                    return ActualActiveVideoInput == eVst.Vga ? tx.VgaInput.VideoAttributes.GetVideoResolutionString() : "";
+                },
+                VideoSyncFeedbackFunc = () =>
+                    (ActualActiveVideoInput == eVst.Hdmi1
+                    && tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.Hdmi2
+                    && tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.Vga
+                    && tx.VgaInput.SyncDetectedFeedback.BoolValue)
+
+            };
+
+            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.DmCat, null, this);
+            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, null, this);
+
+
+            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
+                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
+                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
+                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiIn1HdcpCapabilityFeedback, HdmiIn2HdcpCapabilityFeedback,
+                Hdmi1VideoSyncFeedback, Hdmi2VideoSyncFeedback, VgaVideoSyncFeedback);
+
+            // Set Ports for CEC
+            HdmiIn1.Port = Tx.HdmiInputs[1];
+            HdmiIn2.Port = Tx.HdmiInputs[2];
+            HdmiLoopOut.Port = Tx.HdmiOutput;
+            DmOut.Port = Tx.DmOutput;
+        }
 
         void VgaInputOnInputStreamChange(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
         {
@@ -234,13 +229,13 @@ namespace PepperDash.Essentials.DM
                     VgaVideoSyncFeedback.FireUpdate();
                     break;
             }
-        }
-
-        void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
-        {
-            var id = args.EventId;
-            Debug.Console(2, this, "EventId {0}", args.EventId);
-
+        }
+
+        void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
+        {
+            var id = args.EventId;
+            Debug.Console(2, this, "EventId {0}", args.EventId);
+
             switch (id)
             {
                 case VideoControlsEventIds.BrightnessFeedbackEventId:
@@ -249,76 +244,76 @@ namespace PepperDash.Essentials.DM
                 case VideoControlsEventIds.ContrastFeedbackEventId:
                     VgaContrastFeedback.FireUpdate();
                     break;
-            }
-        }
-
-
-
-		public override bool CustomActivate()
-		{
-			// Link up all of these damned events to the various RoutingPorts via a helper handler
-			Tx.HdmiInputs[1].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn1, a.EventId);
-			Tx.HdmiInputs[1].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn1, a.EventId);
-
-			Tx.HdmiInputs[2].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn2, a.EventId);
-			Tx.HdmiInputs[2].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn2, a.EventId);
-
-			Tx.VgaInput.InputStreamChange += (o, a) => FowardInputStreamChange(VgaIn, a.EventId);
-			Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(VgaIn, a.EventId);
-
-			// Base does register and sets up comm monitoring.
-			return base.CustomActivate();
-		}
-
-        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-        {
-            var joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
-
-            if (Hdmi1VideoSyncFeedback != null)
+            }
+        }
+
+
+
+        public override bool CustomActivate()
+        {
+            // Link up all of these damned events to the various RoutingPorts via a helper handler
+            Tx.HdmiInputs[1].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn1, a.EventId);
+            Tx.HdmiInputs[1].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn1, a.EventId);
+
+            Tx.HdmiInputs[2].InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn2, a.EventId);
+            Tx.HdmiInputs[2].VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn2, a.EventId);
+
+            Tx.VgaInput.InputStreamChange += (o, a) => FowardInputStreamChange(VgaIn, a.EventId);
+            Tx.VgaInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(VgaIn, a.EventId);
+
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
+
+            if (Hdmi1VideoSyncFeedback != null)
             {
-                Hdmi1VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
-            }
-            if (Hdmi2VideoSyncFeedback != null)
+                Hdmi1VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
+            }
+            if (Hdmi2VideoSyncFeedback != null)
             {
-                Hdmi2VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
-            }
-            if (VgaVideoSyncFeedback != null)
+                Hdmi2VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
+            }
+            if (VgaVideoSyncFeedback != null)
             {
-                VgaVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input3VideoSyncStatus.JoinNumber]);
-            }
-
-            LinkDmTxToApi(this, trilist, joinMap, bridge);
-        }
-
-        /// <summary>
-        /// Enables or disables free run
-        /// </summary>
-        /// <param name="enable"></param>
+                VgaVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input3VideoSyncStatus.JoinNumber]);
+            }
+
+            LinkDmTxToApi(this, trilist, joinMap, bridge);
+        }
+
+        /// <summary>
+        /// Enables or disables free run
+        /// </summary>
+        /// <param name="enable"></param>
         public void SetFreeRunEnabled(bool enable)
         {
             Tx.VgaInput.FreeRun = enable ? eDmFreeRunSetting.Enabled : eDmFreeRunSetting.Disabled;
         }
 
-        /// <summary>
-        /// Sets the VGA brightness level
-        /// </summary>
-        /// <param name="level"></param>
-        public void SetVgaBrightness(ushort level)
-        {
-            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
-        }
-
-        /// <summary>
-        /// Sets the VGA contrast level
-        /// </summary>
-        /// <param name="level"></param>
-        public void SetVgaContrast(ushort level)
-        {
-            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
-        }
-
-
-
+        /// <summary>
+        /// Sets the VGA brightness level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaBrightness(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Sets the VGA contrast level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaContrast(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
+        }
+
+
+
         public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
         {
             Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
@@ -326,76 +321,76 @@ namespace PepperDash.Essentials.DM
             switch (type)
             {
                 case eRoutingSignalType.Video:
-                    switch (input)
-                    {
-                        case 0:
-                        {
-                            ExecuteSwitch(eVst.Auto, null, type);
-                            break;
-                        }
-                        case 1:
-                        {
-                            ExecuteSwitch(HdmiIn1.Selector, null, type);
-                            break;
-                        }
-                        case 2:
-                        {
-                            ExecuteSwitch(HdmiIn2.Selector, null, type);
-                            break;
-                        }
-                        case 3:
-                        {
-                            ExecuteSwitch(VgaIn.Selector, null, type);
-                            break;
-                        }
-                        case 4:
-                        {
-                            ExecuteSwitch(eVst.AllDisabled, null, type);
-                            break;
-                        }
+                    switch (input)
+                    {
+                        case 0:
+                            {
+                                ExecuteSwitch(eVst.Auto, null, type);
+                                break;
+                            }
+                        case 1:
+                            {
+                                ExecuteSwitch(HdmiIn1.Selector, null, type);
+                                break;
+                            }
+                        case 2:
+                            {
+                                ExecuteSwitch(HdmiIn2.Selector, null, type);
+                                break;
+                            }
+                        case 3:
+                            {
+                                ExecuteSwitch(VgaIn.Selector, null, type);
+                                break;
+                            }
+                        case 4:
+                            {
+                                ExecuteSwitch(eVst.AllDisabled, null, type);
+                                break;
+                            }
                     }
                     break;
                 case eRoutingSignalType.Audio:
-                    switch (input)
-                    {
-                        case 0:
-                        {
-                            ExecuteSwitch(eAst.Auto, null, type);
-                            break;
-                        }
-                        case 1:
-                        {
-                            ExecuteSwitch(eAst.Hdmi1, null, type);
-                            break;
-                        }
-                        case 2:
-                        {
-                            ExecuteSwitch(eAst.Hdmi2, null, type);
-                            break;
-                        }
-                        case 3:
-                        {
-                            ExecuteSwitch(eAst.AudioIn, null, type);
-                            break;
-                        }
-                        case 4:
-                        {
-                            ExecuteSwitch(eAst.AllDisabled, null, type);
-                            break;
-                        }
+                    switch (input)
+                    {
+                        case 0:
+                            {
+                                ExecuteSwitch(eAst.Auto, null, type);
+                                break;
+                            }
+                        case 1:
+                            {
+                                ExecuteSwitch(eAst.Hdmi1, null, type);
+                                break;
+                            }
+                        case 2:
+                            {
+                                ExecuteSwitch(eAst.Hdmi2, null, type);
+                                break;
+                            }
+                        case 3:
+                            {
+                                ExecuteSwitch(eAst.AudioIn, null, type);
+                                break;
+                            }
+                        case 4:
+                            {
+                                ExecuteSwitch(eAst.AllDisabled, null, type);
+                                break;
+                            }
                     }
                     break;
             }
         }
 
-        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
-        {
-            if ((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
-                Tx.VideoSource = (eVst)inputSelector;
-            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
-                Tx.AudioSource = (eAst)inputSelector;
-        }
-
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            if ((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
+                Tx.VideoSource = (eVst)inputSelector;
+            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
+                Tx.AudioSource = (eAst)inputSelector;
+        }
+
         void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
         {
             Debug.Console(2, "{0} event {1} stream {2}", this.Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
@@ -405,7 +400,7 @@ namespace PepperDash.Essentials.DM
                 case EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId:
                 case EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId:
                 case EndpointInputStreamEventIds.HdcpCapabilityFeedbackEventId:
-                    if (inputStream == Tx.HdmiInputs[1]) HdmiIn1HdcpCapabilityFeedback.FireUpdate();
+                    if (inputStream == Tx.HdmiInputs[1]) HdmiIn1HdcpCapabilityFeedback.FireUpdate();
                     if (inputStream == Tx.HdmiInputs[2]) HdmiIn2HdcpCapabilityFeedback.FireUpdate();
                     HdcpStateFeedback.FireUpdate();
                     break;
@@ -450,57 +445,57 @@ namespace PepperDash.Essentials.DM
                     OnSwitchChange(new RoutingNumericEventArgs(1, AudioSourceNumericFeedback.UShortValue, OutputPorts.First(), localInputAudioPort, eRoutingSignalType.Audio));
                     break;
             }
-        }
+        }
 
-        /// <summary>
-		/// Relays the input stream change to the appropriate RoutingInputPort.
-		/// </summary>
-		void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
-		{
+        /// <summary>
+        /// Relays the input stream change to the appropriate RoutingInputPort.
+        /// </summary>
+        void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
             if (eventId != EndpointInputStreamEventIds.SyncDetectedFeedbackEventId) return;
-            inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
+            inputPort.VideoStatus.VideoSyncFeedback.FireUpdate();
             AnyVideoInput.VideoStatus.VideoSyncFeedback.FireUpdate();
-		}
-		
-		/// <summary>
-		/// Relays the VideoAttributes change to a RoutingInputPort
-		/// </summary>
-		void ForwardVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
-		{
-			//// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
-			//Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
-			//    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
-			switch (eventId)
-			{
-				case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
-					inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
-					AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
-					break;
-				case VideoAttributeEventIds.HdcpStateFeedbackEventId:
-					inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
-					AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
-					break;
-				case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
-				case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
-					inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
-					AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
-					break;
-                case VideoAttributeEventIds.FramesPerSecondFeedbackEventId:
-                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
-                    break;
-			}
-		}
-
-
-		#region IIROutputPorts Members
-		public CrestronCollection<IROutputPort> IROutputPorts { get { return Tx.IROutputPorts; } }
-		public int NumberOfIROutputPorts { get { return Tx.NumberOfIROutputPorts; } }
-		#endregion
-
-		#region IComPorts Members
-		public CrestronCollection<ComPort> ComPorts { get { return Tx.ComPorts; } }
-		public int NumberOfComPorts { get { return Tx.NumberOfComPorts; } }
-		#endregion
-	}
-}	
+        }
+
+        /// <summary>
+        /// Relays the VideoAttributes change to a RoutingInputPort
+        /// </summary>
+        void ForwardVideoAttributeChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
+            //// LOCATION: Crestron.SimplSharpPro.DM.VideoAttributeEventIds
+            //Debug.Console(2, this, "VideoAttributes_AttributeChange event id={0} from {1}",
+            //    args.EventId, (sender as VideoAttributesEnhanced).Owner.GetType());
+            switch (eventId)
+            {
+                case VideoAttributeEventIds.HdcpActiveFeedbackEventId:
+                    inputPort.VideoStatus.HdcpActiveFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.HdcpActiveFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.HdcpStateFeedbackEventId:
+                    inputPort.VideoStatus.HdcpStateFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.HdcpStateFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.HorizontalResolutionFeedbackEventId:
+                case VideoAttributeEventIds.VerticalResolutionFeedbackEventId:
+                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    break;
+                case VideoAttributeEventIds.FramesPerSecondFeedbackEventId:
+                    inputPort.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    AnyVideoInput.VideoStatus.VideoResolutionFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+
+        #region IIROutputPorts Members
+        public CrestronCollection<IROutputPort> IROutputPorts { get { return Tx.IROutputPorts; } }
+        public int NumberOfIROutputPorts { get { return Tx.NumberOfIROutputPorts; } }
+        #endregion
+
+        #region IComPorts Members
+        public CrestronCollection<ComPort> ComPorts { get { return Tx.ComPorts; } }
+        public int NumberOfComPorts { get { return Tx.NumberOfComPorts; } }
+        #endregion
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4kz100Controller.cs

@@ -72,6 +72,7 @@ namespace PepperDash.Essentials.DM
             HdmiIn.Port = Tx;
 
             PreventRegistration = true;
+            tx.Register();
         }
 
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4kz302CController.cs

@@ -18,7 +18,7 @@ namespace PepperDash.Essentials.DM
 
 
     [Description("Wrapper class for DM-TX-4K-Z-302-C")]
-    public class DmTx4kz302CController : DmTxControllerBase, ITxRoutingWithFeedback, IHasFeedback,
+    public class DmTx4kz302CController : DmTxControllerBase, ITxRoutingWithFeedback,
         IIROutputPorts, IComPorts
     {
         public DmTx4kz302C Tx { get; private set; }
@@ -34,6 +34,7 @@ namespace PepperDash.Essentials.DM
         public IntFeedback AudioSourceNumericFeedback { get; protected set; }
         public IntFeedback HdmiIn1HdcpCapabilityFeedback { get; protected set; }
         public IntFeedback HdmiIn2HdcpCapabilityFeedback { get; protected set; }
+        public IntFeedback DisplayPortInHdcpCapabilityFeedback { get; protected set; }
         public BoolFeedback Hdmi1VideoSyncFeedback { get; protected set; }
         public BoolFeedback Hdmi2VideoSyncFeedback { get; protected set; }
         public BoolFeedback DisplayPortVideoSyncFeedback { get; protected set; }
@@ -120,7 +121,7 @@ namespace PepperDash.Essentials.DM
 
             Tx.HdmiInputs[1].InputStreamChange += InputStreamChangeEvent;
             Tx.HdmiInputs[2].InputStreamChange += InputStreamChangeEvent;
-            Tx.DisplayPortInput.InputStreamChange += DisplayPortInputStreamChange;
+            Tx.DisplayPortInput.InputStreamChange += InputStreamChangeEvent;
             Tx.BaseEvent += Tx_BaseEvent;
             Tx.OnlineStatusChange += Tx_OnlineStatusChange;
 
@@ -130,15 +131,32 @@ namespace PepperDash.Essentials.DM
             HdmiIn1HdcpCapabilityFeedback = new IntFeedback("HdmiIn1HdcpCapability", () => (int)tx.HdmiInputs[1].HdcpCapabilityFeedback);
 
             HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability", () => (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
+            DisplayPortInHdcpCapabilityFeedback = new IntFeedback("DisplayPortInHdcpCapability",
+                () => (int)tx.DisplayPortInput.HdcpCapabilityFeedback);
 
+
+            /*
             HdcpStateFeedback =
                 new IntFeedback(
                     () =>
                         tx.HdmiInputs[1].HdcpCapabilityFeedback > tx.HdmiInputs[2].HdcpCapabilityFeedback
                             ? (int)tx.HdmiInputs[1].HdcpCapabilityFeedback
                             : (int)tx.HdmiInputs[2].HdcpCapabilityFeedback);
+             */
+
+            //yeah this is gross - but it's the quickest way to do this...
+            /*
+            HdcpStateFeedback = new IntFeedback(() => {
+                var states = new[] {(int) tx.DisplayPortInput.HdcpCapabilityFeedback, (int) tx.HdmiInputs[1].HdcpCapabilityFeedback, (int) tx.HdmiInputs[2].HdcpCapabilityFeedback};
+
+                return states.Max();
+            });
+             */
 
             HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
+            // I feel like we have had this as a misnomer for so long, that it really needed to be fixed 
+            // All we were doing was reporting the best of the current statuses - not the actual capability of the device.
+            HdcpStateFeedback = new IntFeedback(() => (int)HdcpSupportCapability);
 
             Hdmi1VideoSyncFeedback = new BoolFeedback(() => (bool)tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue);
 
@@ -146,20 +164,25 @@ namespace PepperDash.Essentials.DM
 
             DisplayPortVideoSyncFeedback = new BoolFeedback(() => (bool)tx.DisplayPortInput.SyncDetectedFeedback.BoolValue);
 
-
             var combinedFuncs = new VideoStatusFuncsWrapper
             {
                 HdcpActiveFeedbackFunc = () =>
                     (ActualActiveVideoInput == eVst.Hdmi1
                     && tx.HdmiInputs[1].VideoAttributes.HdcpActiveFeedback.BoolValue)
                     || (ActualActiveVideoInput == eVst.Hdmi2
-                    && tx.HdmiInputs[2].VideoAttributes.HdcpActiveFeedback.BoolValue),
+                    && tx.HdmiInputs[2].VideoAttributes.HdcpActiveFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.DisplayPort
+                    && tx.DisplayPortInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
 
                 HdcpStateFeedbackFunc = () =>
                 {
                     if (ActualActiveVideoInput == eVst.Hdmi1)
-                        return tx.HdmiInputs[1].VideoAttributes.HdcpStateFeedback.ToString();
-                    return ActualActiveVideoInput == eVst.Hdmi2 ? tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString() : "";
+                        return tx.HdmiInputs[1].VideoAttributes.HdcpStateFeedback.ToString(); 
+                    if (ActualActiveVideoInput == eVst.Hdmi2)
+                        return tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString();
+                    return ActualActiveVideoInput == eVst.DisplayPort
+                        ? tx.DisplayPortInput.VideoAttributes.HdcpStateFeedback.ToString()
+                        : "";
                 },
 
                 VideoResolutionFeedbackFunc = () =>
@@ -168,6 +191,8 @@ namespace PepperDash.Essentials.DM
                         return tx.HdmiInputs[1].VideoAttributes.GetVideoResolutionString();
                     if (ActualActiveVideoInput == eVst.Hdmi2)
                         return tx.HdmiInputs[2].VideoAttributes.GetVideoResolutionString();
+                    if (ActualActiveVideoInput == eVst.DisplayPort)
+                        return tx.DisplayPortInput.VideoAttributes.GetVideoResolutionString();
                     return ActualActiveVideoInput == eVst.Vga ? tx.DisplayPortInput.VideoAttributes.GetVideoResolutionString() : "";
                 },
                 VideoSyncFeedbackFunc = () =>
@@ -175,6 +200,8 @@ namespace PepperDash.Essentials.DM
                     && tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
                     || (ActualActiveVideoInput == eVst.Hdmi2
                     && tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.DisplayPort
+                    && tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
                     || (ActualActiveVideoInput == eVst.Vga
                     && tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
 
@@ -193,28 +220,15 @@ namespace PepperDash.Essentials.DM
                 AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
                 AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
                 AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiIn1HdcpCapabilityFeedback, HdmiIn2HdcpCapabilityFeedback,
-                Hdmi1VideoSyncFeedback, Hdmi2VideoSyncFeedback, DisplayPortVideoSyncFeedback);
+                Hdmi1VideoSyncFeedback, Hdmi2VideoSyncFeedback, DisplayPortVideoSyncFeedback, DisplayPortInHdcpCapabilityFeedback);
 
-            // Set Ports for CEC
             HdmiIn1.Port = Tx.HdmiInputs[1];
             HdmiIn2.Port = Tx.HdmiInputs[2];
+            DisplayPortIn.Port = Tx.DisplayPortInput;
             HdmiLoopOut.Port = Tx.HdmiOutput;
             DmOut.Port = Tx.DmOutput;
         }
 
-        void DisplayPortInputStreamChange(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
-        {
-            Debug.Console(2, "{0} event {1} stream {2}", Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
-
-            switch (args.EventId)
-            {
-                case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
-                    DisplayPortVideoSyncFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-
 
         public override bool CustomActivate()
         {
@@ -256,41 +270,41 @@ namespace PepperDash.Essentials.DM
         {
             Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
 
-                switch (input)
-                {
-                    case 0:
-                        {
-                            ExecuteSwitch(eVst.Auto, null, type);
-                            break;
-                        }
-                    case 1:
-                        {
-                            ExecuteSwitch(HdmiIn1.Selector, null, type);
-                            break;
-                        }
-                    case 2:
-                        {
-                            ExecuteSwitch(HdmiIn2.Selector, null, type);
-                            break;
-                        }
-                    case 3:
-                        {
-                            ExecuteSwitch(DisplayPortIn.Selector, null, type);
-                            break;
-                        }
-                    case 4:
-                        {
-                            ExecuteSwitch(eVst.AllDisabled, null, type);
-                            break;
-                        }
-                    default:
+            switch (input)
+            {
+                case 0:
+                    {
+                        ExecuteSwitch(eVst.Auto, null, type);
+                        break;
+                    }
+                case 1:
+                    {
+                        ExecuteSwitch(HdmiIn1.Selector, null, type);
+                        break;
+                    }
+                case 2:
+                    {
+                        ExecuteSwitch(HdmiIn2.Selector, null, type);
+                        break;
+                    }
+                case 3:
+                    {
+                        ExecuteSwitch(DisplayPortIn.Selector, null, type);
+                        break;
+                    }
+                case 4:
+                    {
+                        ExecuteSwitch(eVst.AllDisabled, null, type);
+                        break;
+                    }
+                default:
                     {
                         Debug.Console(2, this, "Unable to execute numeric switch to input {0}", input);
                         break;
                     }
 
-                }
-            
+            }
+
 
         }
 
@@ -326,11 +340,17 @@ namespace PepperDash.Essentials.DM
                 case EndpointInputStreamEventIds.HdcpCapabilityFeedbackEventId:
                     if (inputStream == Tx.HdmiInputs[1]) HdmiIn1HdcpCapabilityFeedback.FireUpdate();
                     if (inputStream == Tx.HdmiInputs[2]) HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+                    if (inputStream == Tx.DisplayPortInput) DisplayPortInHdcpCapabilityFeedback.FireUpdate();
+
+                    Debug.Console(2, this, "DisplayPortHDCP Mode Trigger = {0}",
+                        DisplayPortInHdcpCapabilityFeedback.IntValue);
+
                     HdcpStateFeedback.FireUpdate();
                     break;
                 case EndpointInputStreamEventIds.SyncDetectedFeedbackEventId:
                     if (inputStream == Tx.HdmiInputs[1]) Hdmi1VideoSyncFeedback.FireUpdate();
                     if (inputStream == Tx.HdmiInputs[2]) Hdmi2VideoSyncFeedback.FireUpdate();
+                    if (inputStream == Tx.DisplayPortInput) DisplayPortVideoSyncFeedback.FireUpdate();
                     break;
             }
         }
@@ -413,7 +433,6 @@ namespace PepperDash.Essentials.DM
             }
         }
 
-
         #region IIROutputPorts Members
         public CrestronCollection<IROutputPort> IROutputPorts { get { return Tx.IROutputPorts; } }
         public int NumberOfIROutputPorts { get { return Tx.NumberOfIROutputPorts; } }

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTxHelpers.cs

@@ -1,8 +1,6 @@
 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;
@@ -18,8 +16,8 @@ using PepperDash.Essentials.Core.Config;
 
 namespace PepperDash.Essentials.DM
 {
-	public class DmTxHelper
-	{
+    public class DmTxHelper
+    {
 
         public static BasicDmTxControllerBase GetDmTxForChassisWithoutIpId(string key, string name, string typeName, DMInput dmInput)
         {
@@ -44,7 +42,7 @@ namespace PepperDash.Essentials.DM
             if (typeName.StartsWith("dmtx401"))
                 return new DmTx401CController(key, name, new DmTx401C(dmInput), true);
             if (typeName.StartsWith("hdbasettx"))
-                new HDBaseTTxController(key, name, new HDTx3CB(dmInput));
+                return new HDBaseTTxController(key, name, new HDTx3CB(dmInput));
 
             return null;
         }
@@ -77,31 +75,32 @@ namespace PepperDash.Essentials.DM
             return null;
         }
 
-		/// <summary>
-		/// A factory method for various DmTxControllers
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
-		/// <param name="props"></param>
-		/// <returns></returns>
+        /// <summary>
+        /// A factory method for various DmTxControllers
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="props"></param>
+        /// <param name="typeName"></param>
+        /// <returns></returns>
         public static BasicDmTxControllerBase GetDmTxController(string key, string name, string typeName, DmTxPropertiesConfig props)
-		{
-			// switch on type name... later...
+        {
+            // switch on type name... later...
 
-	        typeName = typeName.ToLower();
-	        //uint ipid = Convert.ToUInt16(props.Id, 16);
-	        var ipid = props.Control.IpIdInt;
-	        var pKey = props.ParentDeviceKey.ToLower();
+            typeName = typeName.ToLower();
+            //uint ipid = Convert.ToUInt16(props.Id, 16);
+            var ipid = props.Control.IpIdInt;
+            var pKey = props.ParentDeviceKey.ToLower();
 
             if (pKey == "processor")
-	        {
-				// Catch constructor failures, mainly dues to IPID
-				try
-				{
-                    if(typeName.StartsWith("dmtx200"))
+            {
+                // Catch constructor failures, mainly dues to IPID
+                try
+                {
+                    if (typeName.StartsWith("dmtx200"))
                         return new DmTx200Controller(key, name, new DmTx200C2G(ipid, Global.ControlSystem), false);
-					if (typeName.StartsWith("dmtx201c"))
-						return new DmTx201CController(key, name, new DmTx201C(ipid, Global.ControlSystem), false);
+                    if (typeName.StartsWith("dmtx201c"))
+                        return new DmTx201CController(key, name, new DmTx201C(ipid, Global.ControlSystem), false);
                     if (typeName.StartsWith("dmtx201s"))
                         return new DmTx201SController(key, name, new DmTx201S(ipid, Global.ControlSystem), false);
                     if (typeName.StartsWith("dmtx4k202"))
@@ -112,35 +111,36 @@ namespace PepperDash.Essentials.DM
                         return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, Global.ControlSystem), false);
                     if (typeName.StartsWith("dmtx4kz302"))
                         return new DmTx4kz302CController(key, name, new DmTx4kz302C(ipid, Global.ControlSystem), false);
-					if (typeName.StartsWith("dmtx401"))
+                    if (typeName.StartsWith("dmtx401"))
                         return new DmTx401CController(key, name, new DmTx401C(ipid, Global.ControlSystem), false);
-					Debug.Console(0, "{1} WARNING: Cannot create DM-TX of type: '{0}'", typeName, key);
-				}
-				catch (Exception e)
-				{
-					Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e);
-				}
+                    Debug.Console(0, "{1} WARNING: Cannot create DM-TX of type: '{0}'", typeName, key);
+                }
+                catch (Exception e)
+                {
+                    Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e);
+                }
                 return null;
-			}
+            }
 
             var parentDev = DeviceManager.GetDeviceForKey(pKey);
             DMInput dmInput;
             BasicDmTxControllerBase tx;
+            bool useChassisForOfflineFeedback = false;
 
-		    if (parentDev is DmChassisController)
+            if (parentDev is IDmSwitchWithEndpointOnlineFeedback)
             {
                 // Get the Crestron chassis and link stuff up
-			    var switchDev = (parentDev as DmChassisController);
-			    var chassis = switchDev.Chassis;
+                var switchDev = (parentDev as IDmSwitchWithEndpointOnlineFeedback);
+                var chassis = switchDev.Chassis;
 
                 //Check that the input is within range of this chassis' possible inputs
-			    var num = props.ParentInputNumber;
-			    if (num <= 0 || num > chassis.NumberOfInputs)
-			    {
-				    Debug.Console(0, "Cannot create DM device '{0}'. Input number '{1}' is out of range",
-					    key, num);
-				    return null;
-			    }
+                var num = props.ParentInputNumber;
+                if (num <= 0 || num > chassis.NumberOfInputs)
+                {
+                    Debug.Console(0, "Cannot create DM device '{0}'. Input number '{1}' is out of range",
+                        key, num);
+                    return null;
+                }
 
                 switchDev.TxDictionary.Add(num, key);
                 dmInput = chassis.Inputs[num];
@@ -155,15 +155,23 @@ namespace PepperDash.Essentials.DM
                         chassis is DmMd128x128 || chassis is DmMd64x64)
                     {
                         tx = GetDmTxForChassisWithoutIpId(key, name, typeName, dmInput);
-                        Debug.Console(0, "DM endpoint output {0} is for Cpu3, changing online feedback to chassis", num);
-                        tx.IsOnline.SetValueFunc(() => switchDev.InputEndpointOnlineFeedbacks[num].BoolValue);
-                        switchDev.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => tx.IsOnline.FireUpdate();
-                        return tx;
+                        useChassisForOfflineFeedback = true;
                     }
                     else
                     {
-                        return GetDmTxForChassisWithIpId(key, name, typeName, ipid, dmInput);
+                        tx = GetDmTxForChassisWithIpId(key, name, typeName, ipid, dmInput);
+                        if (typeName == "hdbasettx" || typeName == "dmtx4k100c1g")
+                        {
+                            useChassisForOfflineFeedback = true;
+                        }
                     }
+                    if (useChassisForOfflineFeedback)
+                    {
+                        Debug.Console(0, "DM endpoint output {0} does not have direct online feedback, changing online feedback to chassis", num);
+                        tx.IsOnline.SetValueFunc(() => switchDev.InputEndpointOnlineFeedbacks[num].BoolValue);
+                        switchDev.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => tx.IsOnline.FireUpdate();
+                    }
+                    return tx;
                 }
                 catch (Exception e)
                 {
@@ -171,7 +179,8 @@ namespace PepperDash.Essentials.DM
                     return null;
                 }
             }
-            else if(parentDev is DmpsRoutingController)
+
+            if (parentDev is DmpsRoutingController)
             {
                 // Get the DMPS chassis and link stuff up
                 var dmpsDev = (parentDev as DmpsRoutingController);
@@ -200,33 +209,38 @@ namespace PepperDash.Essentials.DM
 
                 try
                 {
-                    if(Global.ControlSystemIsDmps4kType)
+                    if (Global.ControlSystemIsDmps4kType)
                     {
                         tx = GetDmTxForChassisWithoutIpId(key, name, typeName, dmInput);
-                        Debug.Console(0, "DM endpoint output {0} is for DMPS3-4K, changing online feedback to chassis", num);
-                        tx.IsOnline.SetValueFunc(() => dmpsDev.InputEndpointOnlineFeedbacks[num].BoolValue);
-                        dmpsDev.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => tx.IsOnline.FireUpdate();
-                        return tx;
+                        useChassisForOfflineFeedback = true;
                     }
                     else
                     {
-                        return GetDmTxForChassisWithIpId(key, name, typeName, ipid, dmInput);
+                        tx = GetDmTxForChassisWithIpId(key, name, typeName, ipid, dmInput);
+                        if (typeName == "hdbasettx" || typeName == "dmtx4k100c1g")
+                        {
+                            useChassisForOfflineFeedback = true;
+                        }
                     }
+                    if (useChassisForOfflineFeedback)
+                    {
+                        Debug.Console(0, "DM endpoint output {0} does not have direct online feedback, changing online feedback to chassis", num);
+                        tx.IsOnline.SetValueFunc(() => dmpsDev.InputEndpointOnlineFeedbacks[num].BoolValue);
+                        dmpsDev.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => tx.IsOnline.FireUpdate();
+                    }
+                    return tx;
                 }
                 catch (Exception e)
                 {
                     Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device for dmps: {1}", key, e);
                     return null;
-                }                
+                }
             }
 
-            else
-            {
-			    Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a processor, DM Chassis or DMPS.", key, pKey);
-			    return null;
-			}
-		}
-	}
+            Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a processor, DM Chassis or DMPS.", key, pKey);
+            return null;
+        }
+    }
 
     public abstract class BasicDmTxControllerBase : CrestronGenericBridgeableBaseDevice
     {
@@ -237,21 +251,21 @@ namespace PepperDash.Essentials.DM
         }
     }
 
-	/// <summary>
-	/// 
-	/// </summary>
+    /// <summary>
+    /// 
+    /// </summary>
     [Description("Wrapper class for all DM-TX variants")]
-	public abstract class DmTxControllerBase : BasicDmTxControllerBase
-	{
+    public abstract class DmTxControllerBase : BasicDmTxControllerBase
+    {
         public virtual void SetPortHdcpCapability(eHdcpCapabilityType hdcpMode, uint port) { }
         public virtual eHdcpCapabilityType HdcpSupportCapability { get; protected set; }
         public abstract StringFeedback ActiveVideoInputFeedback { get; protected set; }
         public RoutingInputPortWithVideoStatuses AnyVideoInput { get; protected set; }
         public IntFeedback HdcpStateFeedback { get; protected set; }
 
-	    protected DmTxControllerBase(string key, string name, EndpointTransmitterBase hardware)
-			: base(key, name, hardware) 
-		{
+        protected DmTxControllerBase(string key, string name, EndpointTransmitterBase hardware)
+            : base(key, name, hardware)
+        {
             AddToFeedbackList(ActiveVideoInputFeedback);
 
             IsOnline.OutputChange += (currentDevice, args) =>
@@ -262,11 +276,12 @@ namespace PepperDash.Essentials.DM
                         feedback.FireUpdate();
                 }
             };
-		}
+        }
 
-	    protected DmTxControllerBase(string key, string name, DmHDBasedTEndPoint hardware) : base(key, name, hardware)
-	    {
-	    }
+        protected DmTxControllerBase(string key, string name, DmHDBasedTEndPoint hardware)
+            : base(key, name, hardware)
+        {
+        }
 
         protected DmTxControllerJoinMap GetDmTxJoinMap(uint joinStart, string joinMapKey)
         {
@@ -280,8 +295,8 @@ namespace PepperDash.Essentials.DM
             return joinMap;
         }
 
-	    protected void LinkDmTxToApi(DmTxControllerBase tx, BasicTriList trilist, DmTxControllerJoinMap joinMap, EiscApiAdvanced bridge)
-	    {
+        protected void LinkDmTxToApi(DmTxControllerBase tx, BasicTriList trilist, DmTxControllerJoinMap joinMap, EiscApiAdvanced bridge)
+        {
             if (bridge != null)
             {
                 bridge.AddJoinMap(Key, joinMap);
@@ -291,7 +306,7 @@ namespace PepperDash.Essentials.DM
                 Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
             }
 
-	        Debug.Console(1, tx, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+            Debug.Console(1, tx, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
 
             tx.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
             tx.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus.JoinNumber]);
@@ -318,8 +333,6 @@ namespace PepperDash.Essentials.DM
                 txR.VideoSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.VideoInput.JoinNumber]);
                 txR.AudioSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.AudioInput.JoinNumber]);
 
-                trilist.UShortInput[joinMap.HdcpSupportCapability.JoinNumber].UShortValue = (ushort)tx.HdcpSupportCapability;
-
                 if (txR.InputPorts[DmPortName.HdmiIn] != null)
                 {
                     var inputPort = txR.InputPorts[DmPortName.HdmiIn];
@@ -366,7 +379,7 @@ namespace PepperDash.Essentials.DM
                     {
                         var intFeedback = tx.Feedbacks["HdmiIn2HdcpCapability"] as IntFeedback;
                         if (intFeedback != null)
-                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState.JoinNumber]);
+                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port2HdcpState.JoinNumber]);
                     }
 
                     if (inputPort.ConnectionType == eRoutingPortConnectionType.Hdmi && inputPort.Port != null)
@@ -377,6 +390,40 @@ namespace PepperDash.Essentials.DM
                     }
                 }
 
+                if (txR.InputPorts[DmPortName.DisplayPortIn] != null)
+                {
+                    var inputPort = txR.InputPorts[DmPortName.DisplayPortIn];
+
+                    if (tx.Feedbacks["DisplayPortInHdcpCapability"] != null)
+                    {
+
+                        var intFeedback = tx.Feedbacks["DisplayPortInHdcpCapability"] as IntFeedback;
+                        if (intFeedback != null)
+
+                            intFeedback.LinkInputSig(trilist.UShortInput[joinMap.Port3HdcpState.JoinNumber]);
+
+                        if (inputPort.ConnectionType == eRoutingPortConnectionType.DisplayPort && inputPort.Port != null)
+                        {
+                            var port = inputPort.Port as EndpointDisplayPortInput;
+                            SetHdcpCapabilityAction(port, joinMap.Port3HdcpState.JoinNumber, trilist);
+                        }
+                    }
+                }
+
+
+                var hdcpInputPortCount =
+                    (ushort)
+                        txR.InputPorts.Where(
+                            x => (x.Type == eRoutingSignalType.Video) || (x.Type == eRoutingSignalType.AudioVideo))
+                            .Where(
+                                x =>
+                                    (x.ConnectionType == eRoutingPortConnectionType.DmCat) ||
+                                    (x.ConnectionType == eRoutingPortConnectionType.Hdmi) ||
+                                    (x.ConnectionType == eRoutingPortConnectionType.DisplayPort))
+                            .ToList().Count();
+
+                trilist.SetUshort(joinMap.HdcpInputPortCount.JoinNumber, hdcpInputPortCount);
+
             }
 
             var txFreeRun = tx as IHasFreeRun;
@@ -416,7 +463,7 @@ namespace PepperDash.Essentials.DM
                     });
             }
             else
-            {
+            { 
                 trilist.SetUShortSigAction(join,
                         s =>
                         {
@@ -424,14 +471,40 @@ namespace PepperDash.Essentials.DM
                         });
             }
         }
-	}
+
+        private void SetHdcpCapabilityAction(EndpointDisplayPortInput port, uint join,
+            BasicTriList trilist)
+        {
+            trilist.SetUShortSigAction(join,
+                s =>
+                {
+                    Debug.Console(0, this, "Trying to set HDCP to {0} on port {1}", s, port.ToString());
+                    port.HdcpCapability = (eHdcpCapabilityType) s;
+                });
+        }
+
+    }
 
     public class DmTxControllerFactory : EssentialsDeviceFactory<DmTxControllerBase>
     {
         public DmTxControllerFactory()
         {
-            TypeNames = new List<string>() { "dmtx200c", "dmtx201c", "dmtx201s", "dmtx4k100c", "dmtx4k202c", "dmtx4kz202c", "dmtx4k302c", "dmtx4kz302c",
-                "dmtx401c", "dmtx401s", "dmtx4k100c1g", "dmtx4kz100c1g", "hdbasettx" };
+            TypeNames = new List<string>
+            {
+                "dmtx200c",
+                "dmtx201c",
+                "dmtx201s",
+                "dmtx4k100c",
+                "dmtx4k202c",
+                "dmtx4kz202c",
+                "dmtx4k302c",
+                "dmtx4kz302c",
+                "dmtx401c",
+                "dmtx401s",
+                "dmtx4k100c1g",
+                "dmtx4kz100c1g",
+                "hdbasettx"
+            };
         }
 
         public override EssentialsDevice BuildDevice(DeviceConfig dc)
@@ -441,8 +514,8 @@ namespace PepperDash.Essentials.DM
             Debug.Console(1, "Factory Attempting to create new DM-TX Device");
 
             var props = JsonConvert.DeserializeObject
-                <PepperDash.Essentials.DM.Config.DmTxPropertiesConfig>(dc.Properties.ToString());
-            return PepperDash.Essentials.DM.DmTxHelper.GetDmTxController(dc.Key, dc.Name, type, props);
+                <DmTxPropertiesConfig>(dc.Properties.ToString());
+            return DmTxHelper.GetDmTxController(dc.Key, dc.Name, type, props);
         }
     }
 

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/HDBaseTTxController.cs

@@ -52,6 +52,9 @@ namespace PepperDash.Essentials.DM
                 IsOnline.SetValueFunc(() => controller.InputEndpointOnlineFeedbacks[num].BoolValue);
                 controller.InputEndpointOnlineFeedbacks[num].OutputChange += (o, a) => IsOnline.FireUpdate();
             }
+
+            PreventRegistration = true;
+            tx.Register();
         }
 
         #region IRoutingInputs Members

essentials-framework/Essentials DM/Essentials_DM/IDmSwitch.cs

@@ -16,10 +16,17 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.DM.Config;
 
 namespace PepperDash.Essentials.DM {
-    public interface IDmSwitch {
+    public interface IDmSwitch
+	{
         Switch Chassis { get; }
 
         Dictionary<uint, string> TxDictionary { get; }
         Dictionary<uint, string> RxDictionary { get; }
     }
+
+	public interface IDmSwitchWithEndpointOnlineFeedback : IDmSwitch
+	{
+		Dictionary<uint, BoolFeedback> InputEndpointOnlineFeedbacks { get; }
+		Dictionary<uint, BoolFeedback> OutputEndpointOnlineFeedbacks { get; }
+	}
 }

essentials-framework/Essentials DM/Essentials_DM/PepperDash_Essentials_DM.csproj

@@ -105,6 +105,8 @@
     <Compile Include="Chassis\HdMdNxM4kEBridgeableController.cs" />
     <Compile Include="Chassis\HdMdNxM4kEController.cs" />
     <Compile Include="Config\InputPropertiesConfig.cs" />
+    <Compile Include="Endpoints\EndpointInterfaces.cs" />
+    <Compile Include="Endpoints\DGEs\DgeJoinMap.cs" />
     <Compile Include="Endpoints\DGEs\DmDge200CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZ100CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZScalerCController.cs" />

essentials-framework/Essentials Devices Common/Essentials Devices Common/Cameras/CameraBase.cs

@@ -223,7 +223,7 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
 
                 SendCameraPresetNamesToApi(presetsCamera, joinMap, trilist);
 
-                for (int i = 0; i < joinMap.NumberOfPresets.JoinNumber; i++)
+                for (int i = 0; i < joinMap.NumberOfPresets.JoinSpan; i++)
                 {
                     int tempNum = i;
 

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

@@ -1004,7 +1004,9 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 		    if (codec.DirectoryRoot != null)
 		    {
-                trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)codec.DirectoryRoot.CurrentDirectoryResults.Count);
+				var contactsCount = codec.DirectoryRoot.CurrentDirectoryResults.Where(c => c.ParentFolderId.Equals("root")).ToList().Count;				
+                trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)contactsCount);
+				Debug.Console(2, this, ">>> contactsCount: {0}", contactsCount);
 
                 var clearBytes = XSigHelpers.ClearOutputs();
 
@@ -1020,7 +1022,13 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 			codec.DirectoryResultReturned += (sender, args) =>
 			{
-				trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)args.Directory.CurrentDirectoryResults.Count);
+				var isRoot = codec.CurrentDirectoryResultIsNotDirectoryRoot.BoolValue == false;
+				var argsCount = isRoot 
+					? args.Directory.CurrentDirectoryResults.Where(a => a.ParentFolderId.Equals("root")).ToList().Count
+					: args.Directory.CurrentDirectoryResults.Count;
+
+				trilist.SetUshort(joinMap.DirectoryRowCount.JoinNumber, (ushort)argsCount);
+				Debug.Console(2, this, ">>> argsCount: {0}", argsCount);
 
 				var clearBytes = XSigHelpers.ClearOutputs();
 
@@ -1184,46 +1192,47 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
             return GetXSigString(tokenArray);
         }
 
-	    private string UpdateDirectoryXSig(CodecDirectory directory, bool isRoot)
-	    {
-	        var xSigMaxIndex = 1023;
-	        var tokenArray = new XSigToken[directory.CurrentDirectoryResults.Count > xSigMaxIndex
-	            ? xSigMaxIndex
-	            : directory.CurrentDirectoryResults.Count];
+		private string UpdateDirectoryXSig(CodecDirectory directory, bool isRoot)
+		{
+			var xSigMaxIndex = 1023;
+			var tokenArray = new XSigToken[directory.CurrentDirectoryResults.Count > xSigMaxIndex
+				? xSigMaxIndex
+				: directory.CurrentDirectoryResults.Count];
 
-	        Debug.Console(2, this, "IsRoot: {0}, Directory Count: {1}, TokenArray.Length: {2}", isRoot,
-	            directory.CurrentDirectoryResults.Count, tokenArray.Length);
+			Debug.Console(2, this, "IsRoot: {0}, Directory Count: {1}, TokenArray.Length: {2}", isRoot, directory.CurrentDirectoryResults.Count, tokenArray.Length);
 
-	        var contacts = directory.CurrentDirectoryResults.Count > xSigMaxIndex
-	            ? directory.CurrentDirectoryResults.Take(xSigMaxIndex)
-	            : directory.CurrentDirectoryResults;
+			var contacts = directory.CurrentDirectoryResults.Count > xSigMaxIndex
+				? directory.CurrentDirectoryResults.Take(xSigMaxIndex)
+				: directory.CurrentDirectoryResults;
 
-	        var counterIndex = 1;
-	        foreach (var entry in contacts)
-	        {
-	            var arrayIndex = counterIndex - 1;
-	            var entryIndex = counterIndex;
+			var contactsToDisplay = isRoot
+				? contacts.Where(c => c.ParentFolderId == "root")
+				: contacts.Where(c => c.ParentFolderId != "root");
 
-	            Debug.Console(2, this, "Entry{2:0000} Name: {0}, Folder ID: {1}", entry.Name, entry.FolderId, entryIndex);
+			var counterIndex = 1;
+			foreach (var entry in contactsToDisplay)
+			{
+				var arrayIndex = counterIndex - 1;
+				var entryIndex = counterIndex;
 
-	            if (entry is DirectoryFolder && entry.ParentFolderId == "root")
-	            {
-	                tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, String.Format("[+] {0}", entry.Name));
+				Debug.Console(2, this, "Entry{2:0000} Name: {0}, Folder ID: {1}, Type: {3}, ParentFolderId: {4}",
+					entry.Name, entry.FolderId, entryIndex, entry.GetType().GetCType().FullName, entry.ParentFolderId);
 
-	                counterIndex++;
-	                counterIndex++;
+				if (entry is DirectoryFolder)
+				{
+					tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, String.Format("[+] {0}", entry.Name));
 
-	                continue;
-	            }
+					counterIndex++;
 
-	            tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, entry.Name);
+					continue;
+				}
 
-	            counterIndex++;
-	        }
-
-	        return GetXSigString(tokenArray);
+				tokenArray[arrayIndex] = new XSigSerialToken(entryIndex, entry.Name);
 
+				counterIndex++;
+			}
 
+			return GetXSigString(tokenArray);
 		}
 
 	    private void LinkVideoCodecCallControlsToApi(BasicTriList trilist, VideoCodecControllerJoinMap joinMap)
@@ -1393,11 +1402,11 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
                 tokenArray[digitalIndex + 1] = new XSigDigitalToken(digitalIndex + 2, call.IsOnHold);
 
 				//serials
-				tokenArray[arrayIndex] = new XSigSerialToken(stringIndex + 1, call.Name ?? String.Empty);
-				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 2, call.Number ?? String.Empty);
-				tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 3, call.Direction.ToString());
-				tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 4, call.Type.ToString());
-				tokenArray[arrayIndex + 4] = new XSigSerialToken(stringIndex + 5, call.Status.ToString());
+                tokenArray[stringIndex] = new XSigSerialToken(stringIndex + 1, call.Name ?? String.Empty);
+                tokenArray[stringIndex + 1] = new XSigSerialToken(stringIndex + 2, call.Number ?? String.Empty);
+                tokenArray[stringIndex + 2] = new XSigSerialToken(stringIndex + 3, call.Direction.ToString());
+                tokenArray[stringIndex + 3] = new XSigSerialToken(stringIndex + 4, call.Type.ToString());
+                tokenArray[stringIndex + 4] = new XSigSerialToken(stringIndex + 5, call.Status.ToString());
                 if(call.Duration != null)
                 {
                     // May need to verify correct string format here
@@ -1417,12 +1426,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 
                 //serials
-				tokenArray[arrayIndex] = new XSigSerialToken(stringIndex + 1, String.Empty);
-				tokenArray[arrayIndex + 1] = new XSigSerialToken(stringIndex + 2, String.Empty);
-				tokenArray[arrayIndex + 2] = new XSigSerialToken(stringIndex + 3, String.Empty);
-				tokenArray[arrayIndex + 3] = new XSigSerialToken(stringIndex + 4, String.Empty);
-				tokenArray[arrayIndex + 4] = new XSigSerialToken(stringIndex + 5, String.Empty);
-                tokenArray[arrayIndex + 5] = new XSigSerialToken(stringIndex + 6, String.Empty);
+                tokenArray[stringIndex] = new XSigSerialToken(stringIndex + 1, String.Empty);
+                tokenArray[stringIndex + 1] = new XSigSerialToken(stringIndex + 2, String.Empty);
+                tokenArray[stringIndex + 2] = new XSigSerialToken(stringIndex + 3, String.Empty);
+                tokenArray[stringIndex + 3] = new XSigSerialToken(stringIndex + 4, String.Empty);
+                tokenArray[stringIndex + 4] = new XSigSerialToken(stringIndex + 5, String.Empty);
+                tokenArray[stringIndex + 5] = new XSigSerialToken(stringIndex + 6, String.Empty);
 
 				arrayIndex += offset;
 				stringIndex += maxStrings;

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

@@ -303,11 +303,19 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 					{
 						var contact = new InvitableDirectoryContact { Name = c.ScreenName, ContactId = c.Jid };
 
-                        contact.ContactMethods.Add(new ContactMethod() { Number = c.Jid, Device = eContactMethodDevice.Video, CallType = eContactMethodCallType.Video, ContactMethodId = c.Jid });
+                        contact.ContactMethods.Add(new ContactMethod()
+                        {
+	                        Number = c.Jid, 
+							Device = eContactMethodDevice.Video, 
+							CallType = eContactMethodCallType.Video, 
+							ContactMethodId = c.Jid
+                        });
 
 						if (folders.Count > 0)
 						{
-							contact.ParentFolderId = c.IsZoomRoom ? "rooms" : "contacts";
+							contact.ParentFolderId = c.IsZoomRoom
+								? roomFolder.FolderId // "rooms" 
+								: contactFolder.FolderId; // "contacts"
 						}
 
 						contacts.Add(contact);

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

@@ -59,14 +59,18 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		private CameraBase _selectedCamera;
         private string _lastDialedMeetingNumber;
 
+        private CTimer contactsDebounceTimer;
+
 
 		private readonly ZoomRoomPropertiesConfig _props;
 
 		private bool _meetingPasswordRequired;
 
+        private bool _waitingForUserToAcceptOrRejectIncomingCall;
+
 		public void Poll(string pollString)
 		{
-			if(_meetingPasswordRequired) return;
+			if(_meetingPasswordRequired || _waitingForUserToAcceptOrRejectIncomingCall) return;
 			
 			SendText(string.Format("{0}{1}", pollString, SendDelimiter));
 		}
@@ -374,26 +378,12 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void SelectCamera(string key)
 		{
-			if (Cameras == null)
-			{
-				return;
-			}
+            if (CameraIsMutedFeedback.BoolValue)
+            {
+                CameraMuteOff();
+            }
 
-			var camera = Cameras.FirstOrDefault(c => c.Key.IndexOf(key, StringComparison.OrdinalIgnoreCase) > -1);
-			if (camera != null)
-			{
-				Debug.Console(1, this, "Selected Camera with key: '{0}'", camera.Key);
-				SelectedCamera = camera;
-
-                if (CameraIsMutedFeedback.BoolValue)
-                {
-                    CameraMuteOff();
-                }
-			}
-			else
-			{
-				Debug.Console(1, this, "Unable to select camera with key: '{0}'", key);
-			}
+            SendText(string.Format("zConfiguration Video Camera selectedId: {0}", key));
 		}
 
 		public CameraBase FarEndCamera { get; private set; }
@@ -656,8 +646,27 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 			{
 				if (a.PropertyName == "SelectedId")
 				{
-					SelectCamera(Configuration.Video.Camera.SelectedId);
-					// this will in turn fire the affected feedbacks
+                    if (Cameras == null)
+                    {
+                        return;
+                    }
+
+                    var camera = Cameras.FirstOrDefault(c => c.Key.IndexOf(Configuration.Video.Camera.SelectedId, StringComparison.OrdinalIgnoreCase) > -1);
+                    if (camera != null)
+                    {
+                        Debug.Console(1, this, "Camera selected with key: '{0}'", camera.Key);
+
+                        SelectedCamera = camera;
+
+                        if (CameraIsMutedFeedback.BoolValue)
+                        {
+                            CameraMuteOff();
+                        }
+                    }
+                    else
+                    {
+                        Debug.Console(1, this, "No camera found with key: '{0}'", Configuration.Video.Camera.SelectedId);
+                    }
 				}
 			};
 
@@ -968,6 +977,18 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void SendText(string command)
 		{
+            if (_meetingPasswordRequired)
+            {
+                Debug.Console(2, this, "Blocking commands to ZoomRoom while waiting for user to enter meeting password");
+                return;
+            }
+
+            if (_waitingForUserToAcceptOrRejectIncomingCall)
+            {
+                Debug.Console(2, this, "Blocking commands to ZoomRoom while waiting for user to accept or reject incoming call");
+                return;
+            }
+
 			if (CommDebuggingIsOn)
 			{
 				Debug.Console(1, this, "Sending: '{0}'", command);
@@ -1363,22 +1384,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 								JsonConvert.PopulateObject(responseObj.ToString(), Status.Phonebook);
 
-								var directoryResults =
-									zStatus.Phonebook.ConvertZoomContactsToGeneric(Status.Phonebook.Contacts);
-
-								if (!PhonebookSyncState.InitialSyncComplete)
-								{
-									PhonebookSyncState.InitialPhonebookFoldersReceived();
-									PhonebookSyncState.PhonebookRootEntriesReceived();
-									PhonebookSyncState.SetPhonebookHasFolders(true);
-									PhonebookSyncState.SetNumberOfContacts(Status.Phonebook.Contacts.Count);
-								}
-
-								directoryResults.ResultsFolderId = "root";
-
-								DirectoryRoot = directoryResults;
-
-								CurrentDirectoryResult = directoryResults;
+                                UpdateDirectory();
 
 								break;
 							}
@@ -1507,36 +1513,37 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 						{
 							case "phonebook":
 							{
+                                zStatus.Contact contact = new zStatus.Contact();
+
 								if (responseObj["Updated Contact"] != null)
-								{
-									var updatedContact =
-										JsonConvert.DeserializeObject<zStatus.Contact>(
-											responseObj["Updated Contact"].ToString());
-
-									var existingContact =
-										Status.Phonebook.Contacts.FirstOrDefault(c => c.Jid.Equals(updatedContact.Jid));
-
-									if (existingContact != null)
-									{
-										// Update existing contact
-										JsonConvert.PopulateObject(responseObj["Updated Contact"].ToString(),
-											existingContact);
-									}
+								{                                    
+                                    contact = responseObj["Updated Contact"].ToObject<zStatus.Contact>();									
 								}
 								else if (responseObj["Added Contact"] != null)
 								{
-									var jToken = responseObj["Updated Contact"];
-									if (jToken != null)
-									{
-										var newContact =
-											JsonConvert.DeserializeObject<zStatus.Contact>(
-												jToken.ToString());
-
-										// Add a new contact
-										Status.Phonebook.Contacts.Add(newContact);
-									}
+									contact = responseObj["Added Contact"].ToObject<zStatus.Contact>();
 								}
 
+                                var existingContactIndex = Status.Phonebook.Contacts.FindIndex(c => c.Jid.Equals(contact.Jid));
+
+                                if (existingContactIndex > 0)
+                                {                                    
+                                    Status.Phonebook.Contacts[existingContactIndex] = contact;
+                                } 
+                                else 
+                                {                                    
+                                    Status.Phonebook.Contacts.Add(contact);
+                                }
+
+                                if(contactsDebounceTimer == null)
+                                {
+                                    contactsDebounceTimer = new CTimer(o => UpdateDirectory(), 2000);
+                                }
+                                else
+                                {
+                                    contactsDebounceTimer.Reset();
+                                }                                
+
 								break;
 							}
 							case "bookingslistresult":
@@ -1592,6 +1599,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 										Id = incomingCall.callerJID
 									};
 
+                                    _waitingForUserToAcceptOrRejectIncomingCall = true;
+
 									ActiveCalls.Add(newCall);
 
 									OnCallStatusChange(newCall);
@@ -1618,6 +1627,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 										OnCallStatusChange(existingCall);
 									}
 
+                                    _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 									UpdateCallStatus();
 								}
 
@@ -2000,7 +2011,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 		/// </summary>
 		private void GetBookings()
 		{
-			if (_meetingPasswordRequired) return;
+			if (_meetingPasswordRequired || _waitingForUserToAcceptOrRejectIncomingCall) return;
 
 			SendText("zCommand Bookings List");
 		}
@@ -2229,6 +2240,42 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
             }
         }
 
+        private void UpdateDirectory()
+        {
+            Debug.Console(2, this, "Updating directory");
+            var directoryResults = zStatus.Phonebook.ConvertZoomContactsToGeneric(Status.Phonebook.Contacts);
+
+            if (!PhonebookSyncState.InitialSyncComplete)
+            {
+                PhonebookSyncState.InitialPhonebookFoldersReceived();
+                PhonebookSyncState.PhonebookRootEntriesReceived();
+                PhonebookSyncState.SetPhonebookHasFolders(true);
+                PhonebookSyncState.SetNumberOfContacts(Status.Phonebook.Contacts.Count);
+            }
+
+            directoryResults.ResultsFolderId = "root";
+
+            DirectoryRoot = directoryResults;
+
+            CurrentDirectoryResult = directoryResults;
+
+            //
+            if (contactsDebounceTimer != null)
+            {
+                ClearContactDebounceTimer();
+            }
+        }
+
+        private void ClearContactDebounceTimer()
+        {
+            Debug.Console(2, this, "Clearing Timer");
+            if (!contactsDebounceTimer.Disposed && contactsDebounceTimer != null)
+            {
+                contactsDebounceTimer.Dispose();
+                contactsDebounceTimer = null;
+            }
+        }
+
         /// <summary>
         /// Will return true if the host is myself (this zoom room)
         /// </summary>
@@ -2560,7 +2607,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 			PasswordRequired += (devices, args) =>
 			{
-                Debug.Console(0, this, "***********************************PaswordRequired. Message: {0} Cancelled: {1} Last Incorrect: {2} Failed: {3}", args.Message, args.LoginAttemptCancelled, args.LastAttemptWasIncorrect, args.LoginAttemptFailed);
+                Debug.Console(2, this, "***********************************PaswordRequired. Message: {0} Cancelled: {1} Last Incorrect: {2} Failed: {3}", args.Message, args.LoginAttemptCancelled, args.LastAttemptWasIncorrect, args.LoginAttemptFailed);
 
 				if (args.LoginAttemptCancelled)
 				{
@@ -2637,6 +2684,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void AcceptCall()
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			var incomingCall =
 				ActiveCalls.FirstOrDefault(
 					c => c.Status.Equals(eCodecCallStatus.Ringing) && c.Direction.Equals(eCodecCallDirection.Incoming));
@@ -2646,6 +2695,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public override void AcceptCall(CodecActiveCallItem call)
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText(string.Format("zCommand Call Accept callerJID: {0}", call.Id));
 
 			call.Status = eCodecCallStatus.Connected;
@@ -2657,6 +2708,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public void RejectCall()
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			var incomingCall =
 				ActiveCalls.FirstOrDefault(
 					c => c.Status.Equals(eCodecCallStatus.Ringing) && c.Direction.Equals(eCodecCallDirection.Incoming));
@@ -2666,6 +2719,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 		public override void RejectCall(CodecActiveCallItem call)
 		{
+            _waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText(string.Format("zCommand Call Reject callerJID: {0}", call.Id));
 
 			call.Status = eCodecCallStatus.Disconnected;
@@ -2792,16 +2847,25 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
         public void LeaveMeeting()
         {
-            SendText("zCommand Call Leave");
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
+			SendText("zCommand Call Leave");
         }
 
 		public override void EndCall(CodecActiveCallItem call)
 		{
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText("zCommand Call Disconnect");
 		}
 
 		public override void EndAllCalls()
 		{
+			_meetingPasswordRequired = false;
+			_waitingForUserToAcceptOrRejectIncomingCall = false;
+
 			SendText("zCommand Call Disconnect");
 		}
 
@@ -3451,20 +3515,21 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
         public void SubmitPassword(string password)
         {
+            _meetingPasswordRequired = false;
             Debug.Console(2, this, "Password Submitted: {0}", password);
             Dial(_lastDialedMeetingNumber, password);
-            //OnPasswordRequired(false, false, true, "");		
         }
 
         void OnPasswordRequired(bool lastAttemptIncorrect, bool loginFailed, bool loginCancelled, string message)
         {
+			_meetingPasswordRequired = !loginFailed || !loginCancelled;
+
             var handler = PasswordRequired;
             if (handler != null)
-            {
-				if(!loginFailed || !loginCancelled)
-					_meetingPasswordRequired = true;
-				
-                handler(this, new PasswordPromptEventArgs(lastAttemptIncorrect, loginFailed, loginCancelled, message));
+            {	            
+				Debug.Console(2, this, "Meeting Password Required: {0}", _meetingPasswordRequired);
+
+	            handler(this, new PasswordPromptEventArgs(lastAttemptIncorrect, loginFailed, loginCancelled, message));
             }
         }
 

packages.config

@@ -1,3 +1,3 @@
 <packages>
-  <package id="PepperDashCore" version="1.1.1" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
-</packages>
+	<package id="PepperDashCore" version="1.2.1" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
+</packages>