Merge remote-tracking branch 'origin/feature/ecs-967' into JTA

# Conflicts:
#	PepperDashEssentials/AppServer/CotijaSystemController.cs
#	PepperDashEssentials/Bridges/BridgeBase.cs
#	PepperDashEssentials/Bridges/IBasicCommunicationBridge.cs
#	PepperDashEssentials/PepperDashEssentials.csproj
#	Release Package/PepperDashEssentials.cpz
#	Release Package/PepperDashEssentials.dll
#	essentials-framework

PepperDashEssentials/Bridges/BridgeBase.cs

@@ -10,8 +10,8 @@ using Newtonsoft.Json;
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Devices;
-using PepperDash.Essentials.Devices.Common;
 using PepperDash.Essentials.Core.Config;
+using PepperDash.Essentials.Core.CrestronIO;
 using PepperDash.Essentials.DM;
 
 namespace PepperDash.Essentials.Bridges
@@ -75,31 +75,41 @@ namespace PepperDash.Essentials.Bridges
 
                     if (device != null)
                     {
-                        if (device is GenericComm)
+                        if (device is PepperDash.Essentials.Core.Monitoring.SystemMonitorController)
+                        {
+                            (device as PepperDash.Essentials.Core.Monitoring.SystemMonitorController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is GenericComm)
                         {
                             (device as GenericComm).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
                             continue;
                         }
-						else if (device is DigitalLogger)
-						{
-							(device as DigitalLogger).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
-							continue;
-						}
-						else if (device is DmChassisController)
-						{
-							// (device as DmChassisController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
-							continue;
-						}
-						else if (device is DmTxControllerBase)
-						{
-							// (device as DmTxControllerBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
-							continue;
-						}
-						else if (device is DmRmcControllerBase)
-						{
-							// (device as DmRmcControllerBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
-							continue;
-						}
+                        else if (device is DmChassisController)
+                        {
+                            (device as DmChassisController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is DmTxControllerBase)
+                        {
+                            (device as DmTxControllerBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is DmRmcControllerBase)
+                        {
+                            (device as DmRmcControllerBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is GenericRelayDevice)
+                        {
+                            (device as GenericRelayDevice).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
+                        else if (device is IDigitalInput)
+                        {
+                            (device as IDigitalInput).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
                     }
                 }
 
@@ -134,6 +144,7 @@ namespace PepperDash.Essentials.Bridges
         [JsonProperty("devices")]
         public List<ApiDevice> Devices { get; set; }
 
+
         public class ApiDevice
         {
             [JsonProperty("deviceKey")]
@@ -149,108 +160,4 @@ namespace PepperDash.Essentials.Bridges
     }
 
 
-    ///// <summary>
-    ///// API class for IBasicCommunication devices
-    ///// </summary>
-    //public class IBasicCommunicationApi : DeviceApiBase
-    //{
-    //    public IBasicCommunication Device { get; set; }
-
-    //    SerialFeedback TextReceivedFeedback;
-
-    //    public IBasicCommunicationApi(IBasicCommunication dev)
-    //    {
-    //        TextReceivedFeedback = new SerialFeedback();
-
-    //        Device = dev;
-
-    //        SetupFeedbacks();
-
-    //        ActionApi = new Dictionary<string, Object>
-    //        {
-    //            { "connect", new Action(Device.Connect) },
-    //            { "disconnect", new Action(Device.Disconnect) },
-    //            { "connectstate", new Action<bool>( b => ConnectByState(b) ) },
-    //            { "sendtext", new Action<string>( s => Device.SendText(s) ) }
-
-    //        };
-
-    //        FeedbackApi = new Dictionary<string, Feedback>
-    //        {
-    //            { "isconnected", new BoolFeedback( () => Device.IsConnected ) },
-    //            { "textrecieved", TextReceivedFeedback }
-    //        };
-    //    }
-
-    //    /// <summary>
-    //    /// Controls connection based on state of input
-    //    /// </summary>
-    //    /// <param name="state"></param>
-    //    void ConnectByState(bool state)
-    //    {
-    //        if (state)
-    //            Device.Connect();
-    //        else
-    //            Device.Disconnect();                             
-    //    }
-
-    //    void SetupFeedbacks()
-    //    {
-    //        Device.TextReceived += new EventHandler<GenericCommMethodReceiveTextArgs>(Device_TextReceived);
-
-    //        if(Device is ISocketStatus)
-    //            (Device as ISocketStatus).ConnectionChange += new EventHandler<GenericSocketStatusChageEventArgs>(IBasicCommunicationApi_ConnectionChange);
-    //    }
-
-    //    void IBasicCommunicationApi_ConnectionChange(object sender, GenericSocketStatusChageEventArgs e)
-    //    {
-    //        FeedbackApi["isconnected"].FireUpdate();
-    //    }
-
-    //    void Device_TextReceived(object sender, GenericCommMethodReceiveTextArgs e)
-    //    {
-    //        TextReceivedFeedback.FireUpdate(e.Text);
-    //    }
-    //}
-
- 
-
-    ///// <summary>
-    ///// Each flavor of API is a static class with static properties and a static constructor that
-    ///// links up the things to do.
-    ///// </summary>
-    //public class DmChassisControllerApi : DeviceApiBase
-    //{
-    //    IntFeedback Output1Feedback;
-    //    IntFeedback Output2Feedback;
-
-    //    public DmChassisControllerApi(DmChassisController dev)
-    //    {
-    //        Output1Feedback = new IntFeedback( new Func<int>(() => 1));
-    //        Output2Feedback = new IntFeedback( new Func<int>(() => 2));
-
-    //        ActionApi = new Dictionary<string, Object>
-    //        {
-                
-    //        };
-
-    //        FeedbackApi = new Dictionary<string, Feedback>
-    //        {
-    //            { "Output-1/fb", Output1Feedback },
-    //            { "Output-2/fb", Output2Feedback }
-    //        };
-    //    }
-
-    //    /// <summary>
-    //    /// Factory method
-    //    /// </summary>
-    //    /// <param name="dev"></param>
-    //    /// <returns></returns>
-    //    public static DmChassisControllerApi GetActionApiForDevice(DmChassisController dev)
-    //    {
-    //        return new DmChassisControllerApi(dev);
-    //    }
-    //}
-
-
 }

PepperDashEssentials/Bridges/BridgeFactory.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+using PepperDash.Core;
+using PepperDash.Essentials.Core.Routing;
+using PepperDash.Essentials.Bridges;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.EthernetCommunication;
+
+namespace PepperDash.Essentials 
+{
+	public class BridgeFactory 
+    {
+		public static IKeyed GetDevice(DeviceConfig dc) 
+        {
+			// ? why is this static JTA 2018-06-13? 
+			
+			var key = dc.Key;
+			var name = dc.Name;
+			var type = dc.Type;
+			var properties = dc.Properties;
+			var propAnon = new { };
+			
+			var typeName = dc.Type.ToLower();
+			var groupName = dc.Group.ToLower();
+
+			//Debug.Console(2, "Name {0}, Key {1}, Type {2}, Properties {3}", name, key, type, properties.ToString());
+
+			if (typeName == "eiscapi") 
+            {
+			    return new EiscApi(dc);
+			}
+
+		    return null;
+		}
+	}
+
+	public class DmBridge : Device 
+    {
+        public EiscBridgeProperties Properties { get; private set; }
+
+        public PepperDash.Essentials.DM.DmChassisController DmSwitch { get; private set; }
+
+		public DmBridge(string key, string name, JToken properties) : base(key, name) 
+        {
+	        Properties = JsonConvert.DeserializeObject<EiscBridgeProperties>(properties.ToString());
+	    }
+
+		public override bool CustomActivate() 
+        {
+			// Create EiscApis 
+			if (Properties.Eiscs != null) 
+            {
+				foreach (var eisc in Properties.Eiscs) 
+                {
+					var ApiEisc = new BridgeApiEisc(eisc.IpId, eisc.Hostname);
+
+					ApiEisc.Eisc.SetUShortSigAction(101, u => DmSwitch.ExecuteSwitch(u,1, eRoutingSignalType.Video));
+					ApiEisc.Eisc.SetUShortSigAction(102, u => DmSwitch.ExecuteSwitch(u,2, eRoutingSignalType.Video));								
+				}
+			}
+
+			foreach (var device in DeviceManager.AllDevices) 
+            {
+				if (device.Key == this.Properties.ParentDeviceKey) 
+                {
+					Debug.Console(0, "deviceKey {0} Matches", device.Key);
+					DmSwitch = DeviceManager.GetDeviceForKey(device.Key) as PepperDash.Essentials.DM.DmChassisController;
+				} 
+				else 
+                {
+					Debug.Console(0, "deviceKey {0} doesn't match", device.Key);
+				}
+			}
+
+			Debug.Console(0, "Bridge {0} Activated", this.Name);
+			return true;
+		}
+	}
+
+    public class CommBridge : Device
+    {
+        public CommBridgeProperties Properties { get; private set; }
+
+        public List<IBasicCommunication> CommDevices { get; private set; }
+
+        public CommBridge(string key, string name, JToken properties)
+            : base(key, name)
+        {
+            Properties = JsonConvert.DeserializeObject<CommBridgeProperties>(properties.ToString());
+        }
+
+        public override bool CustomActivate()
+        {
+            // Create EiscApis 
+            if (Properties.Eiscs != null)
+            {
+                foreach (var eisc in Properties.Eiscs)
+                {
+                    var ApiEisc = new BridgeApiEisc(eisc.IpId, eisc.Hostname);
+                }
+            }
+
+            foreach (var deviceKey in Properties.CommDevices)
+            {
+                var device = DeviceManager.GetDeviceForKey(deviceKey);
+
+                if (device != null)
+                {
+                    Debug.Console(0, "deviceKey {0} Found in Device Manager", device.Key);
+                    CommDevices.Add(device as IBasicCommunication);
+                }
+                else
+                {
+                    Debug.Console(0, "deviceKey {0} Not Found in Device Manager", deviceKey);
+                }
+            }
+
+            // Iterate through all the CommDevices and link up their Actions and Feedbacks
+
+            Debug.Console(0, "Bridge {0} Activated", this.Name);
+
+            return true;
+        }
+    }
+
+
+	public class EiscBridgeProperties 
+    {
+        public string ParentDeviceKey { get; set; }
+        public eApiType ApiType { get; set; } 
+        public List<EiscProperties> Eiscs { get; set; }
+        public string ApiOverrideFilePath { get; set; }
+
+        public class EiscProperties
+        {
+            public string IpId { get; set; }
+            public string Hostname { get; set; }
+        }
+	}
+
+    public class CommBridgeProperties : EiscBridgeProperties
+    {
+        public List<string> CommDevices { get; set; }
+    }
+
+    public enum eApiType { Eisc = 0 }
+
+	public class BridgeApiEisc 
+    {
+        public uint Ipid { get; private set; }
+        public ThreeSeriesTcpIpEthernetIntersystemCommunications Eisc { get; private set; }
+
+		public BridgeApiEisc(string ipid, string hostname) 
+        {
+			Ipid = (UInt32)int.Parse(ipid, System.Globalization.NumberStyles.HexNumber);
+			Eisc = new ThreeSeriesTcpIpEthernetIntersystemCommunications(Ipid, hostname, Global.ControlSystem);
+			Eisc.Register();
+			Eisc.SigChange += Eisc_SigChange;
+			Debug.Console(0, "BridgeApiEisc Created at Ipid {0}", ipid);
+		}
+		void Eisc_SigChange(object currentDevice, Crestron.SimplSharpPro.SigEventArgs args) 
+        {
+			if (Debug.Level >= 1)
+				Debug.Console(1, "BridgeApiEisc change: {0} {1}={2}", args.Sig.Type, args.Sig.Number, args.Sig.StringValue);
+			var uo = args.Sig.UserObject;
+			if (uo is Action<bool>)
+				(uo as Action<bool>)(args.Sig.BoolValue);
+			else if (uo is Action<ushort>)
+				(uo as Action<ushort>)(args.Sig.UShortValue);
+			else if (uo is Action<string>)
+				(uo as Action<string>)(args.Sig.StringValue);
+		}
+	}
+}

PepperDashEssentials/Bridges/DmChassisControllerBridge.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmChassisControllerApiExtentions 
+    {
+        public static void LinkToApi(this DmChassisController dmChassis, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DmChassisControllerJoinMap;
+
+            if (joinMap == null)
+                joinMap = new DmChassisControllerJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, dmChassis, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            dmChassis.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+
+            // Link up outputs
+            for (uint i = 1; i <= dmChassis.Chassis.NumberOfOutputs - 1; i++)
+            {
+                var ioSlot = i;
+
+                // Control
+                trilist.SetUShortSigAction(joinMap.OutputVideo + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Video)));
+                trilist.SetUShortSigAction(joinMap.OutputAudio + ioSlot, new Action<ushort>(o => dmChassis.ExecuteSwitch(o, ioSlot, eRoutingSignalType.Audio)));
+
+                // Feedback
+                dmChassis.VideoOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputVideo + ioSlot]);
+                dmChassis.AudioOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputAudio + ioSlot]);
+
+                dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + 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]);
+                dmChassis.OutputAudioRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentAudioInputNames + ioSlot]);
+                dmChassis.InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline + ioSlot]);
+                dmChassis.OutputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
+            }
+        }
+
+
+        public class DmChassisControllerJoinMap : JoinMapBase
+        {
+            public uint IsOnline { get; set; }
+            public uint OutputVideo { get; set; }
+            public uint OutputAudio { get; set; }
+            public uint VideoSyncStatus { get; set; }
+            public uint InputNames { get; set; }
+            public uint OutputNames { get; set; }
+            public uint OutputCurrentVideoInputNames { get; set; }
+            public uint OutputCurrentAudioInputNames { get; set; }
+            public uint InputCurrentResolution { get; set; }
+            public uint InputEndpointOnline { get; set; }
+            public uint OutputEndpointOnline { get; set; }
+            //public uint HdcpSupport { get; set; }
+            //public uint HdcpSupportCapability { get; set; }
+
+
+            public DmChassisControllerJoinMap()
+            {
+                IsOnline = 11;
+                OutputVideo = 100; //101-299
+                OutputAudio = 300; //301-499
+                VideoSyncStatus = 100; //101-299
+                InputNames = 100; //101-299
+                OutputNames = 300; //301-499
+                OutputCurrentVideoInputNames = 2000; //2001-2199
+                OutputCurrentAudioInputNames = 2200; //2201-2399
+                InputCurrentResolution = 2400; // 2401-2599
+                InputEndpointOnline = 500;
+                OutputEndpointOnline = 700;
+                //HdcpSupport = 1000; //1001-1199
+               //HdcpSupportCapability = 1200; //1201-1399
+
+            }
+
+            public override void OffsetJoinNumbers(uint joinStart)
+            {
+                var joinOffset = joinStart - 1;
+
+                IsOnline = IsOnline + joinOffset;
+                OutputVideo = OutputVideo + joinOffset;
+                OutputAudio = OutputAudio + joinOffset;
+                VideoSyncStatus = VideoSyncStatus + joinOffset;
+                InputNames = InputNames + joinOffset;
+                OutputNames = OutputNames + joinOffset;
+                OutputCurrentVideoInputNames = OutputCurrentVideoInputNames + joinOffset;
+                OutputCurrentAudioInputNames = OutputCurrentAudioInputNames + joinOffset;
+                InputCurrentResolution = InputCurrentResolution + joinOffset;
+                InputEndpointOnline = InputEndpointOnline + joinOffset;
+                OutputEndpointOnline = OutputEndpointOnline + joinOffset;
+                //HdcpSupport = HdcpSupport + joinOffset;
+                //HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+            }
+        }
+    }
+}

