Merge pull request #206 from PepperDash/feature/Improve-ControlPort-Constructors

Improve Control Port Constructors

PepperDashEssentials/UI/EssentialsTouchpanelController.cs

@@ -211,7 +211,7 @@ namespace PepperDash.Essentials
             var comm = CommFactory.GetControlPropertiesConfig(dc);
             var props = Newtonsoft.Json.JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
 
-            Debug.Console(1, "Factory Attempting to create new Generic Comm Device");
+            Debug.Console(1, "Factory Attempting to create new EssentialsTouchpanelController");
 
             var panelController = new EssentialsTouchpanelController(dc.Key, dc.Name, dc.Type, props, comm.IpIdInt);
 

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

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Core.Bridges
+{
+    public class HdMdNxM4kEControllerJoinMap : JoinMapBaseAdvanced
+    {
+        [JoinName("Name")]
+        public JoinDataComplete Name = new JoinDataComplete(new JoinData() { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata() { Label = "Device Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+        [JoinName("EnableAutoRoute")]
+        public JoinDataComplete EnableAutoRoute = new JoinDataComplete(new JoinData() { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata() { Label = "Enable Automatic Routing on 4x1 Switchers", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("DisableAutoRoute")]
+        public JoinDataComplete DisableAutoRoute = new JoinDataComplete(new JoinData() { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata() { Label = "Disable Automatic Routing on 4x1 Switchers", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("InputName")]
+        public JoinDataComplete InputName = new JoinDataComplete(new JoinData() { JoinNumber = 2, JoinSpan = 8 },
+            new JoinMetadata() { Label = "Device Input Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+        [JoinName("InputSync")]
+        public JoinDataComplete InputSync = new JoinDataComplete(new JoinData() { JoinNumber = 2, JoinSpan = 8 },
+            new JoinMetadata() { Label = "Device Input Sync", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("OutputName")]
+        public JoinDataComplete OutputName = new JoinDataComplete(new JoinData() { JoinNumber = 11, JoinSpan = 2 },
+            new JoinMetadata() { Label = "Device Output Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+        [JoinName("OutputRoute")]
+        public JoinDataComplete OutputRoute = new JoinDataComplete(new JoinData() { JoinNumber = 11, JoinSpan = 2 },
+            new JoinMetadata() { Label = "Device Output Route Set/Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("OutputRoutedName")]
+        public JoinDataComplete OutputRoutedName = new JoinDataComplete(new JoinData() { JoinNumber = 16, JoinSpan = 2 },
+            new JoinMetadata() { Label = "Device Output Route Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+        [JoinName("EnableInputHdcp")]
+        public JoinDataComplete EnableInputHdcp = new JoinDataComplete(new JoinData() { JoinNumber = 11, JoinSpan = 8 },
+            new JoinMetadata() { Label = "Device Enable Input Hdcp", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("DisableInputHdcp")]
+        public JoinDataComplete DisableInputHdcp = new JoinDataComplete(new JoinData() { JoinNumber = 21, JoinSpan = 8 },
+            new JoinMetadata() { Label = "Device Disnable Input Hdcp", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("IsOnline")]
+        public JoinDataComplete IsOnline = new JoinDataComplete(new JoinData() { JoinNumber = 30, JoinSpan = 1 },
+            new JoinMetadata() { Label = "Device Onlne", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        public HdMdNxM4kEControllerJoinMap(uint joinStart)
+            : base(joinStart, typeof(HdMdNxM4kEControllerJoinMap))
+        {
+        }
+    }
+}

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

@@ -78,70 +78,145 @@ namespace PepperDash.Essentials.Core
 					portDevKey, portNum);
 				return port;
 			}
-		}
+		}
+
+	    public static IROutputPort GetIrOutputPort(DeviceConfig dc)
+	    {
+	        var irControllerKey = dc.Key + "-ir";
+	        if (dc.Properties == null)
+	        {
+	            Debug.Console(0, "[{0}] WARNING: Device config does not include properties.  IR will not function.", dc.Key);
+	            return null;
+	        }
+
+	        var control = dc.Properties["control"];
+	        if (control == null)
+	        {
+	            Debug.Console(0,
+	                "WARNING: Device config does not include control properties.  IR will not function for {0}", dc.Key);
+	            return null;
+	        }
+
+	        var portDevKey = control.Value<string>("controlPortDevKey");
+	        var portNum = control.Value<uint>("controlPortNumber");
+	        IIROutputPorts irDev = null;
+
+	        if (portDevKey == null)
+	        {
+	            Debug.Console(0, "WARNING: control properties is missing ir device for {0}", dc.Key);
+	            return null;
+	        }
+
+	        if (portNum == 0)
+	        {
+	            Debug.Console(0, "WARNING: control properties is missing ir port number for {0}", dc.Key);
+	            return null;
+	        }
+
+	        if (portDevKey.Equals("controlSystem", StringComparison.OrdinalIgnoreCase)
+	            || portDevKey.Equals("processor", StringComparison.OrdinalIgnoreCase))
+	            irDev = Global.ControlSystem;
+	        else
+	            irDev = DeviceManager.GetDeviceForKey(portDevKey) as IIROutputPorts;
+
+	        if (irDev == null)
+	        {
+	            Debug.Console(0, "WARNING: device with IR ports '{0}' not found", portDevKey);
+	            return null;
+	        }
+	        if (portNum >= irDev.NumberOfIROutputPorts)
+	        {
+	            Debug.Console(0, "WARNING: device '{0}' IR port {1} out of range",
+	                portDevKey, portNum);
+	            return null;
+	        }
+
+
+	        var port = irDev.IROutputPorts[portNum];
+
+	        port.LoadIRDriver(Global.FilePathPrefix + "IR" + Global.DirectorySeparator + control["irFile"].Value<string>());
+
+	        return port;
+
+	    }
+
+	    public static IrOutputPortController GetIrOutputPortController(DeviceConfig config)
+	    {
+            Debug.Console(1, "Attempting to create new Ir Port Controller");
+
+	        if (config == null)
+	        {
+	            return null;
+	        }
+
+	        var irDevice = new IrOutputPortController(config.Key, GetIrOutputPort, config);
+
+	        return irDevice;
+	    }
+
+	    /*
+        /// <summary>
+        /// Returns a ready-to-go IrOutputPortController from a DeviceConfig object.
+        /// </summary>	
+        public static IrOutputPortController GetIrOutputPortController(DeviceConfig devConf)
+        {
+            var irControllerKey = devConf.Key + "-ir";
+            if (devConf.Properties == null)
+            {
+                Debug.Console(0, "[{0}] WARNING: Device config does not include properties.  IR will not function.", devConf.Key);
+                return new IrOutputPortController(irControllerKey, null, "");
+            }
 
-		/// <summary>
-		/// Returns a ready-to-go IrOutputPortController from a DeviceConfig object.
-		/// </summary>
-		public static IrOutputPortController GetIrOutputPortController(DeviceConfig devConf)
-		{
-			var irControllerKey = devConf.Key + "-ir";
-			if (devConf.Properties == null)
-			{
-				Debug.Console(0, "[{0}] WARNING: Device config does not include properties.  IR will not function.", devConf.Key);
-				return new IrOutputPortController(irControllerKey, null, "");
-			}
+            var control = devConf.Properties["control"];
+            if (control == null)
+            {
+                var c = new IrOutputPortController(irControllerKey, null, "");
+                Debug.Console(0, c, "WARNING: Device config does not include control properties.  IR will not function");
+                return c;
+            }
 
-			var control = devConf.Properties["control"];
-			if (control == null)
-			{
-				var c = new IrOutputPortController(irControllerKey, null, "");
-				Debug.Console(0, c, "WARNING: Device config does not include control properties.  IR will not function");
-				return c;
-			}
+            var portDevKey = control.Value<string>("controlPortDevKey");
+            var portNum = control.Value<uint>("controlPortNumber");
+            IIROutputPorts irDev = null;
 
-			var portDevKey = control.Value<string>("controlPortDevKey");
-			var portNum = control.Value<uint>("controlPortNumber");
-			IIROutputPorts irDev = null;
+            if (portDevKey == null)
+            {
+                var c = new IrOutputPortController(irControllerKey, null, "");
+                Debug.Console(0, c, "WARNING: control properties is missing ir device");
+                return c;
+            }
 
-			if (portDevKey == null)
-			{
-				var c = new IrOutputPortController(irControllerKey, null, "");
-				Debug.Console(0, c, "WARNING: control properties is missing ir device");
-				return c;
-			}
+            if (portNum == 0)
+            {
+                var c = new IrOutputPortController(irControllerKey, null, "");
+                Debug.Console(0, c, "WARNING: control properties is missing ir port number");
+                return c;
+            } 
 
-			if (portNum == 0)
-			{
-				var c = new IrOutputPortController(irControllerKey, null, "");
-				Debug.Console(0, c, "WARNING: control properties is missing ir port number");
-				return c;
-			} 
+            if (portDevKey.Equals("controlSystem", StringComparison.OrdinalIgnoreCase)
+                || portDevKey.Equals("processor", StringComparison.OrdinalIgnoreCase))
+                irDev = Global.ControlSystem;
+            else
+                irDev = DeviceManager.GetDeviceForKey(portDevKey) as IIROutputPorts;
 
-			if (portDevKey.Equals("controlSystem", StringComparison.OrdinalIgnoreCase)
-				|| portDevKey.Equals("processor", StringComparison.OrdinalIgnoreCase))
-				irDev = Global.ControlSystem;
-			else
-				irDev = DeviceManager.GetDeviceForKey(portDevKey) as IIROutputPorts;
+            if (irDev == null)
+            {
+                var c = new IrOutputPortController(irControllerKey, null, "");
+                Debug.Console(0, c, "WARNING: device with IR ports '{0}' not found", portDevKey);
+                return c;
+            }
 
-			if (irDev == null)
-			{
-				var c = new IrOutputPortController(irControllerKey, null, "");
-				Debug.Console(0, c, "WARNING: device with IR ports '{0}' not found", portDevKey);
-				return c;
-			}
-
-			if (portNum <= irDev.NumberOfIROutputPorts) // success!
-				return new IrOutputPortController(irControllerKey, irDev.IROutputPorts[portNum],
-					IrDriverPathPrefix + control["irFile"].Value<string>());
-			else
-			{
-				var c = new IrOutputPortController(irControllerKey, null, "");
-				Debug.Console(0, c, "WARNING: device '{0}' IR port {1} out of range",
-					portDevKey, portNum);
-				return c;
-			}
-		}
+            if (portNum <= irDev.NumberOfIROutputPorts) // success!
+                return new IrOutputPortController(irControllerKey, irDev.IROutputPorts[portNum],
+                    IrDriverPathPrefix + control["irFile"].Value<string>());
+            else
+            {
+                var c = new IrOutputPortController(irControllerKey, null, "");
+                Debug.Console(0, c, "WARNING: device '{0}' IR port {1} out of range",
+                    portDevKey, portNum);
+                return c;
+            }
+        }*/
 	}
 
 	/// <summary>

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

@@ -26,23 +26,78 @@ namespace PepperDash.Essentials.Core.CrestronIO
                 return () => InputPort.State;
             }
         }
-
-        public GenericDigitalInputDevice(string key, DigitalInput inputPort):
-            base(key)
-        {
-            InputStateFeedback = new BoolFeedback(InputStateFeedbackFunc);
-
-            InputPort = inputPort;
-
-            InputPort.StateChange += InputPort_StateChange;
-
-        }
-
+
+
+        public GenericDigitalInputDevice(string key, string name, Func<IOPortConfig, DigitalInput> postActivationFunc,
+            IOPortConfig config)
+            : base(key, name)
+        {
+
+            AddPostActivationAction(() =>
+            {
+                InputPort = postActivationFunc(config);
+
+                InputPort.Register();
+
+                InputPort.StateChange += InputPort_StateChange;
+
+            });
+        }
+
+        #region Events
+
         void InputPort_StateChange(DigitalInput digitalInput, DigitalInputEventArgs args)
         {
-            InputStateFeedback.FireUpdate();
-        }
-
+            InputStateFeedback.FireUpdate();
+        }
+
+        #endregion
+
+        #region PreActivate
+
+        private static DigitalInput GetDigitalInput(IOPortConfig dc)
+        {
+            IDigitalInputPorts ioPortDevice;
+
+            if (dc.PortDeviceKey.Equals("processor"))
+            {
+                if (!Global.ControlSystem.SupportsDigitalInput)
+                {
+                    Debug.Console(0, "GetDigitalInput: Processor does not support Digital Inputs");
+                    return null;
+                }
+                ioPortDevice = Global.ControlSystem;
+            }
+            else
+            {
+                var ioPortDev = DeviceManager.GetDeviceForKey(dc.PortDeviceKey) as IDigitalInputPorts;
+                if (ioPortDev == null)
+                {
+                    Debug.Console(0, "GetDigitalInput: Device {0} is not a valid device", dc.PortDeviceKey);
+                    return null;
+                }
+                ioPortDevice = ioPortDev;
+            }
+            if (ioPortDevice == null)
+            {
+                Debug.Console(0, "GetDigitalInput: Device '0' is not a valid IRelayPorts Device", dc.PortDeviceKey);
+                return null;
+            }
+
+            if (dc.PortNumber > ioPortDevice.NumberOfDigitalInputPorts)
+            {
+                Debug.Console(0, "GetDigitalInput: Device {0} does not contain a port {1}", dc.PortDeviceKey, dc.PortNumber);
+            }
+
+            return ioPortDevice.DigitalInputPorts[dc.PortNumber];
+
+
+        }
+
+        #endregion
+
+        #region Bridge Linking
+
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
         {
             var joinMap = new IDigitalInputJoinMap(joinStart);
@@ -65,98 +120,37 @@ namespace PepperDash.Essentials.Core.CrestronIO
             {
                 Debug.Console(1, this, "Unable to link device '{0}'.  Input is null", Key);
                 Debug.Console(1, this, "Error: {0}", e);
-            }
-        }
+            }
+        }
+
+        #endregion
+
+        #region Factory
+
+        public class GenericDigitalInputDeviceFactory : EssentialsDeviceFactory<GenericDigitalInputDevice>
+        {
+            public GenericDigitalInputDeviceFactory()
+            {
+                TypeNames = new List<string>() { "digitalinput" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new Generic Relay Device");
+
+                var props = JsonConvert.DeserializeObject<IOPortConfig>(dc.Properties.ToString());
+
+                if (props == null) return null;
+
+                var portDevice = new GenericDigitalInputDevice(dc.Key, dc.Name, GetDigitalInput, props);
+
+                return portDevice;
+            }
+        }
+
+        #endregion
+
     }
 
-    public class GenericDigitalInputDeviceFactory : EssentialsDeviceFactory<GenericDigitalInputDevice>
-    {
-        public GenericDigitalInputDeviceFactory()
-        {
-            TypeNames = new List<string>() { "digitalinput" };
-        }
-
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
-        {
-            Debug.Console(1, "Factory Attempting to create new Digtal Input Device");
-
-            var props = JsonConvert.DeserializeObject<IOPortConfig>(dc.Properties.ToString());
-
-            IDigitalInputPorts portDevice;
-
-            if (props.PortDeviceKey == "processor")
-                portDevice = Global.ControlSystem as IDigitalInputPorts;
-            else
-                portDevice = DeviceManager.GetDeviceForKey(props.PortDeviceKey) as IDigitalInputPorts;
-
-            if (portDevice == null)
-                Debug.Console(0, "ERROR: Unable to add digital input device with key '{0}'. Port Device does not support digital inputs", dc.Key);
-            else
-            {
-                var cs = (portDevice as CrestronControlSystem);
-                if (cs == null)
-                {
-                    Debug.Console(0, "ERROR: Port device for [{0}] is not control system", props.PortDeviceKey);
-                    return null;
-                }
-
-                if (cs.SupportsVersiport)
-                {
-                    Debug.Console(1, "Attempting to add Digital Input device to Versiport port '{0}'", props.PortNumber);
-
-                    if (props.PortNumber > cs.NumberOfVersiPorts)
-                    {
-                        Debug.Console(0, "WARNING: Cannot add Vesiport {0} on {1}. Out of range",
-                            props.PortNumber, props.PortDeviceKey);
-                        return null;
-                    }
-
-                    Versiport vp = cs.VersiPorts[props.PortNumber];
-
-                    if (!vp.Registered)
-                    {
-                        var regSuccess = vp.Register();
-                        if (regSuccess == eDeviceRegistrationUnRegistrationResponse.Success)
-                        {
-                            Debug.Console(1, "Successfully Created Digital Input Device on Versiport");
-                            return new GenericVersiportDigitalInputDevice(dc.Key, vp, props);
-                        }
-                        else
-                        {
-                            Debug.Console(0, "WARNING: Attempt to register versiport {0} on device with key '{1}' failed: {2}",
-                                props.PortNumber, props.PortDeviceKey, regSuccess);
-                            return null;
-                        }
-                    }
-                }
-                else if (cs.SupportsDigitalInput)
-                {
-                    Debug.Console(1, "Attempting to add Digital Input device to Digital Input port '{0}'", props.PortNumber);
-
-                    if (props.PortNumber > cs.NumberOfDigitalInputPorts)
-                    {
-                        Debug.Console(0, "WARNING: Cannot register DIO port {0} on {1}. Out of range",
-                            props.PortNumber, props.PortDeviceKey);
-                        return null;
-                    }
-
-                    DigitalInput digitalInput = cs.DigitalInputPorts[props.PortNumber];
-
-                    if (!digitalInput.Registered)
-                    {
-                        if (digitalInput.Register() == eDeviceRegistrationUnRegistrationResponse.Success)
-                        {
-                            Debug.Console(1, "Successfully Created Digital Input Device on Digital Input");
-                            return new GenericDigitalInputDevice(dc.Key, digitalInput);
-                        }
-                        else
-                            Debug.Console(0, "WARNING: Attempt to register digital input {0} on device with key '{1}' failed.",
-                                props.PortNumber, props.PortDeviceKey);
-                    }
-                }
-            }
-            return null;
-        }
-    }
 
 }

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

@@ -19,41 +19,108 @@ namespace PepperDash.Essentials.Core.CrestronIO
     {
         public Relay RelayOutput { get; private set; }
 
-        public BoolFeedback OutputIsOnFeedback { get; private set; }
-
-        public GenericRelayDevice(string key, Relay relay):
-            base(key)
-        {
-            OutputIsOnFeedback = new BoolFeedback(new Func<bool>(() => RelayOutput.State));
-
-            RelayOutput = relay;
-            RelayOutput.Register();
-
-            RelayOutput.StateChange += new RelayEventHandler(RelayOutput_StateChange);
-        }
-
+        public BoolFeedback OutputIsOnFeedback { get; private set; }
+
+        //Maintained for compatibility with PepperDash.Essentials.Core.Devices.CrestronProcessor
+        public GenericRelayDevice(string key, Relay relay) :
+            base(key)
+        {
+            OutputIsOnFeedback = new BoolFeedback(new Func<bool>(() => RelayOutput.State));
+
+            RelayOutput = relay;
+            RelayOutput.Register();
+
+            RelayOutput.StateChange += new RelayEventHandler(RelayOutput_StateChange);
+        }
+
+        public GenericRelayDevice(string key, string name, Func<IOPortConfig, Relay> postActivationFunc,
+            IOPortConfig config)
+            : base(key, name)
+        {
+
+            AddPostActivationAction(() =>
+            {
+                RelayOutput = postActivationFunc(config);
+
+                RelayOutput.Register();
+
+                RelayOutput.StateChange += RelayOutput_StateChange;
+
+            });
+        }
+
+        #region PreActivate
+
+        private static Relay GetRelay(IOPortConfig dc)
+        {
+
+            IRelayPorts relayDevice;
+
+            if(dc.PortDeviceKey.Equals("processor"))
+            {
+                if (!Global.ControlSystem.SupportsRelay)
+                {
+                    Debug.Console(0, "GetRelayDevice: Processor does not support relays");
+                    return null;
+                }
+                relayDevice = Global.ControlSystem;
+            }
+            else
+            {
+                var relayDev = DeviceManager.GetDeviceForKey(dc.PortDeviceKey) as IRelayPorts;
+                if (relayDev == null)
+                {
+                    Debug.Console(0, "GetRelayDevice: Device {0} is not a valid device", dc.PortDeviceKey);
+                    return null;
+                }
+                relayDevice = relayDev;
+            }
+            if (relayDevice == null)
+            {
+                Debug.Console(0, "GetRelayDevice: Device '0' is not a valid IRelayPorts Device", dc.PortDeviceKey);
+                return null;
+            }
+
+            if (dc.PortNumber > relayDevice.NumberOfRelayPorts)
+            {
+                Debug.Console(0, "GetRelayDevice: Device {0} does not contain a port {1}", dc.PortDeviceKey, dc.PortNumber);
+            }
+            
+            return relayDevice.RelayPorts[dc.PortNumber];
+        }
+
+        #endregion
+
+        #region Events
+
         void RelayOutput_StateChange(Relay relay, RelayEventArgs args)
         {
-            OutputIsOnFeedback.FireUpdate();
+            OutputIsOnFeedback.FireUpdate();
         }
 
-        public void OpenRelay()
-        {
-            RelayOutput.State = false;
-        }
-
-        public void CloseRelay()
-        {
-            RelayOutput.State = true;
-        }
-
-        public void ToggleRelayState()
-        {
-            if (RelayOutput.State == true)
-                OpenRelay();
-            else
-                CloseRelay();
+        #endregion
+
+        #region Methods
+
+        public void OpenRelay()
+        {
+            RelayOutput.State = false;
+        }
+
+        public void CloseRelay()
+        {
+            RelayOutput.State = true;
+        }
+
+        public void ToggleRelayState()
+        {
+            if (RelayOutput.State == true)
+                OpenRelay();
+            else
+                CloseRelay();
         }
+
+        #endregion
 
         #region ISwitchedOutput Members
 
@@ -67,8 +134,10 @@ namespace PepperDash.Essentials.Core.CrestronIO
             OpenRelay();
         }
 
-        #endregion
-
+        #endregion
+
+        #region Bridge Linking
+
         public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
         {
             var joinMap = new GenericRelayControllerJoinMap(joinStart);
@@ -98,77 +167,90 @@ namespace PepperDash.Essentials.Core.CrestronIO
 
             // feedback for relay state
 
-            OutputIsOnFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Relay.JoinNumber]);
-        }
-    }
+            OutputIsOnFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Relay.JoinNumber]);
+        }
+
+        #endregion
+
+        #region Factory
+
+        public class GenericRelayDeviceFactory : EssentialsDeviceFactory<GenericRelayDevice>
+        {
+            public GenericRelayDeviceFactory()
+            {
+                TypeNames = new List<string>() { "relayoutput" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new Generic Relay Device");
+
+                var props = JsonConvert.DeserializeObject<IOPortConfig>(dc.Properties.ToString());
+
+                if (props == null) return null;
+
+                var portDevice = new GenericRelayDevice(dc.Key, dc.Name, GetRelay, props);
+
+                return portDevice;
+
+
+                /*
+                if (props.PortDeviceKey == "processor")
+                    portDevice = Global.ControlSystem as IRelayPorts;
+                else
+                    portDevice = DeviceManager.GetDeviceForKey(props.PortDeviceKey) as IRelayPorts;
 
-    public class GenericRelayDeviceFactory : EssentialsDeviceFactory<GenericRelayDevice>
-    {
-        public GenericRelayDeviceFactory()
-        {
-            TypeNames = new List<string>() { "relayoutput" };
-        }
-
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
-        {
-            Debug.Console(1, "Factory Attempting to create new Generic Relay Device");
-
-            var props = JsonConvert.DeserializeObject<IOPortConfig>(dc.Properties.ToString());
-            var key = dc.Key;
-
-            IRelayPorts portDevice;
-
-            if (props.PortDeviceKey == "processor")
-                portDevice = Global.ControlSystem as IRelayPorts;
-            else
-                portDevice = DeviceManager.GetDeviceForKey(props.PortDeviceKey) as IRelayPorts;
-
-            if (portDevice == null)
-                Debug.Console(0, "Unable to add relay device with key '{0}'. Port Device does not support relays", key);
-            else
-            {
-                var cs = (portDevice as CrestronControlSystem);
-
-                if (cs != null)
-                {
-                    // The relay is on a control system processor
-                    if (!cs.SupportsRelay || props.PortNumber > cs.NumberOfRelayPorts)
-                    {
-                        Debug.Console(0, "Port Device: {0} does not support relays or does not have enough relays");
-                        return null;
-                    }
-                }
+                if (portDevice == null)
+                    Debug.Console(0, "Unable to add relay device with key '{0}'. Port Device does not support relays", key);
                 else
                 {
-                    // The relay is on another device type
+                    var cs = (portDevice as CrestronControlSystem);
 
-                    if (props.PortNumber > portDevice.NumberOfRelayPorts)
+                    if (cs != null)
                     {
-                        Debug.Console(0, "Port Device: {0} does not have enough relays");
-                        return null;
+                        // The relay is on a control system processor
+                        if (!cs.SupportsRelay || props.PortNumber > cs.NumberOfRelayPorts)
+                        {
+                            Debug.Console(0, "Port Device: {0} does not support relays or does not have enough relays");
+                            return null;
+                        }
                     }
-                }
-
-                Relay relay = portDevice.RelayPorts[props.PortNumber];
-
-                if (!relay.Registered)
-                {
-                    if (relay.Register() == eDeviceRegistrationUnRegistrationResponse.Success)
-                        return new GenericRelayDevice(key, relay);
                     else
-                        Debug.Console(0, "Attempt to register relay {0} on device with key '{1}' failed.", props.PortNumber, props.PortDeviceKey);
+                    {
+                        // The relay is on another device type
+
+                        if (props.PortNumber > portDevice.NumberOfRelayPorts)
+                        {
+                            Debug.Console(0, "Port Device: {0} does not have enough relays");
+                            return null;
+                        }
+                    }
+
+                    Relay relay = portDevice.RelayPorts[props.PortNumber];
+
+                    if (!relay.Registered)
+                    {
+                        if (relay.Register() == eDeviceRegistrationUnRegistrationResponse.Success)
+                            return new GenericRelayDevice(key, relay);
+                        else
+                            Debug.Console(0, "Attempt to register relay {0} on device with key '{1}' failed.", props.PortNumber, props.PortDeviceKey);
+                    }
+                    else
+                    {
+                        return new GenericRelayDevice(key, relay);
+                    }
+
+                    // Future: Check if portDevice is 3-series card or other non control system that supports versiports
                 }
-                else
-                {
-                    return new GenericRelayDevice(key, relay);
-                }
-
-                // Future: Check if portDevice is 3-series card or other non control system that supports versiports
-            }
-
-            return null;
-
-        }
+                */
+
+            }
+        }
+
+        #endregion
+
+
     }
 
+
 }

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

@@ -53,7 +53,7 @@ namespace PepperDash.Essentials.Core
 
         public ConfigSnippetAttribute(string configSnippet)
         {
-            Debug.Console(2, "Setting Description {0}", configSnippet);
+            Debug.Console(2, "Setting Config Snippet {0}", configSnippet);
             _ConfigSnippet = configSnippet;
         }
 
@@ -83,8 +83,9 @@ namespace PepperDash.Essentials.Core
             foreach (var typeName in TypeNames)
             {
                 Debug.Console(2, "Getting Description Attribute from class: '{0}'", typeof(T).FullName);
-                var attributes = typeof(T).GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
-                string description = attributes[0].Description;
+                var descriptionAttribute = typeof(T).GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
+                string description = descriptionAttribute[0].Description;
+                var snippetAttribute = typeof(T).GetCustomAttributes(typeof(ConfigSnippetAttribute), true) as ConfigSnippetAttribute[];
                 DeviceFactory.AddFactoryForType(typeName.ToLower(), description, typeof(T), BuildDevice);
             }
         }

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

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core
+{
+    public interface IBasicVideoMute
+    {
+        void VideoMuteToggle();
+    }
+
+    public interface IBasicVideoMuteWithFeedback : IBasicVideoMute
+    {
+        BoolFeedback VideoMuteIsOn { get; }
+
+        void VideoMuteOn();
+        void VideoMuteOff();
+ 
+    }
+}

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

@@ -3,7 +3,10 @@ using System.Collections.Generic;
 using System.Linq;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core.Config;
+
 
 using PepperDash.Core;
 
@@ -37,9 +40,21 @@ namespace PepperDash.Essentials.Core
 				return;
 			}
 			LoadDriver(irDriverFilepath);
-		}
-
-		/// <summary>
+		}
+
+	    public IrOutputPortController(string key, Func<DeviceConfig, IROutputPort> postActivationFunc,
+	        DeviceConfig config)
+	        : base(key)
+	    {
+            AddPostActivationAction(() =>
+            {
+                IrPort = postActivationFunc(config);
+            });
+	    }
+
+	    
+
+	    /// <summary>
 		/// Loads the IR driver at path
 		/// </summary>
 		/// <param name="path"></param>
