Fixed syntax issue in CustomActivate()

Bugfix/ecs 1190

Approved-by: Neil Dorin <ndorin@pepperdash.com>

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "essentials-framework/pepperdashcore-builds"]
+	path = essentials-framework/pepperdashcore-builds
+	url = https://bitbucket.org/Pepperdash_Products/pepperdashcore-builds.git

PepperDashEssentials/AppServer/Messengers/Ddvc01VtcMessenger.cs

@@ -132,6 +132,14 @@ namespace PepperDash.Essentials.AppServer.Messengers
 		/// 842
 		/// </summary>
 		const uint BCameraLayout = 842;
+		/// <summary>
+		/// 843
+		/// </summary>
+		const uint BCameraSupportsAutoMode = 843;
+		/// <summary>
+		/// 844
+		/// </summary>
+		const uint BCameraSupportsOffMode = 844;
 
 
 		/********* Ushorts *********/
@@ -294,6 +302,21 @@ namespace PepperDash.Essentials.AppServer.Messengers
 				PostCallsList();
 			});
 
+			EISC.SetBoolSigAction(BCameraSupportsAutoMode, b =>
+			{
+				PostStatusMessage(new
+				{	
+					cameraSupportsAutoMode = b
+				});
+			});
+			EISC.SetBoolSigAction(BCameraSupportsOffMode, b =>
+			{
+				PostStatusMessage(new
+				{
+					cameraSupportsOffMode = b
+				});
+			});
+
 			// Directory insanity
 			EISC.SetUShortSigAction(UDirectoryRowCount, u =>
 			{
@@ -455,6 +478,8 @@ namespace PepperDash.Essentials.AppServer.Messengers
 				calls = GetCurrentCallList(),
 				cameraMode = GetCameraMode(),
 				cameraSelfView = EISC.GetBool(BCameraSelfView),
+				cameraSupportsAutoMode = EISC.GetBool(BCameraSupportsAutoMode),
+				cameraSupportsOffMode = EISC.GetBool(BCameraSupportsOffMode),
 				currentCallString = EISC.GetString(SCurrentCallNumber),
 				currentDialString = EISC.GetString(SCurrentDialString),
 				directoryContactSelected = new

PepperDashEssentials/AppServer/RoomBridges/CotijaDdvc01RoomBridge.cs

@@ -81,6 +81,7 @@ namespace PepperDash.Essentials.Room.Cotija
 			/// 72
 			/// </summary>
 			public const uint SourceHasChanged = 71;
+
 			/// <summary>
 			/// 261 - The start of the range of speed dial visibles
 			/// </summary>
@@ -98,9 +99,17 @@ namespace PepperDash.Essentials.Room.Cotija
 			/// </summary>
 			public const uint ShowCameraWhenNotInCall = 503;
 			/// <summary>
+			/// 504
+			/// </summary>
+			public const uint UseSourceEnabled = 504;
+			/// <summary>
 			/// 601
 			/// </summary>
-			public const uint SourceShareDisableStartJoin = 601;
+			public const uint SourceShareDisableJoinStart = 601;
+			/// <summary>
+			/// 621
+			/// </summary>
+			public const uint SourceIsEnabledJoinStart = 621;
 
 		}
 
@@ -121,7 +130,7 @@ namespace PepperDash.Essentials.Room.Cotija
 			/// <summary>
 			/// 101
 			/// </summary>
-			public const uint VolumeSliderCount = 101;
+			public const uint NumberOfAuxFaders = 101;
 		}
 
 		public class StringJoin
@@ -344,6 +353,10 @@ namespace PepperDash.Essentials.Room.Cotija
 				EISC.PulseBool(BoolJoin.MasterVolumeIsMuted)));
 			Parent.AddAction(@"/room/room1/volumes/master/privacyMuteToggle", new Action(() =>
 				EISC.PulseBool(BoolJoin.PrivacyMute)));
+
+
+			// /xyzxyz/volumes/master/muteToggle ---> BoolInput[1]
+
 			for (uint i = 2; i <= 7; i++)
 			{
 				var index = i;
@@ -410,6 +423,10 @@ namespace PepperDash.Essentials.Room.Cotija
                         }
                     }
                 }));
+
+			// map MasterVolumeIsMuted join -> status/volumes/master/muted
+			// 
+
 			EISC.SetBoolSigAction(BoolJoin.MasterVolumeIsMuted, b =>
                 PostStatusMessage(new
                 {
@@ -464,6 +481,12 @@ namespace PepperDash.Essentials.Room.Cotija
 				});
 			}
 
