Adds GetJoinMapForDevice method back

somehow was missing from dev branch...

.github/workflows/docker.yml

@@ -11,7 +11,7 @@ on:
 
 env:
   # solution path doesn't need slashes unless there it is multiple folders deep
-  # solution name does not include extension. .sln is assumed  
+  # solution name does not include extension. .sln is assumed
   SOLUTION_PATH: PepperDashEssentials
   SOLUTION_FILE: PepperDashEssentials
   # Do not edit this, we're just creating it here
@@ -52,6 +52,12 @@ jobs:
         run: |
           Write-Output ${{ env.VERSION }}
           ./.github/scripts/UpdateAssemblyVersion.ps1 ${{ env.VERSION }}
+      # Login to Docker
+      - name: Login to Docker
+        uses: azure/docker-login@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
       # Build the solutions in the docker image
       - name: Build Solution
         shell: powershell
@@ -77,9 +83,15 @@ jobs:
           name: Version
           path: ${{env.GITHUB_HOME}}\output\version.txt
       # Create the release on the source repo
+      - name: Create tag for non-rc builds
+        if: contains(env.VERSION, 'alpha') || contains(env.VERSION, 'beta')
+        run: |
+          git tag $($Env:VERSION)
+          git push --tags origin
       - name: Create Release
         id: create_release
         # using contributor's version to allow for pointing at the right commit
+        if: contains(env.VERSION,'-rc-') || contains(env.VERSION,'-hotfix-')
         uses: fleskesvor/create-release@feature/support-target-commitish
         with:
           tag_name: ${{ env.VERSION  }}
@@ -89,6 +101,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       # Upload the build package to the release
       - name: Upload Release Package
+        if: contains(env.VERSION,'-rc-') || contains(env.VERSION,'-hotfix-')
         id: upload_release
         uses: actions/upload-release-asset@v1
         with:
@@ -103,6 +116,8 @@ jobs:
     needs: Build_Project
     runs-on: windows-latest
     steps:
+      - name: check Github ref
+        run: ${{toJson(github.ref)}}
       # Checkout the repo
       - name: Checkout Builds Repo
         uses: actions/checkout@v2
@@ -178,9 +193,11 @@ jobs:
   Public_Push_Output:
     needs: Build_Project
     runs-on: windows-latest
-    if: contains(github.ref, 'master') || contains(github.ref, 'release')
+    if: contains(github.ref, 'master') || contains(github.ref, '/release/')
     steps:
       # Checkout the repo
+      - name: check Github ref
+        run: ${{toJson(github.ref)}}
       - name: Checkout Builds Repo
         uses: actions/checkout@v2
         with:

.github/workflows/master.yml

@@ -44,6 +44,12 @@ jobs:
         run: |
           Write-Output ${{ env.VERSION }}
           ./.github/scripts/UpdateAssemblyVersion.ps1 ${{ env.VERSION }}
+      # Login to Docker
+      - name: Login to Docker
+        uses: azure/docker-login@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
       # Build the solutions in the docker image
       - name: Build Solution
         shell: powershell

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

