feature: Add re-registration of feedbacks if there is a failure

feat: log errors only, do not try to self-heal

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

@@ -17,11 +17,12 @@ using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using Crestron.SimplSharpPro.DeviceSupport;
 using PepperDash.Essentials.Core.DeviceInfo;
+using PepperDash.Essentials.Core.Bridges;
 
 namespace PepperDash.Essentials.DM.Endpoints.DGEs
 {
     [Description("Wrapper class for DGE-100")]    
-    public class Dge100Controller : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject, ICec, IDeviceInfoProvider
+    public class Dge100Controller : CrestronGenericBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject, ICec, IDeviceInfoProvider, IBridgeAdvanced
     {
         private const int CtpPort = 41795;
         private readonly Dge100 _dge;
@@ -30,9 +31,12 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
 
         public BasicTriListWithSmartObject Panel { get { return _dge; } }
 
-        private DeviceConfig _dc;
+        private DeviceConfig _dc;
+
+		public VideoStatusOutputs VideoStatusFeedbacks { get; private set;  }
+
+        CrestronTouchpanelPropertiesConfig PropertiesConfig;        
 
-        CrestronTouchpanelPropertiesConfig PropertiesConfig;
 
         public Dge100Controller(string key, string name, Dge100 device, DeviceConfig dc, CrestronTouchpanelPropertiesConfig props)
             :base(key, name, device)
@@ -48,8 +52,20 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
 
             _dc = dc;
 
-            PropertiesConfig = props;
-        }
+            PropertiesConfig = props;
+
+            var videoStatusFuncs = new VideoStatusFuncsWrapper
+            {
+                HdcpActiveFeedbackFunc = () => _dge.HdmiIn.HdcpSupportOnFeedback.BoolValue,
+                VideoResolutionFeedbackFunc = () => _dge.HdmiIn.VideoAttributes.GetVideoResolutionString(),
+                VideoSyncFeedbackFunc = () => _dge.HdmiIn.SyncDetectedFeedback.BoolValue, 
+            };
+
+			VideoStatusFeedbacks = new VideoStatusOutputs(videoStatusFuncs);
+
+			_dge.HdmiIn.StreamChange += (s,a) => VideoStatusFeedbacks.FireAll();
+			_dge.HdmiIn.VideoAttributes.AttributeChange += (o, a) => VideoStatusFeedbacks.FireAll();
+        }		
 
         #region IComPorts Members
 
@@ -187,6 +203,63 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             handler(this, new DeviceInfoEventArgs(DeviceInfo));
         }
 
+        #endregion
+
+        #region IBridgeAdvanced Members
+
+        public void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new DgeJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<DgeJoinMap>(joinMapSerialized);
+
+            if (bridge != null)
+            {
+                bridge.AddJoinMap(Key, joinMap);
+            }
+            else
+            {
+                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+            }
+
+            Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+			//Presses
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpOn.JoinNumber, () => _dge.HdmiIn.HdcpSupportOn());
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpOff.JoinNumber,() => _dge.HdmiIn.HdcpSupportOff());
+			trilist.SetSigTrueAction(joinMap.HdmiInHdcpToggle.JoinNumber, () => {
+				if(_dge.HdmiIn.HdcpSupportOnFeedback.BoolValue)
+				{
+					_dge.HdmiIn.HdcpSupportOff();
+					return;
+				}
+			
+				_dge.HdmiIn.HdcpSupportOn();
+			});
+
+
+			// Feedbacks
+			VideoStatusFeedbacks.HdcpActiveFeedback.LinkInputSig(trilist.BooleanInput[joinMap.HdmiInHdcpOn.JoinNumber]);
+			VideoStatusFeedbacks.HdcpActiveFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.HdmiInHdcpOff.JoinNumber]);
+
+			VideoStatusFeedbacks.VideoResolutionFeedback.LinkInputSig(trilist.StringInput[joinMap.CurrentInputResolution.JoinNumber]);
+			VideoStatusFeedbacks.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.SyncDetected.JoinNumber]);
+
+			IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+
+			trilist.OnlineStatusChange += (o, a) =>
+			{
+				if (!a.DeviceOnLine) return;
+
+				VideoStatusFeedbacks.FireAll();
+			};
+        }
+
+        
+
         #endregion
     }
 

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