PepperDashEssentials/Bridges/DmRmcControllerBridge.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmRmcControllerApiExtensions
+    {
+        public static void LinkToApi(this DmRmcControllerBase rmc, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DmRmcControllerJoinMap;
+
+            if (joinMap == null)
+                joinMap = new DmRmcControllerJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, rmc, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            rmc.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            if(rmc.VideoOutputResolutionFeedback != null)
+                rmc.VideoOutputResolutionFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentOutputResolution]);
+            if(rmc.EdidManufacturerFeedback != null)
+                rmc.EdidManufacturerFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidManufacturer]);
+            if(rmc.EdidNameFeedback != null)
+                rmc.EdidNameFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidName]);
+            if(rmc.EdidPreferredTimingFeedback != null)
+                rmc.EdidPreferredTimingFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidPrefferedTiming]);
+            if(rmc.EdidSerialNumberFeedback != null)
+                rmc.EdidSerialNumberFeedback.LinkInputSig(trilist.StringInput[joinMap.EdidSerialNumber]);
+        }
+
+        public class DmRmcControllerJoinMap : JoinMapBase
+        {
+            public uint IsOnline { get; set; }
+            public uint CurrentOutputResolution { get; set; }
+            public uint EdidManufacturer { get; set; }
+            public uint EdidName { get; set; }
+            public uint EdidPrefferedTiming { get; set; }
+            public uint EdidSerialNumber { get; set; }
+
+            public DmRmcControllerJoinMap()
+            {
+                // Digital
+                IsOnline = 1;
+
+                // Serial
+                CurrentOutputResolution = 1;
+                EdidManufacturer = 2;
+                EdidName = 3;
+                EdidPrefferedTiming = 4;
+                EdidSerialNumber = 5;
+            }
+
+            public override void OffsetJoinNumbers(uint joinStart)
+            {
+                var joinOffset = joinStart - 1;
+
+                IsOnline = IsOnline + joinOffset;
+                CurrentOutputResolution = CurrentOutputResolution + joinOffset;
+                EdidManufacturer = EdidManufacturer + joinOffset;
+                EdidName = EdidName + joinOffset;
+                EdidPrefferedTiming = EdidPrefferedTiming + joinOffset;
+                EdidSerialNumber = EdidSerialNumber + joinOffset;
+            }
+        }
+    }
+}