@@ -9,6 +9,25 @@ namespace PepperDash.Essentials.Core.Bridges
 {
     public class DmChassisControllerJoinMap : JoinMapBaseAdvanced
     {
+        [JoinName("EnableAudioBreakaway")]
+        public JoinDataComplete EnableAudioBreakaway = new JoinDataComplete(
+            new JoinData {JoinNumber = 4, JoinSpan = 1},
+            new JoinMetadata
+            {
+                Label = "DM Chassis enable audio breakaway routing",
+                JoinCapabilities = eJoinCapabilities.ToSIMPL,
+                JoinType = eJoinType.Digital
+            });
+
+        [JoinName("EnableUsbBreakaway")]
+        public JoinDataComplete EnableUsbBreakaway = new JoinDataComplete(
+            new JoinData { JoinNumber = 5, JoinSpan = 1 },
+            new JoinMetadata
+            {
+                Label = "DM Chassis enable USB breakaway routing",
+                JoinCapabilities = eJoinCapabilities.ToSIMPL,
+                JoinType = eJoinType.Digital
+            });
 
         [JoinName("SystemId")]
         public JoinDataComplete SystemId = new JoinDataComplete(new JoinData() { JoinNumber = 10, JoinSpan = 1 },

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

@@ -27,7 +27,16 @@ namespace PepperDash.Essentials.Core
         {
             PropertiesConfig = CommFactory.GetControlPropertiesConfig(config);
 
-            CommPort = CommFactory.CreateCommForDevice(config);
+            var commPort = CommFactory.CreateCommForDevice(config);
+
+            //Fixing decision to require '-comPorts' in delcaration for DGE in order to get a device with comports included
+            if (commPort == null)
+            {
+                config.Key = config.Key + "-comPorts";
+                commPort = CommFactory.CreateCommForDevice(config);
+            }
+
+            CommPort = commPort;
 
         }
 

essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/StatusSign/StatusSignController.cs

@@ -1,127 +1,127 @@
-using System;
-using System.Collections.Generic;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DeviceSupport;
-using Crestron.SimplSharpPro.GeneralIO;
-using Newtonsoft.Json;
-using PepperDash.Core;
-using PepperDash.Essentials.Core.Bridges;
-using PepperDash.Essentials.Core.Config;
-
-namespace PepperDash.Essentials.Core.CrestronIO
-{
-    [Description("Wrapper class for the Crestron StatusSign device")]
-    public class StatusSignController : CrestronGenericBridgeableBaseDevice
-    {
-        private readonly StatusSign _device;
-
-        public BoolFeedback RedLedEnabledFeedback { get; private set; }
-        public BoolFeedback GreenLedEnabledFeedback { get; private set; }
-        public BoolFeedback BlueLedEnabledFeedback { get; private set; }
-
-        public IntFeedback RedLedBrightnessFeedback { get; private set; }
-        public IntFeedback GreenLedBrightnessFeedback { get; private set; }
-        public IntFeedback BlueLedBrightnessFeedback { get; private set; }
-
-        public StatusSignController(string key, string name, GenericBase hardware) : base(key, name, hardware)
-        {
-            _device = hardware as StatusSign;
-
-            RedLedEnabledFeedback =
-                new BoolFeedback(
-                    () =>
-                        _device.Leds[(uint) StatusSign.Led.eLedColor.Red]
-                            .ControlFeedback.BoolValue);
-            GreenLedEnabledFeedback =
-                new BoolFeedback(
-                    () =>
-                        _device.Leds[(uint) StatusSign.Led.eLedColor.Green]
-                            .ControlFeedback.BoolValue);
-            BlueLedEnabledFeedback =
-                new BoolFeedback(
-                    () =>
-                        _device.Leds[(uint) StatusSign.Led.eLedColor.Blue]
-                            .ControlFeedback.BoolValue);
-
-            RedLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Red].BrightnessFeedback);
-            GreenLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Green].BrightnessFeedback);
-            BlueLedBrightnessFeedback =
-                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Blue].BrightnessFeedback);
-
-            if (_device != null) _device.BaseEvent += _device_BaseEvent;
-        }
-
-        void _device_BaseEvent(GenericBase device, BaseEventArgs args)
-        {
-            switch (args.EventId)
-            {
-                case StatusSign.LedBrightnessFeedbackEventId:
-                    RedLedBrightnessFeedback.FireUpdate();
-                    GreenLedBrightnessFeedback.FireUpdate();
-                    BlueLedBrightnessFeedback.FireUpdate();
-                    break;
-                case StatusSign.LedControlFeedbackEventId:
-                    RedLedEnabledFeedback.FireUpdate();
-                    GreenLedEnabledFeedback.FireUpdate();
-                    BlueLedEnabledFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-        public void EnableLedControl(bool red, bool green, bool blue)
-        {
-            _device.Leds[(uint) StatusSign.Led.eLedColor.Red].Control.BoolValue = red;
-            _device.Leds[(uint)StatusSign.Led.eLedColor.Green].Control.BoolValue = green;
-            _device.Leds[(uint)StatusSign.Led.eLedColor.Blue].Control.BoolValue = blue;
-        }
-
-        public void SetColor(uint red, uint green, uint blue)
-        {
-            try
-            {
-                _device.Leds[(uint)StatusSign.Led.eLedColor.Red].Brightness =
-                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(red);
-            }
-            catch (InvalidOperationException)
-            {
-                Debug.Console(1, this, "Error converting value to Red LED brightness. value: {0}", red);
-            }
-            try
-            {
-                _device.Leds[(uint)StatusSign.Led.eLedColor.Green].Brightness =
-                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(green);
-            }
-            catch (InvalidOperationException)
-            {
-                Debug.Console(1, this, "Error converting value to Green LED brightness. value: {0}", green);
-            }
-
-            try
-            {
-                _device.Leds[(uint)StatusSign.Led.eLedColor.Blue].Brightness =
-                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(blue);
-            }
-            catch (InvalidOperationException)
-            {
-                Debug.Console(1, this, "Error converting value to Blue LED brightness. value: {0}", blue);
-            }
-        }
-
-        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.GeneralIO;
+using Newtonsoft.Json;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Core.CrestronIO
+{
+    [Description("Wrapper class for the Crestron StatusSign device")]
+    public class StatusSignController : CrestronGenericBridgeableBaseDevice
+    {
+        private readonly StatusSign _device;
+
+        public BoolFeedback RedLedEnabledFeedback { get; private set; }
+        public BoolFeedback GreenLedEnabledFeedback { get; private set; }
+        public BoolFeedback BlueLedEnabledFeedback { get; private set; }
+
+        public IntFeedback RedLedBrightnessFeedback { get; private set; }
+        public IntFeedback GreenLedBrightnessFeedback { get; private set; }
+        public IntFeedback BlueLedBrightnessFeedback { get; private set; }
+
+        public StatusSignController(string key, string name, GenericBase hardware) : base(key, name, hardware)
         {
-            var joinMap = new StatusSignControllerJoinMap(joinStart);
-
-            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
-
-            if (!string.IsNullOrEmpty(joinMapSerialized))
+            _device = hardware as StatusSign;
+
+            RedLedEnabledFeedback =
+                new BoolFeedback(
+                    () =>
+                        _device.Leds[(uint) StatusSign.Led.eLedColor.Red]
+                            .ControlFeedback.BoolValue);
+            GreenLedEnabledFeedback =
+                new BoolFeedback(
+                    () =>
+                        _device.Leds[(uint) StatusSign.Led.eLedColor.Green]
+                            .ControlFeedback.BoolValue);
+            BlueLedEnabledFeedback =
+                new BoolFeedback(
+                    () =>
+                        _device.Leds[(uint) StatusSign.Led.eLedColor.Blue]
+                            .ControlFeedback.BoolValue);
+
+            RedLedBrightnessFeedback =
+                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Red].BrightnessFeedback);
+            GreenLedBrightnessFeedback =
+                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Green].BrightnessFeedback);
+            BlueLedBrightnessFeedback =
+                new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Blue].BrightnessFeedback);
+
+            if (_device != null) _device.BaseEvent += _device_BaseEvent;
+        }
+
+        void _device_BaseEvent(GenericBase device, BaseEventArgs args)
+        {
+            switch (args.EventId)
+            {
+                case StatusSign.LedBrightnessFeedbackEventId:
+                    RedLedBrightnessFeedback.FireUpdate();
+                    GreenLedBrightnessFeedback.FireUpdate();
+                    BlueLedBrightnessFeedback.FireUpdate();
+                    break;
+                case StatusSign.LedControlFeedbackEventId:
+                    RedLedEnabledFeedback.FireUpdate();
+                    GreenLedEnabledFeedback.FireUpdate();
+                    BlueLedEnabledFeedback.FireUpdate();
+                    break;
+            }
+        }
+
+        public void EnableLedControl(bool red, bool green, bool blue)
+        {
+            _device.Leds[(uint) StatusSign.Led.eLedColor.Red].Control.BoolValue = red;
+            _device.Leds[(uint)StatusSign.Led.eLedColor.Green].Control.BoolValue = green;
+            _device.Leds[(uint)StatusSign.Led.eLedColor.Blue].Control.BoolValue = blue;
+        }
+
+        public void SetColor(uint red, uint green, uint blue)
+        {
+            try
+            {
+                _device.Leds[(uint)StatusSign.Led.eLedColor.Red].Brightness =
+                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(red);
+            }
+            catch (InvalidOperationException)
+            {
+                Debug.Console(1, this, "Error converting value to Red LED brightness. value: {0}", red);
+            }
+            try
+            {
+                _device.Leds[(uint)StatusSign.Led.eLedColor.Green].Brightness =
+                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(green);
+            }
+            catch (InvalidOperationException)
+            {
+                Debug.Console(1, this, "Error converting value to Green LED brightness. value: {0}", green);
+            }
+
+            try
+            {
+                _device.Leds[(uint)StatusSign.Led.eLedColor.Blue].Brightness =
+                    (StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(blue);
+            }
+            catch (InvalidOperationException)
+            {
+                Debug.Console(1, this, "Error converting value to Blue LED brightness. value: {0}", blue);
+            }
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new StatusSignControllerJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
                 joinMap = JsonConvert.DeserializeObject<StatusSignControllerJoinMap>(joinMapSerialized);
 
-            bridge.AddJoinMap(Key, joinMap);
-
-            Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
-
+            bridge.AddJoinMap(Key, joinMap);
+
+            Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
             trilist.SetBoolSigAction(joinMap.RedControl.JoinNumber, b => EnableControl(trilist, joinMap, this));
             trilist.SetBoolSigAction(joinMap.GreenControl.JoinNumber, b => EnableControl(trilist, joinMap, this));
             trilist.SetBoolSigAction(joinMap.BlueControl.JoinNumber, b => EnableControl(trilist, joinMap, this));
@@ -139,44 +139,44 @@ namespace PepperDash.Essentials.Core.CrestronIO
 
             RedLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.RedLed.JoinNumber]);
             BlueLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.BlueLed.JoinNumber]);
