Removes essentials-framework as a submodule and brings the files back into the main repo

essentials-framework/Essentials DM/Essentials_DM.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Essentials_DM", "Essentials_DM\Essentials_DM.csproj", "{9199CE8A-0C9F-4952-8672-3EED798B284F}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9199CE8A-0C9F-4952-8672-3EED798B284F}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

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

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.DeviceSupport.Support;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.AirMedia;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.DM.AirMedia
+{
+    public class AirMediaController : CrestronGenericBaseDevice, IRoutingInputsOutputs, IIROutputPorts, IComPorts
+    {
+        public AmX00 AirMedia { get; private set; }
+
+        public DeviceConfig DeviceConfig { get; private set; }
+
+        AirMediaPropertiesConfig PropertiesConfig;
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+        public BoolFeedback IsInSessionFeedback { get; private set; }
+        public IntFeedback ErrorFeedback { get; private set; }
+        public IntFeedback NumberOfUsersConnectedFeedback { get; set; }
+        public IntFeedback LoginCodeFeedback { get; set; }
+        public StringFeedback ConnectionAddressFeedback { get; set; }
+        public StringFeedback HostnameFeedback { get; set; }
+        public IntFeedback VideoOutFeedback { get; private set; }
+        public BoolFeedback HdmiVideoSyncDetectedFeedback { get; private set; }
+        public StringFeedback SerialNumberFeedback { get; private set; }
+        public BoolFeedback AutomaticInputRoutingEnabledFeedback { get; private set; }
+
+        public AirMediaController(string key, string name, AmX00 device, DeviceConfig dc, AirMediaPropertiesConfig props)
+            :base(key, name, device)
+        {
+            AirMedia = device;
+
+            DeviceConfig = dc;
+
+            PropertiesConfig = props;
+
+            InputPorts.Add(new RoutingInputPort(DmPortName.Osd, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.None, new Action(SelectPinPointUxLandingPage), this));
+
+            InputPorts.Add(new RoutingInputPort(DmPortName.AirMediaIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Streaming, new Action(SelectAirMedia), this));
+
+            InputPorts.Add(new RoutingInputPort(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(SelectHdmiIn), this));
+
+            InputPorts.Add(new RoutingInputPort(DmPortName.AirBoardIn, eRoutingSignalType.Video,
+                eRoutingPortConnectionType.None, new Action(SelectAirboardIn), this));
+
+            if (AirMedia is Am300)
+            {
+                InputPorts.Add(new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+                    eRoutingPortConnectionType.DmCat, new Action(SelectDmIn), this));
+            }
+
+            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));
+
+            // TODO: Figure out if we can actually get the TSID/Serial
+            SerialNumberFeedback = new StringFeedback(new Func<string>(() => "unknown"));
+
+            AirMedia.DisplayControl.DisplayControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(DisplayControl_DisplayControlChange);
+
+            VideoOutFeedback = new IntFeedback(new Func<int>(() => Convert.ToInt16(AirMedia.DisplayControl.VideoOutFeedback)));
+            AutomaticInputRoutingEnabledFeedback = new BoolFeedback(new Func<bool>(() => AirMedia.DisplayControl.EnableAutomaticRoutingFeedback.BoolValue));
+
+            AirMedia.HdmiIn.StreamChange += new Crestron.SimplSharpPro.DeviceSupport.StreamEventHandler(HdmiIn_StreamChange);
+
+            HdmiVideoSyncDetectedFeedback = new BoolFeedback(new Func<bool>(() => AirMedia.HdmiIn.SyncDetectedFeedback.BoolValue));
+        }
+
+        public override bool CustomActivate()
+        {
+            if (PropertiesConfig.AutoSwitchingEnabled)
+                AirMedia.DisplayControl.EnableAutomaticRouting();
+            else
+                AirMedia.DisplayControl.DisableAutomaticRouting();
+
+            return base.CustomActivate();
+        }
+
+        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();
+        }
+
+        void DisplayControl_DisplayControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
+        {
+            if (args.EventId == AmX00.VideoOutFeedbackEventId)
+                VideoOutFeedback.FireUpdate();
+            else if (args.EventId == AmX00.EnableAutomaticRoutingFeedbackEventId)
+                AutomaticInputRoutingEnabledFeedback.FireUpdate();
+        }
+
+        void HdmiIn_StreamChange(Crestron.SimplSharpPro.DeviceSupport.Stream stream, Crestron.SimplSharpPro.DeviceSupport.StreamEventArgs args)
+        {
+            if (args.EventId == DMInputEventIds.SourceSyncEventId)
+                HdmiVideoSyncDetectedFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// Sets the VideoOut source ( 0 = PinpointUX, 1 = AirMedia, 2 = HDMI, 3 = DM, 4 = Airboard )
+        /// </summary>
+        /// <param name="source">source number</param>
+        public void SelectVideoOut(uint source)
+        {
+            AirMedia.DisplayControl.VideoOut = (AmX00DisplayControl.eAirMediaX00VideoSource)source;
+        }
+
+        /// <summary>
+        /// Selects the PinPointUXLandingPage input
+        /// </summary>
+        public void SelectPinPointUxLandingPage()
+        {
+            AirMedia.DisplayControl.VideoOut = AmX00DisplayControl.eAirMediaX00VideoSource.PinPointUxLandingPage;
+        }
+
+        /// <summary>
+        /// Selects the AirMedia input
+        /// </summary>
+        public void SelectAirMedia()
+        {
+            AirMedia.DisplayControl.VideoOut = AmX00DisplayControl.eAirMediaX00VideoSource.AirMedia;
+        }
+
+        /// <summary>
+        /// Selects the DM input
+        /// </summary>
+        public void SelectDmIn()
+        {
+            AirMedia.DisplayControl.VideoOut = AmX00DisplayControl.eAirMediaX00VideoSource.HDMI;
+        }
+
+        /// <summary>
+        /// Selects the HDMI INput
+        /// </summary>
+        public void SelectHdmiIn()
+        {
+            AirMedia.DisplayControl.VideoOut = AmX00DisplayControl.eAirMediaX00VideoSource.DM;
+        }
+
+        public void SelectAirboardIn()
+        {
+            AirMedia.DisplayControl.VideoOut = AmX00DisplayControl.eAirMediaX00VideoSource.AirBoard;
+        }
+
+        /// <summary>
+        /// Reboots the device
+        /// </summary>
+        public void RebootDevice()
+        {
+            AirMedia.AirMedia.DeviceReboot();
+        }
+
+        #region IIROutputPorts Members
+
+        public CrestronCollection<IROutputPort> IROutputPorts
+        {
+            get { return AirMedia.IROutputPorts; }
+        }
+
+        public int NumberOfIROutputPorts
+        {
+            get { return AirMedia.NumberOfIROutputPorts; }
+        }
+
+
+
+        #endregion
+
+
+
+        #region IComPorts Members
+
+        public CrestronCollection<ComPort> ComPorts
+        {
+            get { return AirMedia.ComPorts; }
+        }
+
+        public int NumberOfComPorts
+        {
+            get { return AirMedia.NumberOfComPorts; }
+        }
+
+        #endregion
+
+
+    }
+}

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

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.DM.AirMedia
+{
+    public class AirMediaPropertiesConfig
+    {
+        [JsonProperty("control")]
+        public ControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("autoSwitching")]
+        public bool AutoSwitchingEnabled { get; set; }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/DmInputCardBase.cs

@@ -0,0 +1,62 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM;
+
+//namespace PepperDash.Essentials.DM.Cards
+//{
+//    public class DmInputCardControllerBase : IRoutingInputsOutputs
+//    {
+//        public string Key { get; private set; }
+//        public uint Slot { get; private set; }
+//        public abstract eDmInputCardType Type { get; }
+
+//        //public RoutingOutputPort BackplaneVideoOut { get; private set; }
+//        //public RoutingOutputPort BackplaneAudioOut { get; private set; }
+
+//        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+
+//        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+//        public DmInputCardControllerBase(string key, uint slot)
+//        {
+//            Key = key;
+//            Slot = slot;
+//            //BackplaneAudioOut = new RoutingOutputPort("backplaneAudioOut", eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.BackplaneOnly, slot, this);
+//            //BackplaneVideoOut = new RoutingOutputPort("backplaneVideoOut", eRoutingSignalType.Video,
+//            //    eRoutingPortConnectionType.BackplaneOnly, slot, this);
+//            //InputPorts = new RoutingPortCollection<RoutingInputPort>();
+//            //OutputPorts = new RoutingPortCollection<RoutingOutputPort> { BackplaneAudioOut, BackplaneVideoOut };
+//        }
+
+//        ///// <summary>
+//        ///// Gets a physical port by name.  Returns null if doesn't exist
+//        ///// </summary>
+//        //public RoutingInputPort GetInputPort(string key)
+//        //{
+//        //    return InputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+//        //}
+
+//        ///// <summary>
+//        ///// Gets a physical port by name.  Returns null if doesn't exist
+//        ///// </summary>
+//        //public RoutingOutputPort GetOutputPort(string key)
+//        //{
+//        //    return OutputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+//        //}
+//    }
+
+//    public enum eDmInputCardType
+//    {
+//        None, DmcHd, DmcHdDsp, Dmc4kHd, Dmc4kHdDsp, Dmc4kC, Dmc4kCDsp
+//    }
+//}

essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/DmOutputCardBase.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.DM.Cards
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	public abstract class DmSingleOutputCardControllerBase// : IRoutingInputsOutputs
+	{
+		public string Key { get; private set; }
+		public uint Slot { get; private set; }
+		public abstract eDmOutputCardType Type { get; }
+
+        //public RoutingInputPort BackplaneAudioIn1 { get; private set; }
+        //public RoutingInputPort BackplaneVideoIn1 { get; private set; }
+        //public RoutingInputPort BackplaneAudioIn2 { get; private set; }
+        //public RoutingInputPort BackplaneVideoIn2 { get; private set; }
+
+        //public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+        //public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		public DmSingleOutputCardControllerBase(string key, uint cardSlot)
+		{
+			Key = key;
+			Slot = cardSlot;
+            //BackplaneAudioIn1 = new RoutingInputPort("backplaneAudioIn1", eRoutingSignalType.Audio,
+            //    eRoutingPortConnectionType.BackplaneOnly, cardSlot, this);
+            //BackplaneVideoIn1 = new RoutingInputPort("backplaneVideoIn1", eRoutingSignalType.Video,
+            //    eRoutingPortConnectionType.BackplaneOnly, cardSlot, this);
+            //BackplaneAudioIn2 = new RoutingInputPort("backplaneAudioIn2", eRoutingSignalType.Audio,
+            //    eRoutingPortConnectionType.BackplaneOnly, cardSlot + 1, this);
+            //BackplaneVideoIn2 = new RoutingInputPort("backplaneVideoIn2", eRoutingSignalType.Video,
+            //    eRoutingPortConnectionType.BackplaneOnly, cardSlot + 1, this);
+            //InputPorts = new RoutingPortCollection<RoutingInputPort>
+            //{
+            //    BackplaneAudioIn1,
+            //    BackplaneAudioIn2,
+            //    BackplaneVideoIn1,
+            //    BackplaneVideoIn2
+            //};
+            //OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+		}
+
+		///// <summary>
+		///// Gets a physical port by name.  Returns null if doesn't exist
+		///// </summary>
+		//public RoutingInputPort GetInputPort(string key)
+		//{
+		//    return InputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+		//}
+
+        ///// <summary>
+        ///// Gets a physical port by name.  Returns null if doesn't exist
+        ///// </summary>
+        //public RoutingOutputPort GetOutputPort(string key)
+        //{
+        //    return OutputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+        //}
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public enum eDmOutputCardType
+	{
+        None, Dmc4kCoHd, Dmc4kHdo, DmcCoHd, DmcSoHd
+	}
+}

essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/Dmc4kCoHdSingleOutputCard.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.DM.Cards
+{
+	public class Dmc4kCoHdSingleOutputCard : DmSingleOutputCardControllerBase
+	{
+		public override eDmOutputCardType Type
+		{
+			get { return eDmOutputCardType.Dmc4kCoHd; }
+		}
+		public Dmc4kCoHdSingle Card { get; private set; }
+
+        //public RoutingOutputPort DmOut1 { get; private set; }
+        //public RoutingOutputPort DmOut2 { get; private set; }
+        //public RoutingOutputPort HdmiOut1 { get; private set; }
+
+		public Dmc4kCoHdSingleOutputCard(string key, Dmc4kCoHdSingle card, uint slot)
+			: base(key, slot)
+		{
+			Card = card;
+            //DmOut1 = new RoutingOutputPort(DmPortName.DmOut1, eRoutingSignalType.AudioVideo,
+            //    eRoutingPortConnectionType.DmCat, null, this);
+            //DmOut2 = new RoutingOutputPort(DmPortName.DmOut2, eRoutingSignalType.AudioVideo,
+            //    eRoutingPortConnectionType.DmCat, null, this);
+            //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.AudioVideo,
+            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+            //OutputPorts.AddRange(new[] { DmOut1, DmOut2, HdmiOut1 });
+		}
+	}
+}

essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/Dmc4kHdoSingleOutputCard.cs

@@ -0,0 +1,46 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+
+//using PepperDash.Core;
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM;
+
+//namespace PepperDash.Essentials.DM.Cards
+//{
+//    public class Dmc4kHdoSingleOutputCard : DmSingleOutputCardControllerBase
+//    {
+//        public override eDmOutputCardType Type
+//        {
+//            get { return eDmOutputCardType.Dmc4kHdo; }
+//        }
+//        public Dmc4kHdoSingle Card { get; private set; }
+
+//        //public RoutingOutputPort AudioOut1 { get; private set; }
+//        //public RoutingOutputPort AudioOut2 { get; private set; }
+//        //public RoutingOutputPort HdmiOut1 { get; private set; }
+//        //public RoutingOutputPort HdmiOut2 { get; private set; }
+
+//        public Dmc4kHdoSingleOutputCard(string key, Dmc4kHdoSingle card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            //AudioOut1 = new RoutingOutputPort(DmPortName.BalancedAudioOut1, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.LineAudio, null, this);
+//            //AudioOut2 = new RoutingOutputPort(DmPortName.BalancedAudioOut2, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.LineAudio, null, this);
+//            //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+//            //HdmiOut2 = new RoutingOutputPort(DmPortName.HdmiOut2, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+//            //OutputPorts.AddRange(new[] { AudioOut1, AudioOut2, HdmiOut1, HdmiOut2 });
+//        }
+//    }
+//}

essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/DmcC4kInputCard.cs

@@ -0,0 +1,76 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM;
+
+//namespace PepperDash.Essentials.DM.Cards
+//{
+//    public class Dmc4kCController : DmInputCardControllerBase
+//    {
+//        public override eDmInputCardType Type
+//        {
+//            get { return eDmInputCardType.Dmc4kC; }
+//        }
+//        public Dmc4kC Card { get; private set; }
+
+//        //public RoutingInputPortWithVideoStatuses DmIn { get; private set; }
+//        //public RoutingOutputPort HdmiLoopOut { get; private set; }
+//        //public RoutingOutputPort AudioLoopOut { get; private set; }
+		
+//        public Dmc4kCController(string key, Dmc4kC card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.DmCat, null, this, 
+//            //    VideoStatusHelper.GetDmInputStatusFuncs(Card.DmInput));
+
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+//            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+//            //InputPorts.Add(DmIn);
+//            //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
+//        }
+//    }
+
+//    public class Dmc4kCDspController : DmInputCardControllerBase
+//    {
+//        public override eDmInputCardType Type
+//        {
+//            get { return eDmInputCardType.Dmc4kCDsp; }
+//        }
+//        public Dmc4kCDsp Card { get; private set; }
+
+//        //public RoutingInputPortWithVideoStatuses DmIn { get; private set; }
+//        //public RoutingOutputPort HdmiLoopOut { get; private set; }
+//        //public RoutingOutputPort AudioLoopOut { get; private set; }
+
+//        public Dmc4kCDspController(string key, Dmc4kCDsp card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.DmCat, null, this,
+//            //    VideoStatusHelper.GetDmInputStatusFuncs(Card.DmInput));
+
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+//            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+//            //InputPorts.Add(DmIn);
+//            //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
+//        }
+//    }
+
+//}

essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/DmcHD4kInputCard.cs

@@ -0,0 +1,82 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM;
+
+//namespace PepperDash.Essentials.DM.Cards
+//{
+//    /// <summary>
+//    /// 
+//    /// </summary>
+//    public class Dmc4kHdController : DmInputCardControllerBase
+//    {
+//        public Dmc4kHd Card { get; private set; }
+//        public override eDmInputCardType Type
+//        {
+//            get { return eDmInputCardType.Dmc4kHd; }
+//        }
+
+//        public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
+//        public RoutingOutputPort HdmiLoopOut { get; private set; }
+//        public RoutingOutputPort AudioLoopOut { get; private set; }
+
+//        public Dmc4kHdController(string key, Dmc4kHd card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
+//                eRoutingPortConnectionType.Hdmi, null, this,
+//                VideoStatusHelper.GetHdmiInputStatusFuncs(Card.HdmiInput));
+
+//            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//                eRoutingPortConnectionType.Hdmi, null, this);
+//            AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
+//                eRoutingPortConnectionType.Hdmi, null, this);
+
+//            InputPorts.Add(HdmiIn);
+//            OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
+//        }
+//    }
+
+//    /// <summary>
+//    /// 
+//    /// </summary>
+//    public class Dmc4kHdDspController : DmInputCardControllerBase
+//    {
+//        public Dmc4kHdDsp Card { get; private set; }
+//        public override eDmInputCardType Type
+//        {
+//            get { return eDmInputCardType.Dmc4kHdDsp; }
+//        }
+
+//        //public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
+//        //public RoutingOutputPort HdmiLoopOut { get; private set; }
+//        //public RoutingOutputPort AudioLoopOut { get; private set; }
+
+//        public Dmc4kHdDspController(string key, Dmc4kHdDsp card, uint slot)
+//            : base(key, slot)
+//        {
+//            Card = card;
+//            //HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this,
+//            //    VideoStatusHelper.GetHdmiInputStatusFuncs(Card.HdmiInput));
+
+//            //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+//            //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
+//            //    eRoutingPortConnectionType.Hdmi, null, this);
+
+//            //InputPorts.Add(HdmiIn);
+//            //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
+//        }
+//    }
+//}
+

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

@@ -0,0 +1,116 @@
+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;
+
+namespace PepperDash.Essentials.DM
+{
+    public class DmCardAudioOutputController : IBasicVolumeWithFeedback
+    {
+        public Audio.Output Output { get; private set; }
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
+
+        public BoolFeedback MuteFeedback { get; private set; }
+
+        ushort PreMuteVolumeLevel;
+        bool IsMuted;
+
+        public DmCardAudioOutputController(Audio.Output output)
+        {
+            Output = output;
+            VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
+            MuteFeedback = new BoolFeedback(() => IsMuted);
+        }
+
+        #region IBasicVolumeWithFeedback Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOff()
+        {
+            SetVolume(PreMuteVolumeLevel);
+            IsMuted = false;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOn()
+        {
+            PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
+            SetVolume(0);
+            IsMuted = true;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void SetVolume(ushort level)
+        {
+            Debug.Console(2, "Set volume out {0}", level);
+            Output.Volume.UShortValue = level;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        internal void VolumeEventFromChassis()
+        {
+            VolumeLevelFeedback.FireUpdate();
+        }
+
+        #endregion
+
+        #region IBasicVolumeControls Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteToggle()
+        {
+            if (IsMuted)
+                MuteOff();
+            else
+                MuteOn();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeDown(bool pressRelease)
+        {
+            if (pressRelease)
+            {
+                var remainingRatio = Output.Volume.UShortValue / 65535;
+                Output.Volume.CreateRamp(0, (uint)(400 * remainingRatio));
+            }
+            else
+                Output.Volume.StopRamp();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeUp(bool pressRelease)
+        {
+            if (pressRelease)
+            {
+                var remainingRatio = (65535 - Output.Volume.UShortValue) / 65535;
+                Output.Volume.CreateRamp(65535, 400);
+            }
+            else
+                Output.Volume.StopRamp();
+        }
+
+        #endregion
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Chassis/DmCardAudioOutput.cs.orig

@@ -0,0 +1,120 @@
+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;
+
+namespace PepperDash.Essentials.DM
+{
+    public class DmCardAudioOutputController : IBasicVolumeWithFeedback
+    {
+        public Audio.Output Output { get; private set; }
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
+
+        public BoolFeedback MuteFeedback { get; private set; }
+
+        ushort PreMuteVolumeLevel;
+        bool IsMuted;
+
+        public DmCardAudioOutputController(Audio.Output output)
+        {
+            Output = output;
+            VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
+            MuteFeedback = new BoolFeedback(() => IsMuted);
+        }
+
+        #region IBasicVolumeWithFeedback Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOff()
+        {
+            SetVolume(PreMuteVolumeLevel);
+            IsMuted = false;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOn()
+        {
+            PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
+            SetVolume(0);
+            IsMuted = true;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void SetVolume(ushort level)
+        {
+            Debug.Console(2, "Set volume out {0}", level);
+            Output.Volume.UShortValue = level;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        internal void VolumeEventFromChassis()
+        {
+            VolumeLevelFeedback.FireUpdate();
+        }
+
+        #endregion
+
+        #region IBasicVolumeControls Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteToggle()
+        {
+            if (IsMuted)
+                MuteOff();
+            else
+                MuteOn();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeDown(bool pressRelease)
+        {
+            if (pressRelease)
+<<<<<<< HEAD
+            {
+                var remainingRatio = Output.Volume.UShortValue / 65535;
+                Output.Volume.CreateRamp(0, (uint)(400 * remainingRatio));
+            }
+=======
+                Output.Volume.CreateRamp(0, 400);
+>>>>>>> origin/feature/fusion-nyu
+            else
+                Output.Volume.StopRamp();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeUp(bool pressRelease)
+        {
+            if (pressRelease)
+            {
+                var remainingRatio = (65535 - Output.Volume.UShortValue) / 65535;
+                Output.Volume.CreateRamp(65535, 400);
+            }
+            else
+                Output.Volume.StopRamp();
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,120 @@
+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;
+
+namespace PepperDash.Essentials.DM
+{
+    public class DmCardAudioOutputController : IBasicVolumeWithFeedback
+    {
+        public Audio.Output Output { get; private set; }
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
+
+        public BoolFeedback MuteFeedback { get; private set; }
+
+        ushort PreMuteVolumeLevel;
+        bool IsMuted;
+
+        public DmCardAudioOutputController(Audio.Output output)
+        {
+            Output = output;
+            VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
+            MuteFeedback = new BoolFeedback(() => IsMuted);
+        }
+
+        #region IBasicVolumeWithFeedback Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOff()
+        {
+            SetVolume(PreMuteVolumeLevel);
+            IsMuted = false;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOn()
+        {
+            PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
+            SetVolume(0);
+            IsMuted = true;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void SetVolume(ushort level)
+        {
+            Debug.Console(2, "Set volume out {0}", level);
+            Output.Volume.UShortValue = level;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        internal void VolumeEventFromChassis()
+        {
+            VolumeLevelFeedback.FireUpdate();
+        }
+
+        #endregion
+
+        #region IBasicVolumeControls Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteToggle()
+        {
+            if (IsMuted)
+                MuteOff();
+            else
+                MuteOn();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeDown(bool pressRelease)
+        {
+            if (pressRelease)
+<<<<<<< HEAD
+            {
+                var remainingRatio = Output.Volume.UShortValue / 65535;
+                Output.Volume.CreateRamp(0, (uint)(400 * remainingRatio));
+            }
+=======
+                Output.Volume.CreateRamp(0, 400);
+>>>>>>> origin/feature/fusion-nyu
+            else
+                Output.Volume.StopRamp();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeUp(bool pressRelease)
+        {
+            if (pressRelease)
+            {
+                var remainingRatio = (65535 - Output.Volume.UShortValue) / 65535;
+                Output.Volume.CreateRamp(65535, 400);
+            }
+            else
+                Output.Volume.StopRamp();
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,111 @@
+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;
+
+namespace PepperDash.Essentials.DM
+{
+    public class DmCardAudioOutputController : IBasicVolumeWithFeedback
+    {
+        public Audio.Output Output { get; private set; }
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
+
+        public BoolFeedback MuteFeedback { get; private set; }
+
+        ushort PreMuteVolumeLevel;
+        bool IsMuted;
+
+        public DmCardAudioOutputController(Audio.Output output)
+        {
+            Output = output;
+            VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
+            MuteFeedback = new BoolFeedback(() => IsMuted);
+        }
+
+        #region IBasicVolumeWithFeedback Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOff()
+        {
+            SetVolume(PreMuteVolumeLevel);
+            IsMuted = false;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOn()
+        {
+            PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
+            SetVolume(0);
+            IsMuted = true;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void SetVolume(ushort level)
+        {
+            Debug.Console(2, "Set volume out {0}", level);
+            Output.Volume.UShortValue = level;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        internal void VolumeEventFromChassis()
+        {
+            VolumeLevelFeedback.FireUpdate();
+        }
+
+        #endregion
+
+        #region IBasicVolumeControls Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteToggle()
+        {
+            if (IsMuted)
+                MuteOff();
+            else
+                MuteOn();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeDown(bool pressRelease)
+        {
+            if (pressRelease)
+                Output.Volume.CreateRamp(0, 400);
+#warning SCALE THIS RAMP
+            else
+                Output.Volume.StopRamp();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeUp(bool pressRelease)
+        {
+            if (pressRelease)
+                Output.Volume.CreateRamp(65535, 400);
+            else
+                Output.Volume.StopRamp();
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,116 @@
+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;
+
+namespace PepperDash.Essentials.DM
+{
+    public class DmCardAudioOutputController : IBasicVolumeWithFeedback
+    {
+        public Audio.Output Output { get; private set; }
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
+
+        public BoolFeedback MuteFeedback { get; private set; }
+
+        ushort PreMuteVolumeLevel;
+        bool IsMuted;
+
+        public DmCardAudioOutputController(Audio.Output output)
+        {
+            Output = output;
+            VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
+            MuteFeedback = new BoolFeedback(() => IsMuted);
+        }
+
+        #region IBasicVolumeWithFeedback Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOff()
+        {
+            SetVolume(PreMuteVolumeLevel);
+            IsMuted = false;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOn()
+        {
+            PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
+            SetVolume(0);
+            IsMuted = true;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void SetVolume(ushort level)
+        {
+            Debug.Console(2, "Set volume out {0}", level);
+            Output.Volume.UShortValue = level;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        internal void VolumeEventFromChassis()
+        {
+            VolumeLevelFeedback.FireUpdate();
+        }
+
+        #endregion
+
+        #region IBasicVolumeControls Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteToggle()
+        {
+            if (IsMuted)
+                MuteOff();
+            else
+                MuteOn();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeDown(bool pressRelease)
+        {
+            if (pressRelease)
+            {
+                var remainingRatio = Output.Volume.UShortValue / 65535;
+                Output.Volume.CreateRamp(0, (uint)(400 * remainingRatio));
+            }
+            else
+                Output.Volume.StopRamp();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeUp(bool pressRelease)
+        {
+            if (pressRelease)
+            {
+                var remainingRatio = (65535 - Output.Volume.UShortValue) / 65535;
+                Output.Volume.CreateRamp(65535, 400);
+            }
+            else
+                Output.Volume.StopRamp();
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,110 @@
+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;
+
+namespace PepperDash.Essentials.DM
+{
+    public class DmCardAudioOutputController : IBasicVolumeWithFeedback
+    {
+        public Audio.Output Output { get; private set; }
+
+        public IntFeedback VolumeLevelFeedback { get; private set; }
+
+        public BoolFeedback MuteFeedback { get; private set; }
+
+        ushort PreMuteVolumeLevel;
+        bool IsMuted;
+
+        public DmCardAudioOutputController(Audio.Output output)
+        {
+            Output = output;
+            VolumeLevelFeedback = new IntFeedback(() => Output.VolumeFeedback.UShortValue);
+            MuteFeedback = new BoolFeedback(() => IsMuted);
+        }
+
+        #region IBasicVolumeWithFeedback Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOff()
+        {
+            SetVolume(PreMuteVolumeLevel);
+            IsMuted = false;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteOn()
+        {
+            PreMuteVolumeLevel = Output.VolumeFeedback.UShortValue;
+            SetVolume(0);
+            IsMuted = true;
+            MuteFeedback.FireUpdate();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void SetVolume(ushort level)
+        {
+            Debug.Console(2, "Set volume out {0}", level);
+            Output.Volume.UShortValue = level;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        internal void VolumeEventFromChassis()
+        {
+            VolumeLevelFeedback.FireUpdate();
+        }
+
+        #endregion
+
+        #region IBasicVolumeControls Members
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void MuteToggle()
+        {
+            if (IsMuted)
+                MuteOff();
+            else
+                MuteOn();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeDown(bool pressRelease)
+        {
+            if (pressRelease)
+                Output.Volume.CreateRamp(0, 400);
+            else
+                Output.Volume.StopRamp();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void VolumeUp(bool pressRelease)
+        {
+            if (pressRelease)
+                Output.Volume.CreateRamp(65535, 400);
+            else
+                Output.Volume.StopRamp();
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,808 @@
+	using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Cards;
+
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmChassisController : CrestronGenericBaseDevice, IRoutingInputsOutputs, IRouting, IHasFeedback//, ICardPortsDevice
+	{
+		public DmMDMnxn Chassis { get; private set; }
+		
+		// Feedbacks for EssentialDM
+		public Dictionary<uint, IntFeedback> VideoOutputFeedbacks { get; private set; }
+		public Dictionary<uint, IntFeedback> AudioOutputFeedbacks { get; private set; }
+		public Dictionary<uint, BoolFeedback> VideoInputSyncFeedbacks { get; private set; }
+		public Dictionary<uint, BoolFeedback> InputEndpointOnlineFeedbacks { get; private set; }
+        public Dictionary<uint, BoolFeedback> OutputEndpointOnlineFeedbacks { get; private set; }
+        public Dictionary<uint, StringFeedback> InputNameFeedbacks { get; private set; }
+		public Dictionary<uint, StringFeedback> OutputNameFeedbacks { get; private set; }
+		public Dictionary<uint, StringFeedback> OutputVideoRouteNameFeedbacks { get; private set; }
+        public Dictionary<uint, StringFeedback> OutputAudioRouteNameFeedbacks { get; private set; }
+		
+		
+		// Need a couple Lists of generic Backplane ports
+		public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		public Dictionary<uint, string> TxDictionary { get; set; }
+		public Dictionary<uint, string> RxDictionary { get; set; }
+
+        //public Dictionary<uint, DmInputCardControllerBase> InputCards { get; private set; }
+        //public Dictionary<uint, DmSingleOutputCardControllerBase> OutputCards { get; private set; }
+
+		public Dictionary<uint, string> InputNames { get; set; }
+		public Dictionary<uint, string> OutputNames { get; set; }
+        public Dictionary<uint, DmCardAudioOutputController> VolumeControls { get; private set; }
+
+		public const int RouteOffTime = 500;
+		Dictionary<PortNumberType, CTimer> RouteOffTimers = new Dictionary<PortNumberType, CTimer>();
+
+		/// <summary>
+		/// Factory method to create a new chassis controller from config data. Limited to 8x8 right now
+		/// </summary>
+		public static DmChassisController GetDmChassisController(string key, string name,
+			string type, DMChassisPropertiesConfig properties)
+		{
+			try
+			{
+				type = type.ToLower();
+				uint ipid = properties.Control.IpIdInt;
+
+				DmMDMnxn chassis = null;
+				if (type == "dmmd8x8") { chassis = new DmMd8x8(ipid, Global.ControlSystem); }
+				else if (type == "dmmd8x8rps") { chassis = new DmMd8x8rps(ipid, Global.ControlSystem); }
+				else if (type == "dmmd8x8cpu3") { chassis = new DmMd8x8Cpu3(ipid, Global.ControlSystem); }
+				else if (type == "dmmd8x8cpu3rps") { chassis = new DmMd8x8Cpu3rps(ipid, Global.ControlSystem); }
+
+				else if (type == "dmmd16x16") { chassis = new DmMd16x16(ipid, Global.ControlSystem); }
+				else if (type == "dmmd16x16rps") { chassis = new DmMd16x16rps(ipid, Global.ControlSystem); }
+				else if (type == "dmmd16x16cpu3") { chassis = new DmMd16x16Cpu3(ipid, Global.ControlSystem); }
+				else if (type == "dmmd16x16cpu3rps") { chassis = new DmMd16x16Cpu3rps(ipid, Global.ControlSystem); }
+
+				else if (type == "dmmd32x32") { chassis = new DmMd32x32(ipid, Global.ControlSystem); }
+				else if (type == "dmmd32x32rps") { chassis = new DmMd32x32rps(ipid, Global.ControlSystem); }
+				else if (type == "dmmd32x32cpu3") { chassis = new DmMd32x32Cpu3(ipid, Global.ControlSystem); }
+				else if (type == "dmmd32x32cpu3rps") { chassis = new DmMd32x32Cpu3rps(ipid, Global.ControlSystem); }
+
+				if (chassis == null)
+				{
+					return null;
+				}
+
+				var controller = new DmChassisController(key, name, chassis);
+				// add the cards and port names
+				foreach (var kvp in properties.InputSlots)
+					controller.AddInputCard(kvp.Value, kvp.Key);
+				foreach (var kvp in properties.OutputSlots)
+				{
+					controller.AddOutputCard(kvp.Value, kvp.Key);
+				}
+
+				foreach (var kvp in properties.VolumeControls)
+				{
+					// get the card
+					// check it for an audio-compatible type
+					// make a something-something that will make it work
+					// retire to mountain village
+					var outNum = kvp.Key;
+					var card = controller.Chassis.Outputs[outNum].Card;
+					Audio.Output audio = null;
+					if (card is DmcHdo)
+						audio = (card as DmcHdo).Audio;
+					else if (card is Dmc4kHdo)
+						audio = (card as Dmc4kHdo).Audio;
+					if (audio == null)
+						continue;
+					// wire up the audio to something here...
+					controller.AddVolumeControl(outNum, audio);
+				}
+
+				controller.InputNames = properties.InputNames;
+				controller.OutputNames = properties.OutputNames;
+				return controller;
+
+
+				//DmChassisController controller = null;
+
+				//if (type == "dmmd8x8")
+				//{
+				//    controller = new DmChassisController(key, name, new DmMd8x8(ipid, Global.ControlSystem));
+
+				//    // add the cards and port names
+				//    foreach (var kvp in properties.InputSlots)
+				//        controller.AddInputCard(kvp.Value, kvp.Key);
+				//    foreach (var kvp in properties.OutputSlots)
+				//    {
+				//        controller.AddOutputCard(kvp.Value, kvp.Key);
+
+				//    }
+
+				//    foreach (var kvp in properties.VolumeControls)
+				//    {
+				//        // get the card
+				//        // check it for an audio-compatible type
+				//        // make a something-something that will make it work
+				//        // retire to mountain village
+				//        var outNum = kvp.Key;
+				//        var card = controller.Chassis.Outputs[outNum].Card;
+				//        Audio.Output audio = null;
+				//        if (card is DmcHdo)
+				//            audio = (card as DmcHdo).Audio;
+				//        else if (card is Dmc4kHdo)
+				//            audio = (card as Dmc4kHdo).Audio;
+				//        if (audio == null)
+				//            continue;
+				//        // wire up the audio to something here...
+				//        controller.AddVolumeControl(outNum, audio);
+				//    }
+
+				//    controller.InputNames = properties.InputNames;
+				//    controller.OutputNames = properties.OutputNames;
+				//    return controller;
+				//}
+				//else if (type == "dmmd16x16")
+				//{
+				//    controller = new DmChassisController(key, name, new DmMd16x16(ipid, Global.ControlSystem));
+
+				//    // add the cards and port names
+				//    foreach (var kvp in properties.InputSlots)
+				//        controller.AddInputCard(kvp.Value, kvp.Key);
+				//    foreach (var kvp in properties.OutputSlots)
+				//    {
+				//        controller.AddOutputCard(kvp.Value, kvp.Key);
+
+				//    }
+
+				//    foreach (var kvp in properties.VolumeControls)
+				//    {
+				//        // get the card
+				//        // check it for an audio-compatible type
+				//        // make a something-something that will make it work
+				//        // retire to mountain village
+				//        var outNum = kvp.Key;
+				//        var card = controller.Chassis.Outputs[outNum].Card;
+				//        Audio.Output audio = null;
+				//        if (card is DmcHdo)
+				//            audio = (card as DmcHdo).Audio;
+				//        else if (card is Dmc4kHdo)
+				//            audio = (card as Dmc4kHdo).Audio;
+				//        if (audio == null)
+				//            continue;
+				//        // wire up the audio to something here...
+				//        controller.AddVolumeControl(outNum, audio);
+				//    }
+
+				//    controller.InputNames = properties.InputNames;
+				//    controller.OutputNames = properties.OutputNames;
+				//    return controller;
+				//}
+			}
+			catch (System.Exception e)
+			{
+				Debug.Console(0, "Error creating DM chassis:\r{0}", e);
+			}
+			return null;
+		}
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="chassis"></param>
+		public DmChassisController(string key, string name, DmMDMnxn chassis)
+			: base(key, name, chassis)
+		{
+			Chassis = chassis;
+			InputPorts = new RoutingPortCollection<RoutingInputPort>();
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+            VolumeControls = new Dictionary<uint, DmCardAudioOutputController>();
+			TxDictionary = new Dictionary<uint, string>();
+			RxDictionary = new Dictionary<uint, string>();
+			IsOnline.OutputChange += new EventHandler<FeedbackEventArgs>(IsOnline_OutputChange);
+            //IsOnline.OutputChange += new EventHandler<EventArgs>(this.IsOnline_OutputChange);
+			Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
+			//Chassis.DMSystemChange += new DMSystemEventHandler(Chassis_DMSystemChange);
+            Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
+			VideoOutputFeedbacks = new Dictionary<uint, IntFeedback>();
+			AudioOutputFeedbacks = new Dictionary<uint, IntFeedback>();
+			VideoInputSyncFeedbacks = new Dictionary<uint, BoolFeedback>();
+			InputNameFeedbacks = new Dictionary<uint, StringFeedback>();
+			OutputNameFeedbacks = new Dictionary<uint, StringFeedback>();
+			OutputVideoRouteNameFeedbacks = new Dictionary<uint, StringFeedback>();
+            OutputAudioRouteNameFeedbacks = new Dictionary<uint, StringFeedback>();
+            InputEndpointOnlineFeedbacks = new Dictionary<uint, BoolFeedback>();
+            OutputEndpointOnlineFeedbacks = new Dictionary<uint, BoolFeedback>();
+
+
+			for (uint x = 1; x <= Chassis.NumberOfOutputs; x++) 
+            {
+				var tempX = x;
+
+				VideoOutputFeedbacks[tempX] = new IntFeedback(() => { 
+					if (Chassis.Outputs[tempX].VideoOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number;} 
+					else { return 0; };
+					});
+				AudioOutputFeedbacks[tempX] = new IntFeedback(() => {
+					if (Chassis.Outputs[tempX].AudioOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number; } 
+					else { return 0; };
+					});
+				VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {			
+					return Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue;
+					});
+				InputNameFeedbacks[tempX] = new StringFeedback(() => {
+					    if (Chassis.Inputs[tempX].NameFeedback.StringValue != null) 
+                        {
+						     return Chassis.Inputs[tempX].NameFeedback.StringValue;
+					    }
+					    else 
+                        {
+						    return "";
+					    }				
+					});
+				OutputNameFeedbacks[tempX] = new StringFeedback(() => {
+					    if (Chassis.Outputs[tempX].NameFeedback.StringValue != null) 
+                        {
+						    return Chassis.Outputs[tempX].NameFeedback.StringValue;
+					    }
+					    else 
+                        {
+						    return "";
+					    }
+					});
+				OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() => 
+				{
+					    if (Chassis.Outputs[tempX].VideoOutFeedback != null) 
+                        {
+						    return Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue;
+					    }
+					    else 
+                        {
+						    return "";
+					    }
+					});
+                OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() =>
+                    {
+                        if (Chassis.Outputs[tempX].AudioOutFeedback != null)
+                        {
+                            return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
+                        }
+                        else
+                        {
+                            return "";
+
+                        }
+                    });
+				InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Inputs[tempX].EndpointOnlineFeedback; });
+
+                OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Outputs[tempX].EndpointOnlineFeedback; });
+			}
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="type"></param>
+		/// <param name="number"></param>
+		public void AddInputCard(string type, uint number)
+        {
+            Debug.Console(2, this, "Adding input card '{0}', slot {1}", type, number);
+
+            if (type == "dmcHd")
+            {
+                var inputCard = new DmcHd(number, this.Chassis);
+                var cecPort = inputCard.HdmiInput as ICec;
+                AddHdmiInCardPorts(number, cecPort);
+            }
+            else if (type == "dmcHdDsp")
+            {
+                var inputCard = new DmcHdDsp(number, this.Chassis);
+                var cecPort = inputCard.HdmiInput as ICec;
+                AddHdmiInCardPorts(number, cecPort);
+            }
+            else if (type == "dmc4kHd")
+            {
+                var inputCard = new Dmc4kHd(number, this.Chassis);
+                var cecPort = inputCard.HdmiInput as ICec;
+                AddHdmiInCardPorts(number, cecPort);
+            }
+            else if (type == "dmc4kHdDsp")
+            {
+                var inputCard = new Dmc4kHdDsp(number, this.Chassis);
+                var cecPort = inputCard.HdmiInput as ICec;
+                AddHdmiInCardPorts(number, cecPort);
+            }
+            else if (type == "dmc4kzHd")
+            {
+                var inputCard = new Dmc4kzHd(number, this.Chassis);
+                var cecPort = inputCard.HdmiInput as ICec;
+                AddHdmiInCardPorts(number, cecPort);
+            }
+            else if (type == "dmc4kzHdDsp")
+            {
+                var inputCard = new Dmc4kzHdDsp(number, this.Chassis);
+                var cecPort = inputCard.HdmiInput as ICec;
+                AddHdmiInCardPorts(number, cecPort);
+            }
+            else if (type == "dmcC")
+            {
+                new DmcC(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmcCDsp")
+            {
+                new DmcCDsp(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmc4kC")
+            {
+                new Dmc4kC(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmc4kCDsp")
+            {
+                new Dmc4kCDsp(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmc4kzC")
+            {
+                new Dmc4kzC(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmc4kzCDsp")
+            {
+                new Dmc4kzCDsp(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmcCat")
+            {
+                new DmcCat(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmcCatDsp")
+            {
+                new DmcCatDsp(number, this.Chassis);
+                AddDmInCardPorts(number);
+            }
+            else if (type == "dmcS")
+            {
+                new DmcS(number, Chassis);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+                AddInCardHdmiAndAudioLoopPorts(number);
+            }
+            else if (type == "dmcSDsp")
+            {
+                new DmcSDsp(number, Chassis);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+                AddInCardHdmiAndAudioLoopPorts(number);
+            }
+            else if (type == "dmcS2")
+            {
+                new DmcS2(number, Chassis);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+                AddInCardHdmiAndAudioLoopPorts(number);
+            }
+            else if (type == "dmcS2Dsp")
+            {
+                new DmcS2Dsp(number, Chassis);
+                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+                AddInCardHdmiAndAudioLoopPorts(number);
+            }
+            else if (type == "dmcSdi")
+            {
+                new DmcSdi(number, Chassis);
+                AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Sdi);
+                AddOutputPortWithDebug(number, "sdiOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Sdi, null);
+                AddInCardHdmiAndAudioLoopPorts(number);
+            }
+            else if (type == "dmcDvi")
+            {
+                new DmcDvi(number, Chassis);
+                AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Dvi);
+                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
+                AddInCardHdmiLoopPort(number);
+            }
+            else if (type == "dmcVga")
+            {
+                new DmcVga(number, Chassis);
+                AddInputPortWithDebug(number, "vgaIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Vga);
+                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
+                AddInCardHdmiLoopPort(number);
+            }
+            else if (type == "dmcVidBnc")
+            {
+                new DmcVidBnc(number, Chassis);
+                AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
+                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
+                AddInCardHdmiLoopPort(number);
+            }
+            else if (type == "dmcVidRcaA")
+            {
+                new DmcVidRcaA(number, Chassis);
+                AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
+                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
+                AddInCardHdmiLoopPort(number);
+            }
+            else if (type == "dmcVidRcaD")
+            {
+                new DmcVidRcaD(number, Chassis);
+                AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
+                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.DigitalAudio);
+                AddInCardHdmiLoopPort(number);
+            }
+            else if (type == "dmcVid4")
+            {
+                new DmcVid4(number, Chassis);
+                AddInputPortWithDebug(number, "compositeIn1", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
+                AddInputPortWithDebug(number, "compositeIn2", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
+                AddInputPortWithDebug(number, "compositeIn3", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
+                AddInputPortWithDebug(number, "compositeIn4", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
+                AddInCardHdmiLoopPort(number);
+            }
+            else if (type == "dmcStr")
+            {
+                new DmcStr(number, Chassis);
+                AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming);
+                AddInCardHdmiAndAudioLoopPorts(number);
+            }
+        }
+
+        void AddDmInCardPorts(uint number)
+        {
+            AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat);
+            AddInCardHdmiAndAudioLoopPorts(number);
+        }
+
+        void AddHdmiInCardPorts(uint number, ICec cecPort)
+        {
+            AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, cecPort);
+            AddInCardHdmiAndAudioLoopPorts(number);
+        }
+
+        void AddInCardHdmiAndAudioLoopPorts(uint number)
+        {
+            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
+            AddOutputPortWithDebug(number, "audioLoopOut", eRoutingSignalType.Audio, eRoutingPortConnectionType.Hdmi, null);
+        }
+
+        void AddInCardHdmiLoopPort(uint number)
+        {
+            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="number"></param>
+        public void AddOutputCard(string type, uint number)
+        {
+            Debug.Console(2, this, "Adding output card '{0}', slot {1}", type, number);
+            if (type == "dmc4kHdo")
+            {
+                var outputCard = new Dmc4kHdoSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                var cecPort2 = outputCard.Card2.HdmiOutput;
+                AddDmcHdoPorts(number, cecPort1, cecPort2);
+            }
+            else if (type == "dmcHdo")
+            {
+                var outputCard = new DmcHdoSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                var cecPort2 = outputCard.Card2.HdmiOutput;
+                AddDmcHdoPorts(number, cecPort1, cecPort2);
+            }
+            else if (type == "dmc4kCoHd")
+            {
+                var outputCard = new Dmc4kCoHdSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                AddDmcCoPorts(number, cecPort1);
+            }
+			else if (type == "dmc4kzCoHd")
+			{
+                var outputCard = new Dmc4kzCoHdSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                AddDmcCoPorts(number, cecPort1);
+            }
+			else if (type == "dmcCoHd")
+            {
+                var outputCard = new DmcCoHdSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                AddDmcCoPorts(number, cecPort1);
+            }
+            else if (type == "dmCatoHd")
+            {
+                var outputCard = new DmcCatoHdSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                AddDmcCoPorts(number, cecPort1);
+            }
+            else if (type == "dmcSoHd")
+            {
+                var outputCard = new DmcSoHdSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
+
+            }
+            else if (type == "dmcS2oHd")
+            {
+                var outputCard = new DmcS2oHdSingle(number, Chassis);
+                var cecPort1 = outputCard.Card1.HdmiOutput;
+                AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
+            }
+            else if (type == "dmcStro")
+            {
+                var outputCard = new DmcStroSingle(number, Chassis);
+                AddOutputPortWithDebug(number, "streamOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
+            }
+
+            else
+                Debug.Console(1, this, "  WARNING: Output card type '{0}' is not available", type);
+        }
+
+        void AddDmcHdoPorts(uint number, ICec cecPort1, ICec cecPort2)
+        {
+            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+            AddOutputPortWithDebug(number, "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(number, "hdmiOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2);
+            AddOutputPortWithDebug(number, "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 2);
+        }
+
+        void AddDmcCoPorts(uint number, ICec cecPort1)
+        {
+            AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+            AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
+        }
+
+
+        /// <summary>
+        /// Adds InputPort
+        /// </summary>
+        void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType)
+        {
+            var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
+            Debug.Console(2, this, "Adding input port '{0}'", portKey);
+            var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
+
+            InputPorts.Add(inputPort);
+        }
+
+        /// <summary>
+        /// Adds InputPort and sets Port as ICec object
+        /// </summary>
+        void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, ICec cecPort)
+        {
+            var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
+            Debug.Console(2, this, "Adding input port '{0}'", portKey);
+            var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
+
+            if (cecPort != null)
+                inputPort.Port = cecPort;
+
+            InputPorts.Add(inputPort);
+        }
+
+        /// <summary>
+        /// Adds OutputPort
+        /// </summary>
+        void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
+        {
+            var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
+            Debug.Console(2, this, "Adding output port '{0}'", portKey);
+            OutputPorts.Add(new RoutingOutputPort(portKey, sigType, portType, selector, this));
+        }
+
+        /// <summary>
+        /// Adds OutputPort and sets Port as ICec object
+        /// </summary>
+        void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector, ICec cecPort)
+        {
+            var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
+            Debug.Console(2, this, "Adding output port '{0}'", portKey);
+            var outputPort = new RoutingOutputPort(portKey, sigType, portType, selector, this);
+
+            if (cecPort != null)
+                outputPort.Port = cecPort;
+
+            OutputPorts.Add(outputPort);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void AddVolumeControl(uint number, Audio.Output audio)
+        {
+            VolumeControls.Add(number, new DmCardAudioOutputController(audio));
+        }
+
+        //public void SetInputHdcpSupport(uint input, ePdtHdcpSupport hdcpSetting)
+        //{
+
+        //}
+
+
+		void Chassis_DMSystemChange(Switch device, DMSystemEventArgs args) {
+
+			}
+		void Chassis_DMInputChange(Switch device, DMInputEventArgs args) {
+			//Debug.Console(2, this, "DMSwitch:{0} Input:{1} Event:{2}'", this.Name, args.Number, args.EventId.ToString());
+				
+			switch (args.EventId) {
+				case (DMInputEventIds.OnlineFeedbackEventId): {
+					Debug.Console(2, this, "DMINput OnlineFeedbackEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
+					InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
+					break;
+					}
+				case (DMInputEventIds.VideoDetectedEventId): {
+					Debug.Console(2, this, "DM Input {0} VideoDetectedEventId", args.Number);
+					VideoInputSyncFeedbacks[args.Number].FireUpdate();
+					break;
+					}
+				case (DMInputEventIds.InputNameEventId): {
+					Debug.Console(2, this, "DM Input {0} NameFeedbackEventId", args.Number);
+					InputNameFeedbacks[args.Number].FireUpdate();
+					break;
+					}
+				}
+			}
+        /// 
+        /// </summary>
+        void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
+        {
+
+			//This should be a switch case JTA 2018-07-02
+			var output = args.Number;
+            if (args.EventId == DMOutputEventIds.VolumeEventId &&
+                VolumeControls.ContainsKey(output))
+            {
+                VolumeControls[args.Number].VolumeEventFromChassis();
+            }
+            else if (args.EventId == DMOutputEventIds.OnlineFeedbackEventId)
+            {
+                OutputEndpointOnlineFeedbacks[output].FireUpdate();
+            }
+            else if (args.EventId == DMOutputEventIds.VideoOutEventId)
+            {
+                if (Chassis.Outputs[output].VideoOutFeedback != null)
+                {
+                    Debug.Console(2, this, "DMSwitchVideo:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].VideoOutFeedback.Number, output);
+                }
+                if (VideoOutputFeedbacks.ContainsKey(output))
+                {
+                    VideoOutputFeedbacks[output].FireUpdate();
+
+                }
+                if (OutputVideoRouteNameFeedbacks.ContainsKey(output))
+                {
+                    OutputVideoRouteNameFeedbacks[output].FireUpdate();
+                }
+            }
+            else if (args.EventId == DMOutputEventIds.AudioOutEventId)
+            {
+                if (Chassis.Outputs[output].AudioOutFeedback != null)
+                {
+                    Debug.Console(2, this, "DMSwitchAudio:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].AudioOutFeedback.Number, output);
+                }
+                if (AudioOutputFeedbacks.ContainsKey(output))
+                {
+                    AudioOutputFeedbacks[output].FireUpdate();
+                }
+            }
+            else if (args.EventId == DMOutputEventIds.OutputNameEventId)
+            {
+                Debug.Console(2, this, "DM Output {0} NameFeedbackEventId", output);
+                OutputNameFeedbacks[output].FireUpdate();
+            }
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pnt"></param>
+		void StartOffTimer(PortNumberType pnt)
+		{
+			if (RouteOffTimers.ContainsKey(pnt))
+				return;
+			RouteOffTimers[pnt] = new CTimer(o =>
+			{
+				ExecuteSwitch(0, pnt.Number, pnt.Type);
+			}, RouteOffTime);
+		}
+
+
+		// Send out sigs when coming online
+		void IsOnline_OutputChange(object sender, EventArgs e)
+		{
+			if (IsOnline.BoolValue)
+			{
+                Chassis.EnableAudioBreakaway.BoolValue = true;
+                //Chassis.EnableUSBBreakaway.BoolValue = true;
+
+				if (InputNames != null)
+					foreach (var kvp in InputNames)
+						Chassis.Inputs[kvp.Key].Name.StringValue = kvp.Value;
+				if (OutputNames != null)
+					foreach(var kvp in OutputNames)
+						Chassis.Outputs[kvp.Key].Name.StringValue = kvp.Value;
+			}
+		}
+
+		#region IRouting Members
+
+		public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType sigType)
+		{
+			Debug.Console(2, this, "Making an awesome DM route from {0} to {1} {2}", inputSelector, outputSelector, sigType);
+
+			var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
+			var output = Convert.ToUInt32(outputSelector);
+			// Check to see if there's an off timer waiting on this and if so, cancel
+			var key = new PortNumberType(output, sigType);
+            if (input == 0)
+            {
+                StartOffTimer(key);
+            }
+            else
+			{
+				if(RouteOffTimers.ContainsKey(key))
+				{
+					Debug.Console(2, this, "{0} cancelling route off due to new source", output);
+					RouteOffTimers[key].Stop();
+					RouteOffTimers.Remove(key);
+				}
+			}
+
+			Card.DMICard inCard = input == 0 ? null : Chassis.Inputs[input];
+
+			// NOTE THAT THESE ARE NOTS - TO CATCH THE AudioVideo TYPE
+			if (sigType != eRoutingSignalType.Audio)
+			{
+				Chassis.VideoEnter.BoolValue = true;
+				Chassis.Outputs[output].VideoOut = inCard;
+			}
+
+			if (sigType != eRoutingSignalType.Video)
+			{
+				Chassis.AudioEnter.BoolValue = true;
+				Chassis.Outputs[output].AudioOut = inCard;
+			}
+		}
+
+		#endregion
+
+	}
+
+	public struct PortNumberType
+	{
+		public uint Number { get; private set; }
+		public eRoutingSignalType Type { get; private set; }
+
+		public PortNumberType(uint number, eRoutingSignalType type) : this()
+		{
+			Number = number;
+			Type = type;
+		}
+	}
+}

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

@@ -0,0 +1,125 @@
+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.AudioVideo,
+					eRoutingPortConnectionType.Hdmi, i, this));
+			}
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+			OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+				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;
+			}
+		}
+	}
+}

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

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.DM;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Cards;
+
+namespace PepperDash.Essentials.DM.Config
+{
+	/// <summary>
+	/// Represents the "properties" property of a DM device config
+	/// </summary>
+	public class DMChassisPropertiesConfig
+	{
+		[JsonProperty("control")]
+		public ControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("volumeControls")]
+        public Dictionary<uint, DmCardAudioPropertiesConfig> VolumeControls { get; set; }
+
+        [JsonProperty("inputSlots")]
+        public Dictionary<uint, string> InputSlots { get; set; }
+
+        [JsonProperty("outputSlots")]
+        public Dictionary<uint, string> OutputSlots { get; set; }
+
+		[JsonProperty("inputNames")]
+		public Dictionary<uint, string> InputNames { get; set; }
+
+		[JsonProperty("outputNames")]
+		public Dictionary<uint, string> OutputNames { get; set; }
+	}
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class DmCardAudioPropertiesConfig
+    {
+        [JsonProperty("outLevel")]
+        public int OutLevel { get; set; }
+
+        [JsonProperty("isVolumeControlPoint")]
+        public bool IsVolumeControlPoint { get; set; }
+    }
+}

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

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.CrestronIO;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM.AirMedia;
+using Crestron.SimplSharpPro.UI;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.DM.AirMedia;
+using PepperDash.Essentials.DM.Endpoints.DGEs;
+
+namespace PepperDash.Essentials.DM
+{
+	public class DeviceFactory
+	{
+		public static IKeyed GetDevice(DeviceConfig dc)
+		{
+			var key = dc.Key;
+			var name = dc.Name;
+			var type = dc.Type;
+			var properties = dc.Properties;
+
+			var typeName = dc.Type.ToLower();
+
+            if (typeName.StartsWith("am"))
+            {
+                var props = JsonConvert.DeserializeObject<AirMediaPropertiesConfig>(properties.ToString());
+                AmX00 amDevice = null;
+                if (typeName == "am200")
+                    amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am200(props.Control.IpIdInt, Global.ControlSystem);
+                else if(typeName == "am300")
+                    amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am300(props.Control.IpIdInt, Global.ControlSystem);
+
+                return new AirMediaController(key, name, amDevice, dc, props);
+            }
+			else if (typeName.StartsWith("dmmd8x") || typeName.StartsWith("dmmd16x") || typeName.StartsWith("dmmd32x"))
+			{
+				var props = JsonConvert.DeserializeObject
+					<PepperDash.Essentials.DM.Config.DMChassisPropertiesConfig>(properties.ToString());
+				return PepperDash.Essentials.DM.DmChassisController.
+					GetDmChassisController(key, name, type, props);
+			}
+			// Hand off to DmTxHelper class
+			else if (typeName.StartsWith("dmtx"))
+			{
+				var props = JsonConvert.DeserializeObject
+					<PepperDash.Essentials.DM.Config.DmTxPropertiesConfig>(properties.ToString());
+				return PepperDash.Essentials.DM.DmTxHelper.GetDmTxController(key, name, type, props);
+			}
+
+			// Hand off to DmRmcHelper class
+			else if (typeName.StartsWith("dmrmc"))
+			{
+				var props = JsonConvert.DeserializeObject
+					<PepperDash.Essentials.DM.Config.DmRmcPropertiesConfig>(properties.ToString());
+				return PepperDash.Essentials.DM.DmRmcHelper.GetDmRmcController(key, name, type, props);
+			}
+
+			else if (typeName.Equals("hdmd4x14ke"))
+			{
+				var props = JsonConvert.DeserializeObject
+					<PepperDash.Essentials.DM.Config.HdMdNxM4kEPropertiesConfig>(properties.ToString());
+				return PepperDash.Essentials.DM.Chassis.HdMdNxM4kEController.GetController(key, name, type, props);
+			}
+
+            
+
+			return null;
+		}
+
+
+	}
+
+}

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

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.DM;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using PepperDash.Core;
+using PepperDash.Essentials.DM.Cards;
+
+namespace PepperDash.Essentials.DM.Config
+{
+	/// <summary>
+	/// Represents the "properties" property of a DM TX device config
+	/// </summary>
+	public class DmRmcPropertiesConfig
+	{
+		[JsonProperty("control")]
+		public ControlPropertiesConfig Control { get; set; }
+
+		[JsonProperty("parentDeviceKey")]
+		public string ParentDeviceKey { get; set; }
+
+		[JsonProperty("parentOutputNumber")]
+		public uint ParentOutputNumber { get; set; }
+	}
+}

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

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro.DM;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using PepperDash.Core;
+using PepperDash.Essentials.DM.Cards;
+
+namespace PepperDash.Essentials.DM.Config
+{
+	/// <summary>
+	/// Represents the "properties" property of a DM TX device config
+	/// </summary>
+	public class DmTxPropertiesConfig
+	{
+		[JsonProperty("control")]
+		public ControlPropertiesConfig Control { get; set; }
+
+		[JsonProperty("parentDeviceKey")]
+		public string ParentDeviceKey { get; set; }
+
+		[JsonProperty("parentInputNumber")]
+		public uint ParentInputNumber { get; set; }
+
+		[JsonProperty("autoSwitching")]
+		public bool AutoSwitching { get; set; }
+	}
+}

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

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+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; }
+	}
+}

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

@@ -0,0 +1,15 @@
+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/DmPortName.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Constants for consistent port naming
+	/// </summary>
+	public class DmPortName
+	{
+        public const string AirBoardIn = "AirBoardIn";
+        public const string AirMediaIn = "AirMediaIn";
+		public const string AnyVideoIn = "AnyVideoIn";
+		public const string AudioLoopOut = "AudioLoopOut";
+		public const string BalancedAudioOut = "BalancedAudioOut";
+        public const string BalancedAudioOut1 = "BalancedAudioOut1";
+        public const string BalancedAudioOut2 = "BalancedAudioOut2";
+        public const string CompositeIn = "CompositeIn";
+		public const string DisplayPortIn = "DisplayPortIn";
+		public const string DmIn = "DmIn";
+		public const string DmOut = "DmOut";
+		public const string DmOut1 = "DmOut1";
+		public const string DmOut2 = "DmOut2";
+		public const string HdmiIn = "HdmiIn";
+		public const string HdmiIn1 = "HdmiIn1";
+		public const string HdmiIn2 = "HdmiIn2";
+		public const string HdmiOut1 = "HdmiOut1";
+        public const string HdmiOut2 = "HdmiOut2";
+        public const string HdmiLoopOut = "HdmiLoopOut";
+		public const string HdmiOut = "HdmiOut";
+        public const string Osd = "Osd";
+		public const string VgaIn = "VgaIn";
+	}
+}

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

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.UI;
+
+using Newtonsoft.Json;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.DM.Endpoints.DGEs
+{
+    /// <summary>
+    /// Wrapper class for DGE-100 and DM-DGE-200-C
+    /// </summary>
+    public class DgeController : CrestronGenericBaseDevice, IComPorts, IIROutputPorts
+    {
+        public Dge100 DigitalGraphicsEngine { get; private set; }
+
+        public DeviceConfig DeviceConfig { get; private set; }
+
+        CrestronTouchpanelPropertiesConfig PropertiesConfig;
+
+        public DgeController(string key, string name, Dge100 device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
+            :base(key, name, device)
+        {
+            DeviceConfig = dc;
+
+            PropertiesConfig = props;
+        }
+
+        #region IComPorts Members
+
+        public CrestronCollection<ComPort> ComPorts
+        {
+            get { return DigitalGraphicsEngine.ComPorts; }
+        }
+
+        public int NumberOfComPorts
+        {
+            get { return DigitalGraphicsEngine.NumberOfComPorts; }
+        }
+
+        #endregion
+
+        #region IIROutputPorts Members
+
+        public CrestronCollection<IROutputPort> IROutputPorts
+        {
+            get { return DigitalGraphicsEngine.IROutputPorts; }
+        }
+
+        public int NumberOfIROutputPorts
+        {
+            get { return DigitalGraphicsEngine.NumberOfIROutputPorts; }
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.DM.Endpoints.DGEs
+{
+    public class DgePropertiesConfig
+    {
+        [JsonProperty("control")]
+        public ControlPropertiesConfig Control { get; set; }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/NVX/DmNvx35xController.cs

@@ -0,0 +1,19 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+
+//using Crestron.SimplSharpPro.DM.Streaming;
+
+//using PepperDash.Core;
+//using PepperDash.Essentials.Core;
+
+//namespace PepperDash.Essentials.DM.Endpoints.NVX
+//{
+//    public class DmNvx35xController: DmNvxControllerBase
+//    {
+
+
+//    }
+//}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/NVX/DmNvxConfig.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM.Streaming;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.DM.Endpoints.NVX
+{
+    /// <summary>
+    /// Represents the "properties" property of a DM NVX device config
+    /// </summary>
+    public class DmNvxConfig
+    {
+        [JsonProperty("control")]
+        public ControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("parrentDeviceKey")]
+        public string ParentDeviceKey { get; set; }
+
+        [JsonProperty("deviceMode")]
+        public eDeviceMode DeviceMode { get; set; }
+
+
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/NVX/DmNvxControllerBase.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM.Streaming;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM.Endpoints.NVX
+{
+    public abstract class DmNvxControllerBase: CrestronGenericBaseDevice
+    {
+        public DmNvx35x DmNvx { get; private set; }
+
+        
+
+        public abstract StringFeedback ActiveVideoInputFeedback { get; protected set; }
+        public RoutingInputPortWithVideoStatuses AnyVideoInput { get; protected set; }
+
+
+        public DmNvxControllerBase(string key, string name, DmNvxBaseClass hardware)
+            : base(key, name, hardware)
+        {
+            AddToFeedbackList(ActiveVideoInputFeedback);
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    public class HDBaseTRxController : DmHdBaseTControllerBase, IRoutingInputsOutputs,
+             IComPorts
+    {
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HDBaseTSink { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get { return new RoutingPortCollection<RoutingOutputPort> { HDBaseTSink }; }
+        }
+
+        public HDBaseTRxController(string key, string name, HDRx3CB rmc)
+            : base(key, name, rmc)
+        {
+            Rmc = rmc;
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DmCat, 0, this);
+            HDBaseTSink = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, null, this);
+
+            // Set Ports for CEC
+            HDBaseTSink.Port = Rmc; // Unique case, this class has no HdmiOutput port and ICec is implemented on the receiver class itself
+        }
+
+        #region IComPorts Members
+        public CrestronCollection<ComPort> ComPorts { get { return Rmc.ComPorts; } }
+        public int NumberOfComPorts { get { return Rmc.NumberOfComPorts; } }
+        #endregion
+    }
+}

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

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
+    /// </summary>
+    public class DmRmc100SController : DmRmcControllerBase, IRoutingInputsOutputs,
+        IIROutputPorts, IComPorts, ICec
+    {
+        public DmRmc100S Rmc { get; private set; }
+
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+        }
+
+        /// <summary>
+        ///  Make a Crestron RMC and put it in here
+        /// </summary>
+        public DmRmc100SController(string key, string name, DmRmc100S 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);
+
+            // Set Ports for CEC
+            HdmiOut.Port = Rmc; // Unique case, this class has no HdmiOutput port and ICec is implemented on the receiver class itself
+        }
+
+        public override bool CustomActivate()
+        {
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        #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/DmRmc150SController.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
+    /// </summary>
+    public class DmRmc150SController : DmRmcControllerBase, IRoutingInputsOutputs,
+        IIROutputPorts, IComPorts, ICec
+    {
+        public DmRmc150S Rmc { get; private set; }
+
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+        }
+
+        /// <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);
+
+            //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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+        public override bool CustomActivate()
+        {
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        #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

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmRmc200CController : DmRmcControllerBase, IRoutingInputsOutputs,
+		IIROutputPorts, IComPorts, ICec
+	{
+		public DmRmc200C Rmc { get; private set; }
+
+		public RoutingInputPort DmIn { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+		}
+
+		/// <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;
+
+            // 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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+		public override bool CustomActivate()
+		{
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		#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/DmRmc200S2Controller.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
+    /// </summary>
+    public class DmRmc200S2Controller : DmRmcControllerBase, IRoutingInputsOutputs,
+        IIROutputPorts, IComPorts, ICec
+    {
+        public DmRmc200S2 Rmc { get; private set; }
+
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+        }
+
+        /// <summary>
+        ///  Make a Crestron RMC and put it in here
+        /// </summary>
+        public DmRmc200S2Controller(string key, string name, DmRmc200S2 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;
+
+            // 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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+        public override bool CustomActivate()
+        {
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        #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/DmRmc200SController.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmRmc200SController : DmRmcControllerBase, IRoutingInputsOutputs,
+		IIROutputPorts, IComPorts, ICec
+	{
+		public DmRmc200S Rmc { get; private set; }
+
+		public RoutingInputPort DmIn { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+		}
+
+		/// <summary>
+		///  Make a Crestron RMC and put it in here
+		/// </summary>
+		public DmRmc200SController(string key, string name, DmRmc200S 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;
+
+            // 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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+		public override bool CustomActivate()
+		{
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		#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

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmRmc4kScalerCController : DmRmcControllerBase, IRoutingInputsOutputs, IBasicVolumeWithFeedback,
+		IIROutputPorts, IComPorts, ICec, IRelayPorts
+	{
+		public DmRmc4kScalerC Rmc { get; private set; }
+
+		public RoutingInputPort DmIn { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
+		public RoutingOutputPort BalancedAudioOut { get; private set; }
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut, BalancedAudioOut }; }
+		}
+
+		/// <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);
+
+            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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+		public override bool CustomActivate()
+		{
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		#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()
+		{	
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		public void MuteOn()
+		{
+		}
+
+		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()
+		{
+		}
+
+		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
+	}
+}

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

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+
+namespace PepperDash.Essentials.DM
+{
+    public class DmRmc4k100C1GController : DmHdBaseTControllerBase, IRoutingInputsOutputs,
+        IIROutputPorts, IComPorts, ICec
+    {
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+        }
+
+        public DmRmc4k100C1GController(string key, string name, DmRmc4K100C1G 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);
+
+            // Set Ports for CEC
+            HdmiOut.Port = Rmc; // Unique case, this class has no HdmiOutput port and ICec is implemented on the receiver class itself
+        }
+
+        #region IIROutputPorts Members
+        public CrestronCollection<IROutputPort> IROutputPorts { get { return (Rmc as DmRmc4K100C1G).IROutputPorts; } }
+        public int NumberOfIROutputPorts { get { return (Rmc as DmRmc4K100C1G).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 as DmRmc4K100C1G).StreamCec; } }
+        #endregion
+    }
+}

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

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
+    /// </summary>
+    public class DmRmc4kScalerCDspController : DmRmcControllerBase, IRoutingInputsOutputs, IBasicVolumeWithFeedback,
+        IIROutputPorts, IComPorts, ICec, IRelayPorts
+    {
+        public DmRmc4kScalerCDsp Rmc { get; private set; }
+
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+        public RoutingOutputPort BalancedAudioOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut, BalancedAudioOut }; }
+        }
+
+        /// <summary>
+        ///  Make a Crestron RMC and put it in here
+        /// </summary>
+        public DmRmc4kScalerCDspController(string key, string name, DmRmc4kScalerCDsp 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);
+
+            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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+        public override bool CustomActivate()
+        {
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        #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()
+        {
+        }
+
+        /// <summary>
+        /// Not implemented
+        /// </summary>
+        public void MuteOn()
+        {
+        }
+
+        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()
+        {
+        }
+
+        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
+    }
+}

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

@@ -0,0 +1,250 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	public abstract class DmRmcControllerBase : CrestronGenericBaseDevice
+	{
+        public virtual StringFeedback VideoOutputResolutionFeedback { get; protected set; }
+        public virtual StringFeedback EdidManufacturerFeedback { get; protected set; }
+        public virtual StringFeedback EdidNameFeedback { get; protected set; }
+        public virtual StringFeedback EdidPreferredTimingFeedback { get; protected set; }
+        public virtual StringFeedback EdidSerialNumberFeedback { get; protected set; }
+
+		public DmRmcControllerBase(string key, string name, EndpointReceiverBase device)
+			: base(key, name, device)
+		{
+			// if wired to a chassis, skip registration step in base class
+			if (device.DMOutput != null)
+			{
+				this.PreventRegistration = true;
+			}
+            AddToFeedbackList(VideoOutputResolutionFeedback, EdidManufacturerFeedback, EdidSerialNumberFeedback, EdidNameFeedback, EdidPreferredTimingFeedback);
+        }
+	}
+
+    public abstract class DmHdBaseTControllerBase : CrestronGenericBaseDevice
+    {
+        public HDBaseTBase Rmc { get; protected set; }
+
+        /// <summary>
+        ///  Make a Crestron RMC and put it in here
+        /// </summary>
+        public DmHdBaseTControllerBase(string key, string name, HDBaseTBase rmc)
+            : base(key, name, rmc)
+        {
+
+        }
+    }
+
+	public class DmRmcHelper
+	{
+		/// <summary>
+		/// A factory method for various DmTxControllers
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="props"></param>
+		/// <returns></returns>
+		public static CrestronGenericBaseDevice GetDmRmcController(string key, string name, string typeName, DmRmcPropertiesConfig props)
+		{
+			// switch on type name... later...
+
+			typeName = typeName.ToLower();
+			uint ipid = props.Control.IpIdInt; // Convert.ToUInt16(props.Id, 16);
+
+
+
+            // right here, we need to grab the tie line that associates this
+            // RMC with a chassis or processor.  If the RMC input's tie line is not
+            // connected to a chassis, then it's parent is the processor.
+            // If the RMC is connected to a chassis, then we need to grab the 
+            // output number from the tie line and use that to plug it in.
+            // Example of chassis-connected:
+            //{
+            //  "sourceKey": "dmMd8x8-1",
+            //  "sourcePort": "anyOut2",
+            //  "destinationKey": "dmRmc100C-2",
+            //  "destinationPort": "DmIn"
+            //}
+
+            // Tx -> RMC link:
+            //{
+            //  "sourceKey": "dmTx201C-1",
+            //  "sourcePort": "DmOut",
+            //  "destinationKey": "dmRmc100C-2",
+            //  "destinationPort": "DmIn"
+            //}
+
+            var tlc = TieLineCollection.Default;
+            // grab the tie line that has this key as 
+            // THIS DOESN'T WORK BECAUSE THE RMC THAT WE NEED (THIS) HASN'T BEEN MADE
+            // YET AND THUS WILL NOT HAVE A TIE LINE...
+            var inputTieLine = tlc.FirstOrDefault(t => 
+                {
+                    var d = t.DestinationPort.ParentDevice;
+                    return d.Key.Equals(key, StringComparison.OrdinalIgnoreCase)
+                        && d is DmChassisController;
+                });
+
+			var pKey = props.ParentDeviceKey.ToLower();
+
+            
+
+
+			// Non-DM-chassis endpoints
+			if (pKey == "processor")
+			{
+				// Catch constructor failures, mainly dues to IPID
+				try
+				{
+                    if (typeName.StartsWith("dmrmc100c"))
+						return new DmRmcX100CController(key, name, new DmRmc100C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmc4k100c"))
+                        return new DmRmcX100CController(key, name, new DmRmc4k100C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmc4kz100c"))
+                        return new DmRmcX100CController(key, name, new DmRmc4kz100C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmc150s"))
+                        return new DmRmc150SController(key, name, new DmRmc150S(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmrmc200c"))
+						return new DmRmc200CController(key, name, new DmRmc200C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmc200s"))
+                        return new DmRmc200SController(key, name, new DmRmc200S(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmc200s2"))
+                        return new DmRmc200S2Controller(key, name, new DmRmc200S2(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmrmcscalerc"))
+						return new DmRmcScalerCController(key, name, new DmRmcScalerC(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmcscalers"))
+                        return new DmRmcScalerSController(key, name, new DmRmcScalerS(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmcscalers2"))
+                        return new DmRmcScalerS2Controller(key, name, new DmRmcScalerS2(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmc4kscalerc"))
+						return new DmRmc4kScalerCController(key, name, new DmRmc4kScalerC(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmrmc4kscalercdsp"))
+                        return new DmRmc4kScalerCDspController(key, name, new DmRmc4kScalerCDsp(ipid, Global.ControlSystem));
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-RMC device: {1}", key, e.Message);
+				}
+
+
+				Debug.Console(0, "Cannot create DM-RMC of type: '{0}'", typeName);
+			}
+			// Endpoints attached to DM Chassis
+			else
+			{
+				var parentDev = DeviceManager.GetDeviceForKey(pKey);
+				if (!(parentDev is DmChassisController))
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a DM Chassis.",
+						key, pKey);
+					return null;
+				}
+
+				var chassis = (parentDev as DmChassisController).Chassis;
+				var num = props.ParentOutputNumber;
+				if (num <= 0 || num > chassis.NumberOfOutputs)
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'. Output number '{1}' is out of range",
+						key, num);
+					return null;
+				}
+                else
+                {
+                    var controller = (parentDev as DmChassisController);
+                    controller.RxDictionary.Add(num, key);
+                }
+								// Catch constructor failures, mainly dues to IPID
+				try
+				{
+
+					// Must use different constructor for CPU3 chassis types. No IPID
+					if (chassis is DmMd8x8Cpu3 || chassis is DmMd16x16Cpu3 ||
+						chassis is DmMd32x32Cpu3 || chassis is DmMd8x8Cpu3rps ||
+						chassis is DmMd16x16Cpu3rps || chassis is DmMd32x32Cpu3rps)
+					{
+						if (typeName.StartsWith("hdbasetrx"))
+							return new HDBaseTRxController(key, name, new HDRx3CB(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4k100c1g"))
+							return new DmRmc4k100C1GController(key, name, new DmRmc4K100C1G(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc100c"))
+							return new DmRmcX100CController(key, name, new DmRmc100C(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4k100c"))
+							return new DmRmcX100CController(key, name, new DmRmc4k100C(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4kz100c"))
+							return new DmRmcX100CController(key, name, new DmRmc4kz100C(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc150s"))
+							return new DmRmc150SController(key, name, new DmRmc150S(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc200c"))
+							return new DmRmc200CController(key, name, new DmRmc200C(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc200s"))
+							return new DmRmc200SController(key, name, new DmRmc200S(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc200s2"))
+							return new DmRmc200S2Controller(key, name, new DmRmc200S2(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmcscalerc"))
+							return new DmRmcScalerCController(key, name, new DmRmcScalerC(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmcscalers"))
+							return new DmRmcScalerSController(key, name, new DmRmcScalerS(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmcscalers2"))
+							return new DmRmcScalerS2Controller(key, name, new DmRmcScalerS2(chassis.Outputs[num]));
+                        if (typeName.StartsWith("dmrmc4kscalerc"))
+							return new DmRmc4kScalerCController(key, name, new DmRmc4kScalerC(chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4kscalercdsp"))
+							return new DmRmc4kScalerCDspController(key, name, new DmRmc4kScalerCDsp(chassis.Outputs[num]));
+					}
+					else
+					{
+						if (typeName.StartsWith("hdbasetrx"))
+							return new HDBaseTRxController(key, name, new HDRx3CB(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4k100c1g"))
+							return new DmRmc4k100C1GController(key, name, new DmRmc4K100C1G(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc100c"))
+							return new DmRmcX100CController(key, name, new DmRmc100C(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4k100c"))
+							return new DmRmcX100CController(key, name, new DmRmc4k100C(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4kz100c"))
+							return new DmRmcX100CController(key, name, new DmRmc4kz100C(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc150s"))
+							return new DmRmc150SController(key, name, new DmRmc150S(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc200c"))
+							return new DmRmc200CController(key, name, new DmRmc200C(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc200s"))
+							return new DmRmc200SController(key, name, new DmRmc200S(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc200s2"))
+							return new DmRmc200S2Controller(key, name, new DmRmc200S2(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmcscalerc"))
+							return new DmRmcScalerCController(key, name, new DmRmcScalerC(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmcscalers"))
+							return new DmRmcScalerSController(key, name, new DmRmcScalerS(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmcscalers2"))
+							return new DmRmcScalerS2Controller(key, name, new DmRmcScalerS2(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4kscalerc"))
+							return new DmRmc4kScalerCController(key, name, new DmRmc4kScalerC(ipid, chassis.Outputs[num]));
+						if (typeName.StartsWith("dmrmc4kscalercdsp"))
+							return new DmRmc4kScalerCDspController(key, name, new DmRmc4kScalerCDsp(ipid, chassis.Outputs[num]));
+					}
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-RMC device: {1}", key, e.Message);
+				}
+			}
+
+			return null;
+		}
+	}
+
+}

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

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmRmcScalerCController : DmRmcControllerBase, IRoutingInputsOutputs, 
+		IIROutputPorts, IComPorts, ICec
+	{
+		public DmRmcScalerC Rmc { get; private set; }
+
+		public RoutingInputPort DmIn { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+		}
+
+		/// <summary>
+		///  Make a Crestron RMC and put it in here
+		/// </summary>
+		public DmRmcScalerCController(string key, string name, DmRmcScalerC 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;
+
+            // 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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+		public override bool CustomActivate()
+		{
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		#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
+	}
+}

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

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
+    /// </summary>
+    public class DmRmcScalerS2Controller : DmRmcControllerBase, IRoutingInputsOutputs,
+        IIROutputPorts, IComPorts, ICec
+    {
+        public DmRmcScalerS2 Rmc { get; private set; }
+
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+        }
+
+        /// <summary>
+        ///  Make a Crestron RMC and put it in here
+        /// </summary>
+        public DmRmcScalerS2Controller(string key, string name, DmRmcScalerS2 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;
+
+            // 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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+        public override bool CustomActivate()
+        {
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        #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
+    }
+}

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

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
+    /// </summary>
+    public class DmRmcScalerSController : DmRmcControllerBase, IRoutingInputsOutputs,
+        IIROutputPorts, IComPorts, ICec
+    {
+        public DmRmcScalerS Rmc { get; private set; }
+
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+        }
+
+        /// <summary>
+        ///  Make a Crestron RMC and put it in here
+        /// </summary>
+        public DmRmcScalerSController(string key, string name, DmRmcScalerS 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;
+
+            // 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)
+        {
+            if (args.EventId == ConnectedDeviceEventIds.ManufacturerEventId)
+            {
+                EdidManufacturerFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.NameEventId)
+            {
+                EdidNameFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.PreferredTimingEventId)
+            {
+                EdidPreferredTimingFeedback.FireUpdate();
+            }
+            else if (args.EventId == ConnectedDeviceEventIds.SerialNumberEventId)
+            {
+                EdidSerialNumberFeedback.FireUpdate();
+            }
+        }
+
+        public override bool CustomActivate()
+        {
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        #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
+    }
+}

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

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// Builds a controller for basic DM-RMCs (both 4K and non-4K) with Com and IR ports and no control functions
+	/// 
+	/// </summary>
+	public class DmRmcX100CController : DmRmcControllerBase, IRoutingInputsOutputs, 
+		IIROutputPorts, IComPorts, ICec
+	{
+		public DmRmc100C Rmc { get; private set; }
+
+		public RoutingInputPort DmIn { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { DmIn }; }
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get { return new RoutingPortCollection<RoutingOutputPort> { HdmiOut }; }
+		}
+
+		/// <summary>
+		///  Make a Crestron RMC and put it in here
+		/// </summary>
+		public DmRmcX100CController(string key, string name, DmRmc100C 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);
+
+            // Set Ports for CEC
+            HdmiOut.Port = Rmc; // Unique case, this class has no HdmiOutput port and ICec is implemented on the receiver class itself
+		}
+
+		public override bool CustomActivate()
+		{
+			// Base does register and sets up comm monitoring.
+			return base.CustomActivate();
+		}
+
+		#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.StreamCec; } }
+		#endregion
+	}
+}

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

@@ -0,0 +1,308 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+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.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+    // using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+
+    /// <summary>
+    /// Controller class for all DM-TX-201C/S/F transmitters
+    /// </summary>
+    public class DmTx200Controller : DmTxControllerBase, ITxRouting, IHasFeedback
+    {
+        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; }
+
+        //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 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 };
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="tx"></param>
+        public DmTx200Controller(string key, string name, DmTx200C2G tx)
+            : base(key, name, tx)
+        {
+            Tx = tx;
+
+            HdmiInput = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, DmTx200Base.eSourceSelection.Digital, this,
+                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInput));
+            VgaInput = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, DmTx200Base.eSourceSelection.Analog, this,
+                VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+
+            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+                () => ActualActiveVideoInput.ToString());
+
+            Tx.HdmiInput.InputStreamChange += new EndpointInputStreamChangeEventHandler(InputStreamChangeEvent);
+            Tx.BaseEvent += Tx_BaseEvent;
+            Tx.OnlineStatusChange += new OnlineStatusChangeEventHandler(Tx_OnlineStatusChange);
+
+            VideoSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.VideoSourceFeedback;
+            });
+            AudioSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.AudioSourceFeedback;
+            });
+
+            HdmiInHdcpCapabilityFeedback = new IntFeedback("HdmiInHdcpCapability", () =>
+            {
+                if (tx.HdmiInput.HdpcSupportOnFeedback.BoolValue)
+                    return 1;
+                else
+                    return 0;
+            });
+
+            HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
+
+            var combinedFuncs = new VideoStatusFuncsWrapper
+            {
+                HdcpActiveFeedbackFunc = () =>
+                    (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
+                    && tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
+
+                HdcpStateFeedbackFunc = () =>
+                {
+                    if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital)
+                        return tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString();
+                    return "";
+                },
+
+                VideoResolutionFeedbackFunc = () =>
+                {
+                    if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital)
+                        return tx.HdmiInput.VideoAttributes.GetVideoResolutionString();
+                    if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog)
+                        return tx.VgaInput.VideoAttributes.GetVideoResolutionString();
+                    return "";
+                },
+                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.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+            DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, null, this);
+
+            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
+                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
+                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
+                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiInHdcpCapabilityFeedback);
+
+            // Set Ports for CEC
+            HdmiInput.Port = Tx.HdmiInput;
+            VgaInput.Port = Tx.VgaInput;
+            DmOutput.Port = Tx.DmOutput;
+        }
+
+        void Tx_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
+        {
+            ActiveVideoInputFeedback.FireUpdate();
+            VideoSourceNumericFeedback.FireUpdate();
+            AudioSourceNumericFeedback.FireUpdate();
+
+        }
+
+        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 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);
+
+            if (id == EndpointTransmitterBase.VideoSourceFeedbackEventId)
+            {
+                Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+                VideoSourceNumericFeedback.FireUpdate();
+                ActiveVideoInputFeedback.FireUpdate();
+            }
+
+            // ------------------------------ incomplete -----------------------------------------
+            else if (id == EndpointTransmitterBase.AudioSourceFeedbackEventId)
+            {
+                Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+                AudioSourceNumericFeedback.FireUpdate();
+            }
+        }
+
+        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
+        {
+            Debug.Console(2, "{0} event {1} stream {2}", this.Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
+
+            if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId)
+            {
+                HdmiInHdcpCapabilityFeedback.FireUpdate();
+            }
+            else if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId)
+            {
+                HdmiInHdcpCapabilityFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// Relays the input stream change to the appropriate RoutingInputPort.
+        /// </summary>
+        void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
+            if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+            {
+                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

@@ -0,0 +1,312 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+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.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	// using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+
+    /// <summary>
+    /// Controller class for all DM-TX-201C/S/F transmitters
+    /// </summary>
+	public class DmTx201XController : DmTxControllerBase, ITxRouting, IHasFeedback
+	{
+		public DmTx201S Tx { get; private set; } // uses the 201S class as it is the base class for the 201C
+
+		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 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 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 DmTx201XController(string key, string name, DmTx201S tx)
+			: base(key, name, tx)
+		{
+			Tx = tx;
+
+			HdmiInput = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, DmTx200Base.eSourceSelection.Digital, this,
+				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInput));
+			VgaInput = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+				eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, DmTx200Base.eSourceSelection.Analog, this,
+				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+
+			ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+				() => ActualActiveVideoInput.ToString());
+
+            Tx.HdmiInput.InputStreamChange += new EndpointInputStreamChangeEventHandler(InputStreamChangeEvent);
+            Tx.BaseEvent += Tx_BaseEvent;
+            Tx.OnlineStatusChange += new OnlineStatusChangeEventHandler(Tx_OnlineStatusChange);
+
+            VideoSourceNumericFeedback = new IntFeedback(() => 
+                {
+                    return (int)Tx.VideoSourceFeedback;
+                });
+            AudioSourceNumericFeedback = new IntFeedback(() =>
+                {
+                    return (int)Tx.AudioSourceFeedback;
+                });
+
+            HdmiInHdcpCapabilityFeedback = new IntFeedback("HdmiInHdcpCapability", () =>
+                {
+                    if (tx.HdmiInput.HdpcSupportOnFeedback.BoolValue)
+                        return 1;
+                    else
+                        return 0;
+                });
+
+            HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
+
+			var combinedFuncs = new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () =>
+					(ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital
+					&& tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
+
+				HdcpStateFeedbackFunc = () =>
+				{
+					if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital)
+						return tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString();
+					return "";
+				},
+
+				VideoResolutionFeedbackFunc = () =>
+				{
+					if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Digital)
+						return tx.HdmiInput.VideoAttributes.GetVideoResolutionString();
+					if (ActualActiveVideoInput == DmTx200Base.eSourceSelection.Analog)
+						return tx.VgaInput.VideoAttributes.GetVideoResolutionString();
+					return "";
+				},
+				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.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+			DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, null, this);
+			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, null, this);
+
+            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
+                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
+                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
+                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiInHdcpCapabilityFeedback);
+
+            // Set Ports for CEC
+            HdmiInput.Port = Tx.HdmiInput;
+            VgaInput.Port = Tx.VgaInput;
+            HdmiLoopOut.Port = Tx.HdmiOutput;
+            DmOutput.Port = Tx.DmOutput;
+		}
+
+        void Tx_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
+        {
+            ActiveVideoInputFeedback.FireUpdate();
+            VideoSourceNumericFeedback.FireUpdate();
+            AudioSourceNumericFeedback.FireUpdate();
+            
+        }
+
+		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 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);
+
+            if (id == EndpointTransmitterBase.VideoSourceFeedbackEventId)
+			{
+                Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+                VideoSourceNumericFeedback.FireUpdate();
+                ActiveVideoInputFeedback.FireUpdate();
+			}
+
+			// ------------------------------ incomplete -----------------------------------------
+            else if (id == EndpointTransmitterBase.AudioSourceFeedbackEventId)
+			{
+				Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+                AudioSourceNumericFeedback.FireUpdate();
+			}
+		}
+
+        void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
+        {
+            Debug.Console(2, "{0} event {1} stream {2}", this.Tx.ToString(), inputStream.ToString(), args.EventId.ToString());
+
+            if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId)
+            {
+                HdmiInHdcpCapabilityFeedback.FireUpdate();
+            }
+            else if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId)
+            {
+                HdmiInHdcpCapabilityFeedback.FireUpdate();
+            }
+        }
+
+		/// <summary>
+		/// Relays the input stream change to the appropriate RoutingInputPort.
+		/// </summary>
+		void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+			{
+				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/DmTx401CController.cs

@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	using eVst = DmTx401C.eSourceSelection;
+
+    public class DmTx401CController : DmTxControllerBase, ITxRouting, IHasFeedback, IIROutputPorts, IComPorts
+	{
+		public DmTx401C Tx { get; private set; }
+
+		public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
+		public RoutingInputPortWithVideoStatuses DisplayPortIn { get; private set; }
+		public RoutingInputPortWithVideoStatuses VgaIn { get; private set; }
+		public RoutingInputPortWithVideoStatuses CompositeIn { get; private set; }
+		public RoutingOutputPort DmOut { 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; }
+
+		/// <summary>
+		/// Helps get the "real" inputs, including when in Auto
+		/// </summary>
+		public BaseDmTx401.eSourceSelection ActualVideoInput
+		{
+			get
+			{
+				if (Tx.VideoSourceFeedback != BaseDmTx401.eSourceSelection.Auto)
+					return Tx.VideoSourceFeedback;
+				else // auto
+				{
+					if (Tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+						return BaseDmTx401.eSourceSelection.HDMI;
+					else if (Tx.VgaInput.SyncDetectedFeedback.BoolValue)
+						return BaseDmTx401.eSourceSelection.VGA;
+					else if (Tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
+						return BaseDmTx401.eSourceSelection.DisplayPort;
+					else if (Tx.CvbsInput.SyncDetectedFeedback.BoolValue)
+						return BaseDmTx401.eSourceSelection.Composite;
+					else
+						return BaseDmTx401.eSourceSelection.Disabled;
+				}
+			}
+		}
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiIn,
+					DisplayPortIn,
+					VgaIn, 
+					CompositeIn,
+					AnyVideoInput 
+				};
+			}
+		}
+
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts
+		{
+			get
+			{
+				return new RoutingPortCollection<RoutingOutputPort> { DmOut };
+			}
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="tx"></param>
+		public DmTx401CController(string key, string name, DmTx401C tx)
+			: base(key, name, tx)
+		{
+			Tx = tx;
+
+			HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.HDMI, this,
+				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInput));
+			DisplayPortIn = new RoutingInputPortWithVideoStatuses(DmPortName.DisplayPortIn,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.DisplayPort, this,
+				VideoStatusHelper.GetDisplayPortInputStatusFuncs(tx.DisplayPortInput));
+			VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, eVst.VGA, this, 
+				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+			CompositeIn = new RoutingInputPortWithVideoStatuses(DmPortName.CompositeIn,
+                eRoutingSignalType.Video, eRoutingPortConnectionType.Composite, eVst.Composite, this,
+				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+
+            Tx.BaseEvent += Tx_BaseEvent;
+
+			ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+				() => ActualVideoInput.ToString());
+
+            VideoSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.VideoSourceFeedback;
+            });
+            AudioSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.AudioSourceFeedback;
+            });
+
+            HdmiInHdcpCapabilityFeedback = new IntFeedback("HdmiInHdcpCapability", () =>
+            {
+                if (tx.HdmiInput.HdpcSupportOnFeedback.BoolValue)
+                    return 1;
+                else
+                    return 0;
+            });
+
+            HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
+
+			var combinedFuncs = new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () =>
+					(ActualVideoInput == eVst.HDMI
+					&& tx.HdmiInput.VideoAttributes.HdcpActiveFeedback.BoolValue)
+					|| (ActualVideoInput == eVst.DisplayPort
+					&& tx.DisplayPortInput.VideoAttributes.HdcpActiveFeedback.BoolValue),
+
+				HdcpStateFeedbackFunc = () =>
+				{
+					if (ActualVideoInput == eVst.HDMI)
+						return tx.HdmiInput.VideoAttributes.HdcpStateFeedback.ToString();
+					if (ActualVideoInput == eVst.DisplayPort)
+						return tx.DisplayPortInput.VideoAttributes.HdcpStateFeedback.ToString();
+					return "";
+				},
+
+				VideoResolutionFeedbackFunc = () =>
+				{
+					if (ActualVideoInput == eVst.HDMI)
+						return tx.HdmiInput.VideoAttributes.GetVideoResolutionString();
+					if (ActualVideoInput == eVst.DisplayPort)
+						return tx.DisplayPortInput.VideoAttributes.GetVideoResolutionString();
+					if (ActualVideoInput == eVst.VGA)
+						return tx.VgaInput.VideoAttributes.GetVideoResolutionString();
+					if (ActualVideoInput == eVst.Composite)
+						return tx.CvbsInput.VideoAttributes.GetVideoResolutionString();
+					return "";
+				},
+				VideoSyncFeedbackFunc = () =>
+					(ActualVideoInput == eVst.HDMI
+					&& tx.HdmiInput.SyncDetectedFeedback.BoolValue)
+					|| (ActualVideoInput == eVst.DisplayPort
+					&& tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
+					|| (ActualVideoInput == eVst.VGA
+					&& tx.VgaInput.SyncDetectedFeedback.BoolValue)
+					|| (ActualVideoInput == eVst.Composite
+					&& tx.CvbsInput.SyncDetectedFeedback.BoolValue)
+			};
+
+			AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+				eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+			DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.DmCat, null, this);
+
+            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
+                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
+                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
+                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiInHdcpCapabilityFeedback);
+
+            // Set Ports for CEC
+            DisplayPortIn.Port = Tx.DisplayPortInput;
+            HdmiIn.Port = Tx.HdmiInput;
+            DmOut.Port = Tx.DmOutput;
+		}
+
+		public override bool CustomActivate()
+		{
+			// Link up all of these damned events to the various RoutingPorts via a helper handler
+			Tx.HdmiInput.InputStreamChange += (o, a) => FowardInputStreamChange(HdmiIn, a.EventId);
+			Tx.HdmiInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(HdmiIn, a.EventId);
+
+			Tx.DisplayPortInput.InputStreamChange += (o, a) => FowardInputStreamChange(DisplayPortIn, a.EventId);
+			Tx.DisplayPortInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(DisplayPortIn, 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 void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
+        {
+            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
+
+            switch (input)
+            {
+                case 0:
+                    {
+                        ExecuteSwitch(eVst.Auto, null, type);
+                        break;
+                    }
+                case 1:
+                    {
+                        ExecuteSwitch(DisplayPortIn.Selector, null, type);
+                        break;
+                    }
+                case 2:
+                    {
+                        ExecuteSwitch(HdmiIn.Selector, null, type);
+                        break;
+                    }
+                case 3:
+                    {
+                        ExecuteSwitch(VgaIn.Selector, null, type);
+                        break;
+                    }
+                case 4:
+                    {
+                        ExecuteSwitch(CompositeIn.Selector, null, type);
+                        break;
+                    }
+                case 5:
+                    {
+                        ExecuteSwitch(eVst.Disabled, null, type);
+                        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 = (eVst)inputSelector;
+        }
+
+		void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+		{
+			var id = args.EventId;
+			if (id == EndpointTransmitterBase.VideoSourceFeedbackEventId)
+			{
+				Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+                VideoSourceNumericFeedback.FireUpdate();
+                ActiveVideoInputFeedback.FireUpdate();
+            }
+
+			// ------------------------------ incomplete -----------------------------------------
+			else if (id == EndpointTransmitterBase.AudioSourceFeedbackEventId)
+			{
+				Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+                AudioSourceNumericFeedback.FireUpdate();
+            }
+		}
+
+		/// <summary>
+		/// Relays the input stream change to the appropriate RoutingInputPort.
+		/// </summary>
+		void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+			{
+				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/DmTx4k100Controller.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+    using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+    using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
+
+    public class DmTx4k100Controller : BasicDmTxControllerBase, IRoutingInputsOutputs, IHasFeedback,
+        IIROutputPorts, IComPorts, ICec
+    {
+        public DmTx4K100C1G Tx { get; private set; }
+
+        public RoutingInputPort HdmiIn { get; private set; }
+        public RoutingOutputPort DmOut { get; private 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 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
+                {
+                    return eVst.Hdmi1;
+                }
+        }
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiIn				 
+				};
+            }
+        }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingOutputPort> { DmOut };
+            }
+        }
+        public DmTx4k100Controller(string key, string name, DmTx4K100C1G tx)
+            : base(key, name, tx)
+        {
+            Tx = tx;
+
+            HdmiIn = new RoutingInputPort(DmPortName.HdmiIn1,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this);
+
+            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DmCat, null, this);
+
+            // Set Ports for CEC
+            HdmiIn.Port = Tx;
+        }
+
+
+
+        public override bool CustomActivate()
+        {
+            // Link up all of these damned events to the various RoutingPorts via a helper handler
+
+
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+
+        #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
+
+        #region ICec Members
+        public Cec StreamCec { get { return Tx.StreamCec; } }
+        #endregion
+    }
+}

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

@@ -0,0 +1,348 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+    using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+    using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
+
+    public class DmTx4k202CController : DmTxControllerBase, ITxRouting, IHasFeedback,
+        IIROutputPorts, IComPorts
+    {
+        public DmTx4kX02CBase 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 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 DmTx4k202CController(string key, string name, DmTx4kX02CBase tx)
+            : base(key, name, tx)
+        {
+            Tx = tx;
+
+            HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
+                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]));
+            HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
+                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]));
+            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+                () => ActualActiveVideoInput.ToString());
+
+
+
+            Tx.HdmiInputs[1].InputStreamChange += InputStreamChangeEvent;
+            Tx.HdmiInputs[2].InputStreamChange += InputStreamChangeEvent;
+            Tx.BaseEvent += Tx_BaseEvent;
+
+            VideoSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.VideoSourceFeedback;
+            });
+            AudioSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.AudioSourceFeedback;
+            });
+
+            HdmiIn1HdcpCapabilityFeedback = new IntFeedback("HdmiIn1HdcpCapability", () =>
+            {
+                return (int)tx.HdmiInputs[1].HdcpCapabilityFeedback;
+            });
+
+            HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability", () =>
+            {
+                return (int)tx.HdmiInputs[2].HdcpCapabilityFeedback;
+            });
+
+            HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
+
+            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();
+                    if (ActualActiveVideoInput == eVst.Hdmi2)
+                        return tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString();
+                    return "";
+                },
+
+                VideoResolutionFeedbackFunc = () =>
+                {
+                    if (ActualActiveVideoInput == eVst.Hdmi1)
+                        return tx.HdmiInputs[1].VideoAttributes.GetVideoResolutionString();
+                    if (ActualActiveVideoInput == eVst.Hdmi2)
+                        return tx.HdmiInputs[2].VideoAttributes.GetVideoResolutionString();
+                    return "";
+                },
+                VideoSyncFeedbackFunc = () =>
+                    (ActualActiveVideoInput == eVst.Hdmi1
+                    && tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.Hdmi2
+                    && tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+
+            };
+
+            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DmCat, null, this);
+            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+                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);
+
+            // Set Ports for CEC
+            HdmiIn1.Port = Tx.HdmiInputs[1];
+            HdmiIn2.Port = Tx.HdmiInputs[2];
+            HdmiLoopOut.Port = Tx.HdmiOutput;
+            DmOut.Port = Tx.DmOutput;
+        }
+
+
+
+        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 void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
+        {
+            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
+
+            if (type == 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;
+                        }
+                }
+            }
+            else if (type == 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;
+                        }
+                }
+            }
+        }
+
+        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());
+
+            if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId)
+            {
+                if (inputStream == Tx.HdmiInputs[1])
+                    HdmiIn1HdcpCapabilityFeedback.FireUpdate();
+                else if (inputStream == Tx.HdmiInputs[2])
+                    HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+            }
+            else if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId)
+            {
+                if (inputStream == Tx.HdmiInputs[1])
+                    HdmiIn1HdcpCapabilityFeedback.FireUpdate();
+                else if (inputStream == Tx.HdmiInputs[2])
+                    HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+            }
+        }
+
+        void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+        {
+            var id = args.EventId;
+            if (id == EndpointTransmitterBase.VideoSourceFeedbackEventId)
+            {
+                Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+                VideoSourceNumericFeedback.FireUpdate();
+                ActiveVideoInputFeedback.FireUpdate();
+            }
+
+            // ------------------------------ incomplete -----------------------------------------
+            else if (id == EndpointTransmitterBase.AudioSourceFeedbackEventId)
+            {
+                Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+                AudioSourceNumericFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// Relays the input stream change to the appropriate RoutingInputPort.
+        /// </summary>
+        void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
+            if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+            {
+                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

@@ -0,0 +1,369 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+    using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
+
+    public class DmTx4k302CController : DmTxControllerBase, ITxRouting, IHasFeedback, 
+		IIROutputPorts, IComPorts
+	{
+		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 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 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)
+			: base(key, name, tx)
+		{
+			Tx = tx;
+
+			HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
+				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]));
+			HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
+				VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]));
+			VgaIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+                eRoutingSignalType.Video, eRoutingPortConnectionType.Vga, eVst.Vga, this, 
+				VideoStatusHelper.GetVgaInputStatusFuncs(tx.VgaInput));
+			ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+				() => ActualActiveVideoInput.ToString());
+
+			Tx.HdmiInputs[1].InputStreamChange += InputStreamChangeEvent;
+            Tx.HdmiInputs[2].InputStreamChange += InputStreamChangeEvent;
+            Tx.BaseEvent += Tx_BaseEvent;
+
+            VideoSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.VideoSourceFeedback;
+            });
+            AudioSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.AudioSourceFeedback;
+            });
+
+            HdmiIn1HdcpCapabilityFeedback = new IntFeedback("HdmiIn1HdcpCapability", () =>
+            {
+                return (int)tx.HdmiInputs[1].HdcpCapabilityFeedback;
+            });
+
+            HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability", () =>
+            {
+                return (int)tx.HdmiInputs[2].HdcpCapabilityFeedback;
+            });
+
+            HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
+
+
+			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();
+						if (ActualActiveVideoInput == eVst.Hdmi2)
+							return tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString();
+						return "";
+					},
+
+				VideoResolutionFeedbackFunc = () =>
+					{
+						if (ActualActiveVideoInput == eVst.Hdmi1)
+							return tx.HdmiInputs[1].VideoAttributes.GetVideoResolutionString();
+						if (ActualActiveVideoInput == eVst.Hdmi2)
+							return tx.HdmiInputs[2].VideoAttributes.GetVideoResolutionString();
+						if (ActualActiveVideoInput == eVst.Vga)
+							return tx.VgaInput.VideoAttributes.GetVideoResolutionString();
+						return "";
+					},
+				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.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+			DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.DmCat, null, this);
+			HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+				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);
+
+            // Set Ports for CEC
+            HdmiIn1.Port = Tx.HdmiInputs[1];
+            HdmiIn2.Port = Tx.HdmiInputs[2];
+            HdmiLoopOut.Port = Tx.HdmiOutput;
+            DmOut.Port = Tx.DmOutput;
+		}
+
+
+
+		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 void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
+        {
+            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
+
+            if (type == 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;
+                        }
+                }
+            }
+            else if (type == 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;
+                        }
+                }
+            }
+        }
+
+        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());
+
+            if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId)
+            {
+                if (inputStream == Tx.HdmiInputs[1])
+                    HdmiIn1HdcpCapabilityFeedback.FireUpdate();
+                else if (inputStream == Tx.HdmiInputs[2])
+                    HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+            }
+            else if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId)
+            {
+                if (inputStream == Tx.HdmiInputs[1])
+                    HdmiIn1HdcpCapabilityFeedback.FireUpdate();
+                else if (inputStream == Tx.HdmiInputs[2])
+                    HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+            }
+        }
+
+		void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+		{
+			var id = args.EventId;
+            if (id == EndpointTransmitterBase.VideoSourceFeedbackEventId)
+            {
+                Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+                VideoSourceNumericFeedback.FireUpdate();
+                ActiveVideoInputFeedback.FireUpdate();
+            }
+
+			// ------------------------------ incomplete -----------------------------------------
+            else if (id == EndpointTransmitterBase.AudioSourceFeedbackEventId)
+            {
+                Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+                AudioSourceNumericFeedback.FireUpdate();
+            }
+		}
+
+		/// <summary>
+		/// Relays the input stream change to the appropriate RoutingInputPort.
+		/// </summary>
+		void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+		{
+			if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+			{
+				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/DmTx4kz302CController.cs

@@ -0,0 +1,340 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+    using eVst = Crestron.SimplSharpPro.DeviceSupport.eX02VideoSourceType;
+    using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
+
+    public class DmTx4kz302CController : DmTxControllerBase, ITxRouting, IHasFeedback,
+        IIROutputPorts, IComPorts
+    {
+        public DmTx4kz302C Tx { get; private set; }
+
+        public RoutingInputPortWithVideoStatuses HdmiIn1 { get; private set; }
+        public RoutingInputPortWithVideoStatuses HdmiIn2 { get; private set; }
+        public RoutingInputPortWithVideoStatuses DisplayPortIn { 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 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 if (Tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
+                        return eVst.Vga;
+                    else
+                        return eVst.AllDisabled;
+                }
+            }
+        }
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingInputPort> 
+				{ 
+					HdmiIn1,
+					HdmiIn2,
+					DisplayPortIn, 
+					AnyVideoInput 
+				};
+            }
+        }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get
+            {
+                return new RoutingPortCollection<RoutingOutputPort> { DmOut, HdmiLoopOut };
+            }
+        }
+        public DmTx4kz302CController(string key, string name, DmTx4kz302C tx)
+            : base(key, name, tx)
+        {
+            Tx = tx;
+
+            HdmiIn1 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn1,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi1, this,
+                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[1]));
+            HdmiIn2 = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn2,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, eVst.Hdmi2, this,
+                VideoStatusHelper.GetHdmiInputStatusFuncs(tx.HdmiInputs[2]));
+            DisplayPortIn = new RoutingInputPortWithVideoStatuses(DmPortName.VgaIn,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DisplayPort, eVst.DisplayPort, this,
+                VideoStatusHelper.GetDisplayPortInputStatusFuncs(tx.DisplayPortInput));
+            ActiveVideoInputFeedback = new StringFeedback("ActiveVideoInput",
+                () => ActualActiveVideoInput.ToString());
+
+            Tx.HdmiInputs[1].InputStreamChange += InputStreamChangeEvent;
+            Tx.HdmiInputs[2].InputStreamChange += InputStreamChangeEvent;
+            Tx.BaseEvent += Tx_BaseEvent;
+
+            VideoSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.VideoSourceFeedback;
+            });
+            AudioSourceNumericFeedback = new IntFeedback(() =>
+            {
+                return (int)Tx.AudioSourceFeedback;
+            });
+
+            HdmiIn1HdcpCapabilityFeedback = new IntFeedback("HdmiIn1HdcpCapability", () =>
+            {
+                return (int)tx.HdmiInputs[1].HdcpCapabilityFeedback;
+            });
+
+            HdmiIn2HdcpCapabilityFeedback = new IntFeedback("HdmiIn2HdcpCapability", () =>
+            {
+                return (int)tx.HdmiInputs[2].HdcpCapabilityFeedback;
+            });
+
+            HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
+
+
+            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();
+                    if (ActualActiveVideoInput == eVst.Hdmi2)
+                        return tx.HdmiInputs[2].VideoAttributes.HdcpStateFeedback.ToString();
+                    return "";
+                },
+
+                VideoResolutionFeedbackFunc = () =>
+                {
+                    if (ActualActiveVideoInput == eVst.Hdmi1)
+                        return tx.HdmiInputs[1].VideoAttributes.GetVideoResolutionString();
+                    if (ActualActiveVideoInput == eVst.Hdmi2)
+                        return tx.HdmiInputs[2].VideoAttributes.GetVideoResolutionString();
+                    if (ActualActiveVideoInput == eVst.Vga)
+                        return tx.DisplayPortInput.VideoAttributes.GetVideoResolutionString();
+                    return "";
+                },
+                VideoSyncFeedbackFunc = () =>
+                    (ActualActiveVideoInput == eVst.Hdmi1
+                    && tx.HdmiInputs[1].SyncDetectedFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.Hdmi2
+                    && tx.HdmiInputs[2].SyncDetectedFeedback.BoolValue)
+                    || (ActualActiveVideoInput == eVst.Vga
+                    && tx.DisplayPortInput.SyncDetectedFeedback.BoolValue)
+
+            };
+
+            AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
+                eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+            DmOut = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DmCat, null, this);
+            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.AudioVideo,
+                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);
+
+            // Set Ports for CEC
+            HdmiIn1.Port = Tx.HdmiInputs[1];
+            HdmiIn2.Port = Tx.HdmiInputs[2];
+            HdmiLoopOut.Port = Tx.HdmiOutput;
+            DmOut.Port = Tx.DmOutput;
+        }
+
+
+
+        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.DisplayPortInput.InputStreamChange += (o, a) => FowardInputStreamChange(DisplayPortIn, a.EventId);
+            Tx.DisplayPortInput.VideoAttributes.AttributeChange += (o, a) => ForwardVideoAttributeChange(DisplayPortIn, a.EventId);
+
+            // Base does register and sets up comm monitoring.
+            return base.CustomActivate();
+        }
+
+        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(eVst.Auto, null, eRoutingSignalType.AudioVideo);
+                            break;
+                        }
+                    case 1:
+                        {
+                            ExecuteSwitch(HdmiIn1.Selector, null, eRoutingSignalType.AudioVideo);
+                            break;
+                        }
+                    case 2:
+                        {
+                            ExecuteSwitch(HdmiIn2.Selector, null, eRoutingSignalType.AudioVideo);
+                            break;
+                        }
+                    case 3:
+                        {
+                            ExecuteSwitch(DisplayPortIn.Selector, null, eRoutingSignalType.AudioVideo);
+                            break;
+                        }
+                    case 4:
+                        {
+                            ExecuteSwitch(eVst.AllDisabled, null, eRoutingSignalType.AudioVideo);
+                            break;
+                        }
+                }
+            
+
+        }
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            if ((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
+                Tx.VideoSource = (eVst)inputSelector;
+
+            // NOTE:  It's possible that this particular TX model may not like the AudioSource property being set.  
+            // The SIMPL definition only shows a single analog for AudioVideo Source
+            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());
+
+            if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOffFeedbackEventId)
+            {
+                if (inputStream == Tx.HdmiInputs[1])
+                    HdmiIn1HdcpCapabilityFeedback.FireUpdate();
+                else if (inputStream == Tx.HdmiInputs[2])
+                    HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+            }
+            else if (args.EventId == EndpointInputStreamEventIds.HdcpSupportOnFeedbackEventId)
+            {
+                if (inputStream == Tx.HdmiInputs[1])
+                    HdmiIn1HdcpCapabilityFeedback.FireUpdate();
+                else if (inputStream == Tx.HdmiInputs[2])
+                    HdmiIn2HdcpCapabilityFeedback.FireUpdate();
+            }
+        }
+
+        void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+        {
+            var id = args.EventId;
+            if (id == EndpointTransmitterBase.VideoSourceFeedbackEventId)
+            {
+                Debug.Console(2, this, "  Video Source: {0}", Tx.VideoSourceFeedback);
+                VideoSourceNumericFeedback.FireUpdate();
+                ActiveVideoInputFeedback.FireUpdate();
+            }
+
+            // ------------------------------ incomplete -----------------------------------------
+            else if (id == EndpointTransmitterBase.AudioSourceFeedbackEventId)
+            {
+                Debug.Console(2, this, "  Audio Source: {0}", Tx.AudioSourceFeedback);
+                AudioSourceNumericFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// Relays the input stream change to the appropriate RoutingInputPort.
+        /// </summary>
+        void FowardInputStreamChange(RoutingInputPortWithVideoStatuses inputPort, int eventId)
+        {
+            if (eventId == EndpointInputStreamEventIds.SyncDetectedFeedbackEventId)
+            {
+                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/DmTxHelpers.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+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.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	public class DmTxHelper
+	{
+		/// <summary>
+		/// A factory method for various DmTxControllers
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="props"></param>
+		/// <returns></returns>
+        public static BasicDmTxControllerBase GetDmTxController(string key, string name, string typeName, DmTxPropertiesConfig props)
+		{
+			// 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();
+
+			if (pKey == "processor")
+			{
+				// Catch constructor failures, mainly dues to IPID
+				try
+				{
+                    if(typeName.StartsWith("dmTx200"))
+                        return new DmTx200Controller(key, name, new DmTx200C2G(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmtx201"))
+						return new DmTx201XController(key, name, new DmTx201S(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx4k202"))
+                        return new DmTx4k202CController(key, name, new DmTx4k202C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx4kz202"))
+                        return new DmTx4k202CController(key, name, new DmTx4kz202C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx4k302"))
+						return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx4kz302"))
+                        return new DmTx4kz302CController(key, name, new DmTx4kz302C(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmtx401"))
+						return new DmTx401CController(key, name, new DmTx401C(ipid, Global.ControlSystem));
+					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.Message);
+				}
+			}
+			else
+			{
+				var parentDev = DeviceManager.GetDeviceForKey(pKey);
+				if (!(parentDev is DmChassisController))
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a DM Chassis.",
+						key, pKey);
+					return null;
+				}
+
+                // Get the Crestron chassis and link stuff up
+				var switchDev = parentDev as DmChassisController;
+				var chassis = switchDev.Chassis;
+
+				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;
+				}
+                else
+                {
+                    var controller = (parentDev as DmChassisController);
+                    controller.TxDictionary.Add(num, key);
+                }
+
+				// Catch constructor failures, mainly dues to IPID
+				try
+				{
+					// Must use different constructor for CPU3 chassis types. No IPID
+					if (chassis is DmMd8x8Cpu3 || chassis is DmMd16x16Cpu3 ||
+					chassis is DmMd32x32Cpu3 || chassis is DmMd8x8Cpu3rps ||
+					chassis is DmMd16x16Cpu3rps || chassis is DmMd32x32Cpu3rps)
+					{
+						if (typeName.StartsWith("dmTx200"))
+							return new DmTx200Controller(key, name, new DmTx200C2G(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx201"))
+							return new DmTx201XController(key, name, new DmTx201C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k100"))
+							return new DmTx4k100Controller(key, name, new DmTx4K100C1G(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k202"))
+							return new DmTx4k202CController(key, name, new DmTx4k202C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4kz202"))
+							return new DmTx4k202CController(key, name, new DmTx4kz202C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k302"))
+							return new DmTx4k302CController(key, name, new DmTx4k302C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4kz302"))
+							return new DmTx4kz302CController(key, name, new DmTx4kz302C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx401"))
+							return new DmTx401CController(key, name, new DmTx401C(chassis.Inputs[num]));
+					}
+					else
+					{
+						if (typeName.StartsWith("dmTx200"))
+							return new DmTx200Controller(key, name, new DmTx200C2G(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx201"))
+							return new DmTx201XController(key, name, new DmTx201C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k100"))
+							return new DmTx4k100Controller(key, name, new DmTx4K100C1G(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k202"))
+							return new DmTx4k202CController(key, name, new DmTx4k202C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4kz202"))
+							return new DmTx4k202CController(key, name, new DmTx4kz202C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k302"))
+							return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4kz302"))
+							return new DmTx4kz302CController(key, name, new DmTx4kz302C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx401"))
+							return new DmTx401CController(key, name, new DmTx401C(ipid, chassis.Inputs[num]));
+					}
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e.Message);
+				}
+			}
+			
+			return null;
+		}
+	}
+
+    public abstract class BasicDmTxControllerBase : CrestronGenericBaseDevice
+    {
+        public BasicDmTxControllerBase(string key, string name, GenericBase hardware)
+            : base(key, name, hardware)
+        {
+
+        }
+    }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	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 DmTxControllerBase(string key, string name, EndpointTransmitterBase hardware)
+			: base(key, name, hardware) 
+		{
+			// if wired to a chassis, skip registration step in base class
+			if (hardware.DMInput != null)
+			{
+				this.PreventRegistration = true;
+			}
+            AddToFeedbackList(ActiveVideoInputFeedback);
+		}
+	}
+    //public enum ePdtHdcpSupport
+    //{
+    //    HdcpOff = 0,
+    //    Hdcp1 = 1,
+    //    Hdcp2 = 2,
+    //    Hdcp2_2= 3,
+    //    Auto = 99
+    //}
+}

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

@@ -0,0 +1,160 @@
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{9199CE8A-0C9F-4952-8672-3EED798B284F}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>PepperDash.Essentials.DM</RootNamespace>
+    <AssemblyName>PepperDash_Essentials_DM</AssemblyName>
+    <ProjectTypeGuids>{0B4745B0-194B-4BB6-8E21-E9057CA92300};{4D628B5B-2FBC-4AA6-8C16-197242AEB884};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <PlatformFamilyName>WindowsCE</PlatformFamilyName>
+    <PlatformID>E2BECB1F-8C8C-41ba-B736-9BE7D946A398</PlatformID>
+    <OSVersion>5.0</OSVersion>
+    <DeployDirSuffix>SmartDeviceProject1</DeployDirSuffix>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <NativePlatformName>Windows CE</NativePlatformName>
+    <FormFactorID>
+    </FormFactorID>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <AllowedReferenceRelatedFileExtensions>.allowedReferenceRelatedFileExtensions</AllowedReferenceRelatedFileExtensions>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE;</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <FileAlignment>512</FileAlignment>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <GenerateSerializationAssemblies>off</GenerateSerializationAssemblies>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <AllowedReferenceRelatedFileExtensions>.allowedReferenceRelatedFileExtensions</AllowedReferenceRelatedFileExtensions>
+    <DebugType>none</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <FileAlignment>512</FileAlignment>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <GenerateSerializationAssemblies>off</GenerateSerializationAssemblies>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Crestron.SimplSharpPro.DeviceSupport, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DeviceSupport.dll</HintPath>
+    </Reference>
+    <Reference Include="Crestron.SimplSharpPro.DM, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DM.dll</HintPath>
+    </Reference>
+    <Reference Include="Crestron.SimplSharpPro.UI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.UI.dll</HintPath>
+    </Reference>
+    <Reference Include="mscorlib" />
+    <Reference Include="PepperDash_Core, Version=1.0.4.20530, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\references\PepperDash_Core.dll</HintPath>
+    </Reference>
+    <Reference Include="SimplSharpCustomAttributesInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCustomAttributesInterface.dll</HintPath>
+      <Private>False</Private>
+    </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>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="SimplSharpNewtonsoft, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpNewtonsoft.dll</HintPath>
+    </Reference>
+    <Reference Include="SimplSharpPro, Version=1.5.3.17, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpPro.exe</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AirMedia\AirMediaPropertiesConfig.cs" />
+    <Compile Include="AirMedia\AirMediaController.cs" />
+    <Compile Include="Cards REMOVE\Dmc4kHdoSingleOutputCard.cs" />
+    <Compile Include="Cards REMOVE\Dmc4kCoHdSingleOutputCard.cs" />
+    <Compile Include="Cards REMOVE\DmOutputCardBase.cs" />
+    <Compile Include="Cards REMOVE\DmcC4kInputCard.cs" />
+    <Compile Include="Cards REMOVE\DmcHD4kInputCard.cs" />
+    <Compile Include="Cards REMOVE\DmInputCardBase.cs" />
+    <Compile Include="Chassis\DmCardAudioOutput.cs" />
+    <Compile Include="Chassis\DmChassisController.cs" />
+    <Compile Include="Chassis\HdMdNxM4kEController.cs" />
+    <Compile Include="Config\DmRmcConfig.cs" />
+    <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\NVX\DmNvx35xController.cs" />
+    <Compile Include="Endpoints\NVX\DmNvxConfig.cs" />
+    <Compile Include="Endpoints\NVX\DmNvxControllerBase.cs" />
+    <Compile Include="Endpoints\DGEs\DgeController.cs" />
+    <Compile Include="Endpoints\DGEs\DgePropertiesConfig.cs" />
+    <Compile Include="Endpoints\Receivers\DmHdBaseTEndpointController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc100SController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc150SController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc200CController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc200S2Controller.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc200SController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc4k100C1GController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc4KScalerCController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmc4kScalerCDspController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmcScalerCController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmcX100CController.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmcHelper.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmcScalerS2Controller.cs" />
+    <Compile Include="Endpoints\Receivers\DmRmcScalerSController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx200Controller.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx401CController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx4k100Controller.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx4k202CController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx4k302CController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx201CController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx4kz302CController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTxHelpers.cs" />
+    <Compile Include="Extensions.cs" />
+    <Compile Include="Config\DeviceFactory.cs" />
+    <Compile Include="IDmHdmiInputExtensions.cs" />
+    <Compile Include="MOVE IBasicVideoStatusFeedbacks.cs" />
+    <Compile Include="Nvx\NvxDirectorController.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="VideoStatusHelpers.cs" />
+    <None Include="app.config" />
+    <None Include="Properties\ControlSystem.cfg" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Essentials Core\PepperDashEssentialsBase\PepperDash_Essentials_Core.csproj">
+      <Project>{A49AD6C8-FC0A-4CC0-9089-DFB4CF92D2B5}</Project>
+      <Name>PepperDash_Essentials_Core</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
+  <ProjectExtensions>
+    <VisualStudio>
+    </VisualStudio>
+  </ProjectExtensions>
+  <PropertyGroup>
+    <PostBuildEvent>rem S# Pro preparation will execute after these operations</PostBuildEvent>
+  </PropertyGroup>
+</Project>

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

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Cards;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	public static class VideoAttributesBasicExtensions
+	{
+		public static string GetVideoResolutionString(this VideoAttributesBasic va)
+		{
+			ushort h = va.HorizontalResolutionFeedback.UShortValue;
+			ushort v = va.VerticalResolutionFeedback.UShortValue;
+            ushort r = va.FramesPerSecondFeedback.UShortValue;
+			if (h == 0 || v == 0)
+				return "n/a";
+			else
+				return string.Format("{0}x{1}@{2}Hz", h, v, r);
+		}
+	}
+
+    public static class AdvEndpointHdmiOutputExtensions
+    {
+        public static string GetVideoResolutionString(this AdvEndpointHdmiOutput va)
+        {
+            ushort h = va.HorizontalResolutionFeedback.UShortValue;
+            ushort v = va.VerticalResolutionFeedback.UShortValue;
+            ushort r = va.FramesPerSecondFeedback.UShortValue;
+            if (h == 0 || v == 0)
+                return "n/a";
+            else
+                return string.Format("{0}x{1}@{2}Hz", h, v, r);
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	public static class IBasicDmInputExtensions
+	{
+		public static VideoStatusFuncsWrapper GetVideoStatusFuncsWrapper(this IBasicDMInput input)
+		{
+			var va = (input as IVideoAttributesEnhanced).VideoAttributes;
+			return new VideoStatusFuncsWrapper 
+			{
+				HasVideoStatusFunc = () => true,
+				HdcpActiveFeedbackFunc = () => va.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => va.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => 
+					{
+                        //var h = va.HorizontalResolutionFeedback.UShortValue;
+                        //var v = va.VerticalResolutionFeedback.UShortValue;
+                        //if (h == 0 || v == 0)
+                        //    return "---";
+                        return va.GetVideoResolutionString(); // h + "x" + v;
+					},
+				VideoSyncFeedbackFunc = () => input.SyncDetectedFeedback.BoolValue
+			};
+		}
+	}
+
+
+	public static class IEndpointHdmiInputExtensions
+	{
+		public static VideoStatusFuncsWrapper GetVideoStatusFuncsWrapper(this Crestron.SimplSharpPro.DM.Endpoints.EndpointHdmiInput input)
+		{
+			var va = (input as IVideoAttributesEnhanced).VideoAttributes;
+			return new VideoStatusFuncsWrapper
+			{
+				HasVideoStatusFunc = () => true,
+				HdcpActiveFeedbackFunc = () => va.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => va.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () =>
+				{
+                    //var h = va.HorizontalResolutionFeedback.UShortValue;
+                    //var v = va.VerticalResolutionFeedback.UShortValue;
+                    //if (h == 0 || v == 0)
+                    //    return "---";
+                    return va.GetVideoResolutionString(); // h + "x" + v;
+				},
+				VideoSyncFeedbackFunc = () => input.SyncDetectedFeedback.BoolValue
+			};
+		}
+	}
+
+
+}

essentials-framework/Essentials DM/Essentials_DM/MOVE IBasicVideoStatusFeedbacks.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+    public interface IBasicVideoStatusFeedbacks 
+    {
+		BoolFeedback HasVideoStatusFeedback { get; }
+		BoolFeedback HdcpActiveFeedback { get; }
+		StringFeedback HdcpStateFeedback { get; }
+		StringFeedback VideoResolutionFeedback { get; }
+		BoolFeedback VideoSyncFeedback { get; }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Nvx/NvxDirectorController.cs

@@ -0,0 +1,746 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using Crestron.SimplSharp;
+//using Crestron.SimplSharpPro;
+//using Crestron.SimplSharpPro.DM;
+//using Crestron.SimplSharpPro.DM.Cards;
+//using Crestron.SimplSharpPro.DM.Streaming;
+//using Crestron.SimplSharpPro.DM.Endpoints;
+//using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+//using PepperDash.Core;
+//using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM.Cards;
+//using PepperDash.Essentials.DM.Config;
+
+//namespace PepperDash.Essentials.DM
+//{
+//    /// <summary>
+//    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+//    /// 
+//    /// </summary>
+//    public class NvxDirectorController : CrestronGenericBaseDevice, IRoutingInputsOutputs, IRouting, IHasFeedback//, ICardPortsDevice
+//    {
+//        public NvxDirectorController Chassis { get; private set; }
+		
+//        // Feedbacks for EssentialDM
+//        public Dictionary<uint, IntFeedback> VideoOutputFeedbacks { get; private set; }
+//        public Dictionary<uint, IntFeedback> AudioOutputFeedbacks { get; private set; }
+//        public Dictionary<uint, BoolFeedback> VideoInputSyncFeedbacks { get; private set; }
+//        public Dictionary<uint, BoolFeedback> InputEndpointOnlineFeedbacks { get; private set; }
+//        public Dictionary<uint, BoolFeedback> OutputEndpointOnlineFeedbacks { get; private set; }
+//        public Dictionary<uint, StringFeedback> InputNameFeedbacks { get; private set; }
+//        public Dictionary<uint, StringFeedback> OutputNameFeedbacks { get; private set; }
+//        public Dictionary<uint, StringFeedback> OutputVideoRouteNameFeedbacks { get; private set; }
+//        public Dictionary<uint, StringFeedback> OutputAudioRouteNameFeedbacks { get; private set; }
+		
+		
+//        // Need a couple Lists of generic Backplane ports
+//        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+//        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+//        public Dictionary<uint, string> TxDictionary { get; set; }
+//        public Dictionary<uint, string> RxDictionary { get; set; }
+
+//        //public Dictionary<uint, DmInputCardControllerBase> InputCards { get; private set; }
+//        //public Dictionary<uint, DmSingleOutputCardControllerBase> OutputCards { get; private set; }
+
+//        public Dictionary<uint, string> InputNames { get; set; }
+//        public Dictionary<uint, string> OutputNames { get; set; }
+//        public Dictionary<uint, DmCardAudioOutputController> VolumeControls { get; private set; }
+
+//        public const int RouteOffTime = 500;
+//        Dictionary<PortNumberType, CTimer> RouteOffTimers = new Dictionary<PortNumberType, CTimer>();
+
+//        /// <summary>
+//        /// Factory method to create a new chassis controller from config data. Limited to 8x8 right now
+//        /// </summary>
+//        public static NvxDirectorController GetNvxDirectorController(string key, string name,
+//            string type, DMChassisPropertiesConfig properties)
+//        {
+//            try
+//            {
+//                type = type.ToLower();
+//                uint ipid = properties.Control.IpIdInt; // Convert.ToUInt16(properties.Id, 16);
+//                NvxDirectorController controller = null;
+				
+
+//                if (type == "dmmd8x8")
+//                {
+//                    controller = new NvxDirectorController(key, name, new DmMd8x8(ipid, Global.ControlSystem));
+
+//                    // add the cards and port names
+//                    foreach (var kvp in properties.InputSlots)
+//                        controller.AddInputCard(kvp.Value, kvp.Key);
+//                    foreach (var kvp in properties.OutputSlots) {
+//                        controller.AddOutputCard(kvp.Value, kvp.Key);
+						
+//                        }
+
+//                    foreach (var kvp in properties.VolumeControls)
+//                    {
+//                        // get the card
+//                        // check it for an audio-compatible type
+//                        // make a something-something that will make it work
+//                        // retire to mountain village
+//                        var outNum = kvp.Key;
+//                        var card = controller.Chassis.Outputs[outNum].Card;
+//                        Audio.Output audio = null;
+//                        if (card is DmcHdo)
+//                            audio = (card as DmcHdo).Audio;
+//                        else if (card is Dmc4kHdo)
+//                            audio = (card as Dmc4kHdo).Audio;
+//                        if (audio == null)
+//                            continue;
+//                        // wire up the audio to something here...
+//                        controller.AddVolumeControl(outNum, audio);
+//                    }
+
+//                    controller.InputNames = properties.InputNames;
+//                    controller.OutputNames = properties.OutputNames;
+//                    return controller;
+//                }
+//                else if (type == "dmmd16x16") {
+//                    controller = new NvxDirectorController(key, name, new DmMd16x16(ipid, Global.ControlSystem));
+
+//                    // add the cards and port names
+//                    foreach (var kvp in properties.InputSlots)
+//                        controller.AddInputCard(kvp.Value, kvp.Key);
+//                    foreach (var kvp in properties.OutputSlots) {
+//                        controller.AddOutputCard(kvp.Value, kvp.Key);
+
+//                        }
+
+//                    foreach (var kvp in properties.VolumeControls) {
+//                        // get the card
+//                        // check it for an audio-compatible type
+//                        // make a something-something that will make it work
+//                        // retire to mountain village
+//                        var outNum = kvp.Key;
+//                        var card = controller.Chassis.Outputs[outNum].Card;
+//                        Audio.Output audio = null;
+//                        if (card is DmcHdo)
+//                            audio = (card as DmcHdo).Audio;
+//                        else if (card is Dmc4kHdo)
+//                            audio = (card as Dmc4kHdo).Audio;
+//                        if (audio == null)
+//                            continue;
+//                        // wire up the audio to something here...
+//                        controller.AddVolumeControl(outNum, audio);
+//                        }
+
+//                    controller.InputNames = properties.InputNames;
+//                    controller.OutputNames = properties.OutputNames;
+//                    return controller;
+//                    }
+//            }
+//            catch (System.Exception e)
+//            {
+//                Debug.Console(0, "Error creating DM chassis:\r{0}", e);
+//            }
+//            return null;
+//        }
+
+
+//        /// <summary>
+//        /// 
+//        /// </summary>
+//        /// <param name="key"></param>
+//        /// <param name="name"></param>
+//        /// <param name="chassis"></param>
+//        public NvxDirectorController(string key, string name, DmMDMnxn chassis)
+//            : base(key, name, chassis)
+//        {
+//            Chassis = chassis;
+//            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+//            OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+//            VolumeControls = new Dictionary<uint, DmCardAudioOutputController>();
+//            TxDictionary = new Dictionary<uint, string>();
+//            RxDictionary = new Dictionary<uint, string>();
+//            IsOnline.OutputChange += new EventHandler<FeedbackEventArgs>(IsOnline_OutputChange);
+//            //IsOnline.OutputChange += new EventHandler<EventArgs>(this.IsOnline_OutputChange);
+//            Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
+//            //Chassis.DMSystemChange += new DMSystemEventHandler(Chassis_DMSystemChange);
+//            Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
+//            VideoOutputFeedbacks = new Dictionary<uint, IntFeedback>();
+//            AudioOutputFeedbacks = new Dictionary<uint, IntFeedback>();
+//            VideoInputSyncFeedbacks = new Dictionary<uint, BoolFeedback>();
+//            InputNameFeedbacks = new Dictionary<uint, StringFeedback>();
+//            OutputNameFeedbacks = new Dictionary<uint, StringFeedback>();
+//            OutputVideoRouteNameFeedbacks = new Dictionary<uint, StringFeedback>();
+//            OutputAudioRouteNameFeedbacks = new Dictionary<uint, StringFeedback>();
+//            InputEndpointOnlineFeedbacks = new Dictionary<uint, BoolFeedback>();
+//            OutputEndpointOnlineFeedbacks = new Dictionary<uint, BoolFeedback>();
+
+//            for (uint x = 1; x <= Chassis.NumberOfOutputs; x++) 
+//            {
+//                var tempX = x;
+
+//                VideoOutputFeedbacks[tempX] = new IntFeedback(() => { 
+//                    if (Chassis.Outputs[tempX].VideoOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number;} 
+//                    else { return 0; };
+//                    });
+//                AudioOutputFeedbacks[tempX] = new IntFeedback(() => {
+//                    if (Chassis.Outputs[tempX].AudioOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number; } 
+//                    else { return 0; };
+//                    });
+//                VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {			
+//                    return Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue;
+//                    });
+//                InputNameFeedbacks[tempX] = new StringFeedback(() => {
+//                        if (Chassis.Inputs[tempX].NameFeedback.StringValue != null) 
+//                        {
+//                             return Chassis.Inputs[tempX].NameFeedback.StringValue;
+//                        }
+//                        else 
+//                        {
+//                            return "";
+//                        }				
+//                    });
+//                OutputNameFeedbacks[tempX] = new StringFeedback(() => {
+//                        if (Chassis.Outputs[tempX].NameFeedback.StringValue != null) 
+//                        {
+//                            return Chassis.Outputs[tempX].NameFeedback.StringValue;
+//                        }
+//                        else 
+//                        {
+//                            return "";
+//                        }
+//                    });
+//                OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() => 
+//                {
+//                        if (Chassis.Outputs[tempX].VideoOutFeedback != null) 
+//                        {
+//                            return Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue;
+//                        }
+//                        else 
+//                        {
+//                            return "";
+//                        }
+//                    });
+//                OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() =>
+//                    {
+//                        if (Chassis.Outputs[tempX].AudioOutFeedback != null)
+//                        {
+//                            return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
+//                        }
+//                        else
+//                        {
+//                            return "";
+
+//                        }
+//                    });
+//                InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Inputs[tempX].EndpointOnlineFeedback; });
+
+//                OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Outputs[tempX].EndpointOnlineFeedback; });
+//            }
+//        }
+
+//        /// <summary>
+//        /// 
+//        /// </summary>
+//        /// <param name="type"></param>
+//        /// <param name="number"></param>
+//        public void AddInputCard(string type, uint number)
+//        {
+//            Debug.Console(2, this, "Adding input card '{0}', slot {1}", type, number);
+
+//            if (type == "dmcHd")
+//            {
+//                var inputCard = new DmcHd(number, this.Chassis);
+//                var cecPort = inputCard.HdmiInput as ICec;
+//                AddHdmiInCardPorts(number, cecPort);
+//            }
+//            else if (type == "dmcHdDsp")
+//            {
+//                var inputCard = new DmcHdDsp(number, this.Chassis);
+//                var cecPort = inputCard.HdmiInput as ICec;
+//                AddHdmiInCardPorts(number, cecPort);
+//            }
+//            else if (type == "dmc4kHd")
+//            {
+//                var inputCard = new Dmc4kHd(number, this.Chassis);
+//                var cecPort = inputCard.HdmiInput as ICec;
+//                AddHdmiInCardPorts(number, cecPort);
+//            }
+//            else if (type == "dmc4kHdDsp")
+//            {
+//                var inputCard = new Dmc4kHdDsp(number, this.Chassis);
+//                var cecPort = inputCard.HdmiInput as ICec;
+//                AddHdmiInCardPorts(number, cecPort);
+//            }
+//            else if (type == "dmc4kzHd")
+//            {
+//                var inputCard = new Dmc4kzHd(number, this.Chassis);
+//                var cecPort = inputCard.HdmiInput as ICec;
+//                AddHdmiInCardPorts(number, cecPort);
+//            }
+//            else if (type == "dmc4kzHdDsp")
+//            {
+//                var inputCard = new Dmc4kzHdDsp(number, this.Chassis);
+//                var cecPort = inputCard.HdmiInput as ICec;
+//                AddHdmiInCardPorts(number, cecPort);
+//            }
+//            else if (type == "dmcC")
+//            {
+//                new DmcC(number, this.Chassis);
+//                AddDmInCardPorts(number);
+//            }
+//            else if (type == "dmcCDsp")
+//            {
+//                new DmcCDsp(number, this.Chassis);
+//                AddDmInCardPorts(number);
+//            }
+//            else if (type == "dmc4kC")
+//            {
+//                new Dmc4kC(number, this.Chassis);
+//                AddDmInCardPorts(number);
+//            }
+//            else if (type == "dmc4kCDsp")
+//            {
+//                new Dmc4kCDsp(number, this.Chassis);
+//                AddDmInCardPorts(number);
+//            }
+//            else if (type == "dmc4kzC")
+//            {
+//                new Dmc4kzC(number, this.Chassis);
+//                AddDmInCardPorts(number);
+//            }
+//            else if (type == "dmc4kzCDsp")
+//            {
+//                new Dmc4kzCDsp(number, this.Chassis);
+//                AddDmInCardPorts(number);
+//            }
+//            else if (type == "dmcCat")
+//            {
+//                new DmcCat(number, this.Chassis);
+//                AddDmInCardPorts(number);
+//            }
+//            else if (type == "dmcCatDsp")
+//            {
+//                new DmcCatDsp(number, this.Chassis);
+//                AddDmInCardPorts(number);
+//            }
+//            else if (type == "dmcS")
+//            {
+//                new DmcS(number, Chassis);
+//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+//                AddInCardHdmiAndAudioLoopPorts(number);
+//            }
+//            else if (type == "dmcSDsp")
+//            {
+//                new DmcSDsp(number, Chassis);
+//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber);
+//                AddInCardHdmiAndAudioLoopPorts(number);
+//            }
+//            else if (type == "dmcS2")
+//            {
+//                new DmcS2(number, Chassis);
+//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+//                AddInCardHdmiAndAudioLoopPorts(number);
+//            }
+//            else if (type == "dmcS2Dsp")
+//            {
+//                new DmcS2Dsp(number, Chassis);
+//                AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber);
+//                AddInCardHdmiAndAudioLoopPorts(number);
+//            }
+//            else if (type == "dmcSdi")
+//            {
+//                new DmcSdi(number, Chassis);
+//                AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Sdi);
+//                AddOutputPortWithDebug(number, "sdiOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Sdi, null);
+//                AddInCardHdmiAndAudioLoopPorts(number);
+//            }
+//            else if (type == "dmcDvi")
+//            {
+//                new DmcDvi(number, Chassis);
+//                AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Dvi);
+//                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
+//                AddInCardHdmiLoopPort(number);
+//            }
+//            else if (type == "dmcVga")
+//            {
+//                new DmcVga(number, Chassis);
+//                AddInputPortWithDebug(number, "vgaIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Vga);
+//                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
+//                AddInCardHdmiLoopPort(number);
+//            }
+//            else if (type == "dmcVidBnc")
+//            {
+//                new DmcVidBnc(number, Chassis);
+//                AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
+//                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
+//                AddInCardHdmiLoopPort(number);
+//            }
+//            else if (type == "dmcVidRcaA")
+//            {
+//                new DmcVidRcaA(number, Chassis);
+//                AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
+//                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
+//                AddInCardHdmiLoopPort(number);
+//            }
+//            else if (type == "dmcVidRcaD")
+//            {
+//                new DmcVidRcaD(number, Chassis);
+//                AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
+//                AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.DigitalAudio);
+//                AddInCardHdmiLoopPort(number);
+//            }
+//            else if (type == "dmcVid4")
+//            {
+//                new DmcVid4(number, Chassis);
+//                AddInputPortWithDebug(number, "compositeIn1", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
+//                AddInputPortWithDebug(number, "compositeIn2", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
+//                AddInputPortWithDebug(number, "compositeIn3", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
+//                AddInputPortWithDebug(number, "compositeIn4", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
+//                AddInCardHdmiLoopPort(number);
+//            }
+//            else if (type == "dmcStr")
+//            {
+//                new DmcStr(number, Chassis);
+//                AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming);
+//                AddInCardHdmiAndAudioLoopPorts(number);
+//            }
+//        }
+
+//        void AddDmInCardPorts(uint number)
+//        {
+//            AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat);
+//            AddInCardHdmiAndAudioLoopPorts(number);
+//        }
+
+//        void AddHdmiInCardPorts(uint number, ICec cecPort)
+//        {
+//            AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, cecPort);
+//            AddInCardHdmiAndAudioLoopPorts(number);
+//        }
+
+//        void AddInCardHdmiAndAudioLoopPorts(uint number)
+//        {
+//            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
+//            AddOutputPortWithDebug(number, "audioLoopOut", eRoutingSignalType.Audio, eRoutingPortConnectionType.Hdmi, null);
+//        }
+
+//        void AddInCardHdmiLoopPort(uint number)
+//        {
+//            AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, null);
+//        }
+
+//        /// <summary>
+//        /// 
+//        /// </summary>
+//        /// <param name="type"></param>
+//        /// <param name="number"></param>
+//        public void AddOutputCard(string type, uint number)
+//        {
+//            Debug.Console(2, this, "Adding output card '{0}', slot {1}", type, number);
+//            if (type == "dmc4kHdo")
+//            {
+//                var outputCard = new Dmc4kHdoSingle(number, Chassis);
+//                var cecPort1 = outputCard.Card1.HdmiOutput;
+//                var cecPort2 = outputCard.Card2.HdmiOutput;
+//                AddDmcHdoPorts(number, cecPort1, cecPort2);
+//            }
+//            else if (type == "dmcHdo")
+//            {
+//                var outputCard = new DmcHdoSingle(number, Chassis);
+//                var cecPort1 = outputCard.Card1.HdmiOutput;
+//                var cecPort2 = outputCard.Card2.HdmiOutput;
+//                AddDmcHdoPorts(number, cecPort1, cecPort2);
+//            }
+//            else if (type == "dmc4kCoHd")
+//            {
+//                var outputCard = new Dmc4kCoHdSingle(number, Chassis);
+//                var cecPort1 = outputCard.Card1.HdmiOutput;
+//                AddDmcCoPorts(number, cecPort1);
+//            }
+//            else if (type == "dmc4kzCoHd")
+//            {
+//                var outputCard = new Dmc4kzCoHdSingle(number, Chassis);
+//                var cecPort1 = outputCard.Card1.HdmiOutput;
+//                AddDmcCoPorts(number, cecPort1);
+//            }
+//            else if (type == "dmcCoHd")
+//            {
+//                var outputCard = new DmcCoHdSingle(number, Chassis);
+//                var cecPort1 = outputCard.Card1.HdmiOutput;
+//                AddDmcCoPorts(number, cecPort1);
+//            }
+//            else if (type == "dmCatoHd")
+//            {
+//                var outputCard = new DmcCatoHdSingle(number, Chassis);
+//                var cecPort1 = outputCard.Card1.HdmiOutput;
+//                AddDmcCoPorts(number, cecPort1);
+//            }
+//            else if (type == "dmcSoHd")
+//            {
+//                var outputCard = new DmcSoHdSingle(number, Chassis);
+//                var cecPort1 = outputCard.Card1.HdmiOutput;
+//                AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
+//                AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+//                AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
+
+//            }
+//            else if (type == "dmcS2oHd")
+//            {
+//                var outputCard = new DmcS2oHdSingle(number, Chassis);
+//                var cecPort1 = outputCard.Card1.HdmiOutput;
+//                AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
+//                AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+//                AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
+//            }
+//            else if (type == "dmcStro")
+//            {
+//                var outputCard = new DmcStroSingle(number, Chassis);
+//                AddOutputPortWithDebug(number, "streamOut", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
+//            }
+
+//            else
+//                Debug.Console(1, this, "  WARNING: Output card type '{0}' is not available", type);
+//        }
+
+//        void AddDmcHdoPorts(uint number, ICec cecPort1, ICec cecPort2)
+//        {
+//            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+//            AddOutputPortWithDebug(number, "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 1);
+//            AddOutputPortWithDebug(number, "hdmiOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2);
+//            AddOutputPortWithDebug(number, "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 2);
+//        }
+
+//        void AddDmcCoPorts(uint number, ICec cecPort1)
+//        {
+//            AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
+//            AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+//            AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.AudioVideo, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
+//        }
+
+
+//        /// <summary>
+//        /// Adds InputPort
+//        /// </summary>
+//        void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType)
+//        {
+//            var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
+//            Debug.Console(2, this, "Adding input port '{0}'", portKey);
+//            var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
+
+//            InputPorts.Add(inputPort);
+//        }
+
+//        /// <summary>
+//        /// Adds InputPort and sets Port as ICec object
+//        /// </summary>
+//        void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, ICec cecPort)
+//        {
+//            var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
+//            Debug.Console(2, this, "Adding input port '{0}'", portKey);
+//            var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
+
+//            if (cecPort != null)
+//                inputPort.Port = cecPort;
+
+//            InputPorts.Add(inputPort);
+//        }
+
+//        /// <summary>
+//        /// Adds OutputPort
+//        /// </summary>
+//        void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
+//        {
+//            var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
+//            Debug.Console(2, this, "Adding output port '{0}'", portKey);
+//            OutputPorts.Add(new RoutingOutputPort(portKey, sigType, portType, selector, this));
+//        }
+
+//        /// <summary>
+//        /// Adds OutputPort and sets Port as ICec object
+//        /// </summary>
+//        void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector, ICec cecPort)
+//        {
+//            var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
+//            Debug.Console(2, this, "Adding output port '{0}'", portKey);
+//            var outputPort = new RoutingOutputPort(portKey, sigType, portType, selector, this);
+
+//            if (cecPort != null)
+//                outputPort.Port = cecPort;
+
+//            OutputPorts.Add(outputPort);
+//        }
+
+//        /// <summary>
+//        /// 
+//        /// </summary>
+//        void AddVolumeControl(uint number, Audio.Output audio)
+//        {
+//            VolumeControls.Add(number, new DmCardAudioOutputController(audio));
+//        }
+
+//        //public void SetInputHdcpSupport(uint input, ePdtHdcpSupport hdcpSetting)
+//        //{
+
+//        //}
+
+
+//        void Chassis_DMSystemChange(Switch device, DMSystemEventArgs args) {
+
+//            }
+//        void Chassis_DMInputChange(Switch device, DMInputEventArgs args) {
+//            //Debug.Console(2, this, "DMSwitch:{0} Input:{1} Event:{2}'", this.Name, args.Number, args.EventId.ToString());
+				
+//            switch (args.EventId) {
+//                case (DMInputEventIds.OnlineFeedbackEventId): {
+//                    Debug.Console(2, this, "DMINput OnlineFeedbackEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
+//                    InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
+//                    break;
+//                    }
+//                case (DMInputEventIds.VideoDetectedEventId): {
+//                    Debug.Console(2, this, "DM Input {0} VideoDetectedEventId", args.Number);
+//                    VideoInputSyncFeedbacks[args.Number].FireUpdate();
+//                    break;
+//                    }
+//                case (DMInputEventIds.InputNameEventId): {
+//                    Debug.Console(2, this, "DM Input {0} NameFeedbackEventId", args.Number);
+//                    InputNameFeedbacks[args.Number].FireUpdate();
+//                    break;
+//                    }
+//                }
+//            }
+//        /// 
+//        /// </summary>
+//        void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
+//        {
+
+//            //This should be a switch case JTA 2018-07-02
+//            var output = args.Number;
+//            if (args.EventId == DMOutputEventIds.VolumeEventId &&
+//                VolumeControls.ContainsKey(output))
+//            {
+//                VolumeControls[args.Number].VolumeEventFromChassis();
+//            }
+//            else if (args.EventId == DMOutputEventIds.OnlineFeedbackEventId)
+//            {
+//                OutputEndpointOnlineFeedbacks[output].FireUpdate();
+//            }
+//            else if (args.EventId == DMOutputEventIds.VideoOutEventId)
+//            {
+//                if (Chassis.Outputs[output].VideoOutFeedback != null)
+//                {
+//                    Debug.Console(2, this, "DMSwitchVideo:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].VideoOutFeedback.Number, output);
+//                }
+//                if (VideoOutputFeedbacks.ContainsKey(output))
+//                {
+//                    VideoOutputFeedbacks[output].FireUpdate();
+
+//                }
+//                if (OutputVideoRouteNameFeedbacks.ContainsKey(output))
+//                {
+//                    OutputVideoRouteNameFeedbacks[output].FireUpdate();
+//                }
+//            }
+//            else if (args.EventId == DMOutputEventIds.AudioOutEventId)
+//            {
+//                if (Chassis.Outputs[output].AudioOutFeedback != null)
+//                {
+//                    Debug.Console(2, this, "DMSwitchAudio:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].AudioOutFeedback.Number, output);
+//                }
+//                if (AudioOutputFeedbacks.ContainsKey(output))
+//                {
+//                    AudioOutputFeedbacks[output].FireUpdate();
+//                }
+//            }
+//            else if (args.EventId == DMOutputEventIds.OutputNameEventId)
+//            {
+//                Debug.Console(2, this, "DM Output {0} NameFeedbackEventId", output);
+//                OutputNameFeedbacks[output].FireUpdate();
+//            }
+
+//        }
+
+//        /// <summary>
+//        /// 
+//        /// </summary>
+//        /// <param name="pnt"></param>
+//        void StartOffTimer(PortNumberType pnt)
+//        {
+//            if (RouteOffTimers.ContainsKey(pnt))
+//                return;
+//            RouteOffTimers[pnt] = new CTimer(o =>
+//            {
+//                ExecuteSwitch(0, pnt.Number, pnt.Type);
+//            }, RouteOffTime);
+//        }
+
+
+//        // Send out sigs when coming online
+//        void IsOnline_OutputChange(object sender, EventArgs e)
+//        {
+//            if (IsOnline.BoolValue)
+//            {
+//                if (InputNames != null)
+//                    foreach (var kvp in InputNames)
+//                        Chassis.Inputs[kvp.Key].Name.StringValue = kvp.Value;
+//                if (OutputNames != null)
+//                    foreach(var kvp in OutputNames)
+//                        Chassis.Outputs[kvp.Key].Name.StringValue = kvp.Value;
+//            }
+//        }
+
+//        #region IRouting Members
+
+//        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType sigType)
+//        {
+//            Debug.Console(2, this, "Making an awesome DM route from {0} to {1} {2}", inputSelector, outputSelector, sigType);
+
+//            var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
+//            var output = Convert.ToUInt32(outputSelector);
+//            // Check to see if there's an off timer waiting on this and if so, cancel
+//            var key = new PortNumberType(output, sigType);
+//            if (input == 0)
+//            {
+//                StartOffTimer(key);
+//            }
+//            else
+//            {
+//                if(RouteOffTimers.ContainsKey(key))
+//                {
+//                    Debug.Console(2, this, "{0} cancelling route off due to new source", output);
+//                    RouteOffTimers[key].Stop();
+//                    RouteOffTimers.Remove(key);
+//                }
+//            }
+
+//            Card.DMICard inCard = input == 0 ? null : Chassis.Inputs[input];
+
+//            // NOTE THAT THESE ARE NOTS - TO CATCH THE AudioVideo TYPE
+//            if (sigType != eRoutingSignalType.Audio)
+//            {
+//                Chassis.VideoEnter.BoolValue = true;
+//                Chassis.Outputs[output].VideoOut = inCard;
+//            }
+
+//            if (sigType != eRoutingSignalType.Video)
+//            {
+//                Chassis.AudioEnter.BoolValue = true;
+//                Chassis.Outputs[output].AudioOut = inCard;
+//            }
+//        }
+
+//        #endregion
+
+//    }
+
+//    //public struct PortNumberType
+//    //{
+//    //    public uint Number { get; private set; }
+//    //    public eRoutingSignalType Type { get; private set; }
+
+//    //    public PortNumberType(uint number, eRoutingSignalType type) : this()
+//    //    {
+//    //        Number = number;
+//    //        Type = type;
+//    //    }
+//    //}
+//}

essentials-framework/Essentials DM/Essentials_DM/Properties/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using System.Reflection;
+
+[assembly: AssemblyTitle("Essentials_DM")]
+[assembly: AssemblyCompany("PepperDash Technology Corp")]
+[assembly: AssemblyProduct("Essentials_DM")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyVersion("1.3.*")]

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

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM
+{
+	/// <summary>
+	/// These methods will get the funcs that return values from various video port types...
+	/// </summary>
+	public class VideoStatusHelper
+	{
+		public static VideoStatusFuncsWrapper GetHdmiInputStatusFuncs(HdmiInputPort port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () => port.VideoAttributes.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => port.VideoAttributes.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+
+		public static VideoStatusFuncsWrapper GetHdmiInputStatusFuncs(EndpointHdmiInput port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+
+		public static VideoStatusFuncsWrapper GetVgaInputStatusFuncs(EndpointVgaInput port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () => port.VideoAttributes.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => port.VideoAttributes.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+
+		public static VideoStatusFuncsWrapper GetDmInputStatusFuncs(DMInputPort port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () => port.VideoAttributes.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => port.VideoAttributes.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+
+		public static VideoStatusFuncsWrapper GetDisplayPortInputStatusFuncs(EndpointDisplayPortInput port)
+		{
+			return new VideoStatusFuncsWrapper
+			{
+				HdcpActiveFeedbackFunc = () => port.VideoAttributes.HdcpActiveFeedback.BoolValue,
+				HdcpStateFeedbackFunc = () => port.VideoAttributes.HdcpStateFeedback.ToString(),
+				VideoResolutionFeedbackFunc = () => port.VideoAttributes.GetVideoResolutionString(),
+				VideoSyncFeedbackFunc = () => port.SyncDetectedFeedback.BoolValue
+			};
+		}
+	}
+}

essentials-framework/Essentials DM/Essentials_DM/app.config

@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<configuration>
+	<runtime>
+		<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+			<dependentAssembly>
+				<assemblyIdentity name="ConsoleServiceCE" publicKeyToken="1099C178B3B54C3B" culture="neutral"/>
+				<bindingRedirect oldVersion="0.0.0.0-1.0.6732.19368" newVersion="1.0.6732.19368"/>
+			</dependentAssembly>
+		</assemblyBinding>
+	</runtime>
+</configuration>