+			EISC.SetUShortSigAction(UshortJoin.NumberOfAuxFaders, u => 
+				PostStatusMessage(new {
+					volumes = new {
+						numberOfAuxFaders = u,
+					}
+				}));
 
 			// shutdown things
 			EISC.SetSigTrueAction(BoolJoin.ShutdownCancel, new Action(() =>
@@ -558,7 +581,7 @@ namespace PepperDash.Essentials.Room.Cotija
 			rmProps.VideoCodecKey = "videoCodec";
 
 			// volume control names
-			var volCount = EISC.UShortOutput[UshortJoin.VolumeSliderCount].UShortValue;
+			var volCount = EISC.UShortOutput[UshortJoin.NumberOfAuxFaders].UShortValue;
 
             //// use Volumes object or?
             //rmProps.VolumeSliderNames = new List<string>();
@@ -604,12 +627,17 @@ namespace PepperDash.Essentials.Room.Cotija
 			for (uint i = 0; i <= 19; i++)
 			{
 				var name = EISC.StringOutput[StringJoin.SourceNameJoinStart + i].StringValue;
-				if(string.IsNullOrEmpty(name))
+				if (EISC.BooleanOutput[BoolJoin.UseSourceEnabled].BoolValue
+					&& !EISC.BooleanOutput[BoolJoin.SourceIsEnabledJoinStart + i].BoolValue)
+				{
+					continue;
+				}		
+				else if(!EISC.BooleanOutput[BoolJoin.UseSourceEnabled].BoolValue && string.IsNullOrEmpty(name))
 					break;
 				var icon = EISC.StringOutput[StringJoin.SourceIconJoinStart + i].StringValue;
 				var key = EISC.StringOutput[StringJoin.SourceKeyJoinStart + i].StringValue;
 				var type = EISC.StringOutput[StringJoin.SourceTypeJoinStart + i].StringValue;
-				var disableShare = EISC.BooleanOutput[BoolJoin.SourceShareDisableStartJoin + i].BoolValue;
+				var disableShare = EISC.BooleanOutput[BoolJoin.SourceShareDisableJoinStart + i].BoolValue;
 
 				Debug.Console(0, this, "Adding source {0} '{1}'", key, name);
 				var newSLI = new SourceListItem{
@@ -745,7 +773,7 @@ namespace PepperDash.Essentials.Room.Cotija
 		{
 			if (ConfigIsLoaded)
 			{
-                var count = EISC.UShortOutput[101].UShortValue;
+                var count = EISC.UShortOutput[UshortJoin.NumberOfAuxFaders].UShortValue;
 
                 Debug.Console(1, this, "The Fader Count is : {0}", count);
 
@@ -776,6 +804,7 @@ namespace PepperDash.Essentials.Room.Cotija
 				volumes.Master.PrivacyMuted = EISC.BooleanOutput[BoolJoin.PrivacyMute].BoolValue;
 
                 volumes.AuxFaders = auxFaderDict;
+				volumes.NumberOfAuxFaders = EISC.UShortInput[UshortJoin.NumberOfAuxFaders].UShortValue;
 
                 PostStatusMessage(new
                     {
@@ -862,6 +891,7 @@ namespace PepperDash.Essentials.Room.Cotija
 			var d = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
 			{
 				{ "laptop", "pc" },
+				{ "pc", "pc" },
 				{ "wireless", "genericsource" },
 				{ "iptv", "settopbox" }
 

PepperDashEssentials/AppServer/Volumes.cs

@@ -16,6 +16,9 @@ namespace PepperDash.Essentials.Room.Cotija
 		[JsonProperty("auxFaders")]
 		public Dictionary<string, Volume> AuxFaders { get; set; }
 
+		[JsonProperty("numberOfAuxFaders")]
+		public int NumberOfAuxFaders { get; set; }
+
 		public Volumes()
 		{
 			AuxFaders = new Dictionary<string, Volume>();	

PepperDashEssentials/Bridges/BridgeBase.cs

@@ -103,11 +103,14 @@ namespace PepperDash.Essentials.Bridges
 							(device as DisplayBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
 							continue;
 						}
-                        else if (device is DmChassisController)
-                        {
+                        else if (device is DmChassisController) {
                             (device as DmChassisController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
                             continue;
                         }
+                        else if (device is DmBladeChassisController) {
+                            (device as DmBladeChassisController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
                         else if (device is DmpsRoutingController)
                         {
                             (device as DmpsRoutingController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
@@ -158,6 +161,11 @@ namespace PepperDash.Essentials.Bridges
                             (device as DigitalLogger).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
                             continue;
                         }
+                        else if (device is PepperDash.Essentials.Devices.Common.Occupancy.GlsOccupancySensorBaseController)
+                        {
+                            (device as PepperDash.Essentials.Devices.Common.Occupancy.GlsOccupancySensorBaseController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
                     }
                 }
 

PepperDashEssentials/Bridges/DmBladeChassisControllerBridge.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges {
+    public static class DmBladeChassisControllerApiExtentions {
+        public static void LinkToApi(this DmBladeChassisController dmChassis, BasicTriList trilist, uint joinStart, string joinMapKey) {
+            DmBladeChassisControllerJoinMap joinMap = new DmBladeChassisControllerJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DmBladeChassisControllerJoinMap>(joinMapSerialized);
+
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, dmChassis, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            var chassis = dmChassis.Chassis as BladeSwitch;
+
+            dmChassis.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+
+
+            // Link up outputs
+            for (uint i = 1; i <= dmChassis.Chassis.NumberOfOutputs; i++) {
+                var ioSlot = i;
+
+                // Control
+                trilist.SetUShortSigAction(joinMap.OutputVideo + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Video)));
+
+                if (dmChassis.TxDictionary.ContainsKey(ioSlot)) {
+                    Debug.Console(2, "Creating Tx Feedbacks {0}", ioSlot);
+                    var txKey = dmChassis.TxDictionary[ioSlot];
+                    var basicTxDevice = DeviceManager.GetDeviceForKey(txKey) as BasicDmTxControllerBase;
+
+                    var advancedTxDevice = basicTxDevice as DmTxControllerBase;
+
+                    if (dmChassis.Chassis is DmMd128x128 || dmChassis.Chassis is DmMd64x64) {
+                        dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                    }
+                    else {
+                        if (advancedTxDevice != null) {
+                            advancedTxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                            Debug.Console(2, "Linking Tx Online Feedback from Advanced Transmitter at input {0}", ioSlot);
+                        }
+                        else if (dmChassis.InputEndpointOnlineFeedbacks[ioSlot] != null) {
+                            Debug.Console(2, "Linking Tx Online Feedback from Input Card {0}", ioSlot);
+                            dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                        }
+                    }
+
+                    if (basicTxDevice != null && advancedTxDevice == null)
+                        trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
+
+                    if (advancedTxDevice != null) {
+                        advancedTxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+                    }
+                    else if (advancedTxDevice == null || basicTxDevice != null) {
+                        Debug.Console(1, "Setting up actions and feedbacks on input card {0}", ioSlot);
+                        dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                        var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
+                        if (inputPort != null) {
+                            Debug.Console(1, "Port value for input card {0} is set", ioSlot);
+                            var port = inputPort.Port;
+
+                            if (port != null) {
+                                if (port is HdmiInputWithCEC) {
+                                    Debug.Console(1, "Port is HdmiInputWithCec");
+
+                                    var hdmiInPortWCec = port as HdmiInputWithCEC;
+
+                                    if (hdmiInPortWCec.HdcpSupportedLevel != eHdcpSupportedLevel.Unknown) {
+                                        SetHdcpStateAction(true, hdmiInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                    }
+
+                                    dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+
+                                    if (dmChassis.InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    else
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = 1;
+                                }
+                            }
+                        }
+                        else {
+                            inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--dmIn", ioSlot)];
+
+                            if (inputPort != null) {
+                                var port = inputPort.Port;
+
+                                if (port is DMInputPortWithCec) {
+                                    Debug.Console(1, "Port is DMInputPortWithCec");
+
+                                    var dmInPortWCec = port as DMInputPortWithCec;
+
+                                    if (dmInPortWCec != null) {
+                                        SetHdcpStateAction(dmChassis.PropertiesConfig.InputSlotSupportsHdcp2[ioSlot], dmInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                    }
+
+                                    dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+
+                                    if (dmChassis.InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    else
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = 1;
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+
+                    var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
+                    if (inputPort != null) {
+                        var hdmiPort = inputPort.Port as EndpointHdmiInput;
+
+                        if (hdmiPort != null) {
+                            SetHdcpStateAction(true, hdmiPort, joinMap.HdcpSupportState + ioSlot, trilist);
+                            dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+                        }
+                    }
+                }
+                if (dmChassis.RxDictionary.ContainsKey(ioSlot)) {
+                    Debug.Console(2, "Creating Rx Feedbacks {0}", ioSlot);
+                    //var rxKey = dmChassis.RxDictionary[ioSlot];
+                    //var rxDevice = DeviceManager.GetDeviceForKey(rxKey) as DmRmcControllerBase;
+                    //var hdBaseTDevice = DeviceManager.GetDeviceForKey(rxKey) as DmHdBaseTControllerBase;
+                    //if (hdBaseTDevice != null) {
+                        dmChassis.OutputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+                    //}
+                    //else if (rxDevice != null) {
+                    //    rxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+                    //}
+                }
+
+                // Feedback
+                dmChassis.VideoOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputVideo + ioSlot]);
+
+
+                dmChassis.OutputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputNames + ioSlot]);
+                dmChassis.InputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.InputNames + ioSlot]);
+                dmChassis.OutputVideoRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentVideoInputNames + ioSlot]);
+            }
+        }
+
+        static void SetHdcpStateAction(bool hdcpTypeSimple, HdmiInputWithCEC port, uint join, BasicTriList trilist) {
+            if (hdcpTypeSimple) {
+                trilist.SetUShortSigAction(join,
+                    new Action<ushort>(s => {
+                        if (s == 0) {
+                            port.HdcpSupportOff();
+                        }
+                        else if (s > 0) {
+                            port.HdcpSupportOn();
+                        }
+                    }));
+            }
+            else {
+                trilist.SetUShortSigAction(join,
+                        new Action<ushort>(u => {
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+        static void SetHdcpStateAction(bool hdcpTypeSimple, EndpointHdmiInput port, uint join, BasicTriList trilist) {
+            if (hdcpTypeSimple) {
+                trilist.SetUShortSigAction(join,
+                    new Action<ushort>(s => {
+                        if (s == 0) {
+                            port.HdcpSupportOff();
+                        }
+                        else if (s > 0) {
+                            port.HdcpSupportOn();
+                        }
+                    }));
+            }
+            else {
+                trilist.SetUShortSigAction(join,
+                        new Action<ushort>(u => {
+                            port.HdcpCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+        static void SetHdcpStateAction(bool supportsHdcp2, DMInputPortWithCec port, uint join, BasicTriList trilist) {
+            if (!supportsHdcp2) {
+                trilist.SetUShortSigAction(join,
+                    new Action<ushort>(s => {
+                        if (s == 0) {
+                            port.HdcpSupportOff();
+                        }
+                        else if (s > 0) {
+                            port.HdcpSupportOn();
+                        }
+                    }));
+            }
+            else {
+                trilist.SetUShortSigAction(join,
+                        new Action<ushort>(u => {
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+    }
+}

PepperDashEssentials/Bridges/DmChassisControllerBridge.cs

@@ -32,10 +32,12 @@ namespace PepperDash.Essentials.Bridges
 
             Debug.Console(1, dmChassis, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
 
+            var chassis = dmChassis.Chassis as DmMDMnxn;
+
             dmChassis.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
 
-            trilist.SetUShortSigAction(joinMap.SystemId, new Action<ushort>(o => dmChassis.Chassis.SystemId.UShortValue = o));
-            trilist.SetSigTrueAction(joinMap.SystemId, new Action(() => dmChassis.Chassis.ApplySystemId()));
+            trilist.SetUShortSigAction(joinMap.SystemId, new Action<ushort>(o => chassis.SystemId.UShortValue = o));
+            trilist.SetSigTrueAction(joinMap.SystemId, new Action(() => chassis.ApplySystemId()));
 
             dmChassis.SystemIdFeebdack.LinkInputSig(trilist.UShortInput[joinMap.SystemId]);
             dmChassis.SystemIdBusyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.SystemId]);
@@ -57,7 +59,7 @@ namespace PepperDash.Essentials.Bridges
                     var txKey = dmChassis.TxDictionary[ioSlot];
                     var basicTxDevice = DeviceManager.GetDeviceForKey(txKey) as BasicDmTxControllerBase;
 
-                    var txDevice = basicTxDevice as DmTxControllerBase;
+                    var advancedTxDevice = basicTxDevice as DmTxControllerBase;
 
                     if (dmChassis.Chassis is DmMd8x8Cpu3 || dmChassis.Chassis is DmMd8x8Cpu3rps
                         || dmChassis.Chassis is DmMd16x16Cpu3 || dmChassis.Chassis is DmMd16x16Cpu3rps
@@ -67,43 +69,83 @@ namespace PepperDash.Essentials.Bridges
                     }
                     else
                     {
-                        if (txDevice != null)
+                        if (advancedTxDevice != null)
                         {
-                            txDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                            advancedTxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                            Debug.Console(2, "Linking Tx Online Feedback from Advanced Transmitter at input {0}", ioSlot);
+                        }
+                        else if (dmChassis.InputEndpointOnlineFeedbacks[ioSlot] != null)
+                        {
+                            Debug.Console(2, "Linking Tx Online Feedback from Input Card {0}", ioSlot);
+                            dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);                           
                         }
                     }
 
-                    if (basicTxDevice != null && txDevice == null)
+                    if (basicTxDevice != null && advancedTxDevice == null)
                         trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
 
-
-                    if (txDevice != null)
+                    if (advancedTxDevice != null)
                     {
-                        txDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
+                        advancedTxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
                     }
-                    else
+                    else if(advancedTxDevice == null || basicTxDevice != null)
                     {
+                        Debug.Console(1, "Setting up actions and feedbacks on input card {0}", ioSlot);
                         dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
 
                         var inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
                         if (inputPort != null)
                         {
-                            var hdmiInPort = inputPort.Port;
+                            Debug.Console(1, "Port value for input card {0} is set", ioSlot);
+                            var port = inputPort.Port;
 
-                            if (hdmiInPort != null)
+                            if (port != null)
                             {
-                                if (hdmiInPort is HdmiInputWithCEC)
+                                if (port is HdmiInputWithCEC)
                                 {
-                                    var hdmiInPortWCec = hdmiInPort as HdmiInputWithCEC;
+                                    Debug.Console(1, "Port is HdmiInputWithCec");
+
+                                    var hdmiInPortWCec = port as HdmiInputWithCEC;
 
                                     if (hdmiInPortWCec.HdcpSupportedLevel != eHdcpSupportedLevel.Unknown)
                                     {
-                                        SetHdcpCapabilityAction(true, hdmiInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                        SetHdcpStateAction(true, hdmiInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
                                     }
 
                                     dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
 
-                                    trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    if(dmChassis.InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    else
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = 1;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            inputPort = dmChassis.InputPorts[string.Format("inputCard{0}--dmIn", ioSlot)];
+
+                            if(inputPort != null)
+                            {
+                                var port = inputPort.Port;
+
+                                if (port is DMInputPortWithCec)
+                                {
+                                    Debug.Console(1, "Port is DMInputPortWithCec");
+
+                                    var dmInPortWCec = port as DMInputPortWithCec;
+
+                                    if (dmInPortWCec != null)
+                                    {
+                                        SetHdcpStateAction(dmChassis.PropertiesConfig.InputSlotSupportsHdcp2[ioSlot], dmInPortWCec, joinMap.HdcpSupportState + ioSlot, trilist);
+                                    }
+
+                                    dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
+
+                                    if (dmChassis.InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = (ushort)dmChassis.InputCardHdcpCapabilityTypes[ioSlot];
+                                    else
+                                        trilist.UShortInput[joinMap.HdcpSupportCapability + ioSlot].UShortValue = 1;
                                 }
                             }
                         }
@@ -120,7 +162,7 @@ namespace PepperDash.Essentials.Bridges
 
                         if (hdmiPort != null)
                         {
-                            SetHdcpCapabilityAction(true, hdmiPort, joinMap.HdcpSupportState + ioSlot, trilist);
+                            SetHdcpStateAction(true, hdmiPort, joinMap.HdcpSupportState + ioSlot, trilist);
                             dmChassis.InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState + ioSlot]);
                         }
                     }
@@ -128,18 +170,19 @@ namespace PepperDash.Essentials.Bridges
                 if (dmChassis.RxDictionary.ContainsKey(ioSlot))
                 {
                     Debug.Console(2, "Creating Rx Feedbacks {0}", ioSlot);
-                    var RxKey = dmChassis.RxDictionary[ioSlot];
-                    var RxDevice = DeviceManager.GetDeviceForKey(RxKey) as DmRmcControllerBase;
+                    var rxKey = dmChassis.RxDictionary[ioSlot];
+                    var rxDevice = DeviceManager.GetDeviceForKey(rxKey) as DmRmcControllerBase;
+                    var hdBaseTDevice = DeviceManager.GetDeviceForKey(rxKey) as DmHdBaseTControllerBase;
                     if (dmChassis.Chassis is DmMd8x8Cpu3 || dmChassis.Chassis is DmMd8x8Cpu3rps
                         || dmChassis.Chassis is DmMd16x16Cpu3 || dmChassis.Chassis is DmMd16x16Cpu3rps
-                        || dmChassis.Chassis is DmMd32x32Cpu3 || dmChassis.Chassis is DmMd32x32Cpu3rps)
+                        || dmChassis.Chassis is DmMd32x32Cpu3 || dmChassis.Chassis is DmMd32x32Cpu3rps || hdBaseTDevice != null)
                     {
                         dmChassis.OutputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
                     }
-                    else if (RxDevice != null)
+                    else if (rxDevice != null)
                     {
-                        RxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
-                    }
+                        rxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+                    }          
                 }
 
                 // Feedback
@@ -156,7 +199,7 @@ namespace PepperDash.Essentials.Bridges
             }
         }
 
-        static void SetHdcpCapabilityAction(bool hdcpTypeSimple, HdmiInputWithCEC port, uint join, BasicTriList trilist)
+        static void SetHdcpStateAction(bool hdcpTypeSimple, HdmiInputWithCEC port, uint join, BasicTriList trilist)
         {
             if (hdcpTypeSimple)
             {
@@ -176,14 +219,14 @@ namespace PepperDash.Essentials.Bridges
             else
             {
                 trilist.SetUShortSigAction(join,
-                        new Action<ushort>(s =>
+                        new Action<ushort>(u =>
                         {
-                            port.HdcpReceiveCapability = (eHdcpCapabilityType)s;
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)u;
                         }));
             }
         }
 
-        static void SetHdcpCapabilityAction(bool hdcpTypeSimple, EndpointHdmiInput port, uint join, BasicTriList trilist)
+        static void SetHdcpStateAction(bool hdcpTypeSimple, EndpointHdmiInput port, uint join, BasicTriList trilist)
         {
             if (hdcpTypeSimple)
             {
@@ -203,9 +246,36 @@ namespace PepperDash.Essentials.Bridges
             else
             {
                 trilist.SetUShortSigAction(join,
-                        new Action<ushort>(s =>
+                        new Action<ushort>(u =>
                         {
-                            port.HdcpCapability = (eHdcpCapabilityType)s;
+                            port.HdcpCapability = (eHdcpCapabilityType)u;
+                        }));
+            }
+        }
+
+        static void SetHdcpStateAction(bool supportsHdcp2, DMInputPortWithCec port, uint join, BasicTriList trilist)
+        {
+            if (!supportsHdcp2)
+            {
+                trilist.SetUShortSigAction(join,
+                    new Action<ushort>(s =>
+                    {
+                        if (s == 0)
+                        {
+                            port.HdcpSupportOff();
+                        }
+                        else if (s > 0)
+                        {
+                            port.HdcpSupportOn();
+                        }
+                    }));
+            }
+            else
+            {
+                trilist.SetUShortSigAction(join,
+                        new Action<ushort>(u =>
+                        {
+                            port.HdcpReceiveCapability = (eHdcpCapabilityType)u;
                         }));
             }
         }

PepperDashEssentials/Bridges/GlsOccupancySensorBaseControllerBridge.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Essentials.Devices.Common.Occupancy;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Core;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class GlsOccupancySensorBaseControllerApiExtensions
+    {
+        public static void LinkToApi(this GlsOccupancySensorBaseController occController, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            GlsOccupancySensorBaseJoinMap joinMap = new GlsOccupancySensorBaseJoinMap();
+
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<GlsOccupancySensorBaseJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, occController, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            #region Single and Dual Sensor Stuff
+            occController.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+
+            // Occupied status
+            trilist.SetSigTrueAction(joinMap.ForceOccupied, new Action(() => occController.ForceOccupied()));
+            trilist.SetSigTrueAction(joinMap.ForceVacant, new Action(() => occController.ForceVacant()));
+            occController.RoomIsOccupiedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RoomOccupiedFeedback]);
+            occController.RoomIsOccupiedFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.RoomVacantFeedback]);
+            occController.RawOccupancyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyFeedback]);
+
+            // Timouts
+            trilist.SetUShortSigAction(joinMap.Timeout, new Action<ushort>((u) => occController.SetRemoteTimeout(u)));
+            occController.CurrentTimeoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.Timeout]);
+            occController.LocalTimoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.TimeoutLocalFeedback]);
+
+            // LED Flash
+            trilist.SetSigTrueAction(joinMap.EnableLedFlash, new Action(() => occController.SetLedFlashEnable(true)));
+            trilist.SetSigTrueAction(joinMap.DisableLedFlash, new Action(() => occController.SetLedFlashEnable(false)));
+            occController.LedFlashEnabledFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.EnableLedFlash]);
+
+            // Short Timeout
+            trilist.SetSigTrueAction(joinMap.EnableShortTimeout, new Action(() => occController.SetShortTimeoutState(true)));
+            trilist.SetSigTrueAction(joinMap.DisableShortTimeout, new Action(() => occController.SetShortTimeoutState(false)));
+            occController.ShortTimeoutEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableShortTimeout]);
+
+            // PIR Sensor
+            trilist.SetSigTrueAction(joinMap.EnablePir, new Action(() => occController.SetPirEnable(true)));
+            trilist.SetSigTrueAction(joinMap.DisablePir, new Action(() => occController.SetPirEnable(false)));
+            occController.PirSensorEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnablePir]);
+            
+            // PIR Sensitivity in Occupied State
+            trilist.SetBoolSigAction(joinMap.IncrementPirInOccupiedState, new Action<bool>((b) => occController.IncrementPirSensitivityInOccupiedState(b)));
+            trilist.SetBoolSigAction(joinMap.DecrementPirInOccupiedState, new Action<bool>((b) => occController.DecrementPirSensitivityInOccupiedState(b)));
+            occController.PirSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInOccupiedState]);
+
+            // PIR Sensitivity in Vacant State
+            trilist.SetBoolSigAction(joinMap.IncrementPirInVacantState, new Action<bool>((b) => occController.IncrementPirSensitivityInVacantState(b)));
+            trilist.SetBoolSigAction(joinMap.DecrementPirInVacantState, new Action<bool>((b) => occController.DecrementPirSensitivityInVacantState(b)));
+            occController.PirSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInVacantState]);
+            #endregion
+
+            #region Dual Technology Sensor Stuff
+            var odtOccController = occController as GlsOdtOccupancySensorController;
+
+            if (odtOccController != null)
+            {
+                // OR When Vacated
+                trilist.SetBoolSigAction(joinMap.OrWhenVacated, new Action<bool>((b) => odtOccController.SetOrWhenVacatedState(b)));
+                odtOccController.OrWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.OrWhenVacated]);
+
+                // AND When Vacated
+                trilist.SetBoolSigAction(joinMap.AndWhenVacated, new Action<bool>((b) => odtOccController.SetAndWhenVacatedState(b)));
+                odtOccController.AndWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.AndWhenVacated]);
+
+                // Ultrasonic A Sensor
+                trilist.SetSigTrueAction(joinMap.EnableUsA, new Action(() => odtOccController.SetUsAEnable(true)));
+                trilist.SetSigTrueAction(joinMap.DisableUsA, new Action(() => odtOccController.SetUsAEnable(false)));
+                odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsA]);
+
+                // Ultrasonic B Sensor
+                trilist.SetSigTrueAction(joinMap.EnableUsB, new Action(() => odtOccController.SetUsBEnable(true)));
+                trilist.SetSigTrueAction(joinMap.DisableUsB, new Action(() => odtOccController.SetUsBEnable(false)));
+                odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsB]);
+
+                // US Sensitivity in Occupied State
+                trilist.SetBoolSigAction(joinMap.IncrementUsInOccupiedState, new Action<bool>((b) => odtOccController.IncrementUsSensitivityInOccupiedState(b)));
+                trilist.SetBoolSigAction(joinMap.DecrementUsInOccupiedState, new Action<bool>((b) => odtOccController.DecrementUsSensitivityInOccupiedState(b)));
+                odtOccController.UltrasonicSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInOccupiedState]);
+
+                // US Sensitivity in Vacant State
+                trilist.SetBoolSigAction(joinMap.IncrementUsInVacantState, new Action<bool>((b) => odtOccController.IncrementUsSensitivityInVacantState(b)));
+                trilist.SetBoolSigAction(joinMap.DecrementUsInVacantState, new Action<bool>((b) => odtOccController.DecrementUsSensitivityInVacantState(b)));
+                odtOccController.UltrasonicSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInVacantState]);
+
+            }
+            #endregion
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/DmBladeChassisControllerJoinMap.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges {
+    public class DmBladeChassisControllerJoinMap : JoinMapBase {
+        #region Digital/Analogs
+        #endregion
+
+        #region Digitals
+        /// <summary>
+        /// High when device is online
+        /// </summary>
+        public uint IsOnline { get; set; }
+        /// <summary>
+        /// Range reports video sync feedback for each input
+        /// </summary>
+        public uint VideoSyncStatus { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding input's endpoint is online
+        /// </summary>
+        public uint InputEndpointOnline { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding output's endpoint is online
+        /// </summary>
+        public uint OutputEndpointOnline { get; set; }
+        /// <summary>
+        /// Range reports high if corresponding input's transmitter supports bridging as a separate device for detailed AV switching, HDCP control, etc.
+        /// </summary>
+        public uint TxAdvancedIsPresent { get; set; } // indicates that there is an attached transmitter that should be bridged to be interacted with
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Range sets and reports the current video source for the corresponding output
+        /// </summary>
+        public uint OutputVideo { get; set; }
+        /// <summary>
+        /// Range sets and reports the current HDCP state for the corresponding input card
+        /// </summary>
+        public uint HdcpSupportState { get; set; }
+        /// <summary>
+        /// Range reports the highest supported HDCP state level for the corresponding input card
+        /// </summary>
+        public uint HdcpSupportCapability { get; set; }
+        #endregion
+
+        #region Serials
+        /// <summary>
+        /// Range sets and reports the name for the corresponding input card
+        /// </summary>
+        public uint InputNames { get; set; }
+        /// <summary>
+        /// Range sets and reports the name for the corresponding output card
+        /// </summary>
+        public uint OutputNames { get; set; }
+        /// <summary>
+        /// Range reports the name of the current video source for the corresponding output card
+        /// </summary>
+        public uint OutputCurrentVideoInputNames { get; set; }
+        /// <summary>
+        /// Range reports the current input resolution for each corresponding input card
+        /// </summary>
+        public uint InputCurrentResolution { get; set; }
+        #endregion
+
+        public DmBladeChassisControllerJoinMap() {
+            //Digital/Analog
+
+            //Digital 
+            IsOnline = 11;
+            VideoSyncStatus = 100; //101-299
+            InputEndpointOnline = 500; //501-699
+            OutputEndpointOnline = 700; //701-899
+            TxAdvancedIsPresent = 1000; //1001-1199
+
+            //Analog
+            OutputVideo = 100; //101-299
+            HdcpSupportState = 1000; //1001-1199
+            HdcpSupportCapability = 1200; //1201-1399
+
+
+            //Serial
+            InputNames = 100; //101-299
+            OutputNames = 300; //301-499
+            OutputCurrentVideoInputNames = 2000; //2001-2199
+            InputCurrentResolution = 2400; // 2401-2599
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart) {
+            var joinOffset = joinStart - 1;
+
+            IsOnline = IsOnline + joinOffset;
+            OutputVideo = OutputVideo + joinOffset;
+            VideoSyncStatus = VideoSyncStatus + joinOffset;
+            InputNames = InputNames + joinOffset;
+            OutputNames = OutputNames + joinOffset;
+            OutputCurrentVideoInputNames = OutputCurrentVideoInputNames + joinOffset;
+            InputCurrentResolution = InputCurrentResolution + joinOffset;
+            InputEndpointOnline = InputEndpointOnline + joinOffset;
+            OutputEndpointOnline = OutputEndpointOnline + joinOffset;
+            HdcpSupportState = HdcpSupportState + joinOffset;
+            HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/DmChassisControllerJoinMap.cs

@@ -107,7 +107,6 @@ namespace PepperDash.Essentials.Bridges
             OutputAudio = 300; //301-499
             OutputUsb = 500; //501-699
             InputUsb = 700; //701-899
-            VideoSyncStatus = 100; //101-299
             HdcpSupportState = 1000; //1001-1199
             HdcpSupportCapability = 1200; //1201-1399
 
@@ -118,8 +117,6 @@ namespace PepperDash.Essentials.Bridges
             OutputCurrentVideoInputNames = 2000; //2001-2199
             OutputCurrentAudioInputNames = 2200; //2201-2399
             InputCurrentResolution = 2400; // 2401-2599
-            InputEndpointOnline = 500; //501-699
-            OutputEndpointOnline = 700; //701-899
         }
 
         public override void OffsetJoinNumbers(uint joinStart)

PepperDashEssentials/Bridges/JoinMaps/GlsOccupancySensorBaseJoinMap.cs

@@ -0,0 +1,219 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class GlsOccupancySensorBaseJoinMap : JoinMapBase
+    {
+        #region Digitals
+
+        /// <summary>
+        /// High when device is online
+        /// </summary>
+        public uint IsOnline { get; set; }
+        /// <summary>
+        /// Forces the device to report occupied status
+        /// </summary>
+        public uint ForceOccupied { get; set; }
+        /// <summary>
+        /// Forces the device to report vacant status
+        /// </summary>
+        public uint ForceVacant { get; set; }
+        /// <summary>
+        /// Enables raw status reporting
+        /// </summary>
+        public uint EnableRawStates { get; set; }
+        /// <summary>
+        /// High when raw occupancy is detected
+        /// </summary>
+        public uint RawOccupancyFeedback { get; set; }
+        /// <summary>
+        /// High when occupancy is detected
+        /// </summary>
+        public uint RoomOccupiedFeedback { get; set; }
+        /// <summary>
+        /// Hich when occupancy is detected in the grace period
+        /// </summary>
+        public uint GraceOccupancyDetectedFeedback { get; set; }
+        /// <summary>
+        /// High when vacancy is detected
+        /// </summary>
+        public uint RoomVacantFeedback { get; set; }
+
+        /// <summary>
+        /// Enables the LED Flash when set high
+        /// </summary>
+        public uint EnableLedFlash { get; set; }
+        /// <summary>
+        /// Disables the LED flash when set high
+        /// </summary>
+        public uint DisableLedFlash { get; set; }
+        /// <summary>
+        /// Enables the Short Timeout
+        /// </summary>
+        public uint EnableShortTimeout { get; set; }
+        /// <summary>
+        /// Disables the Short Timout
+        /// </summary>
+        public uint DisableShortTimeout { get; set; }
+        /// <summary>
+        /// Set high to enable one technology to trigger occupancy
+        /// </summary>
+        public uint OrWhenVacated { get; set; }
+        /// <summary>
+        /// Set high to require both technologies to trigger occupancy
+        /// </summary>
+        public uint AndWhenVacated { get; set; }
+        /// <summary>
+        /// Enables Ultrasonic Sensor A
+        /// </summary>
+        public uint EnableUsA { get; set; }
+        /// <summary>
+        /// Disables Ultrasonic Sensor A
+        /// </summary>
+        public uint DisableUsA { get; set; }
+        /// <summary>
+        /// Enables Ultrasonic Sensor B
+        /// </summary>
+        public uint EnableUsB { get; set; }
+        /// <summary>
+        /// Disables Ultrasonic Sensor B
+        /// </summary>
+        public uint DisableUsB { get; set; }
+        /// <summary>
+        /// Enables Pir
+        /// </summary>
+        public uint EnablePir { get; set; }
+        /// <summary>
+        /// Disables Pir
+        /// </summary>
+        public uint DisablePir { get; set; }
+        public uint IncrementUsInOccupiedState { get; set; }
+        public uint DecrementUsInOccupiedState { get; set; }
+        public uint IncrementUsInVacantState { get; set; }
+        public uint DecrementUsInVacantState { get; set; }
+        public uint IncrementPirInOccupiedState { get; set; }
+        public uint DecrementPirInOccupiedState { get; set; }
+        public uint IncrementPirInVacantState { get; set; }
+        public uint DecrementPirInVacantState { get; set; }
+        #endregion
+
+        #region Analogs
+        /// <summary>
+        /// Sets adn reports the remote timeout value
+        /// </summary>
+        public uint Timeout { get; set; }
+        /// <summary>
+        /// Reports the local timeout value
+        /// </summary>
+        public uint TimeoutLocalFeedback { get; set; }
+        /// <summary>
+        /// Sets the minimum internal photo sensor value and reports the current level
+        /// </summary>
+        public uint InternalPhotoSensorValue { get; set; }
+        /// <summary>
+        /// Sets the minimum external photo sensor value and reports the current level
+        /// </summary>
+        public uint ExternalPhotoSensorValue { get; set; }
+
+        public uint UsSensitivityInOccupiedState { get; set; }
+
+        public uint UsSensitivityInVacantState { get; set; }
+
+        public uint PirSensitivityInOccupiedState { get; set; }
+
+        public uint PirSensitivityInVacantState { get; set; }
+        #endregion
+
+        public GlsOccupancySensorBaseJoinMap()
+        {
+            IsOnline = 1;
+            ForceOccupied = 2;
+            ForceVacant = 3;
+            EnableRawStates = 4;
+            RoomOccupiedFeedback = 2;
+            GraceOccupancyDetectedFeedback = 3;
+            RoomVacantFeedback = 4;
+            RawOccupancyFeedback = 5;
+            EnableLedFlash = 11;
+            DisableLedFlash = 12;
+            EnableShortTimeout = 13;
+            DisableShortTimeout = 14;
+            OrWhenVacated = 15;
+            AndWhenVacated = 16;
+            EnableUsA = 17;
+            DisableUsA = 18;
+            EnableUsB = 19;
+            DisableUsB = 20;
+            EnablePir = 21;
+            DisablePir = 22;
+            DisablePir = 23;
+            IncrementUsInOccupiedState = 24;
+            DecrementUsInOccupiedState = 25;
+            IncrementUsInVacantState = 26;
+            DecrementUsInVacantState = 27;
+            IncrementPirInOccupiedState = 28;
+            DecrementPirInOccupiedState = 29;
+            IncrementPirInVacantState = 30;
+            DecrementPirInVacantState = 31;
+
+            Timeout = 1;
+            TimeoutLocalFeedback = 2;
+            InternalPhotoSensorValue = 3;
+            ExternalPhotoSensorValue = 4;
+            UsSensitivityInOccupiedState = 5;
+            UsSensitivityInVacantState = 6;
+            PirSensitivityInOccupiedState = 7;
+            PirSensitivityInVacantState = 8;           
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            IsOnline =                          IsOnline + joinOffset; 
+            ForceOccupied =                     ForceOccupied + joinOffset; 
+            ForceVacant =                       ForceVacant + joinOffset; 
+            EnableRawStates =                   EnableRawStates + joinOffset; 
+            RoomOccupiedFeedback =              RoomOccupiedFeedback + joinOffset; 
+            GraceOccupancyDetectedFeedback =    GraceOccupancyDetectedFeedback + joinOffset;
+            RoomVacantFeedback =                RoomVacantFeedback + joinOffset; 
+            RawOccupancyFeedback =              RawOccupancyFeedback + joinOffset; 
+            EnableLedFlash =                    EnableLedFlash + joinOffset; 
+            DisableLedFlash =                   DisableLedFlash + joinOffset; 
+            EnableShortTimeout =                EnableShortTimeout + joinOffset; 
+            DisableShortTimeout =               DisableShortTimeout + joinOffset; 
+            OrWhenVacated =                     OrWhenVacated + joinOffset; 
+            AndWhenVacated =                    AndWhenVacated + joinOffset; 
+            EnableUsA =                         EnableUsA + joinOffset; 
+            DisableUsA =                        DisableUsA + joinOffset; 
+            EnableUsB =                         EnableUsB + joinOffset; 
+            DisableUsB =                        DisableUsB + joinOffset; 
+            EnablePir =                         EnablePir + joinOffset; 
+            DisablePir =                        DisablePir + joinOffset; 
+            DisablePir =                        DisablePir + joinOffset; 
+            IncrementUsInOccupiedState =        IncrementUsInOccupiedState + joinOffset; 
+            DecrementUsInOccupiedState =        DecrementUsInOccupiedState + joinOffset; 
+            IncrementUsInVacantState =          IncrementUsInVacantState + joinOffset; 
+            DecrementUsInVacantState =          DecrementUsInVacantState + joinOffset; 
+            IncrementPirInOccupiedState =       IncrementPirInOccupiedState + joinOffset;
+            DecrementPirInOccupiedState =       DecrementPirInOccupiedState + joinOffset;
+            IncrementPirInVacantState =         IncrementPirInVacantState + joinOffset; 
+            DecrementPirInVacantState =         DecrementPirInVacantState + joinOffset; 
+                                                
+            Timeout =                           Timeout + joinOffset; 
+            TimeoutLocalFeedback =              TimeoutLocalFeedback + joinOffset; 
+            InternalPhotoSensorValue =          InternalPhotoSensorValue + joinOffset; 
+            ExternalPhotoSensorValue =          ExternalPhotoSensorValue + joinOffset; 
+            UsSensitivityInOccupiedState =      UsSensitivityInOccupiedState + joinOffset;
+            UsSensitivityInVacantState =        UsSensitivityInVacantState + joinOffset; 
+            PirSensitivityInOccupiedState =     PirSensitivityInOccupiedState + joinOffset;
+            PirSensitivityInVacantState =       PirSensitivityInVacantState + joinOffset;
+        }
+    }    
+         
+}        

PepperDashEssentials/ControlSystem.cs

@@ -17,6 +17,8 @@ using PepperDash.Essentials.Fusion;
 using PepperDash.Essentials.Room.Config;
 using PepperDash.Essentials.Room.Cotija;
 
+using Newtonsoft.Json;
+
 namespace PepperDash.Essentials
 {
     public class ControlSystem : CrestronControlSystem
@@ -359,21 +361,7 @@ namespace PepperDash.Essentials
 
             DeviceManager.AddDevice(new PepperDash.Essentials.Core.Devices.CrestronProcessor("processor"));
 
-            // Check if the processor is a DMPS model
-            if (this.ControllerPrompt.IndexOf("dmps", StringComparison.OrdinalIgnoreCase) > -1)
-            {
-                Debug.Console(2, "Adding DmpsRoutingController for {0} to Device Manager.", this.ControllerPrompt);
 
-                var dmpsRoutingController = DmpsRoutingController.GetDmpsRoutingController("processor-avRouting", this.ControllerPrompt, new DM.Config.DmpsRoutingPropertiesConfig());
-
-                DeviceManager.AddDevice(dmpsRoutingController);
-
-
-            }
-            else
-            {
-                Debug.Console(2, "************Processor is not DMPS type***************");
-            }
 
             // Add global System Monitor device
             DeviceManager.AddDevice(new PepperDash.Essentials.Core.Monitoring.SystemMonitorController("systemMonitor"));
@@ -390,7 +378,26 @@ namespace PepperDash.Essentials
                         if (devConf.Type.ToLower() != Global.ControlSystem.ControllerPrompt.ToLower())
                             Debug.Console(0,
                                 "WARNING: Config file defines processor type as '{0}' but actual processor is '{1}'!  Some ports may not be available",
-                                devConf.Type.ToUpper(), Global.ControlSystem.ControllerPrompt.ToUpper());        
+                                devConf.Type.ToUpper(), Global.ControlSystem.ControllerPrompt.ToUpper());
+
+                        // Check if the processor is a DMPS model
+                        if (this.ControllerPrompt.IndexOf("dmps", StringComparison.OrdinalIgnoreCase) > -1)
+                        {
+                            Debug.Console(2, "Adding DmpsRoutingController for {0} to Device Manager.", this.ControllerPrompt);
+
+                            var propertiesConfig = JsonConvert.DeserializeObject<DM.Config.DmpsRoutingPropertiesConfig>(devConf.Properties.ToString());
+
+                            if(propertiesConfig == null)
+                                propertiesConfig =  new DM.Config.DmpsRoutingPropertiesConfig();
+
+                            var dmpsRoutingController = DmpsRoutingController.GetDmpsRoutingController("processor-avRouting", this.ControllerPrompt, propertiesConfig);
+
+                            DeviceManager.AddDevice(dmpsRoutingController);
+                        }
+                        else
+                        {
+                            Debug.Console(2, "************Processor is not DMPS type***************");
+                        }
 
                         continue;
                     }

PepperDashEssentials/PepperDashEssentials.csproj

@@ -71,9 +71,9 @@
       <HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.UI.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
-    <Reference Include="PepperDash_Core, Version=1.0.3.27452, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.26.30384, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\essentials-framework\references\PepperDash_Core.dll</HintPath>
+      <HintPath>..\essentials-framework\pepperdashcore-builds\PepperDash_Core.dll</HintPath>
     </Reference>
     <Reference Include="PepperDash_Essentials_DM, Version=1.0.0.19343, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -121,6 +121,8 @@
     <Compile Include="Bridges\BridgeFactory.cs" />
     <Compile Include="Bridges\CameraControllerBridge.cs" />
     <Compile Include="Bridges\AirMediaControllerBridge.cs" />
+    <Compile Include="Bridges\DmBladeChassisControllerBridge.cs" />
+    <Compile Include="Bridges\JoinMaps\DmBladeChassisControllerJoinMap.cs" />
     <Compile Include="Bridges\DmpsAudioOutputControllerBridge.cs" />
     <Compile Include="Bridges\DmpsRoutingControllerBridge.cs" />
     <Compile Include="Bridges\DisplayControllerBridge.cs" />
@@ -129,6 +131,7 @@
     <Compile Include="Bridges\DmTxControllerBridge.cs" />
     <Compile Include="Bridges\GenericLightingBridge.cs" />
     <Compile Include="Bridges\GenericRelayDeviceBridge.cs" />
+    <Compile Include="Bridges\GlsOccupancySensorBaseControllerBridge.cs" />
     <Compile Include="Bridges\HdMdxxxCEControllerBridge.cs" />
     <Compile Include="Bridges\IBasicCommunicationBridge.cs" />
     <Compile Include="Bridges\DmRmcControllerBridge.cs" />
@@ -149,6 +152,7 @@
     <Compile Include="Bridges\JoinMaps\HdMdxxxCEControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\IBasicCommunicationJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\IDigitalInputJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\GlsOccupancySensorBaseJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\SystemMonitorJoinMap.cs" />
     <Compile Include="Bridges\SystemMonitorBridge.cs" />
     <Compile Include="Configuration ORIGINAL\Builders\TPConfig.cs" />
@@ -181,6 +185,7 @@
     <Compile Include="HttpApiHandler.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Room\Behaviours\RoomOnToDefaultSourceWhenOccupied.cs" />
+    <Compile Include="Room\Config\EssentialsNDisplayRoomPropertiesConfig.cs" />
     <Compile Include="Room\Config\DDVC01RoomPropertiesConfig.cs" />
     <Compile Include="Room\Config\EssentialsPresentationPropertiesConfig.cs" />
     <Compile Include="Room\Config\EssentialsHuddleRoomPropertiesConfig.cs" />
@@ -204,6 +209,7 @@
     <Compile Include="AppServer\Volumes.cs" />
     <Compile Include="Room\Emergency\EsentialsRoomEmergencyContactClosure.cs" />
     <Compile Include="Room\Types\EssentialsHuddleVtc1Room.cs" />
+    <Compile Include="Room\Types\EssentialsNDisplayRoomBase.cs" />
     <Compile Include="Room\Types\EssentialsPresentationRoom.cs" />
     <Compile Include="Room\Types\EssentialsRoomBase.cs" />
     <Compile Include="Room\Config\EssentialsRoomConfig.cs" />

PepperDashEssentials/Room/Config/EssentialsNDisplayRoomPropertiesConfig.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Room.Config
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class EssentialsNDisplayRoomPropertiesConfig : EssentialsRoomPropertiesConfig
+    {
+        public string DefaultAudioBehavior { get; set; }
+        public string DefaultAudioKey { get; set; }
+        public string DefaultVideoBehavior { get; set; }
+        public Dictionary<string, string> Displays { get; set; }
+        public string SourceListKey { get; set; }
+
+        public EssentialsNDisplayRoomPropertiesConfig()
+        {
+            Displays = new Dictionary<string, string>();
+        }
+    }
+}

PepperDashEssentials/Room/Types/EssentialsNDisplayRoomBase.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using Newtonsoft.Json;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Devices;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Room.Config;
+
+namespace PepperDash.Essentials.Room.Types
+{
+    /// <summary>
+    /// Base class for rooms with more than a single display
+    /// </summary>
+    public abstract class EssentialsNDisplayRoomBase : EssentialsRoomBase
+    {
+        public event SourceInfoChangeHandler CurrentSingleSourceChange;
+
+        public Dictionary<string, IRoutingSinkWithSwitching> Displays { get; protected set; }
+
+        protected override Func<bool> IsWarmingFeedbackFunc { get { return () => false; ; } }
+        protected override Func<bool> IsCoolingFeedbackFunc { get { return () => false; } }
+
+        public EssentialsNDisplayRoomBase(DeviceConfig config)
+            : base (config)
+        {
+            Displays = new Dictionary<string, IRoutingSinkWithSwitching>();
+
+            var propertiesConfig = JsonConvert.DeserializeObject<EssentialsNDisplayRoomPropertiesConfig>(config.Properties.ToString());
+
+            foreach (var display in propertiesConfig.Displays)
+            {
+                var displayDevice = DeviceManager.GetDeviceForKey(display.Value) as IRoutingSinkWithSwitching;
+
+                if (displayDevice != null)
+                    Displays.Add(display.Key, displayDevice);
+            }
+        }
+    }
+}

PepperDashEssentials/Room/Types/EssentialsPresentationRoom.cs

@@ -33,7 +33,7 @@
 //        public Dictionary<uint, IRoutingSinkNoSwitching> Displays { get; private set; }
 
 //        public IRoutingSinkNoSwitching DefaultAudioDevice { get; private set; }
-//        public IBasicVolumeControls DefaultVolumeControls { get; private set; }
+//        public IBasicVolumeControls DefaultVolumeControls { get; private set; }C:\Working Directories\PD\essentials\PepperDashEssentials\Room\Types\EssentialsPresentationRoom.cs
 
 //        /// <summary>
 //        /// The config name of the source list

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

@@ -71,9 +71,9 @@
       <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.UI.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
-    <Reference Include="PepperDash_Core, Version=1.0.1.26313, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.26.30384, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\references\PepperDash_Core.dll</HintPath>
+      <HintPath>..\..\pepperdashcore-builds\PepperDash_Core.dll</HintPath>
     </Reference>
     <Reference Include="SimplSharpCustomAttributesInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>

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

@@ -0,0 +1,586 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+using Crestron.SimplSharpPro.DM.Blades;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM {
+    /// <summary>
+    /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
+    /// 
+    /// </summary>
+    public class DmBladeChassisController : CrestronGenericBaseDevice, IDmSwitch, IRoutingInputsOutputs, IRouting, IHasFeedback {
+        public DMChassisPropertiesConfig PropertiesConfig { get; set; }
+
+        public Switch Chassis { get; private set; }
+
+        // Feedbacks for EssentialDM
+        public Dictionary<uint, IntFeedback> VideoOutputFeedbacks { get; private set; }
+        public Dictionary<uint, IntFeedback> AudioOutputFeedbacks { get; private set; }
+        public Dictionary<uint, BoolFeedback> VideoInputSyncFeedbacks { get; private set; }
+        public Dictionary<uint, BoolFeedback> InputEndpointOnlineFeedbacks { get; private set; }
+        public Dictionary<uint, BoolFeedback> OutputEndpointOnlineFeedbacks { get; private set; }
+        public Dictionary<uint, StringFeedback> InputNameFeedbacks { get; private set; }
+        public Dictionary<uint, StringFeedback> OutputNameFeedbacks { get; private set; }
+        public Dictionary<uint, StringFeedback> OutputVideoRouteNameFeedbacks { get; private set; }
+        public Dictionary<uint, StringFeedback> OutputAudioRouteNameFeedbacks { get; private set; }
+        public Dictionary<uint, IntFeedback> UsbOutputRoutedToFeebacks { get; private set; }
+        public Dictionary<uint, IntFeedback> UsbInputRoutedToFeebacks { get; private set; }
+
+        public IntFeedback SystemIdFeebdack { get; private set; }
+        public BoolFeedback SystemIdBusyFeedback { get; private set; }
+
+
+        public Dictionary<uint, IntFeedback> InputCardHdcpCapabilityFeedbacks { get; private set; }
+
+        public Dictionary<uint, eHdcpCapabilityType> InputCardHdcpCapabilityTypes { get; private set; }
+
+
+        // Need a couple Lists of generic Backplane ports
+        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+        public Dictionary<uint, string> TxDictionary { get; set; }
+        public Dictionary<uint, string> RxDictionary { get; set; }
+
+        //public Dictionary<uint, DmInputCardControllerBase> InputCards { get; private set; }
+        //public Dictionary<uint, DmSingleOutputCardControllerBase> OutputCards { get; private set; }
+
+        public Dictionary<uint, string> InputNames { get; set; }
+        public Dictionary<uint, string> OutputNames { get; set; }
+        public Dictionary<uint, DmCardAudioOutputController> VolumeControls { get; private set; }
+
+        public const int RouteOffTime = 500;
+        Dictionary<PortNumberType, CTimer> RouteOffTimers = new Dictionary<PortNumberType, CTimer>();
+
+        /// <summary>
+        /// Factory method to create a new chassis controller from config data. Limited to 8x8 right now
+        /// </summary>
+        public static DmBladeChassisController GetDmChassisController(string key, string name,
+            string type, DMChassisPropertiesConfig properties) {
+            try {
+                type = type.ToLower();
+                uint ipid = properties.Control.IpIdInt;
+
+                BladeSwitch chassis = null;
+                if (type == "dmmd64x64") { chassis = new DmMd64x64(ipid, Global.ControlSystem); }
+                else if (type == "dmmd128x128") { chassis = new DmMd128x128(ipid, Global.ControlSystem); }
+
+
+                if (chassis == null) {
+                    return null;
+                }
+
+                var controller = new DmBladeChassisController(key, name, chassis);
+                // add the cards and port names
+                foreach (var kvp in properties.InputSlots)
+                    controller.AddInputBlade(kvp.Value, kvp.Key);
+                foreach (var kvp in properties.OutputSlots) {
+                    controller.AddOutputBlade(kvp.Value, kvp.Key);
+                }
+
+                foreach (var kvp in properties.VolumeControls) {
+                    // get the card
+                    // check it for an audio-compatible type
+                    // make a something-something that will make it work
+                    // retire to mountain village
+                    var outNum = kvp.Key;
+
+                    var card = controller.Chassis.Outputs[outNum].Card;
+                    Audio.Output audio = null;
+                    if (card is DmHdmi4kOutputBladeCard)
+                        audio = (card as DmHdmi4kOutputBladeCard).Hdmi4kOutput.Audio;
+                    if (audio == null)
+                        continue;
+                    // wire up the audio to something here...
+                    controller.AddVolumeControl(outNum, audio);
+                }
+
+                controller.InputNames = properties.InputNames;
+                controller.OutputNames = properties.OutputNames;
+                controller.PropertiesConfig = properties;
+                return controller;
+            }
+            catch (System.Exception e) {
+                Debug.Console(0, "Error creating DM chassis:\r{0}", e);
+            }
+            return null;
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="chassis"></param>
+        public DmBladeChassisController(string key, string name, BladeSwitch chassis)
+            : base(key, name, chassis) {
+            Chassis = chassis;
+            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+            VolumeControls = new Dictionary<uint, DmCardAudioOutputController>();
+            TxDictionary = new Dictionary<uint, string>();
+            RxDictionary = new Dictionary<uint, string>();
+            IsOnline.OutputChange += new EventHandler<FeedbackEventArgs>(IsOnline_OutputChange);
+            Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
+            Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
+            VideoOutputFeedbacks = new Dictionary<uint, IntFeedback>();
+            UsbOutputRoutedToFeebacks = new Dictionary<uint, IntFeedback>();
+            UsbInputRoutedToFeebacks = new Dictionary<uint, IntFeedback>();
+            VideoInputSyncFeedbacks = new Dictionary<uint, BoolFeedback>();
+            InputNameFeedbacks = new Dictionary<uint, StringFeedback>();
+            OutputNameFeedbacks = new Dictionary<uint, StringFeedback>();
+            OutputVideoRouteNameFeedbacks = new Dictionary<uint, StringFeedback>();
+            OutputAudioRouteNameFeedbacks = new Dictionary<uint, StringFeedback>();
+            InputEndpointOnlineFeedbacks = new Dictionary<uint, BoolFeedback>();
+            OutputEndpointOnlineFeedbacks = new Dictionary<uint, BoolFeedback>();
+
+            InputCardHdcpCapabilityFeedbacks = new Dictionary<uint, IntFeedback>();
+            InputCardHdcpCapabilityTypes = new Dictionary<uint, eHdcpCapabilityType>();
+
+            for (uint x = 1; x <= Chassis.NumberOfOutputs; x++) {
+                var tempX = x;
+
+                if (Chassis.Outputs[tempX] != null) {
+                    VideoOutputFeedbacks[tempX] = new IntFeedback(() => {
+                        if (Chassis.Outputs[tempX].VideoOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number; }
+                        else { return 0; };
+                    });
+
+                    OutputNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Outputs[tempX].NameFeedback != null) {
+                            return Chassis.Outputs[tempX].NameFeedback.StringValue;
+                        }
+                        else {
+                            return "";
+                        }
+                    });
+                    OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Outputs[tempX].VideoOutFeedback != null) {
+                            return Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue;
+                        }
+                        else {
+                            return "";
+                        }
+                    });
+
+                    OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => {
+                        //if (Chassis.Outputs[tempX].Endpoint != null)
+                        //    return Chassis.Outputs[tempX].Endpoint.IsOnline;
+                        //else
+                            return Chassis.Outputs[tempX].EndpointOnlineFeedback;
+                    });
+                }
+
+                if (Chassis.Inputs[tempX] != null) {
+                    UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() => {
+                        if (Chassis.Inputs[tempX].USBRoutedToFeedback != null) { return (ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number; }
+                        else { return 0; };
+                    });
+                    VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {
+                        if (Chassis.Inputs[tempX].VideoDetectedFeedback != null)
+                            return Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue;
+                        else
+                            return false;
+                    });
+                    InputNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Inputs[tempX].NameFeedback != null) {
+                            return Chassis.Inputs[tempX].NameFeedback.StringValue;
+                        }
+                        else {
+                            return "";
+                        }
+                    });
+
+                    InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => {
+                        return Chassis.Inputs[tempX].EndpointOnlineFeedback;
+                    });
+
+                    InputCardHdcpCapabilityFeedbacks[tempX] = new IntFeedback(() => {
+                        var inputCard = Chassis.Inputs[tempX];
+
+                        if (inputCard.Card is DmHdmi4kInputBladeCard) {
+                            InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.Hdcp2_2Support;
+
+                            if ((inputCard.Card as DmHdmi4kInputBladeCard).Hdmi4kInput.HdcpSupportOnFeedback.BoolValue)
+                                return 1;
+                            else
+                                return 0;
+                        }
+
+                        if (inputCard.Card is DmC4kInputBladeCard) {
+                            InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.Hdcp2_2Support;
+
+                            if ((inputCard.Card as DmC4kInputBladeCard).DmInput.HdcpCapabilityFeedback.Equals(eHdcpCapabilityType.HdcpSupportOff))
+                                return 0;
+                            else
+                                return 1;
+                        }
+
+                        else
+                            return 0;
+                    });
+                }
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="number"></param>
+        public void AddInputBlade(string type, uint number) {
+            Debug.Console(2, this, "Adding input blade '{0}', slot {1}", type, number);
+
+            type = type.ToLower();
+
+            if (type == "dmb4kihd") {
+                var inputBlade = new Dmb4kIHd(number, this.Chassis);
+                foreach (var item in inputBlade.Inputs) {
+                    var card = (item.Card as DmHdmi4kInputBladeCard).Hdmi4kInput;
+                    var cecPort = card as ICec;
+                    AddHdmiInBladePorts(item.Number, cecPort);
+                }
+            }
+
+            else if (type == "dmb4kihddnt") {
+                var inputBlade = new Dmb4kIHd(number, this.Chassis);
+                foreach (var item in inputBlade.Inputs) {
+                    var card = (item.Card as DmHdmi4kInputBladeCard).Hdmi4kInput;
+                    var cecPort = card as ICec;
+                    AddHdmiInBladePorts(item.Number, cecPort);
+                }
+            }
+
+            else if (type == "dmb4kic") {
+                var inputBlade = new Dmb4kIC(number, this.Chassis);
+                foreach (var item in inputBlade.Inputs) {
+                    AddDmInBladePorts(item.Number);
+                }
+            }
+
+            else if (type == "dmbis") {
+                var inputBlade = new DmbIS(number, this.Chassis);
+                foreach (var item in inputBlade.Inputs) {
+                    AddDmInMmFiberPorts(item.Number);
+                }
+            }
+            else if (type == "dmbis2") {
+                var inputBlade = new DmbIS2(number, this.Chassis);
+                foreach (var item in inputBlade.Inputs) {
+                    AddDmInSmFiberPorts(item.Number);
+                }
+            }
+        }
+
+
+
+        void AddHdmiInBladePorts(uint number, ICec cecPort) {
+            AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, cecPort);
+        }
+
+        void AddDmInBladePorts(uint number) {
+            AddInputPortWithDebug(number, "dmCIn", eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat);
+        }
+
+        void AddDmInMmFiberPorts(uint number) {
+            AddInputPortWithDebug(number, "dmMmIn", eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
+        }
+
+        void AddDmInSmFiberPorts(uint number) {
+            AddInputPortWithDebug(number, "dmSmIn", eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="number"></param>
+        public void AddOutputBlade(string type, uint number) {
+            type = type.ToLower();
+
+            Debug.Console(2, this, "Adding output blade '{0}', slot {1}", type, number);
+            if (type == "dmb4kohd") {
+                var outputBlade = new Dmb4KOHD(number, Chassis);
+                foreach (var item in outputBlade.Outputs) {
+                    AddHdmiOutBladePorts(item.Number);
+                }
+            }
+
+            else if (type == "dmb4kohddnt") {
+                var outputBlade = new Dmb4KOHD(number, Chassis);
+                foreach (var item in outputBlade.Outputs) {
+                    AddHdmiOutBladePorts(item.Number);
+                }
+            }
+
+            else if (type == "dmb4koc") {
+                var outputBlade = new Dmb4KOC(number, Chassis);
+                foreach (var item in outputBlade.Outputs) {
+                    AddDmOutBladePorts(item.Number);
+                }
+            }
+            else if (type == "dmb4koc") {
+                var outputBlade = new Dmb4KOC(number, Chassis);
+                foreach (var item in outputBlade.Outputs) {
+                    AddDmOutBladePorts(item.Number);
+                }
+            }
+            else if (type == "dmbos") {
+                var outputBlade = new DmbOS(number, Chassis);
+                foreach (var item in outputBlade.Outputs) {
+                    AddDmOutMmFiberBladePorts(item.Number);
+                }
+            }
+            else if (type == "dmbos2") {
+                var outputBlade = new DmbOS2(number, Chassis);
+                foreach (var item in outputBlade.Outputs) {
+                    AddDmOutSmFiberBladePorts(item.Number);
+                }
+            }
+        }
+
+        void AddHdmiOutBladePorts(uint number) {
+            AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("hdmiOut{0}", number) , eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, number);
+        }
+
+        void AddDmOutBladePorts(uint number) {
+            AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, number);
+        }
+
+        void AddDmOutMmFiberBladePorts(uint number) {
+            AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, number);
+        }
+
+        void AddDmOutSmFiberBladePorts(uint number) {
+            AddOutputPortWithDebug(String.Format("outputBlade{0}", (number / 8 > 0 ? 1 : number / 8)), String.Format("dmOut{0}", number), eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, number);
+        }
+
+
+        /// <summary>
+        /// Adds InputPort
+        /// </summary>
+        void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType) {
+            var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
+            Debug.Console(2, this, "Adding input port '{0}'", portKey);
+            var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
+
+            InputPorts.Add(inputPort);
+        }
+
+        /// <summary>
+        /// Adds InputPort and sets Port as ICec object
+        /// </summary>
+        void AddInputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, ICec cecPort) {
+            var portKey = string.Format("inputCard{0}--{1}", cardNum, portName);
+            Debug.Console(2, this, "Adding input port '{0}'", portKey);
+            var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
+
+            if (inputPort != null) {
+                if (cecPort != null)
+                    inputPort.Port = cecPort;
+
+                InputPorts.Add(inputPort);
+            }
+            else
+                Debug.Console(2, this, "inputPort is null");
+        }
+
+
+        /// <summary>
+        /// Adds OutputPort
+        /// </summary>
+        void AddOutputPortWithDebug(string cardName, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector) {
+            var portKey = string.Format("{0}--{1}", cardName, portName);
+            Debug.Console(2, this, "Adding output port '{0}'", portKey);
+            OutputPorts.Add(new RoutingOutputPort(portKey, sigType, portType, selector, this));
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void AddVolumeControl(uint number, Audio.Output audio) {
+            VolumeControls.Add(number, new DmCardAudioOutputController(audio));
+        }
+
+        //public void SetInputHdcpSupport(uint input, ePdtHdcpSupport hdcpSetting)
+        //{
+
+        //}
+
+
+        void Chassis_DMInputChange(Switch device, DMInputEventArgs args) {
+
+            switch (args.EventId) {
+                case DMInputEventIds.EndpointOnlineEventId: {
+                        Debug.Console(2, this, "DM Input EndpointOnlineEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
+                        InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
+                        break;
+                    }
+                case DMInputEventIds.OnlineFeedbackEventId: {
+                        Debug.Console(2, this, "DM Input OnlineFeedbackEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
+                        InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
+                        break;
+                    }
+                case DMInputEventIds.VideoDetectedEventId: {
+                        Debug.Console(2, this, "DM Input {0} VideoDetectedEventId", args.Number);
+                        VideoInputSyncFeedbacks[args.Number].FireUpdate();
+                        break;
+                    }
+                case DMInputEventIds.InputNameEventId: {
+                        Debug.Console(2, this, "DM Input {0} NameFeedbackEventId", args.Number);
+                        InputNameFeedbacks[args.Number].FireUpdate();
+                        break;
+                    }
+                case DMInputEventIds.HdcpCapabilityFeedbackEventId: {
+                        Debug.Console(2, this, "DM Input {0} HdcpCapabilityFeedbackEventId", args.Number);
+                        InputCardHdcpCapabilityFeedbacks[args.Number].FireUpdate();
+                        break;
+                    }
+                default: {
+                        Debug.Console(2, this, "DMInputChange fired for Input {0} with Unhandled EventId: {1}", args.Number, args.EventId);
+                        break;
+                    }
+            }
+        }
+        /// 
+        /// </summary>
+        void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args) 
+        {
+            var output = args.Number;
+
+            switch (args.EventId) {
+                case DMOutputEventIds.VolumeEventId: {
+                        if (VolumeControls.ContainsKey(output)) {
+                            VolumeControls[args.Number].VolumeEventFromChassis();
+                        }
+                        break;
+                    }
+                case DMOutputEventIds.EndpointOnlineEventId: {
+                        Debug.Console(2, this, "Output {0} DMOutputEventIds.EndpointOnlineEventId fired. EndpointOnlineFeedback State: {1}", args.Number, Chassis.Outputs[output].EndpointOnlineFeedback);
+                        if(Chassis.Outputs[output].Endpoint != null)
+                            Debug.Console(2, this, "Output {0} DMOutputEventIds.EndpointOnlineEventId fired. Endpoint.IsOnline State: {1}", args.Number, Chassis.Outputs[output].Endpoint.IsOnline);
+
+                        OutputEndpointOnlineFeedbacks[output].FireUpdate();
+                        break;
+                    }
+                case DMOutputEventIds.OnlineFeedbackEventId: {
+                        Debug.Console(2, this, "Output {0} DMInputEventIds.OnlineFeedbackEventId fired. State: {1}", args.Number, Chassis.Outputs[output].EndpointOnlineFeedback);
+                        OutputEndpointOnlineFeedbacks[output].FireUpdate();
+                        break;
+                    }
+                case DMOutputEventIds.VideoOutEventId: {
+                        if (Chassis.Outputs[output].VideoOutFeedback != null) {
+                            Debug.Console(2, this, "DMSwitchVideo:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].VideoOutFeedback.Number, output);
+                        }
+                        if (VideoOutputFeedbacks.ContainsKey(output)) {
+                            VideoOutputFeedbacks[output].FireUpdate();
+
+                        }
+                        if (OutputVideoRouteNameFeedbacks.ContainsKey(output)) {
+                            OutputVideoRouteNameFeedbacks[output].FireUpdate();
+                        }
+                        break;
+                    }
+                case DMOutputEventIds.OutputNameEventId: {
+                        Debug.Console(2, this, "DM Output {0} NameFeedbackEventId", output);
+                        OutputNameFeedbacks[output].FireUpdate();
+                        break;
+                    }
+                default: {
+                        Debug.Console(2, this, "DMOutputChange fired for Output {0} with Unhandled EventId: {1}", args.Number, args.EventId);
+                        break;
+                    }
+            }
+
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pnt"></param>
+        void StartOffTimer(PortNumberType pnt) {
+            if (RouteOffTimers.ContainsKey(pnt))
+                return;
+            RouteOffTimers[pnt] = new CTimer(o => {
+                ExecuteSwitch(0, pnt.Number, pnt.Type);
+            }, RouteOffTime);
+        }
+
+
+        // Send out sigs when coming online
+        void IsOnline_OutputChange(object sender, EventArgs e) {
+            if (IsOnline.BoolValue) {
+                Chassis.EnableUSBBreakaway.BoolValue = true;
+
+                if (InputNames != null)
+                    foreach (var kvp in InputNames)
+                        Chassis.Inputs[kvp.Key].Name.StringValue = kvp.Value;
+                if (OutputNames != null)
+                    foreach (var kvp in OutputNames)
+                        Chassis.Outputs[kvp.Key].Name.StringValue = kvp.Value;
+            }
+        }
+
+        #region IRouting Members
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType sigType) {
+            Debug.Console(2, this, "Making an awesome DM route from {0} to {1} {2}", inputSelector, outputSelector, sigType);
+
+            var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
+            var output = Convert.ToUInt32(outputSelector);
+            // Check to see if there's an off timer waiting on this and if so, cancel
+            var key = new PortNumberType(output, sigType);
+            if (input == 0) {
+                StartOffTimer(key);
+            }
+            else {
+                if (RouteOffTimers.ContainsKey(key)) {
+                    Debug.Console(2, this, "{0} cancelling route off due to new source", output);
+                    RouteOffTimers[key].Stop();
+                    RouteOffTimers.Remove(key);
+                }
+            }
+
+
+
+            var inCard = input == 0 ? null : Chassis.Inputs[input];
+            var outCard = input == 0 ? null : Chassis.Outputs[output];
+
+            // NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES 
+            if ((sigType | eRoutingSignalType.Video) == eRoutingSignalType.Video) {
+                Chassis.VideoEnter.BoolValue = true;
+                Chassis.Outputs[output].VideoOut = inCard;
+            }
+        }
+
+        #endregion
+
+    }
+
+    /*
+    public struct PortNumberType {
+        public uint Number { get; private set; }
+        public eRoutingSignalType Type { get; private set; }
+
+        public PortNumberType(uint number, eRoutingSignalType type)
+            : this() {
+            Number = number;
+            Type = type;
+        }
+    }*/
+}

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

@@ -116,15 +116,25 @@ namespace PepperDash.Essentials.DM
 
         public override bool CustomActivate()
         {
-
-
             // Set input and output names from config
             if (InputNames != null)
+            {
                 foreach (var kvp in InputNames)
-                    (Dmps.SwitcherInputs[kvp.Key] as DMInput).Name.StringValue = kvp.Value;
+                {
+                    var input = (Dmps.SwitcherInputs[kvp.Key] as DMInput);
+                    if (input != null)
+                        input.Name.StringValue = kvp.Value;
+                }
+            }
             if (OutputNames != null)
+            {
                 foreach (var kvp in OutputNames)
-                    (Dmps.SwitcherOutputs[kvp.Key] as Card.Dmps3OutputBase).Name.StringValue = kvp.Value;
+                {
+                    var output = (Dmps.SwitcherOutputs[kvp.Key] as DMOutput);
+                    if (output != null)
+                        output.Name.StringValue = kvp.Value;
+                }
+            }
 
             // Subscribe to events
             Dmps.DMInputChange += new DMInputEventHandler(Dmps_DMInputChange);
@@ -213,10 +223,10 @@ namespace PepperDash.Essentials.DM
             {
                 var inputCard = card as DMInput;
 
-                Debug.Console(1, this, "Adding Input Card Number {0} Type: {1}", inputCard.Number, inputCard.CardInputOutputType.ToString());
-
                 if (inputCard != null)
                 {
+                    Debug.Console(1, this, "Adding Input Card Number {0} Type: {1}", inputCard.Number, inputCard.CardInputOutputType.ToString());
+
                     InputEndpointOnlineFeedbacks[inputCard.Number] = new BoolFeedback(() => { return inputCard.EndpointOnlineFeedback; });
 
                     if (inputCard.VideoDetectedFeedback != null)
@@ -226,23 +236,28 @@ namespace PepperDash.Essentials.DM
                             return inputCard.VideoDetectedFeedback.BoolValue;
                         });
                     }
+
                     InputNameFeedbacks[inputCard.Number] = new StringFeedback(() =>
                     {
                         if (inputCard.NameFeedback != null && !string.IsNullOrEmpty(inputCard.NameFeedback.StringValue))
                         {
                             Debug.Console(2, this, "Input Card {0} Name: {1}", inputCard.Number, inputCard.NameFeedback.StringValue);
-                                return inputCard.NameFeedback.StringValue;
+                            return inputCard.NameFeedback.StringValue;
 
                         }
                         else
                         {
-                            Debug.Console(2, this, "Input Card {0} Name is null", inputCard.Number, inputCard.NameFeedback.StringValue);
+                            Debug.Console(2, this, "Input Card {0} Name is null", inputCard.Number);
                             return "";
                         }
                     });
-                }
 