-            GreenLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.GreenLed.JoinNumber]);
-        }
-
-        private static void EnableControl(BasicTriList triList, StatusSignControllerJoinMap joinMap,
-            StatusSignController device)
+            GreenLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.GreenLed.JoinNumber]);
+        }
+
+        private static void EnableControl(BasicTriList triList, StatusSignControllerJoinMap joinMap,
+            StatusSignController device)
         {
             var redEnable = triList.BooleanOutput[joinMap.RedControl.JoinNumber].BoolValue;
             var greenEnable = triList.BooleanOutput[joinMap.GreenControl.JoinNumber].BoolValue;
-            var blueEnable = triList.BooleanOutput[joinMap.BlueControl.JoinNumber].BoolValue;
-            device.EnableLedControl(redEnable, greenEnable, blueEnable);
-        }
-
-        private static void SetColor(BasicTriList triList, StatusSignControllerJoinMap joinMap,
-            StatusSignController device)
+            var blueEnable = triList.BooleanOutput[joinMap.BlueControl.JoinNumber].BoolValue;
+            device.EnableLedControl(redEnable, greenEnable, blueEnable);
+        }
+
+        private static void SetColor(BasicTriList triList, StatusSignControllerJoinMap joinMap,
+            StatusSignController device)
         {
             var redBrightness = triList.UShortOutput[joinMap.RedLed.JoinNumber].UShortValue;
             var greenBrightness = triList.UShortOutput[joinMap.GreenLed.JoinNumber].UShortValue;
-            var blueBrightness = triList.UShortOutput[joinMap.BlueLed.JoinNumber].UShortValue;
-
-            device.SetColor(redBrightness, greenBrightness, blueBrightness);
-        }
-    }
-
-    public class StatusSignControllerFactory : EssentialsDeviceFactory<StatusSignController>
-    {
-        public StatusSignControllerFactory()
-        {
-            TypeNames = new List<string>() { "statussign" };
-        }
-
-        public override EssentialsDevice BuildDevice(DeviceConfig dc)
-        {
-            Debug.Console(1, "Factory Attempting to create new StatusSign Device");
-
-            var control = CommFactory.GetControlPropertiesConfig(dc);
-            var cresnetId = control.CresnetIdInt;
-
-            return new StatusSignController(dc.Key, dc.Name, new StatusSign(cresnetId, Global.ControlSystem));
-        }
-    }
+            var blueBrightness = triList.UShortOutput[joinMap.BlueLed.JoinNumber].UShortValue;
+
+            device.SetColor(redBrightness, greenBrightness, blueBrightness);
+        }
+    }
+
+    public class StatusSignControllerFactory : EssentialsDeviceFactory<StatusSignController>
+    {
+        public StatusSignControllerFactory()
+        {
+            TypeNames = new List<string>() { "statussign" };
+        }
+
+        public override EssentialsDevice BuildDevice(DeviceConfig dc)
+        {
+            Debug.Console(1, "Factory Attempting to create new StatusSign Device");
+
+            var control = CommFactory.GetControlPropertiesConfig(dc);
+            var cresnetId = control.CresnetIdInt;
+
+            return new StatusSignController(dc.Key, dc.Name, new StatusSign(cresnetId, Global.ControlSystem));
+        }
+    }
 }

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

