Differentiation between Dge100 and DmDge200C

Fix DisplayControllerJoinMap Constructor

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

@@ -70,7 +70,7 @@ namespace PepperDash.Essentials.Core.Bridges
             new JoinMetadata() { Label = "Is Online", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
 
         public DisplayControllerJoinMap(uint joinStart)
-            : base(joinStart, typeof(CameraControllerJoinMap))
+            : base(joinStart, typeof(DisplayControllerJoinMap))
         {
         }
     }

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

@@ -11,26 +11,29 @@ using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
+using Crestron.SimplSharpPro.DeviceSupport;
 
 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; }
+    public class Dge100Controller : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject
+    {
+        private readonly Dge100 _dge;
+
+        public BasicTriListWithSmartObject Panel { get { return _dge; } }
+
+        public DeviceConfig _dc;
 
         CrestronTouchpanelPropertiesConfig PropertiesConfig;
 
-        public DgeController(string key, string name, Dge100 device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
+        public Dge100Controller(string key, string name, Dge100 device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
             :base(key, name, device)
         {
-            DigitalGraphicsEngine = device;
+            _dge = device;
 
-            DeviceConfig = dc;
+            _dc = dc;
 
             PropertiesConfig = props;
         }
@@ -39,12 +42,12 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
 
         public CrestronCollection<ComPort> ComPorts
         {
-            get { return DigitalGraphicsEngine.ComPorts; }
+            get { return _dge.ComPorts; }
         }
 
         public int NumberOfComPorts
         {
-            get { return DigitalGraphicsEngine.NumberOfComPorts; }
+            get { return _dge.NumberOfComPorts; }
         }
 
         #endregion
@@ -53,22 +56,22 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
 
         public CrestronCollection<IROutputPort> IROutputPorts
         {
-            get { return DigitalGraphicsEngine.IROutputPorts; }
+            get { return _dge.IROutputPorts; }
         }
 
         public int NumberOfIROutputPorts
         {
-            get { return DigitalGraphicsEngine.NumberOfIROutputPorts; }
+            get { return _dge.NumberOfIROutputPorts; }
         }
 
         #endregion
     }
 
-    public class DgeControllerFactory : EssentialsDeviceFactory<DgeController>
+    public class Dge100ControllerFactory : EssentialsDeviceFactory<Dge100Controller>
     {
-        public DgeControllerFactory()
+        public Dge100ControllerFactory()
         {
-            TypeNames = new List<string>() { "dge100", "dmdge200c" };
+            TypeNames = new List<string>() { "dge100" };
         }
 
         public override EssentialsDevice BuildDevice(DeviceConfig dc)
@@ -82,8 +85,6 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             Dge100 dgeDevice = null;
             if (typeName == "dge100")
                 dgeDevice = new Dge100(comm.IpIdInt, Global.ControlSystem);
-            else if (typeName == "dmdge200c")
-                dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
 
             if (dgeDevice == null)
             {
@@ -91,7 +92,7 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
                 return null;
             }
 
-            var dgeController = new DgeController(dc.Key + "-comPorts", dc.Name, dgeDevice, dc, props);
+            var dgeController = new Dge100Controller(dc.Key + "-comPorts", dc.Name, dgeDevice, dc, props);
 
             return dgeController;
         }

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

@@ -0,0 +1,131 @@
+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;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+namespace PepperDash.Essentials.DM.Endpoints.DGEs
+{
+    /// <summary>
+    /// Wrapper class for DGE-100 and DM-DGE-200-C
+    /// </summary>
+    public class DmDge200CController : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, 
+        IHasBasicTriListWithSmartObject, IRoutingInputsOutputs
+    {
+        private readonly DmDge200C _dge;
+
+        public BasicTriListWithSmartObject Panel { get { return _dge; } }
+        public RoutingInputPort DmIn { get; private set; }
+        public RoutingOutputPort HdmiOut { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get;
+            private set;
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get;
+            private set;
+        }
+
+
+        public DeviceConfig _dc;
+
+        CrestronTouchpanelPropertiesConfig PropertiesConfig;
+
+        public DmDge200CController(string key, string name, DmDge200C device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
+            : base(key, name, device)
+        {
+            _dge = device;
+
+            _dc = dc;
+
+            PropertiesConfig = props;
+
+            DmIn = new RoutingInputPort(DmPortName.DmIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DmCat, 0, this);
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, null, this);
+
+
+            InputPorts = new RoutingPortCollection<RoutingInputPort> { DmIn };
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut };
+
+            // Set Ports for CEC
+            HdmiOut.Port = _dge.HdmiOut; ;
+
+        }
+
+        #region IComPorts Members
+
+        public CrestronCollection<ComPort> ComPorts
+        {
+            get { return _dge.ComPorts; }
+        }
+
+        public int NumberOfComPorts
+        {
+            get { return _dge.NumberOfComPorts; }
+        }
+
+        #endregion
+
+        #region IIROutputPorts Members
+
+        public CrestronCollection<IROutputPort> IROutputPorts
+        {
+            get { return _dge.IROutputPorts; }
+        }
+
+        public int NumberOfIROutputPorts
+        {
+            get { return _dge.NumberOfIROutputPorts; }
+        }
+
+        #endregion
+
+    }
+
+    public class DmDge200CControllerFactory : EssentialsDeviceFactory<Dge100Controller>
+    {
+        public DmDge200CControllerFactory()
+        {
+            TypeNames = new List<string>() { "dmdge200c" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            var typeName = dc.Type.ToLower();
+            var comm = CommFactory.GetControlPropertiesConfig(dc);
+            var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
+
+            Debug.Console(1, "Factory Attempting to create new DgeControllerm Device");
+
+            DmDge200C dgeDevice = null;
+
+            if (typeName == "dmdge200c")
+                dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
+
+            if (dgeDevice == null)
+            {
+                Debug.Console(1, "Unable to create DGE device");
+                return null;
+            }
+
+            var dgeController = new DmDge200CController(dc.Key + "-comPorts", dc.Name, dgeDevice, dc, props);
+
+            return dgeController;
+        }
+    }
+}

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

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.DM
 	    private readonly DmRmc200C _rmc;
 
 		public RoutingInputPort DmIn { get; private set; }
-		public RoutingOutputPort HdmiOut { get; private set; }
+		public RoutingOutputPort HdmiOut { get; private set; }
 
 		public RoutingPortCollection<RoutingInputPort> InputPorts
 		{

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

@@ -21,9 +21,9 @@ namespace PepperDash.Essentials.DM
     /// <summary>
     /// Controller class for all DM-TX-201C/S/F transmitters
     /// </summary>
-    public class DmTx201XController : DmTxControllerBase, ITxRouting, IHasFeedback, IHasFreeRun, IVgaBrightnessContrastControls
+    public class DmTx201CController : DmTxControllerBase, ITxRouting, IHasFeedback, IHasFreeRun, IVgaBrightnessContrastControls
 	{
-		public DmTx201S Tx { get; private set; } // uses the 201S class as it is the base class for the 201C
+		public DmTx201C 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; }
@@ -92,7 +92,7 @@ namespace PepperDash.Essentials.DM
 		/// <param name="key"></param>
 		/// <param name="name"></param>
 		/// <param name="tx"></param>
-		public DmTx201XController(string key, string name, DmTx201S tx)
+		public DmTx201CController(string key, string name, DmTx201C tx)
 			: base(key, name, tx)
 		{
 			Tx = tx;

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

@@ -0,0 +1,411 @@
+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.Core.Bridges;
+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 DmTx201SController : DmTxControllerBase, ITxRouting, IHasFeedback, IHasFreeRun, IVgaBrightnessContrastControls
+    {
+        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 BoolFeedback HdmiVideoSyncFeedback { get; protected set; }
+        public BoolFeedback VgaVideoSyncFeedback { get; protected set; }
+
+        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
+
+        public IntFeedback VgaBrightnessFeedback { get; protected set; }
+        public IntFeedback VgaContrastFeedback { get; protected set; }
+
+        /// <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 DmTx201SController(string key, string name, DmTx201S tx)
+            : base(key, name, tx)
+        {
+            Tx = tx;
+
+            HdmiInput = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn,
+                eRoutingSignalType.Audio | eRoutingSignalType.Video, 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.HdcpSupportOnFeedback.BoolValue)
+                    return 1;
+                else
+                    return 0;
+            });
+
+            HdmiVideoSyncFeedback = new BoolFeedback(() =>
+            {
+                return (bool)tx.HdmiInput.SyncDetectedFeedback.BoolValue;
+            });
+
+            VgaVideoSyncFeedback = new BoolFeedback(() =>
+            {
+                return (bool)tx.VgaInput.SyncDetectedFeedback.BoolValue;
+            });
+
+            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
+
+            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
+            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
+
+            tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
+
+            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.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
+
+            DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, null, this);
+            HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, null, this);
+
+            AddToFeedbackList(ActiveVideoInputFeedback, VideoSourceNumericFeedback, AudioSourceNumericFeedback,
+                AnyVideoInput.VideoStatus.HasVideoStatusFeedback, AnyVideoInput.VideoStatus.HdcpActiveFeedback,
+                AnyVideoInput.VideoStatus.HdcpStateFeedback, AnyVideoInput.VideoStatus.VideoResolutionFeedback,
+                AnyVideoInput.VideoStatus.VideoSyncFeedback, HdmiInHdcpCapabilityFeedback, HdmiVideoSyncFeedback,
+                VgaVideoSyncFeedback);
+
+            // Set Ports for CEC
+            HdmiInput.Port = Tx.HdmiInput;
+            VgaInput.Port = Tx.VgaInput;
+            HdmiLoopOut.Port = Tx.HdmiOutput;
+            DmOutput.Port = Tx.DmOutput;
+        }
+
+        void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
+        {
+            var id = args.EventId;
+            Debug.Console(2, this, "EventId {0}", args.EventId);
+
+            if (id == VideoControlsEventIds.BrightnessFeedbackEventId)
+            {
+                VgaBrightnessFeedback.FireUpdate();
+            }
+            else if (id == VideoControlsEventIds.ContrastFeedbackEventId)
+            {
+                VgaContrastFeedback.FireUpdate();
+            }
+        }
+
+        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 override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            DmTxControllerJoinMap joinMap = GetDmTxJoinMap(joinStart, joinMapKey);
+
+            if (HdmiVideoSyncFeedback != null)
+            {
+                HdmiVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input1VideoSyncStatus.JoinNumber]);
+            }
+            if (VgaVideoSyncFeedback != null)
+            {
+                VgaVideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Input2VideoSyncStatus.JoinNumber]);
+            }
+
+            LinkDmTxToApi(this, trilist, joinMap, bridge);
+        }
+
+        /// <summary>
+        /// Enables or disables free run
+        /// </summary>
+        /// <param name="enable"></param>
+        public void SetFreeRunEnabled(bool enable)
+        {
+            if (enable)
+            {
+                Tx.VgaInput.FreeRun = eDmFreeRunSetting.Enabled;
+            }
+            else
+            {
+                Tx.VgaInput.FreeRun = eDmFreeRunSetting.Disabled;
+            }
+        }
+
+        /// <summary>
+        /// Sets the VGA brightness level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaBrightness(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Sets the VGA contrast level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaContrast(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Switches the audio/video source based on the integer value (0-Auto, 1-HDMI, 2-VGA, 3-Disable)
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="output"></param>
+        /// <param name="type"></param>
+        public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
+        {
+            Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
+
+            switch (input)
+            {
+                case 0:
+                    {
+                        ExecuteSwitch(DmTx200Base.eSourceSelection.Auto, null, type);
+                        break;
+                    }
+                case 1:
+                    {
+                        ExecuteSwitch(HdmiInput.Selector, null, type);
+                        break;
+                    }
+                case 2:
+                    {
+                        ExecuteSwitch(VgaInput.Selector, null, type);
+                        break;
+                    }
+                case 3:
+                    {
+                        ExecuteSwitch(DmTx200Base.eSourceSelection.Disable, null, type);
+                        break;
+                    }
+            }
+        }
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            if ((signalType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
+                Tx.VideoSource = (DmTx200Base.eSourceSelection)inputSelector;
+            if ((signalType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
+                Tx.AudioSource = (DmTx200Base.eSourceSelection)inputSelector;
+        }
+
+        void Tx_BaseEvent(GenericBase device, BaseEventArgs args)
+        {
+            var id = args.EventId;
+            Debug.Console(2, this, "EventId {0}", args.EventId);
+
+            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();
+            }
+            else if (args.EventId == EndpointInputStreamEventIds.FreeRunFeedbackEventId)
+            {
+                FreeRunEnabledFeedback.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/DmTxHelpers.cs

@@ -45,8 +45,10 @@ namespace PepperDash.Essentials.DM
                         return new DmTx200Controller(key, name, new DmTx200C2G(ipid, Global.ControlSystem));
                     if (typeName.StartsWith("dmtx4kz100"))
                         return new DmTx4kz100Controller(key, name, new DmTx4kz100C1G(ipid, Global.ControlSystem));
-					if (typeName.StartsWith("dmtx201"))
-						return new DmTx201XController(key, name, new DmTx201S(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmtx201c"))
+						return new DmTx201CController(key, name, new DmTx201C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx201s"))
+                        return new DmTx201SController(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"))
@@ -102,8 +104,10 @@ namespace PepperDash.Essentials.DM
 					{
 						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("dmtx201c"))
+							return new DmTx201CController(key, name, new DmTx201C(chassis.Inputs[num]));
+                        if (typeName.StartsWith("dmtx201s"))
+                            return new DmTx201SController(key, name, new DmTx201S(chassis.Inputs[num]));
 						if (typeName.StartsWith("dmtx4k100"))
 							return new DmTx4k100Controller(key, name, new DmTx4K100C1G(chassis.Inputs[num]));
                         if (typeName.StartsWith("dmtx4kz100"))
@@ -123,8 +127,10 @@ namespace PepperDash.Essentials.DM
 					{
 						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("dmtx201c"))
+							return new DmTx201CController(key, name, new DmTx201C(ipid, chassis.Inputs[num]));
+                        if (typeName.StartsWith("dmtx201s"))
+                            return new DmTx201SController(key, name, new DmTx201S(ipid, chassis.Inputs[num]));
 						if (typeName.StartsWith("dmtx4k100"))
 							return new DmTx4k100Controller(key, name, new DmTx4K100C1G(ipid, chassis.Inputs[num]));
                         if (typeName.StartsWith("dmtx4kz100"))

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

@@ -100,8 +100,10 @@
     <Compile Include="Chassis\DmpsInternalVirtualDmTxController.cs" />
     <Compile Include="Chassis\DmpsRoutingController.cs" />
     <Compile Include="Chassis\HdMdNxM4kEController.cs" />
+    <Compile Include="Endpoints\DGEs\DmDge200CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZ100CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZScalerCController.cs" />
+    <Compile Include="Endpoints\Transmitters\DmTx201SController.cs" />
     <Compile Include="Endpoints\Transmitters\DmTx4kz100Controller.cs" />
     <Compile Include="Endpoints\Transmitters\TxInterfaces.cs" />
     <Compile Include="IDmSwitch.cs" />
@@ -112,7 +114,7 @@
     <Compile Include="Config\HdMdNxM4kEPropertiesConfig.cs" />
     <Compile Include="Config\InputPropertiesConfig.cs" />
     <Compile Include="DmPortName.cs" />
-    <Compile Include="Endpoints\DGEs\DgeController.cs" />
+    <Compile Include="Endpoints\DGEs\Dge100Controller.cs" />
     <Compile Include="Endpoints\DGEs\DgePropertiesConfig.cs" />
     <Compile Include="DmLite\HdMdxxxCEController.cs" />
     <Compile Include="Endpoints\Receivers\DmHdBaseTEndpointController.cs" />