PepperDashEssentials/Bridges/DmTxControllerBridge.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+using Crestron.SimplSharpPro.DM.Endpoints;
+using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class DmTxControllerApiExtensions
+    {
+        public static void LinkToApi(this DmTxControllerBase tx, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as DmTxControllerJoinMap;
+
+            if (joinMap == null)
+                joinMap = new DmTxControllerJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, tx, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            tx.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            tx.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus]);
+            tx.AnyVideoInput.VideoStatus.VideoResolutionFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentInputResolution]);
+            //tx.HdcpSupportAllFeedback.LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportCapability]);
+
+            bool hdcpTypeSimple;
+
+            if (tx.Hardware is DmTx4kX02CBase || tx.Hardware is DmTx4kzX02CBase)
+                hdcpTypeSimple = false;
+            else
+                hdcpTypeSimple = true;
+
+            if (tx is ITxRouting)
+            {
+                var txR = tx as ITxRouting;
+
+                trilist.SetUShortSigAction(joinMap.VideoInput,
+                    new Action<ushort>(i => txR.ExecuteNumericSwitch(i, 0, eRoutingSignalType.Video)));
+                trilist.SetUShortSigAction(joinMap.AudioInput,
+                    new Action<ushort>(i => txR.ExecuteNumericSwitch(i, 0, eRoutingSignalType.Audio)));
+
+                txR.VideoSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.VideoInput]);
+                txR.AudioSourceNumericFeedback.LinkInputSig(trilist.UShortInput[joinMap.AudioInput]);
+
+                trilist.UShortInput[joinMap.HdcpSupportCapability].UShortValue = (ushort)tx.HdcpSupportCapability;
+
+                if(txR.InputPorts[DmPortName.HdmiIn] != null)
+                {
+                    var inputPort = txR.InputPorts[DmPortName.HdmiIn];
+
+                    if (tx.Feedbacks["HdmiInHdcpCapability"] != null)
+                        (tx.Feedbacks["HdmiInHdcpCapability"] as IntFeedback).LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState]);
+
+                    if (inputPort.ConnectionType == eRoutingPortConnectionType.Hdmi && inputPort.Port != null)
+                    {
+                        var port = inputPort.Port as EndpointHdmiInput;
+
+                        SetHdcpCapabilityAction(hdcpTypeSimple, port, joinMap.Port1HdcpState, trilist);
+                    }
+                }
+                
+                if (txR.InputPorts[DmPortName.HdmiIn1] != null)
+                {
+                    var inputPort = txR.InputPorts[DmPortName.HdmiIn1];
+
+                    if (tx.Feedbacks["HdmiIn1HdcpCapability"] != null)
+                        (tx.Feedbacks["HdmiIn1HdcpCapability"] as IntFeedback).LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState]);
+
+                    if (inputPort.ConnectionType == eRoutingPortConnectionType.Hdmi && inputPort.Port != null)
+                    {
+                        var port = inputPort.Port as EndpointHdmiInput;
+
+                        SetHdcpCapabilityAction(hdcpTypeSimple, port, joinMap.Port1HdcpState, trilist);
+                    }
+                }
+
+                if (txR.InputPorts[DmPortName.HdmiIn2] != null)
+                {
+                    var inputPort = txR.InputPorts[DmPortName.HdmiIn2];
+
+                    if (tx.Feedbacks["HdmiIn2HdcpCapability"] != null)
+                        (tx.Feedbacks["HdmiIn2HdcpCapability"] as IntFeedback).LinkInputSig(trilist.UShortInput[joinMap.Port1HdcpState]);
+
+                    if (inputPort.ConnectionType == eRoutingPortConnectionType.Hdmi && inputPort.Port != null)
+                    {
+                        var port = inputPort.Port as EndpointHdmiInput;
+
+                        SetHdcpCapabilityAction(hdcpTypeSimple, port, joinMap.Port2HdcpState, trilist);
+                    }
+                }
+
+            }
+        }
+
+        static void SetHdcpCapabilityAction(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>(s =>
+                        {
+                            port.HdcpCapability = (eHdcpCapabilityType)s;
+                        }));
+            }
+        }
+
+        public class DmTxControllerJoinMap : JoinMapBase
+        {
+            public uint IsOnline { get; set; }
+            public uint VideoSyncStatus { get; set; }
+            public uint CurrentInputResolution { get; set; }
+            public uint HdcpSupportCapability { get; set; }
+            public uint VideoInput { get; set; }
+            public uint AudioInput { get; set; }
+            public uint Port1HdcpState { get; set; }
+            public uint Port2HdcpState { get; set; }
+
+
+            public DmTxControllerJoinMap()
+            {
+                // Digital
+                IsOnline = 1;
+                VideoSyncStatus = 2;
+                // Serial
+                CurrentInputResolution = 1;
+                // Analog
+                VideoInput = 1;
+                AudioInput = 2;
+                HdcpSupportCapability = 3;
+                Port1HdcpState = 4;
+                Port2HdcpState = 5;
+            }
+
+            public override void OffsetJoinNumbers(uint joinStart)
+            {
+                var joinOffset = joinStart - 1;
+
+                IsOnline = IsOnline + joinOffset;
+                VideoSyncStatus = VideoSyncStatus + joinOffset;
+                CurrentInputResolution = CurrentInputResolution + joinOffset;
+                VideoInput = VideoInput + joinOffset;
+                AudioInput = AudioInput + joinOffset;
+                HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+                Port1HdcpState = Port1HdcpState + joinOffset;
+                Port2HdcpState = Port2HdcpState + joinOffset;
+            }
+        }
+    }
+}