@@ -0,0 +1,259 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Sockets;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.UI;
+
+using Crestron.SimplSharpPro.DM;
+
+
+using Newtonsoft.Json;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+using Crestron.SimplSharpPro.DeviceSupport;
+using PepperDash.Essentials.Core.DeviceInfo;
+
+namespace PepperDash.Essentials.DM.Endpoints.DGEs
+{
+    public class DgeBaseController : CrestronGenericBridgeableBaseDevice, IComPorts, IIROutputPorts, IHasBasicTriListWithSmartObject, ICec, IDeviceInfoProvider, IDgeRoutingWithFeedback
+    {
+        private const int CtpPort = 41795;
+        private readonly Dge100 _dge;
+
+        public RoutingInputPort HdmiIn { get; protected set; }
+        public RoutingInputPort ProjectViewIn { get; protected set; }
+        public RoutingOutputPort HdmiOut { get; protected set; }
+
+        protected readonly ushort DmInputJoin;
+        protected readonly ushort HdmiInputJoin;
+        protected readonly ushort ProjectViewJoin;
+
+        private int SwitchValue;
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts
+        {
+            get;
+            private set;
+        }
+
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts
+        {
+            get;
+            private set;
+        }
+
+        private readonly TsxCcsUcCodec100EthernetReservedSigs _dgeEthernetInfo;
+
+        public BasicTriListWithSmartObject Panel { get { return _dge; } }
+
+        private DeviceConfig _dc;
+
+        CrestronDgePropertiesConfig PropertiesConfig;
+
+        public DgeBaseController(string key, string name, Dge100 device, DeviceConfig dc, CrestronDgePropertiesConfig props)
+            :base(key, name, device)
+        {
+            _dge = device;
+            _dc = dc;
+
+            PropertiesConfig = props;
+
+            DmInputJoin = (ushort)PropertiesConfig.DmInputJoin;
+            HdmiInputJoin = (ushort)PropertiesConfig.HdmiInputJoin;
+            ProjectViewJoin = (ushort)PropertiesConfig.ProjectViewVirtualInputJoin;
+
+            // Set Ports for CEC
+            HdmiOut = new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, null, this);
+
+            HdmiOut.Port = _dge.HdmiOut;
+
+
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut };
+
+
+            _dgeEthernetInfo = _dge.ExtenderEthernetReservedSigs;
+            //_dgeEthernetInfo.DeviceExtenderSigChange += (extender, args) => UpdateDeviceInfo();
+            _dgeEthernetInfo.Use();
+
+            DeviceInfo = new DeviceInfo();
+
+            AudioVideoSourceNumericFeedback = new IntFeedback(() => SwitchValue);
+
+
+            _dge.OnlineStatusChange += (currentDevice, args) => { if (args.DeviceOnLine) UpdateDeviceInfo(); };
+
+            _dge.SigChange += TrilistChange;
+
+        }
+
+        public virtual void TrilistChange(BasicTriList currentDevice, SigEventArgs args)
+        {
+
+        }
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+
+        }
+
+
+        #region IComPorts Members
+
+        public CrestronCollection<ComPort> ComPorts
+        {
+            get { return _dge.ComPorts; }
+        }
+
+        public int NumberOfComPorts
+        {
+            get { return _dge.NumberOfComPorts; }
+        }
+
+        #endregion
+
+        #region IIROutputPorts Members
+
+        public CrestronCollection<IROutputPort> IROutputPorts
+        {
+            get { return _dge.IROutputPorts; }
+        }
+
+        public int NumberOfIROutputPorts
+        {
+            get { return _dge.NumberOfIROutputPorts; }
+        }
+
+        #endregion
+
+        #region ICec Members
+        public Cec StreamCec { get { return _dge.HdmiOut.StreamCec; } }
+        #endregion
+
+        #region Implementation of IDeviceInfoProvider
+
+        public DeviceInfo DeviceInfo { get; private set; }
+
+        public event DeviceInfoChangeHandler DeviceInfoChanged;
+
+        public void UpdateDeviceInfo()
+        {
+            DeviceInfo.IpAddress = _dgeEthernetInfo.IpAddressFeedback.StringValue;
+            DeviceInfo.MacAddress = _dgeEthernetInfo.MacAddressFeedback.StringValue;
+
+            GetFirmwareAndSerialInfo();
+
+            OnDeviceInfoChange();
+        }
+
+        private void GetFirmwareAndSerialInfo()
+        {
+            if (String.IsNullOrEmpty(_dgeEthernetInfo.IpAddressFeedback.StringValue))
+            {
+                Debug.Console(1, this, "IP Address information not yet received. No device is online");
+                return;
+            }
+
+            var tcpClient = new GenericTcpIpClient("", _dgeEthernetInfo.IpAddressFeedback.StringValue, CtpPort, 1024) { AutoReconnect = false };
+
+            var gather = new CommunicationGather(tcpClient, "\r\n\r\n");
+
+            tcpClient.ConnectionChange += (sender, args) =>
+            {
+                if (!args.Client.IsConnected)
+                {
+                    return;
+                }
+
+                args.Client.SendText("ver\r\n");
+            };
+
+            gather.LineReceived += (sender, args) =>
+            {
+                try
+                {
+                    Debug.Console(1, this, "{0}", args.Text);
+
+                    if (args.Text.ToLower().Contains("host"))
+                    {
+                        DeviceInfo.HostName = args.Text.Split(':')[1].Trim();
+
+                        Debug.Console(1, this, "hostname: {0}", DeviceInfo.HostName);
+                        tcpClient.Disconnect();
+                        return;
+                    }
+
+                    if (!args.Text.Contains('['))
+                    {
+                        return;
+                    }
+                    var splitResponse = args.Text.Split('[');
+
+                    foreach (string t in splitResponse)
+                    {
+                        Debug.Console(1, this, "{0}", t);
+                    }
+
+                    DeviceInfo.SerialNumber = splitResponse[1].Split(' ')[4].Replace("#", "");
+                    DeviceInfo.FirmwareVersion = splitResponse[1].Split(' ')[0];
+
+                    Debug.Console(1, this, "Firmware: {0} SerialNumber: {1}", DeviceInfo.FirmwareVersion,
+                        DeviceInfo.SerialNumber);
+
+                    tcpClient.SendText("host\r\n");
+                }
+                catch (Exception ex)
+                {
+                    Debug.Console(0, this, "Exception getting data: {0}", ex.Message);
+                    Debug.Console(0, this, "response: {0}", args.Text);
+                }
+            };
+
+            tcpClient.Connect();
+        }
+
+        private void OnDeviceInfoChange()
+        {
+            var handler = DeviceInfoChanged;
+
+            if (handler == null) return;
+
+            handler(this, new DeviceInfoEventArgs(DeviceInfo));
+        }
+
+        #endregion
+
+
+
+
+        #region IDgeRouting Members
+
+        public IntFeedback AudioVideoSourceNumericFeedback { get; set; }
+
+        #endregion
+
+        #region IRoutingNumeric Members
+
+        public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+
+        #region IRouting Members
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.DM.Endpoints.DGEs
+{
+    public class DgeJoinMap : JoinMapBaseAdvanced
+    {
+        [JoinName("IsOnline")]
+        public JoinDataComplete IsOnline = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE Online", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });        
+
+        [JoinName("CurrentInputResolution")]
+        public JoinDataComplete CurrentInputResolution = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE Current Input Resolution", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+		[JoinName("SyncDetected")]
+		public JoinDataComplete SyncDetected = new JoinDataComplete(new JoinData { JoinNumber = 2, JoinSpan = 1 },
+			new JoinMetadata { Description = "DGE Sync Detected", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpOn")]
+        public JoinDataComplete HdmiInHdcpOn = new JoinDataComplete(new JoinData { JoinNumber = 3, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State On", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpOff")]
+        public JoinDataComplete HdmiInHdcpOff = new JoinDataComplete(new JoinData { JoinNumber = 4, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State Off", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("HdmiHdcpToggle")]
+        public JoinDataComplete HdmiInHdcpToggle = new JoinDataComplete(new JoinData { JoinNumber = 5, JoinSpan = 1 },
+            new JoinMetadata { Description = "DGE HDMI HDCP State Toggle", JoinCapabilities = eJoinCapabilities.FromSIMPL, JoinType = eJoinType.Digital });
+
+        public DgeJoinMap(uint joinStart)
+            : this(joinStart, typeof(DgeJoinMap))
+        {
+        }
+
+        /// <summary>
+        /// Constructor to use when extending this Join map
+        /// </summary>
+        /// <param name="joinStart">Join this join map will start at</param>
+        /// <param name="type">Type of the child join map</param>
+        protected DgeJoinMap(uint joinStart, Type type) : base(joinStart, type)
+        {
+        }
+    }
+}

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

@@ -58,37 +58,37 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs
             HdmiOut.Port = _dge.HdmiOut; ;
 
         }
-
-        public class DmDge200CControllerFactory : EssentialsDeviceFactory<DmDge200CController>
-        {
-            public DmDge200CControllerFactory()
-            {
-                TypeNames = new List<string>() { "dmdge200c" };
-            }
-
-            public override EssentialsDevice BuildDevice(DeviceConfig dc)
-            {
-                var typeName = dc.Type.ToLower();
-                var comm = CommFactory.GetControlPropertiesConfig(dc);
-                var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
-
-                Debug.Console(1, "Factory Attempting to create new DgeController  Device");
-
-                DmDge200C dgeDevice = null;
-
-                if (typeName == "dmdge200c")
-                    dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
-
-                if (dgeDevice == null)
-                {
-                    Debug.Console(1, "Unable to create DGE device");
-                    return null;
-                }
-
-                var dgeController = new DmDge200CController(dc.Key , dc.Name, dgeDevice, dc, props);
-
-                return dgeController;
-            }
-        }
     }
+
+	public class DmDge200CControllerFactory : EssentialsDeviceFactory<DmDge200CController>
+	{
+		public DmDge200CControllerFactory()
+		{
+			TypeNames = new List<string>() { "dmdge200c" };
+		}
+
+		public override EssentialsDevice BuildDevice(DeviceConfig dc)
+		{
+			var typeName = dc.Type.ToLower();
+			var comm = CommFactory.GetControlPropertiesConfig(dc);
+			var props = JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
+
+			Debug.Console(1, "Factory Attempting to create new DgeController  Device");
+
+			DmDge200C dgeDevice = null;
+
+			if (typeName == "dmdge200c")
+				dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
+
+			if (dgeDevice == null)
+			{
+				Debug.Console(1, "Unable to create DGE device");
+				return null;
+			}
+
+			var dgeController = new DmDge200CController(dc.Key, dc.Name, dgeDevice, dc, props);
+
+			return dgeController;
+		}
+	}
 }

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

@@ -105,6 +105,7 @@
     <Compile Include="Chassis\HdMdNxM4kEBridgeableController.cs" />
     <Compile Include="Chassis\HdMdNxM4kEController.cs" />
     <Compile Include="Config\InputPropertiesConfig.cs" />
+    <Compile Include="Endpoints\DGEs\DgeJoinMap.cs" />
     <Compile Include="Endpoints\DGEs\DmDge200CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZ100CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZScalerCController.cs" />

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/CiscoSparkCodec.cs

@@ -40,6 +40,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 
         private CTimer _brandingTimer;
 
+        private CTimer _registrationCheckTimer;
+
         public CommunicationGather PortGather { get; private set; }
 
         public StatusMonitorBase CommunicationMonitor { get; private set; }
@@ -262,6 +264,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
 
         private StringBuilder _jsonMessage;
 
+        private StringBuilder _feedbackListMessage;
+
+        private bool _feedbackListMessageIncoming;
+
         private bool _jsonFeedbackMessageIsIncoming;
 
         public bool CommDebuggingIsOn;
@@ -702,6 +708,8 @@ ConnectorID: {2}"
 
             // Fire the ready event
             SetIsReady();
+
+            _registrationCheckTimer = new CTimer(EnqueueCommand, "xFeedback list",  90000, 90000);
         }
 
         public void SetCommDebug(string s)