-                AddInputCard(inputCard.Number, inputCard);
+                    AddInputCard(inputCard.Number, inputCard);
+                }
+                else
+                {
+                    Debug.Console(2, this, "***********Input Card of type {0} is cannot be cast as DMInput*************", card.CardInputOutputType);
+                }
             }
         }
 
@@ -255,7 +270,7 @@ namespace PepperDash.Essentials.DM
         {
             if (inputCard is Card.Dmps3HdmiInputWithoutAnalogAudio)
             {
-                var hdmiInputCard = inputCard as Card.Dmps3HdmiInput;
+                var hdmiInputCard = inputCard as Card.Dmps3HdmiInputWithoutAnalogAudio;
 
                 var cecPort = hdmiInputCard.HdmiInputPort;
 
@@ -272,8 +287,6 @@ namespace PepperDash.Essentials.DM
             }
             else if (inputCard is Card.Dmps3HdmiVgaInput)
             {
-                // TODO: Build a virtual TX device and assign the ports to it
-
                 var hdmiVgaInputCard = inputCard as Card.Dmps3HdmiVgaInput;
 
                 DmpsInternalVirtualHdmiVgaInputController inputCardController = new DmpsInternalVirtualHdmiVgaInputController(Key +
@@ -285,8 +298,6 @@ namespace PepperDash.Essentials.DM
             }
             else if (inputCard is Card.Dmps3HdmiVgaBncInput)
             {
-                // TODO: Build a virtual TX device and assign the ports to it
-
                 var hdmiVgaBncInputCard = inputCard as Card.Dmps3HdmiVgaBncInput;
 
                 DmpsInternalVirtualHdmiVgaBncInputController inputCardController = new DmpsInternalVirtualHdmiVgaBncInputController(Key +
@@ -309,8 +320,6 @@ namespace PepperDash.Essentials.DM
             {
                 var airMediaInputCard = inputCard as Card.Dmps3AirMediaInput;
 
-                
-
                 AddInputPortWithDebug(number, string.Format("AirMediaIn{0}", number), eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming);
             }
         }
@@ -630,41 +639,41 @@ namespace PepperDash.Essentials.DM
                     }
 
                     DMInput inCard = input == 0 ? null : Dmps.SwitcherInputs[input] as DMInput;
-                    Card.Dmps3OutputBase outCard = output == 0 ? null : Dmps.SwitcherOutputs[output] as Card.Dmps3OutputBase;
+                    DMOutput outCard = output == 0 ? null : Dmps.SwitcherOutputs[output] as DMOutput;
 
-                    if (inCard != null)
-                    {
+                    //if (inCard != null)
+                    //{
                         // NOTE THAT BITWISE COMPARISONS - TO CATCH ALL ROUTING TYPES 
                         if ((sigType | eRoutingSignalType.Video) == eRoutingSignalType.Video)
                         {
 
                             //SystemControl.VideoEnter.BoolValue = true;
-                            if (outCard != null && outCard.VideoOut != null)
+                            if (outCard != null)
                                 outCard.VideoOut = inCard;
                         }
 
                         if ((sigType | eRoutingSignalType.Audio) == eRoutingSignalType.Audio)
                         {
-                            if (outCard != null && outCard.AudioOut != null)
+                            if (outCard != null)
                                 outCard.AudioOut = inCard;
                         }
 
                         if ((sigType | eRoutingSignalType.UsbOutput) == eRoutingSignalType.UsbOutput)
                         {
-                            if (outCard != null && outCard.USBRoutedTo != null)
+                            if (outCard != null)
                                 outCard.USBRoutedTo = inCard;
                         }
 
                         if ((sigType | eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
                         {
-                            if (inCard != null && inCard.USBRoutedTo != null)
+                            if (inCard != null)
                                 inCard.USBRoutedTo = outCard;
                         }
-                    }
-                    else
-                    {
-                        Debug.Console(1, this, "Unable to execute route from input {0} to output {1}.  Input card not available", inputSelector, outputSelector);
-                    }
+                    //}
+                    //else
+                    //{
+                    //    Debug.Console(1, this, "Unable to execute route from input {0} to output {1}.  Input card not available", inputSelector, outputSelector);
+                    //}
 
                 }
                 else

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

@@ -31,7 +31,15 @@ namespace PepperDash.Essentials.DM.Config
 
 		[JsonProperty("outputNames")]
 		public Dictionary<uint, string> OutputNames { get; set; }
-	}
+
+        [JsonProperty("inputSlotSupportsHdcp2")]
+        public Dictionary<uint, bool> InputSlotSupportsHdcp2 { get; set; }
+
+        public DMChassisPropertiesConfig()
+        {
+            InputSlotSupportsHdcp2 = new Dictionary<uint, bool>();
+        }
+    }
 
     /// <summary>
     /// 

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

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

essentials-framework/Essentials DM/Essentials_DM/DmLite/HdMdxxxCEController.cs

@@ -73,7 +73,7 @@ namespace PepperDash.Essentials.DM
 
             RemoteEndDetectedFeedback = new BoolFeedback(() => TxRxPair.RemoteEndDetectedOnFeedback.BoolValue);
 
-            AutoRouteOnFeedback = new BoolFeedback(() => TxRxPair.ReceiverAutoModeOnFeedback.BoolValue);
+            AutoRouteOnFeedback = new BoolFeedback(() => TxRxPair.TransmitterAutoModeOnFeedback.BoolValue);
 
             PriorityRoutingOnFeedback = new BoolFeedback(() => TxRxPair.PriorityRoutingOnFeedback.BoolValue);
 
@@ -152,7 +152,7 @@ namespace PepperDash.Essentials.DM
         {
             if (args.EventId == DMSystemEventIds.RemoteEndDetectedEventId)
                 RemoteEndDetectedFeedback.FireUpdate();
-            else if (args.EventId == DMSystemEventIds.ReceiverAutoModeOnEventId)
+            else if (args.EventId == DMSystemEventIds.TransmitterAutoModeOnEventId)
                 AutoRouteOnFeedback.FireUpdate();
             else if (args.EventId == DMSystemEventIds.PriorityRoutingOnEventId)
                 PriorityRoutingOnFeedback.FireUpdate();

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

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

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

@@ -21,6 +21,8 @@ namespace PepperDash.Essentials.DM
 	{
 		public DmTx401C Tx { get; private set; }
 
+
+
 		public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
 		public RoutingInputPortWithVideoStatuses DisplayPortIn { get; private set; }
 		public RoutingInputPortWithVideoStatuses VgaIn { get; private set; }

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

@@ -1,181 +1,182 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
-using Crestron.SimplSharpPro.DM;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.DM.Config;
-
-namespace PepperDash.Essentials.DM
-{
-	public class DmTxHelper
-	{
-		/// <summary>
-		/// A factory method for various DmTxControllers
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
-		/// <param name="props"></param>
-		/// <returns></returns>
-        public static BasicDmTxControllerBase GetDmTxController(string key, string name, string typeName, DmTxPropertiesConfig props)
-		{
-			// switch on type name... later...
-
-			typeName = typeName.ToLower();
-			//uint ipid = Convert.ToUInt16(props.Id, 16);
-			var ipid = props.Control.IpIdInt;
-			var pKey = props.ParentDeviceKey.ToLower();
-
-			if (pKey == "processor")
-			{
-				// Catch constructor failures, mainly dues to IPID
-				try
-				{
-                    if(typeName.StartsWith("dmtx200"))
-                        return new DmTx200Controller(key, name, new DmTx200C2G(ipid, Global.ControlSystem));
-					if (typeName.StartsWith("dmtx201"))
-						return new DmTx201XController(key, name, new DmTx201S(ipid, Global.ControlSystem));
-                    if (typeName.StartsWith("dmtx4k202"))
-                        return new DmTx4k202CController(key, name, new DmTx4k202C(ipid, Global.ControlSystem));
-                    if (typeName.StartsWith("dmtx4kz202"))
-                        return new DmTx4k202CController(key, name, new DmTx4kz202C(ipid, Global.ControlSystem));
-                    if (typeName.StartsWith("dmtx4k302"))
-						return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, Global.ControlSystem));
-                    if (typeName.StartsWith("dmtx4kz302"))
-                        return new DmTx4kz302CController(key, name, new DmTx4kz302C(ipid, Global.ControlSystem));
-					if (typeName.StartsWith("dmtx401"))
-						return new DmTx401CController(key, name, new DmTx401C(ipid, Global.ControlSystem));
-					Debug.Console(0, "{1} WARNING: Cannot create DM-TX of type: '{0}'", typeName, key);
-				}
-				catch (Exception e)
-				{
-					Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e);
-				}
-			}
-			else
-			{
-				var parentDev = DeviceManager.GetDeviceForKey(pKey);
-				if (!(parentDev is DmChassisController))
-				{
-					Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a DM Chassis.",
-						key, pKey);
-					return null;
-				}
-
-                // Get the Crestron chassis and link stuff up
-				var switchDev = parentDev as DmChassisController;
-				var chassis = switchDev.Chassis;
-
-				var num = props.ParentInputNumber;
-				if (num <= 0 || num > chassis.NumberOfInputs)
-				{
-					Debug.Console(0, "Cannot create DM device '{0}'.  Input number '{1}' is out of range",
-						key, num);
-					return null;
-				}
-                else
-                {
-                    var controller = (parentDev as DmChassisController);
-                    controller.TxDictionary.Add(num, key);
-                }
-
-				// Catch constructor failures, mainly dues to IPID
-				try
-				{
-					// Must use different constructor for CPU3 chassis types. No IPID
-					if (chassis is DmMd8x8Cpu3 || chassis is DmMd16x16Cpu3 ||
-					chassis is DmMd32x32Cpu3 || chassis is DmMd8x8Cpu3rps ||
-					chassis is DmMd16x16Cpu3rps || chassis is DmMd32x32Cpu3rps)
-					{
-						if (typeName.StartsWith("dmtx200"))
-							return new DmTx200Controller(key, name, new DmTx200C2G(chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx201"))
-							return new DmTx201XController(key, name, new DmTx201C(chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4k100"))
-							return new DmTx4k100Controller(key, name, new DmTx4K100C1G(chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4k202"))
-							return new DmTx4k202CController(key, name, new DmTx4k202C(chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4kz202"))
-							return new DmTx4k202CController(key, name, new DmTx4kz202C(chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4k302"))
-							return new DmTx4k302CController(key, name, new DmTx4k302C(chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4kz302"))
-							return new DmTx4kz302CController(key, name, new DmTx4kz302C(chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx401"))
-							return new DmTx401CController(key, name, new DmTx401C(chassis.Inputs[num]));
-					}
-					else
-					{
-						if (typeName.StartsWith("dmtx200"))
-							return new DmTx200Controller(key, name, new DmTx200C2G(ipid, chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx201"))
-							return new DmTx201XController(key, name, new DmTx201C(ipid, chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4k100"))
-							return new DmTx4k100Controller(key, name, new DmTx4K100C1G(ipid, chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4k202"))
-							return new DmTx4k202CController(key, name, new DmTx4k202C(ipid, chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4kz202"))
-							return new DmTx4k202CController(key, name, new DmTx4kz202C(ipid, chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4k302"))
-							return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx4kz302"))
-							return new DmTx4kz302CController(key, name, new DmTx4kz302C(ipid, chassis.Inputs[num]));
-						if (typeName.StartsWith("dmtx401"))
-							return new DmTx401CController(key, name, new DmTx401C(ipid, chassis.Inputs[num]));
-					}
-				}
-				catch (Exception e)
-				{
-					Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e);
-				}
-			}
-			
-			return null;
-		}
-	}
-
-    public abstract class BasicDmTxControllerBase : CrestronGenericBaseDevice
-    {
-        public BasicDmTxControllerBase(string key, string name, GenericBase hardware)
-            : base(key, name, hardware)
-        {
-
-        }
-    }
-
-	/// <summary>
-	/// 
-	/// </summary>
-	public abstract class DmTxControllerBase : BasicDmTxControllerBase
-	{
-        public virtual void SetPortHdcpCapability(eHdcpCapabilityType hdcpMode, uint port) { }
-        public virtual eHdcpCapabilityType HdcpSupportCapability { get; protected set; }
-        public abstract StringFeedback ActiveVideoInputFeedback { get; protected set; }
-        public RoutingInputPortWithVideoStatuses AnyVideoInput { get; protected set; }
-
-        public DmTxControllerBase(string key, string name, EndpointTransmitterBase hardware)
-			: base(key, name, hardware) 
-		{
-			// if wired to a chassis, skip registration step in base class
-			if (hardware.DMInput != null)
-			{
-				this.PreventRegistration = true;
-			}
-            AddToFeedbackList(ActiveVideoInputFeedback);
-		}
-	}
-    //public enum ePdtHdcpSupport
-    //{
-    //    HdcpOff = 0,
-    //    Hdcp1 = 1,
-    //    Hdcp2 = 2,
-    //    Hdcp2_2= 3,
-    //    Auto = 99
-    //}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM
+{
+	public class DmTxHelper
+	{
+		/// <summary>
+		/// A factory method for various DmTxControllers
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="props"></param>
+		/// <returns></returns>
+        public static BasicDmTxControllerBase GetDmTxController(string key, string name, string typeName, DmTxPropertiesConfig props)
+		{
+			// switch on type name... later...
+
+			typeName = typeName.ToLower();
+			//uint ipid = Convert.ToUInt16(props.Id, 16);
+			var ipid = props.Control.IpIdInt;
+			var pKey = props.ParentDeviceKey.ToLower();
+
+			if (pKey == "processor")
+			{
+				// Catch constructor failures, mainly dues to IPID
+				try
+				{
+                    if(typeName.StartsWith("dmtx200"))
+                        return new DmTx200Controller(key, name, new DmTx200C2G(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmtx201"))
+						return new DmTx201XController(key, name, new DmTx201S(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx4k202"))
+                        return new DmTx4k202CController(key, name, new DmTx4k202C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx4kz202"))
+                        return new DmTx4k202CController(key, name, new DmTx4kz202C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx4k302"))
+						return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, Global.ControlSystem));
+                    if (typeName.StartsWith("dmtx4kz302"))
+                        return new DmTx4kz302CController(key, name, new DmTx4kz302C(ipid, Global.ControlSystem));
+					if (typeName.StartsWith("dmtx401"))
+						return new DmTx401CController(key, name, new DmTx401C(ipid, Global.ControlSystem));
+					Debug.Console(0, "{1} WARNING: Cannot create DM-TX of type: '{0}'", typeName, key);
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e);
+				}
+			}
+			else
+			{
+				var parentDev = DeviceManager.GetDeviceForKey(pKey);
+				if (!(parentDev is IDmSwitch))
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'. '{1}' is not a DM Chassis.",
+						key, pKey);
+					return null;
+				}
+
+                // Get the Crestron chassis and link stuff up
+				var switchDev = (parentDev as IDmSwitch);
+				var chassis = switchDev.Chassis;
+
+				var num = props.ParentInputNumber;
+				if (num <= 0 || num > chassis.NumberOfInputs)
+				{
+					Debug.Console(0, "Cannot create DM device '{0}'.  Input number '{1}' is out of range",
+						key, num);
+					return null;
+				}
+                else
+                {
+                    var controller = (parentDev as IDmSwitch);
+                    controller.TxDictionary.Add(num, key);
+                }
+
+				// Catch constructor failures, mainly dues to IPID
+				try
+				{
+					// Must use different constructor for CPU3 chassis types. No IPID
+					if (chassis is DmMd8x8Cpu3 || chassis is DmMd16x16Cpu3 ||
+					chassis is DmMd32x32Cpu3 || chassis is DmMd8x8Cpu3rps ||
+					chassis is DmMd16x16Cpu3rps || chassis is DmMd32x32Cpu3rps||
+                    chassis is DmMd128x128 || chassis is DmMd64x64)
+					{
+						if (typeName.StartsWith("dmtx200"))
+							return new DmTx200Controller(key, name, new DmTx200C2G(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx201"))
+							return new DmTx201XController(key, name, new DmTx201C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k100"))
+							return new DmTx4k100Controller(key, name, new DmTx4K100C1G(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k202"))
+							return new DmTx4k202CController(key, name, new DmTx4k202C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4kz202"))
+							return new DmTx4k202CController(key, name, new DmTx4kz202C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k302"))
+							return new DmTx4k302CController(key, name, new DmTx4k302C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4kz302"))
+							return new DmTx4kz302CController(key, name, new DmTx4kz302C(chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx401"))
+							return new DmTx401CController(key, name, new DmTx401C(chassis.Inputs[num]));
+					}
+					else
+					{
+						if (typeName.StartsWith("dmtx200"))
+							return new DmTx200Controller(key, name, new DmTx200C2G(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx201"))
+							return new DmTx201XController(key, name, new DmTx201C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k100"))
+							return new DmTx4k100Controller(key, name, new DmTx4K100C1G(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k202"))
+							return new DmTx4k202CController(key, name, new DmTx4k202C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4kz202"))
+							return new DmTx4k202CController(key, name, new DmTx4kz202C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4k302"))
+							return new DmTx4k302CController(key, name, new DmTx4k302C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx4kz302"))
+							return new DmTx4kz302CController(key, name, new DmTx4kz302C(ipid, chassis.Inputs[num]));
+						if (typeName.StartsWith("dmtx401"))
+							return new DmTx401CController(key, name, new DmTx401C(ipid, chassis.Inputs[num]));
+					}
+				}
+				catch (Exception e)
+				{
+					Debug.Console(0, "[{0}] WARNING: Cannot create DM-TX device: {1}", key, e);
+				}
+			}
+			
+			return null;
+		}
+	}
+
+    public abstract class BasicDmTxControllerBase : CrestronGenericBaseDevice
+    {
+        public BasicDmTxControllerBase(string key, string name, GenericBase hardware)
+            : base(key, name, hardware)
+        {
+
+        }
+    }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public abstract class DmTxControllerBase : BasicDmTxControllerBase
+	{
+        public virtual void SetPortHdcpCapability(eHdcpCapabilityType hdcpMode, uint port) { }
+        public virtual eHdcpCapabilityType HdcpSupportCapability { get; protected set; }
+        public abstract StringFeedback ActiveVideoInputFeedback { get; protected set; }
+        public RoutingInputPortWithVideoStatuses AnyVideoInput { get; protected set; }
+
+        public DmTxControllerBase(string key, string name, EndpointTransmitterBase hardware)
+			: base(key, name, hardware) 
+		{
+			// if wired to a chassis, skip registration step in base class
+			if (hardware.DMInput != null)
+			{
+				this.PreventRegistration = true;
+			}
+            AddToFeedbackList(ActiveVideoInputFeedback);
+		}
+	}
+    //public enum ePdtHdcpSupport
+    //{
+    //    HdcpOff = 0,
+    //    Hdcp1 = 1,
+    //    Hdcp2 = 2,
+    //    Hdcp2_2= 3,
+    //    Auto = 99
+    //}
 }

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

@@ -59,9 +59,9 @@
       <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.UI.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
-    <Reference Include="PepperDash_Core, Version=1.0.4.20530, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.26.30384, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\references\PepperDash_Core.dll</HintPath>
+      <HintPath>..\..\pepperdashcore-builds\PepperDash_Core.dll</HintPath>
     </Reference>
     <Reference Include="SimplSharpCustomAttributesInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -95,12 +95,14 @@
     <Compile Include="Cards REMOVE\DmcC4kInputCard.cs" />
     <Compile Include="Cards REMOVE\DmcHD4kInputCard.cs" />
     <Compile Include="Cards REMOVE\DmInputCardBase.cs" />
+    <Compile Include="Chassis\DmBladeChassisController.cs" />
     <Compile Include="Chassis\DmCardAudioOutput.cs" />
     <Compile Include="Chassis\DmChassisController.cs" />
     <Compile Include="Chassis\DmpsAudioOutputController.cs" />
     <Compile Include="Chassis\DmpsInternalVirtualDmTxController.cs" />
     <Compile Include="Chassis\DmpsRoutingController.cs" />
     <Compile Include="Chassis\HdMdNxM4kEController.cs" />
+    <Compile Include="IDmSwitch.cs" />
     <Compile Include="Config\DmpsRoutingConfig.cs" />
     <Compile Include="Config\DmRmcConfig.cs" />
     <Compile Include="Config\DmTxConfig.cs" />

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

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Cards;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+//using PepperDash.Essentials.DM.Cards;
+
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM {
+    public interface IDmSwitch {
+        Switch Chassis { get; }
+
+        Dictionary<uint, string> TxDictionary { get; }
+        Dictionary<uint, string> RxDictionary { get; }
+    }
+}

essentials-framework/Essentials Devices Common/Essentials Devices Common/Essentials Devices Common.csproj

@@ -63,9 +63,9 @@
       <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.Lighting.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
-    <Reference Include="PepperDash_Core, Version=1.0.4.20530, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="PepperDash_Core, Version=1.0.26.30384, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\references\PepperDash_Core.dll</HintPath>
+      <HintPath>..\..\pepperdashcore-builds\PepperDash_Core.dll</HintPath>
     </Reference>
     <Reference Include="SimplSharpCustomAttributesInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -109,6 +109,7 @@
     <Compile Include="Codec\iCodecAudio.cs" />
     <Compile Include="ImageProcessors\TVOneCorio.cs" />
     <Compile Include="ImageProcessors\TVOneCorioPropertiesConfig.cs" />
+    <Compile Include="Occupancy\GlsOdtOccupancySensorController.cs" />
     <Compile Include="Power Controllers\Digitallogger.cs" />
     <Compile Include="Power Controllers\DigitalLoggerPropertiesConfig.cs" />
     <Compile Include="Evertz\EvertsEndpointStatusServer.cs" />
@@ -151,8 +152,8 @@
     <Compile Include="Generic\GenericSource.cs" />
     <Compile Include="Microphone\MicrophonePrivacyController.cs" />
     <Compile Include="Microphone\MicrophonePrivacyControllerConfig.cs" />
-    <Compile Include="Occupancy\EssentialsGlsOccupancySensorBaseController.cs" />
-    <Compile Include="Occupancy\EssentialsOccupancyAggregator.cs" />
+    <Compile Include="Occupancy\GlsOccupancySensorBaseController.cs" />
+    <Compile Include="Occupancy\IOccupancyStatusProviderAggregator.cs" />
     <Compile Include="Occupancy\iOccupancyStatusProvider.cs" />
     <Compile Include="PC\InRoomPc.cs" />
     <Compile Include="PC\Laptop.cs" />

essentials-framework/Essentials Devices Common/Essentials Devices Common/Factory/DeviceFactory.cs

@@ -339,7 +339,7 @@ namespace PepperDash.Essentials.Devices.Common
                 occSensor = new GlsOirCCn(comm.CresnetIdInt, Global.ControlSystem);
 
                 if (occSensor != null)
-                    return new EssentialsGlsOccupancySensorBaseController(key, name, occSensor);
+                    return new GlsOccupancySensorBaseController(key, name, occSensor);
                 else
                     Debug.Console(0, "ERROR: Unable to create Occupancy Sensor Device. Key: '{0}'", key);
             }
@@ -348,12 +348,10 @@ namespace PepperDash.Essentials.Devices.Common
             {
                 var comm = CommFactory.GetControlPropertiesConfig(dc);
 
-                GlsOccupancySensorBase occSensor = null;
-
-                occSensor = new GlsOdtCCn(comm.CresnetIdInt, Global.ControlSystem);
+                var occSensor = new GlsOdtCCn(comm.CresnetIdInt, Global.ControlSystem);
 
                 if (occSensor != null)
-                    return new EssentialsGlsOccupancySensorBaseController(key, name, occSensor);
+                    return new GlsOdtOccupancySensorController(key, name, occSensor);
                 else
                     Debug.Console(0, "ERROR: Unable to create Occupancy Sensor Device. Key: '{0}'", key);
             }

essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/EssentialsGlsOccupancySensorBaseController.cs

@@ -1,73 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro.GeneralIO;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-
-namespace PepperDash.Essentials.Devices.Common.Occupancy
-{
-    public class EssentialsGlsOccupancySensorBaseController : CrestronGenericBaseDevice, IOccupancyStatusProvider
-    {
-        public GlsOccupancySensorBase OccSensor { get; private set; }
-
-        public BoolFeedback RoomIsOccupiedFeedback { get; private set; }
-
-        // Debug properties
-        public bool InTestMode { get; private set; }
-
-        public bool TestRoomIsOccupiedFeedback { get; private set; }
-
-        public Func<bool> RoomIsOccupiedFeedbackFunc
-        {
-            get
-            {
-                return () => InTestMode ? TestRoomIsOccupiedFeedback : OccSensor.OccupancyDetectedFeedback.BoolValue;
-            }
-        }
-
-        public EssentialsGlsOccupancySensorBaseController(string key, string name, GlsOccupancySensorBase sensor)
-            : base(key, name, sensor)
-        {
-            OccSensor = sensor;
-
-            RoomIsOccupiedFeedback = new BoolFeedback(RoomIsOccupiedFeedbackFunc);
-
-            OccSensor.BaseEvent += new Crestron.SimplSharpPro.BaseEventHandler(OccSensor_BaseEvent);
-        }
-
-        void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
-        {
-            Debug.Console(2, this, "GlsOccupancySensorChange  EventId: {0}", args.EventId);
-
-            if (args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId 
-                || args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId)
-            {
-                Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
-                RoomIsOccupiedFeedback.FireUpdate();
-            }
-        }
-
-        public void SetTestMode(bool mode)
-        {
-            InTestMode = mode;
-
-            Debug.Console(1, this, "In Mock Mode: '{0}'", InTestMode);
-        }
-
-        public void SetTestOccupiedState(bool state)
-        {
-            if (!InTestMode)
-                Debug.Console(1, "Mock mode not enabled");
-            else
-            {
-                TestRoomIsOccupiedFeedback = state;
-
-                RoomIsOccupiedFeedback.FireUpdate();
-            }
-        }
-    }
-}

essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/GlsOccupancySensorBaseController.cs

@@ -0,0 +1,255 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.GeneralIO;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Devices.Common.Occupancy
+{
+    public class GlsOccupancySensorBaseController : CrestronGenericBaseDevice, IOccupancyStatusProvider
+    {
+        public GlsOccupancySensorBase OccSensor { get; private set; }
+
+        public BoolFeedback RoomIsOccupiedFeedback { get; private set; }
+
+        public BoolFeedback GraceOccupancyDetectedFeedback { get; private set; }
+
+        public BoolFeedback RawOccupancyFeedback { get; private set; }
+
+        public BoolFeedback PirSensorEnabledFeedback { get; private set; }
+
+        public BoolFeedback LedFlashEnabledFeedback { get; private set; }
+
+        public BoolFeedback ShortTimeoutEnabledFeedback { get; private set; }
+
+        public IntFeedback PirSensitivityInVacantStateFeedback { get; private set; }
+
+        public IntFeedback PirSensitivityInOccupiedStateFeedback { get; private set; }
+
+        public IntFeedback CurrentTimeoutFeedback { get; private set; }
+
+        public IntFeedback LocalTimoutFeedback { get; private set; }
+
+        public IntFeedback InternalPhotoSensorValue { get; set; }
+
+        public IntFeedback ExternalPhotoSensorValue { get; set; }
+
+        // Debug properties
+        public bool InTestMode { get; private set; }
+
+        public bool TestRoomIsOccupiedFeedback { get; private set; }
+
+        public Func<bool> RoomIsOccupiedFeedbackFunc
+        {
+            get
+            {
+                return () => InTestMode ? TestRoomIsOccupiedFeedback : OccSensor.OccupancyDetectedFeedback.BoolValue;
+            }
+        }
+
+        public GlsOccupancySensorBaseController(string key, string name, GlsOccupancySensorBase sensor)
+            : base(key, name, sensor)
+        {
+            OccSensor = sensor;
+            
+            RoomIsOccupiedFeedback = new BoolFeedback(RoomIsOccupiedFeedbackFunc);
+
+            PirSensorEnabledFeedback = new BoolFeedback(() => OccSensor.PirEnabledFeedback.BoolValue);
+
+            LedFlashEnabledFeedback = new BoolFeedback(() => OccSensor.LedFlashEnabledFeedback.BoolValue);
+
+            ShortTimeoutEnabledFeedback = new BoolFeedback(() => OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
+
+            PirSensitivityInVacantStateFeedback = new IntFeedback(() => OccSensor.PirSensitivityInVacantStateFeedback.UShortValue);
+
+            PirSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.PirSensitivityInOccupiedStateFeedback.UShortValue);
+
+            CurrentTimeoutFeedback = new IntFeedback(() => OccSensor.CurrentTimeoutFeedback.UShortValue);
+
+            LocalTimoutFeedback = new IntFeedback(() => OccSensor.LocalTimeoutFeedback.UShortValue);
+
+            GraceOccupancyDetectedFeedback = new BoolFeedback(() => OccSensor.GraceOccupancyDetectedFeedback.BoolValue);
+
+            RawOccupancyFeedback = new BoolFeedback(() => OccSensor.RawOccupancyFeedback.BoolValue);
+
+            InternalPhotoSensorValue = new IntFeedback(() => OccSensor.InternalPhotoSensorValueFeedback.UShortValue);
+
+            ExternalPhotoSensorValue = new IntFeedback(() => OccSensor.ExternalPhotoSensorValueFeedback.UShortValue);
+
+            OccSensor.BaseEvent += new Crestron.SimplSharpPro.BaseEventHandler(OccSensor_BaseEvent);
+
+            OccSensor.GlsOccupancySensorChange += new GlsOccupancySensorChangeEventHandler(OccSensor_GlsOccupancySensorChange);
+        }
+
+
+        /// <summary>
+        /// Catches events for feedbacks on the base class.  Any extending wrapper class should call this delegate after it checks for it's own event IDs.
+        /// </summary>
+        /// <param name="device"></param>
+        /// <param name="args"></param>
+        protected virtual void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
+        {
+            if (args.EventId == GlsOccupancySensorBase.PirEnabledFeedbackEventId)
+                PirSensorEnabledFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.LedFlashEnabledFeedbackEventId)
+                LedFlashEnabledFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.ShortTimeoutEnabledFeedbackEventId)
+                ShortTimeoutEnabledFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.PirSensitivityInOccupiedStateFeedbackEventId)
+                PirSensitivityInOccupiedStateFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.PirSensitivityInVacantStateFeedbackEventId)
+                PirSensitivityInVacantStateFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.TimeoutFeedbackEventId)
+                CurrentTimeoutFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.TimeoutLocalFeedbackEventId)
+                LocalTimoutFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.GraceOccupancyDetectedFeedbackEventId)
+                GraceOccupancyDetectedFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyFeedbackEventId)
+                RawOccupancyFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.InternalPhotoSensorValueFeedbackEventId)
+                InternalPhotoSensorValue.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.ExternalPhotoSensorValueFeedbackEventId)
+                ExternalPhotoSensorValue.FireUpdate();
+        }
+
+        void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+        {
+            Debug.Console(2, this, "GlsOccupancySensorChange  EventId: {0}", args.EventId);
+
+            if (args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId 
+                || args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId)
+            {
+                Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
+                RoomIsOccupiedFeedback.FireUpdate();
+            }
+        }
+
+        public void SetTestMode(bool mode)
+        {
+            InTestMode = mode;
+
+            Debug.Console(1, this, "In Mock Mode: '{0}'", InTestMode);
+        }
+
+        public void SetTestOccupiedState(bool state)
+        {
+            if (!InTestMode)
+                Debug.Console(1, "Mock mode not enabled");
+            else
+            {
+                TestRoomIsOccupiedFeedback = state;
+
+                RoomIsOccupiedFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// Enables or disables the PIR sensor
+        /// </summary>
+        /// <param name="state"></param>
+        public void SetPirEnable(bool state)
+        {
+            if (state)
+            {
+                OccSensor.EnablePir.BoolValue = state;
+                OccSensor.DisablePir.BoolValue = !state;
+            }
+            else
+            {
+                OccSensor.EnablePir.BoolValue = state;
+                OccSensor.DisablePir.BoolValue = !state;
+            }            
+        }
+
+        /// <summary>
+        /// Enables or disables the LED Flash
+        /// </summary>
+        /// <param name="state"></param>
+        public void SetLedFlashEnable(bool state)
+        {
+            if (state)
+            {
+                OccSensor.EnableLedFlash.BoolValue = state;
+                OccSensor.DisableLedFlash.BoolValue = !state;
+            }
+            else
+            {
+                OccSensor.EnableLedFlash.BoolValue = state;
+                OccSensor.DisableLedFlash.BoolValue = !state;
+            }
+        }
+
+        /// <summary>
+        /// Enables or disables short timeout based on state
+        /// </summary>
+        /// <param name="state"></param>
+        public void SetShortTimeoutState(bool state)
+        {
+            if (state)
+            {
+                OccSensor.EnableShortTimeout.BoolValue = state;
+                OccSensor.DisableShortTimeout.BoolValue = !state;
+            }
+            else
+            {
+                OccSensor.EnableShortTimeout.BoolValue = state;
+                OccSensor.DisableShortTimeout.BoolValue = !state;
+            }
+        }
+
+        public void IncrementPirSensitivityInOccupiedState(bool pressRelease)
+        {
+            OccSensor.IncrementPirSensitivityInOccupiedState.BoolValue = pressRelease;
+        }
+
+        public void DecrementPirSensitivityInOccupiedState(bool pressRelease)
+        {
+            OccSensor.DecrementPirSensitivityInOccupiedState.BoolValue = pressRelease;
+        }
+
+        public void IncrementPirSensitivityInVacantState(bool pressRelease)
+        {
+            OccSensor.IncrementPirSensitivityInVacantState.BoolValue = pressRelease;
+        }
+
+        public void DecrementPirSensitivityInVacantState(bool pressRelease)
+        {
+            OccSensor.DecrementPirSensitivityInVacantState.BoolValue = pressRelease;
+        }
+
+        public void ForceOccupied()
+        {
+            OccSensor.ForceOccupied.BoolValue = true;
+        }
+
+        public void ForceVacant()
+        {
+            OccSensor.ForceVacant.BoolValue = true;
+        }
+
+        public void EnableRawStates(bool state)
+        {
+            OccSensor.EnableRawStates.BoolValue = state;
+        }
+
+        public void SetRemoteTimeout(ushort time)
+        {
+            OccSensor.RemoteTimeout.UShortValue = time;
+        }
+
+        public void SetInternalPhotoSensorMinChange(ushort value)
+        {
+            OccSensor.InternalPhotoSensorMinimumChange.UShortValue = value;
+        }
+
+        public void SetExternalPhotoSensorMinChange(ushort value)
+        {
+            OccSensor.ExternalPhotoSensorMinimumChange.UShortValue = value;
+        }
+    }
+}

essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/GlsOdtOccupancySensorController.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.GeneralIO;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Devices.Common.Occupancy
+{
+    public class GlsOdtOccupancySensorController : GlsOccupancySensorBaseController
+    {
+        public new GlsOdtCCn OccSensor { get; private set; }
+
+        public BoolFeedback OrWhenVacatedFeedback { get; private set; }
+
+        public BoolFeedback AndWhenVacatedFeedback { get; private set; }
+
+        public BoolFeedback UltrasonicAEnabledFeedback { get; private set; }
+
+        public BoolFeedback UltrasonicBEnabledFeedback { get; private set; }
+
+        public IntFeedback UltrasonicSensitivityInVacantStateFeedback { get; private set; }
+
+        public IntFeedback UltrasonicSensitivityInOccupiedStateFeedback { get; private set; }
+
+
+        public GlsOdtOccupancySensorController(string key, string name, GlsOdtCCn sensor)
+            : base(key, name, sensor)
+        {
+            OccSensor = sensor;
+
+            AndWhenVacatedFeedback = new BoolFeedback(() => OccSensor.AndWhenVacatedFeedback.BoolValue);
+
+            OrWhenVacatedFeedback = new BoolFeedback(() => OccSensor.OrWhenVacatedFeedback.BoolValue);
+
+            UltrasonicAEnabledFeedback = new BoolFeedback(() => OccSensor.UsAEnabledFeedback.BoolValue);
+
+            UltrasonicBEnabledFeedback = new BoolFeedback(() => OccSensor.UsBEnabledFeedback.BoolValue);
+
+            UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInVacantStateFeedback.UShortValue);
+
+            UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInOccupiedStateFeedback.UShortValue);
+        }
+
+        /// <summary>
+        /// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
+        /// Then calls the base delegate method to ensure any common event IDs are captured.
+        /// </summary>
+        /// <param name="device"></param>
+        /// <param name="args"></param>
+        protected override void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
+        {
+            if (args.EventId == GlsOccupancySensorBase.AndWhenVacatedFeedbackEventId)
+                AndWhenVacatedFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.OrWhenVacatedFeedbackEventId)
+                OrWhenVacatedFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.UsAEnabledFeedbackEventId)
+                UltrasonicAEnabledFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.UsBEnabledFeedbackEventId)
+                UltrasonicBEnabledFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInOccupiedStateFeedbackEventId)
+                UltrasonicSensitivityInOccupiedStateFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInVacantStateFeedbackEventId)
+                UltrasonicSensitivityInVacantStateFeedback.FireUpdate();
+
+
+            base.OccSensor_GlsOccupancySensorChange(device, args);
+        }
+
+        /// <summary>
+        /// Sets the OrWhenVacated state
+        /// </summary>
+        /// <param name="state"></param>
+        public void SetOrWhenVacatedState(bool state)
+        {
+            OccSensor.OrWhenVacated.BoolValue = state;
+        }
+
+        /// <summary>
+        /// Sets the AndWhenVacated state
+        /// </summary>
+        /// <param name="state"></param>
+        public void SetAndWhenVacatedState(bool state)
+        {
+            OccSensor.AndWhenVacated.BoolValue = state;
+        }
+
+        /// <summary>
+        /// Enables or disables the Ultrasonic A sensor
+        /// </summary>
+        /// <param name="state"></param>
+        public void SetUsAEnable(bool state)
+        {
+            if (state)
+            {
+                OccSensor.EnableUsA.BoolValue = state;
+                OccSensor.DisableUsA.BoolValue = !state;
+            }
+            else
+            {
+                OccSensor.EnableUsA.BoolValue = state;
+                OccSensor.DisableUsA.BoolValue = !state;
+            }
+        }
+
+
+        /// <summary>
+        /// Enables or disables the Ultrasonic B sensor
+        /// </summary>
+        /// <param name="state"></param>
+        public void SetUsBEnable(bool state)
+        {
+            if (state)
+            {
+                OccSensor.EnableUsB.BoolValue = state;
+                OccSensor.DisableUsB.BoolValue = !state;
+            }
+            else
+            {
+                OccSensor.EnableUsB.BoolValue = state;
+                OccSensor.DisableUsB.BoolValue = !state;
+            }
+        }
+
+        public void IncrementUsSensitivityInOccupiedState(bool pressRelease)
+        {
+            OccSensor.IncrementUsSensitivityInOccupiedState.BoolValue = pressRelease;
+        }
+
+        public void DecrementUsSensitivityInOccupiedState(bool pressRelease)
+        {
+            OccSensor.DecrementUsSensitivityInOccupiedState.BoolValue = pressRelease;
+        }
+
+        public void IncrementUsSensitivityInVacantState(bool pressRelease)
+        {
+            OccSensor.IncrementUsSensitivityInVacantState.BoolValue = pressRelease;
+        }
+
+        public void DecrementUsSensitivityInVacantState(bool pressRelease)
+        {
+            OccSensor.DecrementUsSensitivityInVacantState.BoolValue = pressRelease;
+        }
+    }
+}

essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/IOccupancyStatusProviderAggregator.cs

@@ -12,7 +12,7 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
     /// <summary>
     /// Aggregates the RoomIsOccupied feedbacks of one or more IOccupancyStatusProvider objects
     /// </summary>
-    public class EssentialsOccupancyAggregator : Device, IOccupancyStatusProvider
+    public class IOccupancyStatusProviderAggregator : Device, IOccupancyStatusProvider
     {
         /// <summary>
         /// Aggregated feedback of all linked IOccupancyStatusProvider devices
@@ -27,7 +27,7 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
 
         private BoolFeedbackOr AggregatedOccupancyStatus;
 
-        public EssentialsOccupancyAggregator(string key, string name) 
+        public IOccupancyStatusProviderAggregator(string key, string name) 
             : base(key, name)
         {
             AggregatedOccupancyStatus = new BoolFeedbackOr();

essentials-framework/Essentials Devices Common/Essentials Devices Common/Properties/AssemblyInfo.cs

@@ -4,4 +4,4 @@
 [assembly: AssemblyCompany("PepperDash Technology Corp")]
 [assembly: AssemblyProduct("Essentials_Devices_Common")]
 [assembly: AssemblyCopyright("Copyright ©  2019")]
-[assembly: AssemblyVersion("1.3.*")]
+[assembly: AssemblyVersion("1.4.*")]