PepperDashEssentials/Bridges/GenericRelayDeviceBridge.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.CrestronIO;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class GenericRelayDeviceApiExtensions
+    {
+        public static void LinkToApi(this GenericRelayDevice relay, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as GenericRelayControllerJoinMap;
+
+            if (joinMap == null)
+                joinMap = new GenericRelayControllerJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            if (relay.RelayOutput == null)
+            {
+                Debug.Console(1, relay, "Unable to link device '{0}'.  Relay is null", relay.Key);
+                return;
+            }
+
+            Debug.Console(1, relay, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+            trilist.SetBoolSigAction(joinMap.Relay, new Action<bool>(b =>
+                {
+                    if (b)
+                        relay.CloseRelay();
+                    else
+                        relay.OpenRelay();
+                }));
+
+            // feedback for relay state
+
+            relay.OutputIsOnFeedback.LinkInputSig(trilist.BooleanInput[joinMap.Relay]);
+        }
+
+    }
+
+    public class GenericRelayControllerJoinMap : JoinMapBase
+    {
+        //Digital
+        public uint Relay { get; set; }
+
+        public GenericRelayControllerJoinMap()
+        {
+            Relay = 1;
+        }
+
+        public override void  OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            Relay = Relay + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/IBasicCommunicationBridge.cs

@@ -63,13 +63,18 @@ namespace PepperDash.Essentials.Bridges
 
         public class IBasicCommunicationJoinMap : JoinMapBase
         {
-            // Default joins
+            //Digital
+            public uint Connect { get; set; }
+            public uint Connected { get; set; }
+
+            //Analog
+            public uint Status { get; set; }
+
+            // Serial
             public uint TextReceived { get; set; }
             public uint SendText { get; set; }
             public uint SetPortConfig { get; set; }
-            public uint Connect { get; set; }
-            public uint Connected { get; set; }
-            public uint Status { get; set; }
+
 
             public IBasicCommunicationJoinMap()
             {
@@ -94,38 +99,5 @@ namespace PepperDash.Essentials.Bridges
             }
         }
     }
-    ///// <summary>
-    ///// 
-    ///// </summary>
-    //public static class DmChassisControllerApiExtensions
-    //{
-    //    public static void LinkToApi(this PepperDash.Essentials.DM.DmChassisController chassis, 
-    //        BasicTriList trilist, Dictionary<string,uint> map, uint joinstart)
-    //    {
-    //        uint joinOffset = joinstart - 1;
-
-    //        uint videoSelectOffset = 0 + joinOffset;
-    //        uint audioSelectOffset = 40 + joinOffset;
-
-
-    //        // loop chassis number of inupts
-    //        for (uint i = 1; i <= chassis.Chassis.NumberOfOutputs; i++)
-    //        {
-    //            trilist.SetUShortSigAction(videoSelectOffset + i, new Action<ushort>(u => chassis.ExecuteSwitch(u, i, eRoutingSignalType.Video)));
-    //            trilist.SetUShortSigAction(audioSelectOffset + i, new Action<ushort>(u => chassis.ExecuteSwitch(u, i, eRoutingSignalType.Audio)));
-    //        }
-
-    //        // wire up output change detection (try to add feedbacks or something to DMChassisController??
-
-    //        // names?
-
-    //        // HDCP?
-
-
-    //    }
-    //}
-
-
-
 
 }