@@ -778,6 +786,29 @@ ConnectorID: {2}"
                 return;
             }
 
+            if (!args.Text.StartsWith("/") && _feedbackListMessage != null)
+            {
+                _feedbackListMessageIncoming = false;
+
+                var feedbackListString = _feedbackListMessage.ToString();
+                _feedbackListMessage = null;
+
+                ProcessFeedbackList(feedbackListString);
+
+            }
+
+            if (args.Text.StartsWith("/"))
+            {
+                _feedbackListMessageIncoming = true;
+                if(_feedbackListMessage == null) _feedbackListMessage = new StringBuilder();
+            }
+
+            if (_feedbackListMessageIncoming && _feedbackListMessage != null)
+            {
+                _feedbackListMessage.Append(args.Text);
+                return;
+            }
+
             if (args.Text == "{" + Delimiter)        // Check for the beginning of a new JSON message
             {
                 _jsonFeedbackMessageIsIncoming = true;
@@ -846,6 +877,19 @@ ConnectorID: {2}"
             }
         }
 
+        private void ProcessFeedbackList(string data)
+        {
+            Debug.Console(1, this, "Feedback List : ");
+            Debug.Console(1, this, data);
+
+            if (data.Split('\n').Count() == _cliFeedbackRegistrationExpression.Split('\n').Count()) return;
+            Debug.Console(0, this, "Codec Feedback Registrations Lost - Registering Feedbacks");
+            ErrorLog.Error(String.Format("[{0}] :: Codec Feedback Registrations Lost - Registering Feedbacks", Key));
+            //var updateRegistrationString = "xFeedback deregisterall" + Delimiter + _cliFeedbackRegistrationExpression;
+
+            EnqueueCommand(_cliFeedbackRegistrationExpression);
+        }
+
         /// <summary>
         /// Enqueues a command to be sent to the codec.
         /// </summary>
@@ -854,6 +898,12 @@ ConnectorID: {2}"
         {
             _syncState.AddCommandToQueue(command);
         }
+        private void EnqueueCommand(object cmd)
+        {
+            var command = cmd as string;
+            if (String.IsNullOrEmpty(command)) return;
+            _syncState.AddCommandToQueue(command);
+        }
 
         /// <summary>
         /// Appends the delimiter and send the command to the codec.
@@ -869,6 +919,16 @@ ConnectorID: {2}"
             Communication.SendText(command + Delimiter);
         }
 
+        public void SendText(object cmd)
+        {
+            var command = cmd as string;
+            if (String.IsNullOrEmpty(command)) return;
+            if (CommDebuggingIsOn)
+                Debug.Console(1, this, "Sending: '{0}'", ComTextHelper.GetDebugText(command + Delimiter));
+
+            Communication.SendText(command + Delimiter);
+        }
+
         void DeserializeResponse(string response)
         {
             try