@@ -118,7 +133,6 @@ namespace PepperDash.Essentials.Core
 		{
 			Debug.Console(2, this, "Device {0}: IR Driver {1} does not contain command {2}",
 				Key, IrPort.IRDriverFileNameByIRDriverId(IrPortUid), command);
-		}
-
+		}
 	}
 }

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

@@ -129,6 +129,7 @@
     <Compile Include="Bridges\JoinMaps\GenericLightingJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\GenericRelayControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\GlsOccupancySensorBaseJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\HdMdNxM4kEControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\HdMdxxxCEControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\IBasicCommunicationJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\IDigitalInputJoinMap.cs" />
@@ -158,6 +159,7 @@
     <Compile Include="Devices\DeviceFeedbackExtensions.cs" />
     <Compile Include="Devices\EssentialsBridgeableDevice.cs" />
     <Compile Include="Devices\EssentialsDevice.cs" />
+    <Compile Include="Devices\IProjectorInterfaces.cs" />
     <Compile Include="Devices\PC\InRoomPc.cs" />
     <Compile Include="Devices\PC\Laptop.cs" />
     <Compile Include="Devices\ReconfigurableDevice.cs" />

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

@@ -0,0 +1,394 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Newtonsoft.Json;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.DM.Chassis
+{
+    [Description("Wrapper class for all HdMdNxM4E switchers")]
+    public class HdMdNxM4kEBridgeableController : CrestronGenericBridgeableBaseDevice, IRoutingInputsOutputs, IRouting, IHasFeedback
+    {
+        private HdMdNxM _Chassis;
+        private HdMd4x14kE _Chassis4x1;
+
+        public Dictionary<uint, string> InputNames { get; set; }
+        public Dictionary<uint, string> OutputNames { get; set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+        public FeedbackCollection<BoolFeedback> VideoInputSyncFeedbacks { get; private set; }
+        public FeedbackCollection<IntFeedback> VideoOutputRouteFeedbacks { get; private set; }
+        public FeedbackCollection<StringFeedback> InputNameFeedbacks { get; private set; }
+        public FeedbackCollection<StringFeedback> OutputNameFeedbacks { get; private set; }
+        public FeedbackCollection<StringFeedback> OutputRouteNameFeedbacks { get; private set; }
+        public FeedbackCollection<BoolFeedback> InputHdcpEnableFeedback { get; private set; }
+        public FeedbackCollection<StringFeedback> DeviceNameFeedback { get; private set; }
+        public FeedbackCollection<BoolFeedback> AutoRouteFeedback { get; private set; }
+
+        #region Constructor
+
+        public HdMdNxM4kEBridgeableController(string key, string name, HdMdNxM chassis,
+            HdMdNxM4kEBridgeablePropertiesConfig props)
+            : base(key, name, chassis)
+        {
+            _Chassis = chassis;
+            var _props = props;
+
+            InputNames = props.Inputs;
+            OutputNames = props.Outputs;
+
+            VideoInputSyncFeedbacks = new FeedbackCollection<BoolFeedback>();
+            VideoOutputRouteFeedbacks = new FeedbackCollection<IntFeedback>();
+            InputNameFeedbacks = new FeedbackCollection<StringFeedback>();
+            OutputNameFeedbacks = new FeedbackCollection<StringFeedback>();
+            OutputRouteNameFeedbacks = new FeedbackCollection<StringFeedback>();
+            InputHdcpEnableFeedback = new FeedbackCollection<BoolFeedback>();
+            DeviceNameFeedback = new FeedbackCollection<StringFeedback>();
+            AutoRouteFeedback = new FeedbackCollection<BoolFeedback>();
+
+            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+
+            DeviceNameFeedback.Add(new StringFeedback(this.Name, () => this.Name));
+
+            if (_Chassis.NumberOfInputs == 1)
+            {
+                _Chassis4x1 = _Chassis as HdMd4x14kE;
+                AutoRouteFeedback.Add(new BoolFeedback(this.Name + "-" + InputNames[1], () => _Chassis4x1.AutoModeOnFeedback.BoolValue));
+            }
+
+            for (uint i = 1; i <= _Chassis.NumberOfInputs; i++)
+            {
+                var inputName = InputNames[i];
+                _Chassis.Inputs[i].Name.StringValue = inputName;
+
+                InputPorts.Add(new RoutingInputPort(inputName, eRoutingSignalType.AudioVideo,
+                    eRoutingPortConnectionType.Hdmi, i, this));
+                VideoInputSyncFeedbacks.Add(new BoolFeedback(inputName, () => _Chassis.Inputs[i].VideoDetectedFeedback.BoolValue));
+                InputNameFeedbacks.Add(new StringFeedback(inputName, () => _Chassis.Inputs[i].Name.StringValue));
+                InputHdcpEnableFeedback.Add(new BoolFeedback(inputName, () => _Chassis.HdmiInputs[i].HdmiInputPort.HdcpSupportOnFeedback.BoolValue));
+            }
+
+            for (uint i = 1; i <= _Chassis.NumberOfOutputs; i++)
+            {
+                var outputName = OutputNames[i];
+                _Chassis.Outputs[i].Name.StringValue = outputName;
+
+                OutputPorts.Add(new RoutingOutputPort(outputName, eRoutingSignalType.AudioVideo,
+                    eRoutingPortConnectionType.Hdmi, i, this));
+                VideoOutputRouteFeedbacks.Add(new IntFeedback(outputName, () => (int)_Chassis.Outputs[i].VideoOutFeedback.Number));
+                OutputNameFeedbacks.Add(new StringFeedback(outputName, () => _Chassis.Outputs[i].Name.StringValue));
+                OutputRouteNameFeedbacks.Add(new StringFeedback(outputName, () => _Chassis.Outputs[i].VideoOutFeedback.NameFeedback.StringValue));
+            }
+
+            _Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
+            _Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
+
+            AddPostActivationAction(AddFeedbackCollections);
+        }
+
+        #endregion
+
+        #region Methods
+
+        public void EnableHdcp(uint port)
+        {
+            if (port > _Chassis.NumberOfInputs) return;
+            if (port <= 0) return;
+
+            _Chassis.HdmiInputs[port].HdmiInputPort.HdcpSupportOn();
+            InputHdcpEnableFeedback[InputNames[port]].FireUpdate();
+        }
+
+        public void DisableHdcp(uint port)
+        {
+            if (port > _Chassis.NumberOfInputs) return;
+            if (port <= 0) return;
+
+            _Chassis.HdmiInputs[port].HdmiInputPort.HdcpSupportOff();
+            InputHdcpEnableFeedback[InputNames[port]].FireUpdate();
+        }
+
+        public void EnableAutoRoute()
+        {
+            if (_Chassis.NumberOfInputs != 1) return;
+
+            if (_Chassis4x1 == null) return;
+
+            _Chassis4x1.AutoModeOn();
+        }
+
+        public void DisableAutoRoute()
+        {
+            if (_Chassis.NumberOfInputs != 1) return;
+
+            if (_Chassis4x1 == null) return;
+
+            _Chassis4x1.AutoModeOff();
+        }
+
+        #region PostActivate
+
+        public void AddFeedbackCollections()
+        {
+            AddCollectionsToList(VideoInputSyncFeedbacks, InputHdcpEnableFeedback);
+            AddCollectionsToList(VideoOutputRouteFeedbacks);
+            AddCollectionsToList(InputNameFeedbacks, OutputNameFeedbacks, OutputRouteNameFeedbacks, DeviceNameFeedback);
+        }
+
+        #endregion
+
+        #region FeedbackCollection Methods
+
+        //Add arrays of collections
+        public void AddCollectionsToList(params FeedbackCollection<BoolFeedback>[] newFbs)
+        {
+            foreach (FeedbackCollection<BoolFeedback> fbCollection in newFbs)
+            {
+                foreach (var item in newFbs)
+                {
+                    AddCollectionToList(item);
+                }
+            }
+        }
+        public void AddCollectionsToList(params FeedbackCollection<IntFeedback>[] newFbs)
+        {
+            foreach (FeedbackCollection<IntFeedback> fbCollection in newFbs)
+            {
+                foreach (var item in newFbs)
+                {
+                    AddCollectionToList(item);
+                }
+            }
+        }
+
+        public void AddCollectionsToList(params FeedbackCollection<StringFeedback>[] newFbs)
+        {
+            foreach (FeedbackCollection<StringFeedback> fbCollection in newFbs)
+            {
+                foreach (var item in newFbs)
+                {
+                    AddCollectionToList(item);
+                }
+            }
+        }
+
+        //Add Collections
+        public void AddCollectionToList(FeedbackCollection<BoolFeedback> newFbs)
+        {
+            foreach (var f in newFbs)
+            {
+                if (f == null) continue;
+
+                AddFeedbackToList(f);
+            }
+        }
+
+        public void AddCollectionToList(FeedbackCollection<IntFeedback> newFbs)
+        {
+            foreach (var f in newFbs)
+            {
+                if (f == null) continue;
+
+                AddFeedbackToList(f);
+            }
+        }
+
+        public void AddCollectionToList(FeedbackCollection<StringFeedback> newFbs)
+        {
+            foreach (var f in newFbs)
+            {
+                if (f == null) continue;
+
+                AddFeedbackToList(f);
+            }
+        }
+
+        //Add Individual Feedbacks
+        public void AddFeedbackToList(PepperDash.Essentials.Core.Feedback newFb)
+        {
+            if (newFb == null) return;
+
+            if (!Feedbacks.Contains(newFb))
+            {
+                Feedbacks.Add(newFb);
+            }
+        }
+
+        #endregion
+
+        #region IRouting Members
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            // Try to make switch only when necessary.  The unit appears to toggle when already selected.
+            var current = _Chassis.HdmiOutputs[(uint)outputSelector].VideoOut;
+            if (current != _Chassis.HdmiInputs[(uint)inputSelector])
+                _Chassis.HdmiOutputs[(uint)outputSelector].VideoOut = _Chassis.HdmiInputs[(uint)inputSelector];
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Bridge Linking
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new HdMdNxM4kEControllerJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<HdMdNxM4kEControllerJoinMap>(joinMapSerialized);
+
+            bridge.AddJoinMap(Key, joinMap);
+
+            IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+            DeviceNameFeedback[this.Name].LinkInputSig(trilist.StringInput[joinMap.Name.JoinNumber]);
+
+            if (_Chassis4x1 != null)
+            {
+                AutoRouteFeedback[this.Name + "-" + InputNames[1]].LinkInputSig(trilist.BooleanInput[joinMap.EnableAutoRoute.JoinNumber]);
+                AutoRouteFeedback[this.Name + "-" + InputNames[1]].LinkComplementInputSig(trilist.BooleanInput[joinMap.DisableAutoRoute.JoinNumber]);
+            }
+
+            for (uint i = 1; i <= _Chassis.NumberOfInputs; i++)
+            {
+                var joinIndex = i - 1;
+                //Digital
+                VideoInputSyncFeedbacks[InputNames[i]].LinkInputSig(trilist.BooleanInput[joinMap.InputSync.JoinNumber + joinIndex]);
+                InputHdcpEnableFeedback[InputNames[i]].LinkInputSig(trilist.BooleanInput[joinMap.EnableInputHdcp.JoinNumber + joinIndex]);
+                InputHdcpEnableFeedback[InputNames[i]].LinkComplementInputSig(trilist.BooleanInput[joinMap.DisableInputHdcp.JoinNumber + joinIndex]);
+                trilist.SetSigTrueAction(joinMap.EnableInputHdcp.JoinNumber + joinIndex, () => EnableHdcp(i));
+                trilist.SetSigTrueAction(joinMap.DisableInputHdcp.JoinNumber + joinIndex, () => DisableHdcp(i));
+
+                //Serial
+                InputNameFeedbacks[InputNames[i]].LinkInputSig(trilist.StringInput[joinMap.InputName.JoinNumber + joinIndex]);
+            }
+
+            for (uint i = 1; i <= _Chassis.NumberOfOutputs; i++)
+            {
+                var joinIndex = i - 1;
+                //Analog
+                VideoOutputRouteFeedbacks[OutputNames[i]].LinkInputSig(trilist.UShortInput[joinMap.OutputRoute.JoinNumber + joinIndex]);
+                trilist.SetUShortSigAction(joinMap.OutputRoute.JoinNumber + joinIndex, (a) => ExecuteSwitch(a, i, eRoutingSignalType.AudioVideo));
+
+                //Serial
+                OutputNameFeedbacks[OutputNames[i]].LinkInputSig(trilist.StringInput[joinMap.OutputName.JoinNumber + joinIndex]);
+                OutputRouteNameFeedbacks[OutputNames[i]].LinkInputSig(trilist.StringInput[joinMap.OutputRoutedName.JoinNumber + joinIndex]);
+            }
+
+            _Chassis.OnlineStatusChange += new Crestron.SimplSharpPro.OnlineStatusChangeEventHandler(Chassis_OnlineStatusChange);
+
+            trilist.OnlineStatusChange += new Crestron.SimplSharpPro.OnlineStatusChangeEventHandler((d, args) =>
+            {
+                if (args.DeviceOnLine)
+                {
+                    foreach (var feedback in Feedbacks)
+                    {
+                        feedback.FireUpdate();
+                    }
+                }
+            });
+        }
+
+
+        #endregion
+
+        #region Events
+
+        void Chassis_OnlineStatusChange(Crestron.SimplSharpPro.GenericBase currentDevice, Crestron.SimplSharpPro.OnlineOfflineEventArgs args)
+        {
+            if (args.DeviceOnLine)
+            {
+                for (uint i = 1; i <= _Chassis.NumberOfInputs; i++)
+                {
+                    _Chassis.Inputs[i].Name.StringValue = InputNames[i];
+                }
+                for (uint i = 1; i <= _Chassis.NumberOfOutputs; i++)
+                {
+                    _Chassis.Outputs[i].Name.StringValue = OutputNames[i];
+                }
+
+                foreach (var feedback in Feedbacks)
+                {
+                    feedback.FireUpdate();
+                }
+            }
+            
+        }
+
+        void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
+        {
+            if (args.EventId == DMOutputEventIds.VideoOutEventId)
+            {
+                foreach (var item in VideoOutputRouteFeedbacks)
+                {
+                    item.FireUpdate();
+                }
+            }
+        }
+
+        void Chassis_DMInputChange(Switch device, DMInputEventArgs args)
+        {
+            if (args.EventId == DMInputEventIds.VideoDetectedEventId)
+            {
+                foreach (var item in VideoInputSyncFeedbacks)
+                {
+                    item.FireUpdate();
+                }
+            }
+        }
+
+        #endregion
+
+        #region Factory
+
+        public class HdMdNxM4kEControllerFactory : EssentialsDeviceFactory<HdMdNxM4kEBridgeableController>
+        {
+            public HdMdNxM4kEControllerFactory()
+            {
+                TypeNames = new List<string>() { "hdmd4x14ke-bridgeable", "hdmd4x24ke", "hdmd6x24ke" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new HD-MD-NxM-4K-E Device");
+
+                var props = JsonConvert.DeserializeObject<HdMdNxM4kEBridgeablePropertiesConfig>(dc.Properties.ToString());
+
+                var type = dc.Type.ToLower();
+                var control = props.Control;
+                var ipid = control.IpIdInt;
+                var address = control.TcpSshProperties.Address;
+
+                switch (type)
+                {
+                    case ("hdmd4x14ke-bridgeable"):
+                        return new HdMdNxM4kEBridgeableController(dc.Key, dc.Name, new HdMd4x14kE(ipid, address, Global.ControlSystem), props);
+                    case ("hdmd4x24ke"):
+                        return new HdMdNxM4kEBridgeableController(dc.Key, dc.Name, new HdMd4x24kE(ipid, address, Global.ControlSystem), props);
+                    case ("hdmd6x24ke"):
+                        return new HdMdNxM4kEBridgeableController(dc.Key, dc.Name, new HdMd6x24kE(ipid, address, Global.ControlSystem), props);
+                    default:
+                        return null;
+                }
+            }
+        }
+
+        #endregion
+ 
+    }
+}

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

@@ -1,125 +1,128 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro.DM;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.DM.Config;
-
-namespace PepperDash.Essentials.DM.Chassis
-{
-	public class HdMdNxM4kEController : Device, IRoutingInputsOutputs, IRouting
-	{
-		public HdMdNxM Chassis { get; private set; }
-
-		public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
-		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
-
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
-		/// <param name="chassis"></param>
-		public HdMdNxM4kEController(string key, string name, HdMdNxM chassis, 
-			HdMdNxM4kEPropertiesConfig props)
-			: base(key, name)
-		{
-			Chassis = chassis;
-
-			// logical ports
-			InputPorts = new RoutingPortCollection<RoutingInputPort>();
-			for (uint i = 1; i <= 4; i++)
-			{
-				InputPorts.Add(new RoutingInputPort("hdmiIn" + i, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-					eRoutingPortConnectionType.Hdmi, i, this));
-			}
-			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
-			OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this));
-
-			// physical settings
-			if (props != null && props.Inputs != null)
-			{
-				foreach (var kvp in props.Inputs)
-				{
-					// strip "hdmiIn"
-					var inputNum =  Convert.ToUInt32(kvp.Key.Substring(6));
-
-					var port = chassis.HdmiInputs[inputNum].HdmiInputPort;
-					// set hdcp disables
-					if (kvp.Value.DisableHdcp)
-					{
-						Debug.Console(0, this, "Configuration disables HDCP support on {0}", kvp.Key);
-						port.HdcpSupportOff();
-					}
-					else
-						port.HdcpSupportOn();
-				}
-			}
-		}
-
-		public override bool CustomActivate()
-		{
-			var result = Chassis.Register();
-			if (result != Crestron.SimplSharpPro.eDeviceRegistrationUnRegistrationResponse.Success)
-			{
-				Debug.Console(0, this, "Device registration failed: {0}", result);
-				return false;
-			}
-
-			return base.CustomActivate();
-		}
-
-
-
-		#region IRouting Members
-
-		public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
-		{
-			// Try to make switch only when necessary.  The unit appears to toggle when already selected.
-			var current = Chassis.HdmiOutputs[1].VideoOut;
-			if(current != Chassis.HdmiInputs[(uint)inputSelector])
-				Chassis.HdmiOutputs[1].VideoOut = Chassis.HdmiInputs[(uint)inputSelector];
-		}
-
-		#endregion
-
-		/////////////////////////////////////////////////////
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
-		/// <param name="type"></param>
-		/// <param name="properties"></param>
-		/// <returns></returns>
-		public static HdMdNxM4kEController GetController(string key, string name,
-			string type, HdMdNxM4kEPropertiesConfig properties)
-		{
-			try
-			{
-				var ipid = properties.Control.IpIdInt;
-				var address = properties.Control.TcpSshProperties.Address;
-
-				type = type.ToLower();
-				if (type == "hdmd4x14ke")
-				{
-					var chassis = new HdMd4x14kE(ipid, address, Global.ControlSystem);
-					return new HdMdNxM4kEController(key, name, chassis, properties);
-				}
-				return null;
-			}
-			catch (Exception e)
-			{
-				Debug.Console(0, "ERROR Creating device key {0}: \r{1}", key, e);
-				return null;
-			}
-		}
-	}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM.Chassis
+{
+    public class HdMdNxM4kEController : Device, IRoutingInputsOutputs, IRouting
+    {
+        public HdMdNxM Chassis { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="chassis"></param>
+        public HdMdNxM4kEController(string key, string name, HdMdNxM chassis,
+            HdMdNxM4kEPropertiesConfig props)
+            : base(key, name)
+        {
+            Chassis = chassis;
+
+            // logical ports
+            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+            for (uint i = 1; i <= 4; i++)
+            {
+                InputPorts.Add(new RoutingInputPort("hdmiIn" + i, eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.Hdmi, i, this));
+            }
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+            OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, null, this));
+
+            // physical settings
+            if (props != null && props.Inputs != null)
+            {
+                foreach (var kvp in props.Inputs)
+                {
+                    // strip "hdmiIn"
+                    var inputNum = Convert.ToUInt32(kvp.Key.Substring(6));
+
+                    var port = chassis.HdmiInputs[inputNum].HdmiInputPort;
+                    // set hdcp disables
+                    if (kvp.Value.DisableHdcp)
+                    {
+                        Debug.Console(0, this, "Configuration disables HDCP support on {0}", kvp.Key);
+                        port.HdcpSupportOff();
+                    }
+                    else
+                        port.HdcpSupportOn();
+                }
+            }
+        }
+
+        public override bool CustomActivate()
+        {
+            var result = Chassis.Register();
+            if (result != Crestron.SimplSharpPro.eDeviceRegistrationUnRegistrationResponse.Success)
+            {
+                Debug.Console(0, this, "Device registration failed: {0}", result);
+                return false;
+            }
+
+            return base.CustomActivate();
+        }
+
+
+
+        #region IRouting Members
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            // Try to make switch only when necessary.  The unit appears to toggle when already selected.
+            var current = Chassis.HdmiOutputs[1].VideoOut;
+            if (current != Chassis.HdmiInputs[(uint)inputSelector])
+                Chassis.HdmiOutputs[1].VideoOut = Chassis.HdmiInputs[(uint)inputSelector];
+        }
+
+        #endregion
+
+        /////////////////////////////////////////////////////
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="type"></param>
+        /// <param name="properties"></param>
+        /// <returns></returns>
+        public static HdMdNxM4kEController GetController(string key, string name,
+            string type, HdMdNxM4kEPropertiesConfig properties)
+        {
+            try
+            {
+                var ipid = properties.Control.IpIdInt;
+                var address = properties.Control.TcpSshProperties.Address;
+
+                type = type.ToLower();
+                if (type == "hdmd4x14ke")
+                {
+                    Debug.Console(0, @"The 'hdmd4x14ke' device is not an Essentials Bridgeable device.  
+                        If an essentials Bridgeable Device is required, use the 'hdmd4x14ke-bridgeable' type");
+  
+                    var chassis = new HdMd4x14kE(ipid, address, Global.ControlSystem);
+                    return new HdMdNxM4kEController(key, name, chassis, properties);
+                }
+                return null;
+            }
+            catch (Exception e)
+            {
+                Debug.Console(0, "ERROR Creating device key {0}: \r{1}", key, e);
+                return null;
+            }
+        }
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Config/HdMdNxM4kEPropertiesConfig.cs

@@ -8,16 +8,28 @@ using Newtonsoft.Json;
 using PepperDash.Core;
 
 namespace PepperDash.Essentials.DM.Config
-{
-	/// <summary>
-	/// Defines the properties section of HdMdNxM boxes
-	/// </summary>
-	public class HdMdNxM4kEPropertiesConfig
-	{
-		[JsonProperty("control")]
-		public ControlPropertiesConfig Control { get; set; }
-
-		[JsonProperty("inputs")]
-		public Dictionary<string, InputPropertiesConfig> Inputs { get; set; }
-	}
+{
+    /// <summary>
+    /// Defines the properties section of HdMdNxM boxes
+    /// </summary>
+    public class HdMdNxM4kEPropertiesConfig
+    {
+        [JsonProperty("control")]
+        public ControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("inputs")]
+        public Dictionary<string, InputPropertiesConfig> Inputs { get; set; }
+    }
+
+    public class HdMdNxM4kEBridgeablePropertiesConfig
+    {
+        [JsonProperty("control")]
+        public ControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("inputs")]
+        public Dictionary<uint, string> Inputs { get; set; }
+
+        [JsonProperty("outputs")]
+        public Dictionary<uint, string> Outputs { get; set; }
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Config/InputPropertiesConfig.cs

@@ -1,15 +1,16 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
-namespace PepperDash.Essentials.DM.Config
-{
-	public class InputPropertiesConfig
-	{
-		public string Name { get; set; }
-
-		public bool DisableHdcp { get; set; }
-	}
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.DM.Config
+{
+    public class InputPropertiesConfig
+    {
+        public string Name { get; set; }
+
+        public bool DisableHdcp { get; set; }
+    }
 }

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

@@ -99,7 +99,9 @@
     <Compile Include="Chassis\DmpsAudioOutputController.cs" />
     <Compile Include="Chassis\DmpsInternalVirtualDmTxController.cs" />
     <Compile Include="Chassis\DmpsRoutingController.cs" />
+    <Compile Include="Chassis\HdMdNxM4kEBridgeableController.cs" />
     <Compile Include="Chassis\HdMdNxM4kEController.cs" />
+    <Compile Include="Config\InputPropertiesConfig.cs" />
     <Compile Include="Endpoints\DGEs\DmDge200CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZ100CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZScalerCController.cs" />
@@ -112,7 +114,6 @@
     <Compile Include="Config\DmTxConfig.cs" />
     <Compile Include="Config\DMChassisConfig.cs" />
     <Compile Include="Config\HdMdNxM4kEPropertiesConfig.cs" />
-    <Compile Include="Config\InputPropertiesConfig.cs" />
     <Compile Include="DmPortName.cs" />
     <Compile Include="Endpoints\DGEs\Dge100Controller.cs" />
     <Compile Include="Endpoints\DGEs\DgePropertiesConfig.cs" />

essentials-framework/Essentials Devices Common/Essentials Devices Common/Display/InputInterfaces.cs

@@ -12,6 +12,6 @@ namespace PepperDash.Essentials.Devices.Displays
     public interface IInputHdmi4 { void InputHdmi4(); }
     public interface IInputDisplayPort1 { void InputDisplayPort1(); }
     public interface IInputDisplayPort2 { void InputDisplayPort2(); }
-    public interface IInputVga1 { void InputVga1(); }
-
+    public interface IInputVga1 { void InputVga1(); }
+
 }