PepperDashEssentials/Bridges/IDigitalInputBridge.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core.CrestronIO;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class IDigitalInputApiExtenstions
+    {
+        public static void LinkToApi(this IDigitalInput input, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as IDigitalInputApiJoinMap;
+
+            if (joinMap == null)
+                joinMap = new IDigitalInputApiJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            try
+            {
+                Debug.Console(1, input as Device, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+                // Link feedback for input state
+                input.InputStateFeedback.LinkInputSig(trilist.BooleanInput[joinMap.InputState]);
+            }
+            catch (Exception e)
+            {
+                Debug.Console(1, input as Device, "Unable to link device '{0}'.  Input is null", (input as Device).Key);
+                Debug.Console(1, input as Device, "Error: {0}", e);
+                return;
+            }
+        }
+
+        
+    }
+
+    public class IDigitalInputApiJoinMap : JoinMapBase
+    {
+        //Digital
+        public uint InputState { get; set; }
+
+        public IDigitalInputApiJoinMap()
+        {
+            InputState = 1;
+        }
+
+        public override void  OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            InputState = InputState + joinOffset;
+        }
+    }
+}

PepperDashEssentials/Bridges/SystemMonitorBridge.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.Diagnostics;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Monitoring;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class SystemMonitorBridge
+    {
+        public static void LinkToApi(this SystemMonitorController systemMonitorController, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            var joinMap = JoinMapHelper.GetJoinMapForDevice(joinMapKey) as SystemMonitorJoinMap;
+
+            if (joinMap == null)
+                joinMap = new SystemMonitorJoinMap();
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            //Debug.Console(1, systemMonitorController, "Linking API starting at join: {0}", joinStart);
+
+            systemMonitorController.TimeZoneFeedback.LinkInputSig(trilist.UShortInput[joinMap.TimeZone]);
+            //trilist.SetUShortSigAction(joinMap.TimeZone, new Action<ushort>(u => systemMonitorController.SetTimeZone(u)));
+            systemMonitorController.TimeZoneTextFeedback.LinkInputSig(trilist.StringInput[joinMap.TimeZoneName]);
+
+            systemMonitorController.IOControllerVersionFeedback.LinkInputSig(trilist.StringInput[joinMap.IOControllerVersion]);
+            systemMonitorController.SnmpVersionFeedback.LinkInputSig(trilist.StringInput[joinMap.SnmpAppVersion]);
+            systemMonitorController.BACnetAppVersionFeedback.LinkInputSig(trilist.StringInput[joinMap.BACnetAppVersion]);
+            systemMonitorController.ControllerVersionFeedback.LinkInputSig(trilist.StringInput[joinMap.ControllerVersion]);
+
+
+            // iterate the program status feedback collection and map all the joins
+            var programSlotJoinStart = joinMap.ProgramStartJoin;
+
+            foreach (var p in systemMonitorController.ProgramStatusFeedbackCollection)
+            {
+
+                // TODO: link feedbacks for each program slot
+                var programNumber = p.Value.Program.Number;
+
+                //Debug.Console(1, systemMonitorController, "Linking API for Program Slot: {0} starting at join: {1}", programNumber, programSlotJoinStart);
+
+                trilist.SetBoolSigAction(programSlotJoinStart + joinMap.ProgramStart, new Action<bool>
+                    (b => SystemMonitor.ProgramCollection[programNumber].OperatingState = eProgramOperatingState.Start));
+                p.Value.ProgramStartedFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramStart]);
+
+                trilist.SetBoolSigAction(programSlotJoinStart + joinMap.ProgramStop, new Action<bool>
+                    (b => SystemMonitor.ProgramCollection[programNumber].OperatingState = eProgramOperatingState.Stop));
+                p.Value.ProgramStoppedFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramStop]);
+
+                trilist.SetBoolSigAction(programSlotJoinStart + joinMap.ProgramRegister, new Action<bool>
+                    (b => SystemMonitor.ProgramCollection[programNumber].RegistrationState = eProgramRegistrationState.Register));
+                p.Value.ProgramRegisteredFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramRegister]);
+
+                trilist.SetBoolSigAction(programSlotJoinStart + joinMap.ProgramUnregister, new Action<bool>
+                    (b => SystemMonitor.ProgramCollection[programNumber].RegistrationState = eProgramRegistrationState.Unregister));
+                p.Value.ProgramUnregisteredFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramUnregister]);
+
+                programSlotJoinStart = programSlotJoinStart + joinMap.ProgramOffsetJoin;
+            }
+
+        }
+
+
+    }
+
+    public class SystemMonitorJoinMap : JoinMapBase
+    {
+        /// <summary>
+        /// Offset to indicate where the range of iterated program joins will start
+        /// </summary>
+        public uint ProgramStartJoin { get; set; }
+
+        /// <summary>
+        /// Offset between each program join set
+        /// </summary>
+        public uint ProgramOffsetJoin { get; set; }
+
+        //Digital
+        public uint ProgramStart { get; set; }
+        public uint ProgramStop { get; set; }
+        public uint ProgramRegister { get; set; }
+        public uint ProgramUnregister { get; set; }
+
+        //Analog
+        public uint TimeZone { get; set; }
+
+        //Serial
+        public uint TimeZoneName { get; set; }
+        public uint IOControllerVersion { get; set; }
+        public uint SnmpAppVersion { get; set; }
+        public uint BACnetAppVersion { get; set; }
+        public uint ControllerVersion { get; set; }
+
+        public uint ProgramName { get; set; }
+        public uint ProgramCompiledTime { get; set; }
+        public uint ProgramCrestronDatabaseVersion { get; set; }
+        public uint ProgramEnvironmentVersion { get; set; }
+        public uint AggregatedProgramInfo { get; set; }
+
+        public SystemMonitorJoinMap()
+        {
+            TimeZone = 1;
+
+            TimeZoneName = 1;
+            IOControllerVersion = 2;
+            SnmpAppVersion = 3;
+            BACnetAppVersion = 4;
+            ControllerVersion = 5;
+
+            
+            ProgramStartJoin = 10;
+            
+            ProgramOffsetJoin = 5;
+
+            // Offset in groups of 5 joins
+            ProgramStart = 1;
+            ProgramStop = 2;
+            ProgramRegister = 3;
+            ProgramUnregister = 4;
+
+            ProgramName = 1;
+            ProgramCompiledTime = 2;
+            ProgramCrestronDatabaseVersion = 3;
+            ProgramEnvironmentVersion = 4;
+            AggregatedProgramInfo = 5;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            TimeZone = TimeZone + joinOffset;
+
+            TimeZoneName = TimeZoneName + joinOffset;
+            IOControllerVersion = IOControllerVersion + joinOffset;
+            SnmpAppVersion = SnmpAppVersion + joinOffset;
+            BACnetAppVersion = BACnetAppVersion + joinOffset;
+            ControllerVersion = ControllerVersion + joinOffset;
+
+            // Sets the initial join value where the iterated program joins will begin
+            ProgramStartJoin = ProgramStartJoin + joinOffset;
+        }
+    }
+}