@@ -27,6 +27,11 @@ namespace PepperDash.Essentials.Core
             return joinMap;
         }
 
+        public static string GetJoinMapForDevice(string joinMapKey)
+        {
+            return GetSerializedJoinMapForDevice(joinMapKey);
+        }
+
         /// <summary>
         /// Attempts to find a custom join map by key and returns it deserialized if found
         /// </summary>

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

@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DeviceSupport;
 using Crestron.SimplSharpPro.DM;
 using Crestron.SimplSharpPro.DM.Cards;
@@ -42,6 +43,8 @@ namespace PepperDash.Essentials.DM
 
         public IntFeedback SystemIdFeebdack { get; private set; }
         public BoolFeedback SystemIdBusyFeedback { get; private set; }
+        public BoolFeedback EnableAudioBreakawayFeedback { get; private set; }
+        public BoolFeedback EnableUsbBreakawayFeedback { get; private set; }
 
         public Dictionary<uint, IntFeedback> InputCardHdcpCapabilityFeedbacks { get; private set; }
 
@@ -210,6 +213,11 @@ namespace PepperDash.Essentials.DM
 
             SystemIdFeebdack = new IntFeedback(() => { return (Chassis as DmMDMnxn).SystemIdFeedback.UShortValue; });
             SystemIdBusyFeedback = new BoolFeedback(() => { return (Chassis as DmMDMnxn).SystemIdBusy.BoolValue; });
+            EnableAudioBreakawayFeedback =
+                new BoolFeedback(() => (Chassis as DmMDMnxn).EnableAudioBreakawayFeedback.BoolValue);
+            EnableUsbBreakawayFeedback =
+                new BoolFeedback(() => (Chassis as DmMDMnxn).EnableUSBBreakawayFeedback.BoolValue);
+
             InputCardHdcpCapabilityFeedbacks = new Dictionary<uint, IntFeedback>();
             InputCardHdcpCapabilityTypes = new Dictionary<uint, eHdcpCapabilityType>();
 
@@ -376,6 +384,11 @@ namespace PepperDash.Essentials.DM
             }
         }
 
+        private void ChassisOnBaseEvent(GenericBase device, BaseEventArgs args)
+        {
+            
+        }
+
         /// <summary>
         /// 
         /// </summary>
@@ -768,6 +781,20 @@ namespace PepperDash.Essentials.DM
                     SystemIdBusyFeedback.FireUpdate();
                     break;
                 }
+                case DMSystemEventIds.AudioBreakawayEventId:
+                {
+                    Debug.Console(2, this, "AudioBreakaway Event: value: {0}",
+                        (Chassis as DmMDMnxn).EnableAudioBreakawayFeedback.BoolValue);
+                    EnableAudioBreakawayFeedback.FireUpdate();
+                    break;
+                }
+                case DMSystemEventIds.USBBreakawayEventId:
+                {
+                    Debug.Console(2, this, "USBBreakaway Event: value: {0}",
+                        (Chassis as DmMDMnxn).EnableUSBBreakawayFeedback.BoolValue);
+                    EnableUsbBreakawayFeedback.FireUpdate();
+                    break;
+                }
             }
         }
 
@@ -927,6 +954,10 @@ namespace PepperDash.Essentials.DM
                 (Chassis as DmMDMnxn).EnableAudioBreakaway.BoolValue = true;
                 (Chassis as DmMDMnxn).EnableUSBBreakaway.BoolValue = true;
 
+
+                EnableAudioBreakawayFeedback.FireUpdate();
+                EnableUsbBreakawayFeedback.FireUpdate();
+
                 if (InputNames != null)
                     foreach (var kvp in InputNames)
                         Chassis.Inputs[kvp.Key].Name.StringValue = kvp.Value;
@@ -944,6 +975,10 @@ namespace PepperDash.Essentials.DM
             var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
             var output = Convert.ToUInt32(outputSelector);
 
+            var chassisSize = (uint) Chassis.NumberOfInputs; //need this to determine USB routing values 8x8 -> 1-8 is inputs 1-8, 17-24 is outputs 1-8
+                                                      //16x16 1-16 is inputs 1-16, 17-32 is outputs 1-16
+                                                      //32x32 1-32 is inputs 1-32, 33-64 is outputs 1-32
+
             // 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)
@@ -964,30 +999,97 @@ namespace PepperDash.Essentials.DM
             var outCard = input == 0 ? null : Chassis.Outputs[output];
 
             // NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES 
-            if ((sigType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
+            if ((sigType & eRoutingSignalType.Video) == eRoutingSignalType.Video)
             {
                 Chassis.VideoEnter.BoolValue = true;
                 Chassis.Outputs[output].VideoOut = inCard;
             }
 
-            if ((sigType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
+            if ((sigType & eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
             {
                 (Chassis as DmMDMnxn).AudioEnter.BoolValue = true;
                 Chassis.Outputs[output].AudioOut = inCard;
             }
 
-            if ((sigType | eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
+            if ((sigType & eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
             {
+                //using base here because USB can be routed between 2 output cards or 2 input cards
+                DMInputOutputBase dmCard;
+
+                Debug.Console(2, this, "Executing USB Output switch.\r\n in:{0} output: {1}", input, output);
+
+                if (input > chassisSize)
+                {
+                    //wanting to route an output to an output. Subtract chassis size and get output, unless it's 8x8
+                    //need this to determine USB routing values
+                    //8x8 -> 1-8 is inputs 1-8, 17-24 is outputs 1-8
+                    //16x16 1-16 is inputs 1-16, 17-32 is outputs 1-16
+                    //32x32 1-32 is inputs 1-32, 33-64 is outputs 1-32
+                    uint outputIndex;
+
+                    if (chassisSize == 8)
+                    {
+                        outputIndex = input - 16;
+                    }
+                    else
+                    {
+                        outputIndex = input - chassisSize;
+                    }
+                    dmCard = Chassis.Outputs[outputIndex];
+                }
+                else
+                {
+                    dmCard = inCard;
+                }
                 Chassis.USBEnter.BoolValue = true;
                 if (Chassis.Outputs[output] != null)
-                    Chassis.Outputs[output].USBRoutedTo = inCard;
+                {
+                    Debug.Console(2, this, "Routing USB for input {0} to {1}", Chassis.Outputs[input], dmCard);
+                    Chassis.Outputs[output].USBRoutedTo = dmCard;
+                }
             }
 
-            if ((sigType | eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
+            if ((sigType & eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
             {
+                //using base here because USB can be routed between 2 output cards or 2 input cards
+                DMInputOutputBase dmCard;
+
+                Debug.Console(2, this, "Executing USB Input switch.\r\n in:{0} output: {1}", input, output);
+
+                if (output > chassisSize)
+                {
+                    //wanting to route an input to an output. Subtract chassis size and get output, unless it's 8x8
+                    //need this to determine USB routing values
+                    //8x8 -> 1-8 is inputs 1-8, 17-24 is outputs 1-8
+                    //16x16 1-16 is inputs 1-16, 17-32 is outputs 1-16
+                    //32x32 1-32 is inputs 1-32, 33-64 is outputs 1-32
+                    uint outputIndex;
+
+                    if (chassisSize == 8)
+                    {
+                        outputIndex = input - 16;
+                    }
+                    else
+                    {
+                        outputIndex = input - chassisSize;
+                    }
+                    dmCard = Chassis.Outputs[outputIndex];
+                }
+                else
+                {
+                    dmCard = Chassis.Inputs[input];
+                }
+
+                
+
                 Chassis.USBEnter.BoolValue = true;
-                if (Chassis.Inputs[input] != null)
-                    Chassis.Inputs[input].USBRoutedTo = outCard;
+
+                if (Chassis.Inputs[output] == null)
+                {
+                    return;
+                }
+                Debug.Console(2, this, "Routing USB for input {0} to {1}", Chassis.Inputs[output], dmCard);
+                Chassis.Inputs[output].USBRoutedTo = dmCard;
             }
         }
         #endregion
@@ -1023,6 +1125,19 @@ namespace PepperDash.Essentials.DM
             SystemIdFeebdack.LinkInputSig(trilist.UShortInput[joinMap.SystemId.JoinNumber]);
             SystemIdBusyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.SystemId.JoinNumber]);
 
+            EnableAudioBreakawayFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableAudioBreakaway.JoinNumber]);
+            EnableUsbBreakawayFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsbBreakaway.JoinNumber]);
+
+            trilist.OnlineStatusChange += (o, a) =>
+            {
+                if (!a.DeviceOnLine) return;
+
+                EnableAudioBreakawayFeedback.FireUpdate();
+                EnableUsbBreakawayFeedback.FireUpdate();
+                SystemIdBusyFeedback.FireUpdate();
+                SystemIdFeebdack.FireUpdate();
+            };
+
             // Link up outputs
             for (uint i = 1; i <= Chassis.NumberOfOutputs; i++)
             {

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

@@ -4,7 +4,10 @@ using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.UI;
+using Crestron.SimplSharpPro.UI;
+
+using Crestron.SimplSharpPro.DM;
+
 
 using Newtonsoft.Json;
 
@@ -18,17 +21,17 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
     /// <summary>
     /// Wrapper class for DGE-100 and DM-DGE-200-C
     /// </summary>
-    public class DgeController : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject
+    public class Dge100Controller : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject, ICec
     {
         private readonly Dge100 _dge;
 
         public BasicTriListWithSmartObject Panel { get { return _dge; } }
 
-        public DeviceConfig _dc;
+        private 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)
         {
             _dge = device;
@@ -64,14 +67,19 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             get { return _dge.NumberOfIROutputPorts; }
         }
 
+        #endregion
+
+        #region ICec Members
+        public Cec StreamCec { get { return _dge.HdmiOut.StreamCec; } }
         #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)
@@ -80,13 +88,11 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             var comm = CommFactory.GetControlPropertiesConfig(dc);
             var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
 
-            Debug.Console(1, "Factory Attempting to create new DgeControllerm Device");
+            Debug.Console(1, "Factory Attempting to create new DgeController Device");
 
             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)
             {
@@ -94,7 +100,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, dc.Name, dgeDevice, dc, props);
 
             return dgeController;
         }

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

@@ -0,0 +1,93 @@
+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;
+
+using Crestron.SimplSharpPro.DM;
+
+namespace PepperDash.Essentials.DM.Endpoints.DGEs
+{
+    /// <summary>
+    /// Wrapper class for DGE-100 and DM-DGE-200-C
+    /// </summary>
+    public class DmDge200CController : Dge100Controller, IRoutingInputsOutputs
+    {
+        private readonly DmDge200C _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 DmDge200CController(string key, string name, DmDge200C device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
+            : base(key, name, device, dc, props)
+        {
+            _dge = device;
+
+            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; ;
+
+        }
+
+        public class DmDge200CControllerFactory : EssentialsDeviceFactory<DmDge200CController>
+        {
+            public DmDge200CControllerFactory()
+            {
+                TypeNames = new List<string>() { "dmdge200c" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                var typeName = dc.Type.ToLower();
+                var comm = CommFactory.GetControlPropertiesConfig(dc);
+                var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
+
+                Debug.Console(1, "Factory Attempting to create new DgeController  Device");
+
+                DmDge200C dgeDevice = null;
+
+                if (typeName == "dmdge200c")
+                    dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
+
+                if (dgeDevice == null)
+                {
+                    Debug.Console(1, "Unable to create DGE device");
+                    return null;
+                }
+
+                var dgeController = new DmDge200CController(dc.Key , dc.Name, dgeDevice, dc, props);
+
+                return dgeController;
+            }
+        }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Endpoints/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" />