pepperdash/Essentials
1
0
Fork 0
mirror of https://github.com/PepperDash/Essentials.git synced 2026-02-08 09:15:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'development' into feature/ecs-1209

Browse Source 
# Conflicts:
#	PepperDashEssentials/Room/Types/EssentialsHuddleSpaceRoom.cs
#	PepperDashEssentials/Room/Types/EssentialsHuddleVtc1Room.cs
#	essentials-framework/Essentials Devices Common/Essentials Devices Common/DSP/DspBase.cs
#	essentials-framework/Essentials Devices Common/Essentials Devices Common/Power Controllers/Digitallogger.cs
This commit is contained in:
Neil Dorin
2020-03-10 14:23:17 -06:00
parent 113b08a227 cb1115b232
commit f27b6fadb9
151 changed files with 3334 additions and 7182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/CecPortController.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/CecPortController.cs
View File

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/ComPortController.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/ComPortController.cs
View File

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/ComSpecJsonConverter.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/ComSpecJsonConverter.cs
View File

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/CommFactory.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/CommFactory.cs
View File

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/CommunicationExtras.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/CommunicationExtras.cs
View File

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/ConsoleCommMockDevice.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/ConsoleCommMockDevice.cs
View File

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/DELETE ComPortController.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/DELETE ComPortController.cs
View File

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/GenericComm.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/GenericComm.cs
View File

4
essentials-framework/Essentials Devices Common/Essentials Devices Common/Evertz/GenericHttpClient.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/GenericHttpClient.cs
View File

@@ -7,7 +7,7 @@ using Crestron.SimplSharp.Net.Http;
using PepperDash.Core;
using PepperDash.Core.DebugThings;
namespace PepperDash.Essentials.Devices.Common
namespace PepperDash.Essentials.Core
{
public class GenericHttpClient : Device, IBasicCommunication
{
@@ -23,7 +23,6 @@ namespace PepperDash.Essentials.Devices.Common
}
/// <summary>
///
/// </summary>
@@ -53,6 +52,7 @@ namespace PepperDash.Essentials.Devices.Common
Client.Dispatch(request);
Debug.Console(2, this, "GenericHttpClient SentRequest TX:'{0}'", url);
}
private void Response(HttpClientResponse response, HTTP_CALLBACK_ERROR error, object request)
{
if (error == HTTP_CALLBACK_ERROR.COMPLETED)

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/IRPortHelper.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Config/Comm and IR/IRPortHelper.cs
View File

127
essentials-framework/Essentials Core/PepperDashEssentialsBase/Constants/CommonCues.cs
View File

@@ -1,127 +0,0 @@
using Crestron.SimplSharpPro;
namespace PepperDash.Essentials.Core
{
public static class CommonBoolCue
{
public static readonly Cue Power = new Cue("Power", 101, eCueType.Bool);
public static readonly Cue PowerOn = new Cue("PowerOn", 102, eCueType.Bool);
public static readonly Cue PowerOff = new Cue("PowerOff", 103, eCueType.Bool);
public static readonly Cue HasPowerFeedback = new Cue("HasPowerFeedback", 101, eCueType.Bool);
public static readonly Cue PowerOnFeedback = new Cue("PowerOnFeedback", 102, eCueType.Bool);
public static readonly Cue IsOnlineFeedback = new Cue("IsOnlineFeedback", 104, eCueType.Bool);
public static readonly Cue IsWarmingUp = new Cue("IsWarmingUp", 105, eCueType.Bool);
public static readonly Cue IsCoolingDown = new Cue("IsCoolingDown", 106, eCueType.Bool);
public static readonly Cue Dash = new Cue("Dash", 109, eCueType.Bool);
public static readonly Cue Digit0 = new Cue("Digit0", 110, eCueType.Bool);
public static readonly Cue Digit1 = new Cue("Digit1", 111, eCueType.Bool);
public static readonly Cue Digit2 = new Cue("Digit2", 112, eCueType.Bool);
public static readonly Cue Digit3 = new Cue("Digit3", 113, eCueType.Bool);
public static readonly Cue Digit4 = new Cue("Digit4", 114, eCueType.Bool);
public static readonly Cue Digit5 = new Cue("Digit5", 115, eCueType.Bool);
public static readonly Cue Digit6 = new Cue("Digit6", 116, eCueType.Bool);
public static readonly Cue Digit7 = new Cue("Digit7", 117, eCueType.Bool);
public static readonly Cue Digit8 = new Cue("Digit8", 118, eCueType.Bool);
public static readonly Cue Digit9 = new Cue("Digit9", 119, eCueType.Bool);
public static readonly Cue KeypadMisc1 = new Cue("KeypadMisc1", 120, eCueType.Bool);
public static readonly Cue KeypadMisc2 = new Cue("KeypadMisc2", 121, eCueType.Bool);
public static readonly Cue NumericEnter = new Cue("Enter", 122, eCueType.Bool);
public static readonly Cue ChannelUp = new Cue("ChannelUp", 123, eCueType.Bool);
public static readonly Cue ChannelDown = new Cue("ChannelDown", 124, eCueType.Bool);
public static readonly Cue Last = new Cue("Last", 125, eCueType.Bool);
public static readonly Cue OpenClose = new Cue("OpenClose", 126, eCueType.Bool);
public static readonly Cue Subtitle = new Cue("Subtitle", 127, eCueType.Bool);
public static readonly Cue Audio = new Cue("Audio", 128, eCueType.Bool);
public static readonly Cue Info = new Cue("Info", 129, eCueType.Bool);
public static readonly Cue Menu = new Cue("Menu", 130, eCueType.Bool);
public static readonly Cue DeviceMenu = new Cue("DeviceMenu", 131, eCueType.Bool);
public static readonly Cue Return = new Cue("Return", 132, eCueType.Bool);
public static readonly Cue Back = new Cue("Back", 133, eCueType.Bool);
public static readonly Cue Exit = new Cue("Exit", 134, eCueType.Bool);
public static readonly Cue Clear = new Cue("Clear", 135, eCueType.Bool);
public static readonly Cue List = new Cue("List", 136, eCueType.Bool);
public static readonly Cue Guide = new Cue("Guide", 137, eCueType.Bool);
public static readonly Cue Am = new Cue("Am", 136, eCueType.Bool);
public static readonly Cue Fm = new Cue("Fm", 137, eCueType.Bool);
public static readonly Cue Up = new Cue("Up", 138, eCueType.Bool);
public static readonly Cue Down = new Cue("Down", 139, eCueType.Bool);
public static readonly Cue Left = new Cue("Left", 140, eCueType.Bool);
public static readonly Cue Right = new Cue("Right", 141, eCueType.Bool);
public static readonly Cue Select = new Cue("Select", 142, eCueType.Bool);
public static readonly Cue SmartApps = new Cue("SmartApps", 143, eCueType.Bool);
public static readonly Cue Dvr = new Cue("Dvr", 144, eCueType.Bool);
public static readonly Cue Play = new Cue("Play", 145, eCueType.Bool);
public static readonly Cue Pause = new Cue("Pause", 146, eCueType.Bool);
public static readonly Cue Stop = new Cue("Stop", 147, eCueType.Bool);
public static readonly Cue ChapNext = new Cue("ChapNext", 148, eCueType.Bool);
public static readonly Cue ChapPrevious = new Cue("ChapPrevious", 149, eCueType.Bool);
public static readonly Cue Rewind = new Cue("Rewind", 150, eCueType.Bool);
public static readonly Cue Ffwd = new Cue("Ffwd", 151, eCueType.Bool);
public static readonly Cue Replay = new Cue("Replay", 152, eCueType.Bool);
public static readonly Cue Advance = new Cue("Advance", 153, eCueType.Bool);
public static readonly Cue Record = new Cue("Record", 154, eCueType.Bool);
public static readonly Cue Red = new Cue("Red", 155, eCueType.Bool);
public static readonly Cue Green = new Cue("Green", 156, eCueType.Bool);
public static readonly Cue Yellow = new Cue("Yellow", 157, eCueType.Bool);
public static readonly Cue Blue = new Cue("Blue", 158, eCueType.Bool);
public static readonly Cue Home = new Cue("Home", 159, eCueType.Bool);
public static readonly Cue PopUp = new Cue("PopUp", 160, eCueType.Bool);
public static readonly Cue PageUp = new Cue("PageUp", 161, eCueType.Bool);
public static readonly Cue PageDown = new Cue("PageDown", 162, eCueType.Bool);
public static readonly Cue Search = new Cue("Search", 163, eCueType.Bool);
public static readonly Cue Setup = new Cue("Setup", 164, eCueType.Bool);
public static readonly Cue RStep = new Cue("RStep", 165, eCueType.Bool);
public static readonly Cue FStep = new Cue("FStep", 166, eCueType.Bool);
public static readonly Cue IsConnected = new Cue("IsConnected", 281, eCueType.Bool);
public static readonly Cue IsOk = new Cue("IsOk", 282, eCueType.Bool);
public static readonly Cue InWarning = new Cue("InWarning", 283, eCueType.Bool);
public static readonly Cue InError = new Cue("InError", 284, eCueType.Bool);
public static readonly Cue StatusUnknown = new Cue("StatusUnknown", 285, eCueType.Bool);
public static readonly Cue VolumeUp = new Cue("VolumeUp", 401, eCueType.Bool);
public static readonly Cue VolumeDown = new Cue("VolumeDown", 402, eCueType.Bool);
public static readonly Cue MuteOn = new Cue("MuteOn", 403, eCueType.Bool);
public static readonly Cue MuteOff = new Cue("MuteOff", 404, eCueType.Bool);
public static readonly Cue MuteToggle = new Cue("MuteToggle", 405, eCueType.Bool);
public static readonly Cue ShowVolumeButtons = new Cue("ShowVolumeButtons", 406, eCueType.Bool);
public static readonly Cue ShowVolumeSlider = new Cue("ShowVolumeSlider", 407, eCueType.Bool);
public static readonly Cue Hdmi1 = new Cue("Hdmi1", 451, eCueType.Bool);
public static readonly Cue Hdmi2 = new Cue("Hdmi2", 452, eCueType.Bool);
public static readonly Cue Hdmi3 = new Cue("Hdmi3", 453, eCueType.Bool);
public static readonly Cue Hdmi4 = new Cue("Hdmi4", 454, eCueType.Bool);
public static readonly Cue Hdmi5 = new Cue("Hdmi5", 455, eCueType.Bool);
public static readonly Cue Hdmi6 = new Cue("Hdmi6", 456, eCueType.Bool);
public static readonly Cue DisplayPort1 = new Cue("DisplayPort1", 457, eCueType.Bool);
public static readonly Cue DisplayPort2 = new Cue("DisplayPort2", 458, eCueType.Bool);
public static readonly Cue Dvi1 = new Cue("Dvi1", 459, eCueType.Bool);
public static readonly Cue Dvi2 = new Cue("Dvi2", 460, eCueType.Bool);
public static readonly Cue Video1 = new Cue("Video1", 461, eCueType.Bool);
public static readonly Cue Video2 = new Cue("Video2", 462, eCueType.Bool);
public static readonly Cue Component1 = new Cue("Component1", 463, eCueType.Bool);
public static readonly Cue Component2 = new Cue("Component2", 464, eCueType.Bool);
public static readonly Cue Vga1 = new Cue("Vga1", 465, eCueType.Bool);
public static readonly Cue Vga2 = new Cue("Vga2", 466, eCueType.Bool);
public static readonly Cue Rgb1 = new Cue("Rgb1", 467, eCueType.Bool);
public static readonly Cue Rgb2 = new Cue("Rgb2", 468, eCueType.Bool);
public static readonly Cue Antenna = new Cue("Antenna", 469, eCueType.Bool);
public static readonly Cue InCall = new Cue("InCall", 501, eCueType.Bool);
}
public static class CommonIntCue
{
public static readonly Cue MainVolumeLevel = new Cue("MainVolumeLevel", 401, eCueType.Int);
public static readonly Cue MainVolumeLevelFeedback = new Cue("MainVolumeLevelFeedback", 401, eCueType.Int);
}
public static class CommonStringCue
{
public static readonly Cue IpConnectionsText = new Cue("IpConnectionsText", 9999, eCueType.String);
}
}

44
essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/C2nRts/C2nRthsController.cs Normal file
View File

@@ -0,0 +1,44 @@
using System;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.GeneralIO;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Core.CrestronIO
{
public class C2nRthsController:CrestronGenericBaseDevice
{
private C2nRths _device;
public IntFeedback TemperatureFeedback { get; private set; }
public IntFeedback HumidityFeedback { get; private set; }
public C2nRthsController(string key, string name, GenericBase hardware) : base(key, name, hardware)
{
_device = hardware as C2nRths;
TemperatureFeedback = new IntFeedback(() => _device.TemperatureFeedback.UShortValue);
HumidityFeedback = new IntFeedback(() => _device.HumidityFeedback.UShortValue);
_device.BaseEvent += DeviceOnBaseEvent;
}
private void DeviceOnBaseEvent(GenericBase device, BaseEventArgs args)
{
switch (args.EventId)
{
case C2nRths.TemperatureFeedbackEventId:
TemperatureFeedback.FireUpdate();
break;
case C2nRths.HumidityFeedbackEventId:
HumidityFeedback.FireUpdate();
break;
}
}
public void SetTemperatureFormat(bool setToC)
{
_device.TemperatureFormat.BoolValue = setToC;
}
}
}

40
essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/Inputs/CenIoDigIn104Controller.cs Normal file
View File

@@ -0,0 +1,40 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.GeneralIO;
using PepperDash.Core;
namespace PepperDash.Essentials.Core
{
/// <summary>
/// Wrapper class for CEN-IO-DIGIN-104 digital input module
/// </summary>
public class CenIoDigIn104Controller : Device, IDigitalInputPorts
{
public CenIoDi104 Di104 { get; private set; }
public CenIoDigIn104Controller(string key, string name, CenIoDi104 di104)
: base(key, name)
{
Di104 = di104;
}
#region IDigitalInputPorts Members
public CrestronCollection<DigitalInput> DigitalInputPorts
{
get { return Di104.DigitalInputPorts; }
}
public int NumberOfDigitalInputPorts
{
get { return Di104.NumberOfDigitalInputPorts; }
}
#endregion
}
}

107
essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron IO/StatusSign/StatusSignController.cs Normal file
View File

@@ -0,0 +1,107 @@
using System;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
using Crestron.SimplSharpPro.GeneralIO;
using PepperDash.Core;
namespace PepperDash.Essentials.Core.CrestronIO
{
public class StatusSignController:CrestronGenericBaseDevice
{
private StatusSign _device;
public BoolFeedback RedLedEnabledFeedback { get; private set; }
public BoolFeedback GreenLedEnabledFeedback { get; private set; }
public BoolFeedback BlueLedEnabledFeedback { get; private set; }
public IntFeedback RedLedBrightnessFeedback { get; private set; }
public IntFeedback GreenLedBrightnessFeedback { get; private set; }
public IntFeedback BlueLedBrightnessFeedback { get; private set; }
public StatusSignController(string key, string name, GenericBase hardware) : base(key, name, hardware)
{
_device = hardware as StatusSign;
RedLedEnabledFeedback =
new BoolFeedback(
() =>
_device.Leds[(uint) StatusSign.Led.eLedColor.Red]
.ControlFeedback.BoolValue);
GreenLedEnabledFeedback =
new BoolFeedback(
() =>
_device.Leds[(uint) StatusSign.Led.eLedColor.Green]
.ControlFeedback.BoolValue);
BlueLedEnabledFeedback =
new BoolFeedback(
() =>
_device.Leds[(uint) StatusSign.Led.eLedColor.Blue]
.ControlFeedback.BoolValue);
RedLedBrightnessFeedback =
new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Red].BrightnessFeedback);
GreenLedBrightnessFeedback =
new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Green].BrightnessFeedback);
BlueLedBrightnessFeedback =
new IntFeedback(() => (int) _device.Leds[(uint) StatusSign.Led.eLedColor.Blue].BrightnessFeedback);
_device.BaseEvent += _device_BaseEvent;
}
void _device_BaseEvent(GenericBase device, BaseEventArgs args)
{
switch (args.EventId)
{
case StatusSign.LedBrightnessFeedbackEventId:
RedLedBrightnessFeedback.FireUpdate();
GreenLedBrightnessFeedback.FireUpdate();
BlueLedBrightnessFeedback.FireUpdate();
break;
case StatusSign.LedControlFeedbackEventId:
RedLedEnabledFeedback.FireUpdate();
GreenLedEnabledFeedback.FireUpdate();
BlueLedEnabledFeedback.FireUpdate();
break;
}
}
public void EnableLedControl(bool red, bool green, bool blue)
{
_device.Leds[(uint) StatusSign.Led.eLedColor.Red].Control.BoolValue = red;
_device.Leds[(uint)StatusSign.Led.eLedColor.Green].Control.BoolValue = green;
_device.Leds[(uint)StatusSign.Led.eLedColor.Blue].Control.BoolValue = blue;
}
public void SetColor(uint red, uint green, uint blue)
{
try
{
_device.Leds[(uint)StatusSign.Led.eLedColor.Red].Brightness =
(StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(red);
}
catch (InvalidOperationException)
{
Debug.Console(1, this, "Error converting value to Red LED brightness. value: {0}", red);
}
try
{
_device.Leds[(uint)StatusSign.Led.eLedColor.Green].Brightness =
(StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(green);
}
catch (InvalidOperationException)
{
Debug.Console(1, this, "Error converting value to Green LED brightness. value: {0}", green);
}
try
{
_device.Leds[(uint)StatusSign.Led.eLedColor.Blue].Brightness =
(StatusSign.Led.eBrightnessPercentageValues)SimplSharpDeviceHelper.PercentToUshort(blue);
}
catch (InvalidOperationException)
{
Debug.Console(1, this, "Error converting value to Blue LED brightness. value: {0}", blue);
}
}
}
}

323
essentials-framework/Essentials Core/PepperDashEssentialsBase/Crestron/CrestronGenericBaseDevice.cs
View File

@@ -1,156 +1,169 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Core;
namespace PepperDash.Essentials.Core
{
/// <summary>
/// A bridge class to cover the basic features of GenericBase hardware
/// </summary>
public class CrestronGenericBaseDevice : Device, IOnline, IHasFeedback, ICommunicationMonitor, IUsageTracking
{
public virtual GenericBase Hardware { get; protected set; }
/// <summary>
/// Returns a list containing the Outputs that we want to expose.
/// </summary>
public FeedbackCollection<Feedback> Feedbacks { get; private set; }
public BoolFeedback IsOnline { get; private set; }
public BoolFeedback IsRegistered { get; private set; }
public StringFeedback IpConnectionsText { get; private set; }
/// <summary>
/// Used by implementing classes to prevent registration with Crestron TLDM. For
/// devices like RMCs and TXs attached to a chassis.
/// </summary>
public bool PreventRegistration { get; protected set; }
public CrestronGenericBaseDevice(string key, string name, GenericBase hardware)
: base(key, name)
{
Feedbacks = new FeedbackCollection<Feedback>();
Hardware = hardware;
IsOnline = new BoolFeedback("IsOnlineFeedback", () => Hardware.IsOnline);
IsRegistered = new BoolFeedback("IsRegistered", () => Hardware.Registered);
IpConnectionsText = new StringFeedback("IpConnectionsText", () =>
string.Join(",", Hardware.ConnectedIpList.Select(cip => cip.DeviceIpAddress).ToArray()));
AddToFeedbackList(IsOnline, IsRegistered, IpConnectionsText);
CommunicationMonitor = new CrestronGenericBaseCommunicationMonitor(this, hardware, 120000, 300000);
}
/// <summary>
/// Make sure that overriding classes call this!
/// Registers the Crestron device, connects up to the base events, starts communication monitor
/// </summary>
public override bool CustomActivate()
{
Debug.Console(0, this, "Activating");
if (!PreventRegistration)
{
//Debug.Console(1, this, " Does not require registration. Skipping");
var response = Hardware.RegisterWithLogging(Key);
if (response != eDeviceRegistrationUnRegistrationResponse.Success)
{
//Debug.Console(0, this, "ERROR: Cannot register Crestron device: {0}", response);
return false;
}
}
Hardware.OnlineStatusChange += new OnlineStatusChangeEventHandler(Hardware_OnlineStatusChange);
CommunicationMonitor.Start();
return true;
}
/// <summary>
/// This disconnects events and unregisters the base hardware device.
/// </summary>
/// <returns></returns>
public override bool Deactivate()
{
CommunicationMonitor.Stop();
Hardware.OnlineStatusChange -= Hardware_OnlineStatusChange;
return Hardware.UnRegister() == eDeviceRegistrationUnRegistrationResponse.Success;
}
/// <summary>
/// Adds feedback(s) to the list
/// </summary>
/// <param name="newFbs"></param>
public void AddToFeedbackList(params Feedback[] newFbs)
{
foreach (var f in newFbs)
{
if (f != null)
{
if (!Feedbacks.Contains(f))
{
Feedbacks.Add(f);
}
}
}
}
void Hardware_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
{
if (args.DeviceOnLine)
{
foreach (var feedback in Feedbacks)
{
if (feedback != null)
feedback.FireUpdate();
}
}
}
#region IStatusMonitor Members
public StatusMonitorBase CommunicationMonitor { get; private set; }
#endregion
#region IUsageTracking Members
public UsageTracking UsageTracker { get; set; }
#endregion
}
//***********************************************************************************
public class CrestronGenericBaseDeviceEventIds
{
public const uint IsOnline = 1;
public const uint IpConnectionsText =2;
}
/// <summary>
/// Adds logging to Register() failure
/// </summary>
public static class GenericBaseExtensions
{
public static eDeviceRegistrationUnRegistrationResponse RegisterWithLogging(this GenericBase device, string key)
{
var result = device.Register();
var level = result == eDeviceRegistrationUnRegistrationResponse.Success ?
Debug.ErrorLogLevel.Notice : Debug.ErrorLogLevel.Error;
Debug.Console(0, level, "Register device result: '{0}', type '{1}', result {2}", key, device, result);
//if (result != eDeviceRegistrationUnRegistrationResponse.Success)
//{
// Debug.Console(0, Debug.ErrorLogLevel.Error, "Cannot register device '{0}': {1}", key, result);
//}
return result;
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Core;
namespace PepperDash.Essentials.Core
{
/// <summary>
/// A bridge class to cover the basic features of GenericBase hardware
/// </summary>
public class CrestronGenericBaseDevice : Device, IOnline, IHasFeedback, ICommunicationMonitor, IUsageTracking
{
public virtual GenericBase Hardware { get; protected set; }
/// <summary>
/// Returns a list containing the Outputs that we want to expose.
/// </summary>
public FeedbackCollection<Feedback> Feedbacks { get; private set; }
public BoolFeedback IsOnline { get; private set; }
public BoolFeedback IsRegistered { get; private set; }
public StringFeedback IpConnectionsText { get; private set; }
/// <summary>
/// Used by implementing classes to prevent registration with Crestron TLDM. For
/// devices like RMCs and TXs attached to a chassis.
/// </summary>
public bool PreventRegistration { get; protected set; }
public CrestronGenericBaseDevice(string key, string name, GenericBase hardware)
: base(key, name)
{
Feedbacks = new FeedbackCollection<Feedback>();
Hardware = hardware;
IsOnline = new BoolFeedback("IsOnlineFeedback", () => Hardware.IsOnline);
IsRegistered = new BoolFeedback("IsRegistered", () => Hardware.Registered);
IpConnectionsText = new StringFeedback("IpConnectionsText", () =>
{
if (Hardware.ConnectedIpList != null)
return string.Join(",", Hardware.ConnectedIpList.Select(cip => cip.DeviceIpAddress).ToArray());
else
return string.Empty;
});
AddToFeedbackList(IsOnline, IpConnectionsText);
CommunicationMonitor = new CrestronGenericBaseCommunicationMonitor(this, hardware, 120000, 300000);
}
/// <summary>
/// Make sure that overriding classes call this!
/// Registers the Crestron device, connects up to the base events, starts communication monitor
/// </summary>
public override bool CustomActivate()
{
Debug.Console(0, this, "Activating");
if (!PreventRegistration)
{
//Debug.Console(1, this, " Does not require registration. Skipping");
var response = Hardware.RegisterWithLogging(Key);
if (response != eDeviceRegistrationUnRegistrationResponse.Success)
{
//Debug.Console(0, this, "ERROR: Cannot register Crestron device: {0}", response);
return false;
}
IsRegistered.FireUpdate();
}
foreach (var f in Feedbacks)
{
f.FireUpdate();
}
Hardware.OnlineStatusChange += new OnlineStatusChangeEventHandler(Hardware_OnlineStatusChange);
CommunicationMonitor.Start();
return true;
}
/// <summary>
/// This disconnects events and unregisters the base hardware device.
/// </summary>
/// <returns></returns>
public override bool Deactivate()
{
CommunicationMonitor.Stop();
Hardware.OnlineStatusChange -= Hardware_OnlineStatusChange;
var success = Hardware.UnRegister() == eDeviceRegistrationUnRegistrationResponse.Success;
IsRegistered.FireUpdate();
return success;
}
/// <summary>
/// Adds feedback(s) to the list
/// </summary>
/// <param name="newFbs"></param>
public void AddToFeedbackList(params Feedback[] newFbs)
{
foreach (var f in newFbs)
{
if (f != null)
{
if (!Feedbacks.Contains(f))
{
Feedbacks.Add(f);
}
}
}
}
void Hardware_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
{
Debug.Console(2, this, "OnlineStatusChange Event. Online = {0}", args.DeviceOnLine);
foreach (var feedback in Feedbacks)
{
if (feedback != null)
feedback.FireUpdate();
}
}
#region IStatusMonitor Members
public StatusMonitorBase CommunicationMonitor { get; private set; }
#endregion
#region IUsageTracking Members
public UsageTracking UsageTracker { get; set; }
#endregion
}
//***********************************************************************************
public class CrestronGenericBaseDeviceEventIds
{
public const uint IsOnline = 1;
public const uint IpConnectionsText =2;
}
/// <summary>
/// Adds logging to Register() failure
/// </summary>
public static class GenericBaseExtensions
{
public static eDeviceRegistrationUnRegistrationResponse RegisterWithLogging(this GenericBase device, string key)
{
var result = device.Register();
var level = result == eDeviceRegistrationUnRegistrationResponse.Success ?
Debug.ErrorLogLevel.Notice : Debug.ErrorLogLevel.Error;
Debug.Console(0, level, "Register device result: '{0}', type '{1}', result {2}", key, device, result);
//if (result != eDeviceRegistrationUnRegistrationResponse.Success)
//{
// Debug.Console(0, Debug.ErrorLogLevel.Error, "Cannot register device '{0}': {1}", key, result);
//}
return result;
}
}
}

98
essentials-framework/Essentials Core/PepperDashEssentialsBase/Cues and DevAction/Cues.cs
View File

@@ -1,98 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
namespace PepperDash.Essentials.Core
{
/// <summary>
/// Encapsulates a string-named, joined and typed command to a device
/// </summary>
[Obsolete()]
public class DevAction
{
public Cue Cue { get; private set; }
public Action<object> Action { get; private set; }
public DevAction(Cue cue, Action<object> action)
{
Cue = cue;
Action = action;
}
}
public enum eCueType
{
Bool, Int, String, Serial, Void, Other
}
/// <summary>
/// The Cue class is a container to represent a name / join number / type for simplifying
/// commands coming into devices.
/// </summary>
public class Cue
{
public string Name { get; private set; }
public uint Number { get; private set; }
public eCueType Type { get; private set; }
public Cue(string name, uint join, eCueType type)
{
Name = name;
Number = join;
Type = type;
}
/// <summary>
/// Override that prints out the cue's data
/// </summary>
public override string ToString()
{
return string.Format("{0} Cue '{1}'-{2}", Type, Name, Number);
}
///// <summary>
///// Returns a new Cue with JoinNumber offset
///// </summary>
//public Cue GetOffsetCopy(uint offset)
//{
// return new Cue(Name, Number + offset, Type);
//}
/// <summary>
/// Helper method to create a Cue of Bool type
/// </summary>
/// <returns>Cue</returns>
public static Cue BoolCue(string name, uint join)
{
return new Cue(name, join, eCueType.Bool);
}
/// <summary>
/// Helper method to create a Cue of ushort type
/// </summary>
/// <returns>Cue</returns>
public static Cue UShortCue(string name, uint join)
{
return new Cue(name, join, eCueType.Int);
}
/// <summary>
/// Helper method to create a Cue of string type
/// </summary>
/// <returns>Cue</returns>
public static Cue StringCue(string name, uint join)
{
return new Cue(name, join, eCueType.String);
}
public static readonly Cue DefaultBoolCue = new Cue("-none-", 0, eCueType.Bool);
public static readonly Cue DefaultIntCue = new Cue("-none-", 0, eCueType.Int);
public static readonly Cue DefaultStringCue = new Cue("-none-", 0, eCueType.String);
}
}

28
essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/AudioInterfaces.cs Normal file
View File

@@ -0,0 +1,28 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
namespace PepperDash.Essentials.Core
{
public enum AudioChangeType
{
Mute, Volume
}
public class AudioChangeEventArgs
{
public AudioChangeType ChangeType { get; private set; }
public IBasicVolumeControls AudioDevice { get; private set; }
public AudioChangeEventArgs(IBasicVolumeControls device, AudioChangeType changeType)
{
ChangeType = changeType;
AudioDevice = device;
}
}
}

4
essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/IHasFeedbacks.cs
View File

@@ -26,9 +26,7 @@ namespace PepperDash.Essentials.Core
// get the properties and set them into a new collection of NameType wrappers
var props = t.GetProperties().Select(p => new PropertyNameType(p, t));
var feedbacks = source.Feedbacks.OrderBy(x => x.Type);
var feedbacks = source.Feedbacks;
if (feedbacks != null)
{
Debug.Console(0, source, "\n\nAvailable feedbacks:");

21
essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/IrOutputPortController.cs
View File

@@ -120,26 +120,5 @@ namespace PepperDash.Essentials.Core
Key, IrPort.IRDriverFileNameByIRDriverId(IrPortUid), command);
}
///// <summary>
///// When fed a dictionary of uint, string, will return UOs for each item,
///// attached to this IrOutputPort
///// </summary>
///// <param name="numStringDict"></param>
///// <returns></returns>
//public List<CueActionPair> GetUOsForIrCommands(Dictionary<Cue, string> numStringDict)
//{
// var funcs = new List<CueActionPair>(numStringDict.Count);
// foreach (var kvp in numStringDict)
// {
// // Have to assign these locally because of kvp's scope
// var cue = kvp.Key;
// var command = kvp.Value;
// funcs.Add(new BoolCueActionPair(cue, b => this.PressRelease(command, b)));
// }
// return funcs;
//}
}
}

56
essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/NewInterfaces.cs
View File

@@ -1,56 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
namespace PepperDash.Essentials.Core
{
//public interface IVolumeFunctions
//{
// BoolCueActionPair VolumeUpCueActionPair { get; }
// BoolCueActionPair VolumeDownCueActionPair { get; }
// BoolCueActionPair MuteToggleCueActionPair { get; }
//}
//public interface IVolumeTwoWay : IVolumeFunctions
//{
// IntFeedback VolumeLevelFeedback { get; }
// UShortCueActionPair VolumeLevelCueActionPair { get; }
// BoolFeedback IsMutedFeedback { get; }
//}
///// <summary>
/////
///// </summary>
//public static class IFunctionListExtensions
//{
// public static string GetFunctionsConsoleList(this IHasCueActionList device)
// {
// var sb = new StringBuilder();
// var list = device.CueActionList;
// foreach (var cap in list)
// sb.AppendFormat("{0,-15} {1,4} {2}\r", cap.Cue.Name, cap.Cue.Number, cap.GetType().Name);
// return sb.ToString();
// }
//}
public enum AudioChangeType
{
Mute, Volume
}
public class AudioChangeEventArgs
{
public AudioChangeType ChangeType { get; private set; }
public IBasicVolumeControls AudioDevice { get; private set; }
public AudioChangeEventArgs(IBasicVolumeControls device, AudioChangeType changeType)
{
ChangeType = changeType;
AudioDevice = device;
}
}
}

105
essentials-framework/Essentials Core/PepperDashEssentialsBase/Display/DELETE IRDisplayBase.cs
View File

@@ -1,105 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//namespace PepperDash.Essentials.Core
//{
// public abstract class IRDisplayBase : DisplayBase, IHasCueActionList
// {
// public IrOutputPortController IrPort { get; private set; }
// /// <summary>
// /// Default to 200ms
// /// </summary>
// public ushort IrPulseTime { get; set; }
// bool _PowerIsOn;
// bool _IsWarmingUp;
// bool _IsCoolingDown;
// /// <summary>
// /// FunctionList is pre-defined to have power commands.
// /// </summary>
// public IRDisplayBase(string key, string name, IROutputPort port, string irDriverFilepath)
// : base(key, name)
// {
// IrPort = new IrOutputPortController("ir-" + key, port, irDriverFilepath);
// IrPulseTime = 200;
// WarmupTime = 7000;
// CooldownTime = 10000;
// CueActionList = new List<CueActionPair>
// {
// new BoolCueActionPair(CommonBoolCue.Power, b=> PowerToggle()),
// new BoolCueActionPair(CommonBoolCue.PowerOn, b=> PowerOn()),
// new BoolCueActionPair(CommonBoolCue.PowerOff, b=> PowerOff()),
// };
// }
// public override void PowerOn()
// {
// if (!PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
// {
// _IsWarmingUp = true;
// IsWarmingUpFeedback.FireUpdate();
// // Fake power-up cycle
// WarmupTimer = new CTimer(o =>
// {
// _IsWarmingUp = false;
// _PowerIsOn = true;
// IsWarmingUpFeedback.FireUpdate();
// PowerIsOnFeedback.FireUpdate();
// }, WarmupTime);
// }
// IrPort.Pulse(IROutputStandardCommands.IROut_POWER_ON, IrPulseTime);
// }
// public override void PowerOff()
// {
// // If a display has unreliable-power off feedback, just override this and
// // remove this check.
// if (PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
// {
// _IsCoolingDown = true;
// _PowerIsOn = false;
// PowerIsOnFeedback.FireUpdate();
// IsCoolingDownFeedback.FireUpdate();
// // Fake cool-down cycle
// CooldownTimer = new CTimer(o =>
// {
// _IsCoolingDown = false;
// IsCoolingDownFeedback.FireUpdate();
// }, CooldownTime);
// }
// IrPort.Pulse(IROutputStandardCommands.IROut_POWER_OFF, IrPulseTime);
// }
// public override void PowerToggle()
// {
// // Not sure how to handle the feedback, but we should default to power off fb.
// // Does this need to trigger feedback??
// _PowerIsOn = false;
// IrPort.Pulse(IROutputStandardCommands.IROut_POWER, IrPulseTime);
// }
// #region IFunctionList Members
// public List<CueActionPair> CueActionList
// {
// get;
// private set;
// }
// #endregion
// protected override Func<bool> PowerIsOnOutputFunc { get { return () => _PowerIsOn; } }
// protected override Func<bool> IsCoolingDownOutputFunc { get { return () => _IsCoolingDown; } }
// protected override Func<bool> IsWarmingUpOutputFunc { get { return () => _IsWarmingUp; } }
// public override void ExecuteSwitch(object selector)
// {
// IrPort.Pulse((string)selector, IrPulseTime);
// }
// }
//}

11
essentials-framework/Essentials Core/PepperDashEssentialsBase/Ethernet/EthernetStatistics.cs
View File

@@ -30,15 +30,4 @@ namespace PepperDash.Essentials.Core.Ethernet
() => CrestronEthernetHelper.GetEthernetParameter(
CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_ROUTER, 0));
}
public static class EthernetCue
{
public static readonly Cue LinkActive = Cue.BoolCue("LinkActive", 1);
public static readonly Cue DhcpActive = Cue.BoolCue("DhcpActive", 2);
public static readonly Cue Hostname = Cue.StringCue("Hostname", 1);
public static readonly Cue IpAddress0 = Cue.StringCue("IpAddress0", 2);
public static readonly Cue SubnetMask0 = Cue.StringCue("SubnetMask0", 3);
public static readonly Cue DefaultGateway0 = Cue.StringCue("DefaultGateway0", 4);
}
}

24
essentials-framework/Essentials Core/PepperDashEssentialsBase/Factory/DeviceFactory.cs
View File

@@ -4,10 +4,11 @@ using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.GeneralIO;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.Config;
using PepperDash.Essentials.Core.CrestronIO;
namespace PepperDash.Essentials.Core
{
@@ -52,6 +53,27 @@ namespace PepperDash.Essentials.Core
Debug.Console(1, "Factory Attempting to create new Generic Comm Device");
return new GenericComm(dc);
}
else if (typeName == "ceniodigin104")
{
var control = CommFactory.GetControlPropertiesConfig(dc);
var ipid = control.IpIdInt;
return new CenIoDigIn104Controller(key, name, new Crestron.SimplSharpPro.GeneralIO.CenIoDi104(ipid, Global.ControlSystem));
}
if (typeName == "statussign")
{
var control = CommFactory.GetControlPropertiesConfig(dc);
var cresnetId = control.CresnetIdInt;
return new StatusSignController(key, name, new StatusSign(cresnetId, Global.ControlSystem));
}
if (typeName == "c2nrths")
{
var control = CommFactory.GetControlPropertiesConfig(dc);
var cresnetId = control.CresnetIdInt;
return new C2nRthsController(key, name, new C2nRths(cresnetId, Global.ControlSystem));
}
// then check for types that have been added by plugin dlls.
if (FactoryMethods.ContainsKey(typeName))

8
essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/BoolFeedback.cs
View File

@@ -19,8 +19,6 @@ namespace PepperDash.Essentials.Core
public override bool BoolValue { get { return _BoolValue; } }
bool _BoolValue;
public override eCueType Type { get { return eCueType.Bool; } }
/// <summary>
/// Fake value to be used in test mode
/// </summary>
@@ -45,12 +43,6 @@ namespace PepperDash.Essentials.Core
ValueFunc = valueFunc;
}
//public BoolFeedback(Cue cue, Func<bool> valueFunc)
// : base(cue)
//{
// if (cue == null) throw new ArgumentNullException("cue");
// ValueFunc = valueFunc;
//}
public override void FireUpdate()
{

9
essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/FeedbackBase.cs
View File

@@ -20,10 +20,6 @@ namespace PepperDash.Essentials.Core
public virtual string StringValue { get { return ""; } }
public virtual string SerialValue { get { return ""; } }
//public Cue Cue { get; private set; }
public abstract eCueType Type { get; }
/// <summary>
/// Feedbacks can be put into test mode for simulation of events without real data.
/// Using JSON debugging methods and the Set/ClearTestValue methods, we can simulate
@@ -46,10 +42,7 @@ namespace PepperDash.Essentials.Core
Key = key;
}
//protected Feedback(Cue cue)
//{
// Cue = cue;
//}
/// <summary>
/// Clears test mode and fires update.

9
essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/IntFeedback.cs
View File

@@ -13,7 +13,7 @@ namespace PepperDash.Essentials.Core
int _IntValue;
public ushort UShortValue { get { return (ushort)_IntValue; } }
public override eCueType Type { get { return eCueType.Int; } }
//public override eCueType Type { get { return eCueType.Int; } }
public int TestValue { get; private set; }
@@ -34,13 +34,6 @@ namespace PepperDash.Essentials.Core
ValueFunc = valueFunc;
}
//public IntFeedback(Cue cue, Func<int> valueFunc)
// : base(cue)
//{
// if (cue == null) throw new ArgumentNullException("cue");
// ValueFunc = valueFunc;
//}
public override void FireUpdate()
{
var newValue = InTestMode ? TestValue : ValueFunc.Invoke();

2
essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/SerialFeedback.cs
View File

@@ -16,7 +16,7 @@ namespace PepperDash.Essentials.Core
public override string SerialValue { get { return _SerialValue; } }
string _SerialValue;
public override eCueType Type { get { return eCueType.Serial; } }
//public override eCueType Type { get { return eCueType.Serial; } }
/// <summary>
/// Used in testing. Set/Clear functions

8
essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/StringFeedback.cs
View File

@@ -12,8 +12,6 @@ namespace PepperDash.Essentials.Core
public override string StringValue { get { return _StringValue; } } // ValueFunc.Invoke(); } }
string _StringValue;
public override eCueType Type { get { return eCueType.String; } }
/// <summary>
/// Used in testing. Set/Clear functions
/// </summary>
@@ -36,13 +34,7 @@ namespace PepperDash.Essentials.Core
ValueFunc = valueFunc;
}
//public StringFeedback(Cue cue, Func<string> valueFunc)
// : base(cue)
//{
// if (cue == null) throw new ArgumentNullException("cue");
// ValueFunc = valueFunc;
//}
public override void FireUpdate()
{

96
essentials-framework/Essentials Core/PepperDashEssentialsBase/Global/Global.cs
View File

@@ -1,10 +1,16 @@
using Crestron.SimplSharp;
using System;
using System.Text.RegularExpressions;
using Crestron.SimplSharp;
using Crestron.SimplSharp.CrestronIO;
using Crestron.SimplSharp.CrestronDataStore;
using Crestron.SimplSharpPro;
//using PepperDash.Essentials.Core.Http;
using PepperDash.Core;
using PepperDash.Essentials.License;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Schema;
namespace PepperDash.Essentials.Core
@@ -20,6 +26,17 @@ namespace PepperDash.Essentials.Core
/// </summary>
public static string FilePathPrefix { get; private set; }
/// <summary>
/// The file path prefix to the applciation directory
/// </summary>
public static string ApplicationDirectoryPathPrefix
{
get
{
return Crestron.SimplSharp.CrestronIO.Directory.GetApplicationDirectory();
}
}
/// <summary>
/// Returns the directory separator character based on the running OS
/// </summary>
@@ -45,6 +62,81 @@ namespace PepperDash.Essentials.Core
FilePathPrefix = prefix;
}
static string _AssemblyVersion;
/// <summary>
/// Gets the Assembly Version of Essentials
/// </summary>
/// <returns>The Assembly Version at Runtime</returns>
public static string AssemblyVersion
{
get
{
return _AssemblyVersion;
}
private set
{
_AssemblyVersion = value;
}
}
/// <summary>
/// Sets the Assembly version to the version of the Essentials Library
/// </summary>
/// <param name="assemblyVersion"></param>
public static void SetAssemblyVersion(string assemblyVersion)
{
AssemblyVersion = assemblyVersion;
}
/// <summary>
/// Checks to see if the running version meets or exceed the minimum specified version. For beta versions (0.xx.yy), will always return true.
/// </summary>
/// <param name="minimumVersion">Minimum specified version in format of xx.yy.zz</param>
/// <returns>Returns true if the running version meets or exceeds the minimum specified version</returns>
public static bool IsRunningMinimumVersionOrHigher(string minimumVersion)
{
Debug.Console(2, "Comparing running version '{0}' to minimum version '{1}'", AssemblyVersion, minimumVersion);
var runtimeVersion = Regex.Match(AssemblyVersion, @"^(\d*).(\d*).(\d*)$");
var runtimeVersionMajor = Int16.Parse(runtimeVersion.Groups[1].Value);
var runtimeVersionMinor = Int16.Parse(runtimeVersion.Groups[2].Value);
var runtimeVersionBuild = Int16.Parse(runtimeVersion.Groups[3].Value);
// Check for beta build version
if (runtimeVersionMajor == 0)
{
Debug.Console(2, "Running Beta Build. Bypassing Dependency Check.");
return true;
}
var minVersion = Regex.Match(minimumVersion, @"^(\d*).(\d*).(\d*)$");
if(!minVersion.Success)
{
Debug.Console(2, "minimumVersion String does not match format xx.yy.zz");
return false;
}
var minVersionMajor = Int16.Parse(minVersion.Groups[1].Value);
var minVersionMinor = Int16.Parse(minVersion.Groups[2].Value);
var minVersionBuild = Int16.Parse(minVersion.Groups[3].Value);
if (minVersionMajor > runtimeVersionMajor)
return false;
if (minVersionMinor > runtimeVersionMinor)
return false;
if (minVersionBuild > runtimeVersionBuild)
return false;
return true;
}
static Global()
{
// Fire up CrestronDataStoreStatic

4
essentials-framework/Essentials Core/PepperDashEssentialsBase/JoinMaps/JoinMapBase.cs
View File

@@ -34,7 +34,9 @@ namespace PepperDash.Essentials.Core
}
}
/// <summary>
/// Base class for join maps
/// </summary>
public abstract class JoinMapBase
{
/// <summary>

12
essentials-framework/Essentials Core/PepperDashEssentialsBase/License/EssentialsLicenseManager.cs
View File

@@ -83,16 +83,4 @@ namespace PepperDash.Essentials.License
return string.Format("License Status: {0}", IsValid ? "Valid" : "Not Valid");
}
}
public class EssentialsLicenseManager
{
}
public class LicenseCue
{
public static Cue LicenseIsValid = Cue.BoolCue("LicenseIsValid", 15991);
public static Cue LicenseMessage = Cue.StringCue("LicenseMessage", 15991);
}
}

0
essentials-framework/Essentials Core/PepperDashEssentialsBase/Monitoring/Interfaces and things.cs → essentials-framework/Essentials Core/PepperDashEssentialsBase/Monitoring/Interfaces.cs
View File

41
essentials-framework/Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj
View File

@@ -62,6 +62,10 @@
<SpecificVersion>False</SpecificVersion>
<HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.Fusion.dll</HintPath>
</Reference>
<Reference Include="Crestron.SimplSharpPro.GeneralIO, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
<SpecificVersion>False</SpecificVersion>
<HintPath>..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.GeneralIO.dll</HintPath>
</Reference>
<Reference Include="Crestron.SimplSharpPro.Remotes, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
<SpecificVersion>False</SpecificVersion>
<HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.Remotes.dll</HintPath>
@@ -107,19 +111,23 @@
<Reference Include="System.Data" />
</ItemGroup>
<ItemGroup>
<Compile Include="Comm and IR\CecPortController.cs" />
<Compile Include="Comm and IR\GenericComm.cs" />
<Compile Include="Config\Comm and IR\CecPortController.cs" />
<Compile Include="Config\Comm and IR\GenericComm.cs" />
<Compile Include="Config\Comm and IR\GenericHttpClient.cs" />
<Compile Include="Config\Essentials\ConfigUpdater.cs" />
<Compile Include="Config\Essentials\ConfigReader.cs" />
<Compile Include="Config\Essentials\ConfigWriter.cs" />
<Compile Include="Config\Essentials\EssentialsConfig.cs" />
<Compile Include="Config\SourceDevicePropertiesConfigBase.cs" />
<Compile Include="Crestron IO\C2nRts\C2nRthsController.cs" />
<Compile Include="Crestron IO\Inputs\CenIoDigIn104Controller.cs" />
<Compile Include="Crestron IO\Inputs\GenericDigitalInputDevice.cs" />
<Compile Include="Crestron IO\Inputs\GenericVersiportInputDevice.cs" />
<Compile Include="Crestron IO\Inputs\IDigitalInput.cs" />
<Compile Include="Crestron IO\IOPortConfig.cs" />
<Compile Include="Crestron IO\Relay\GenericRelayDevice.cs" />
<Compile Include="Crestron IO\Relay\ISwitchedOutput.cs" />
<Compile Include="Crestron IO\StatusSign\StatusSignController.cs" />
<Compile Include="Devices\CodecInterfaces.cs" />
<Compile Include="Devices\CrestronProcessor.cs" />
<Compile Include="Devices\DeviceApiBase.cs" />
@@ -149,16 +157,15 @@
<Compile Include="Microphone Privacy\MicrophonePrivacyControllerConfig.cs" />
<Compile Include="Presets\PresetBase.cs" />
<Compile Include="Ramps and Increments\ActionIncrementer.cs" />
<Compile Include="Comm and IR\CommFactory.cs" />
<Compile Include="Comm and IR\CommunicationExtras.cs" />
<Compile Include="Comm and IR\ComSpecJsonConverter.cs" />
<Compile Include="Comm and IR\ConsoleCommMockDevice.cs" />
<Compile Include="Comm and IR\IRPortHelper.cs" />
<Compile Include="Config\Comm and IR\CommFactory.cs" />
<Compile Include="Config\Comm and IR\CommunicationExtras.cs" />
<Compile Include="Config\Comm and IR\ComSpecJsonConverter.cs" />
<Compile Include="Config\Comm and IR\ConsoleCommMockDevice.cs" />
<Compile Include="Config\Comm and IR\IRPortHelper.cs" />
<Compile Include="Config\BasicConfig.cs" />
<Compile Include="Config\ConfigPropertiesHelpers.cs" />
<Compile Include="Config\InfoConfig.cs" />
<Compile Include="Config\DeviceConfig.cs" />
<Compile Include="Constants\CommonCues.cs" />
<Compile Include="Devices\DisplayUiConstants.cs" />
<Compile Include="Devices\IUsageTracking.cs" />
<Compile Include="Devices\DeviceJsonApi.cs" />
@@ -195,14 +202,13 @@
<Compile Include="Monitoring\StatusMonitorCollection.cs" />
<Compile Include="Monitoring\CrestronGenericBaseCommunicationMonitor.cs" />
<Compile Include="Monitoring\StatusMonitorBase.cs" />
<Compile Include="Monitoring\Interfaces and things.cs" />
<Compile Include="Monitoring\Interfaces.cs" />
<Compile Include="Monitoring\GenericCommunicationMonitor.cs" />
<Compile Include="Devices\NewInterfaces.cs" />
<Compile Include="Devices\AudioInterfaces.cs" />
<Compile Include="Devices\IAttachVideoStatusExtensions.cs" />
<Compile Include="Devices\IHasFeedbacks.cs" />
<Compile Include="Devices\SmartObjectBaseTypes.cs" />
<Compile Include="Devices\PresentationDeviceType.cs" />
<Compile Include="Display\DELETE IRDisplayBase.cs" />
<Compile Include="Display\MockDisplay.cs" />
<Compile Include="Ethernet\EthernetStatistics.cs" />
<Compile Include="Global\Global.cs" />
@@ -225,25 +231,20 @@
<Compile Include="SmartObjects\SmartObjectNumeric.cs" />
<Compile Include="SmartObjects\SmartObjectDynamicList.cs" />
<Compile Include="SmartObjects\SmartObjectDPad.cs" />
<Compile Include="SmartObjects\SmartObjectHelper.cs" />
<Compile Include="SmartObjects\SmartObjectHelperBase.cs" />
<Compile Include="Routing\TieLine.cs" />
<Compile Include="Timers\CountdownTimer.cs" />
<Compile Include="Touchpanels\CrestronTouchpanelPropertiesConfig.cs" />
<Compile Include="Touchpanels\Interfaces.cs" />
<Compile Include="Touchpanels\Keyboards\HabaneroKeyboardController.cs" />
<Compile Include="Touchpanels\MOVED LargeTouchpanelControllerBase.cs" />
<Compile Include="Touchpanels\TriListExtensions.cs" />
<Compile Include="Touchpanels\MOVED UIControllers\DevicePageControllerBase.cs" />
<Compile Include="UI PageManagers\BlurayPageManager.cs" />
<Compile Include="UI PageManagers\SetTopBoxThreePanelPageManager.cs" />
<Compile Include="UI PageManagers\SinglePageManager.cs" />
<Compile Include="UI PageManagers\PageManager.cs" />
<Compile Include="UI PageManagers\SetTopBoxTwoPanelPageManager.cs" />
<Compile Include="VideoStatus\VideoStatusOutputs.cs" />
<Compile Include="VideoStatus\VideoStatusCues.cs" />
<Compile Include="Cues and DevAction\Cues.cs" />
<Compile Include="Comm and IR\ComPortController.cs" />
<Compile Include="Config\Comm and IR\ComPortController.cs" />
<Compile Include="Crestron\CrestronGenericBaseDevice.cs" />
<Compile Include="DeviceControlsParentInterfaces\IPresentationSource.cs" />
<Compile Include="Devices\DeviceManager.cs" />
@@ -251,23 +252,17 @@
<Compile Include="Display\DisplayBase.cs" />
<Compile Include="Feedbacks\FeedbackBase.cs" />
<Compile Include="Room\Room.cs" />
<Compile Include="Room\RoomCues.cs" />
<Compile Include="SmartObjects\SubpageReferencList\SourceListSubpageReferenceList.cs" />
<Compile Include="Touchpanels\ModalDialog.cs" />
<Compile Include="Touchpanels\SmartGraphicsTouchpanelControllerBase.cs" />
<Compile Include="TriListBridges\HandlerBridge.cs" />
<Compile Include="Devices\FIND HOMES Interfaces.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="SigHelper.cs" />
<Compile Include="REMOVE SigId.cs" />
<Compile Include="SmartObjects\SubpageReferencList\SubpageReferenceList.cs" />
<Compile Include="SmartObjects\SubpageReferencList\SubpageReferenceListItem.cs" />
<None Include="app.config" />
<None Include="Properties\ControlSystem.cfg" />
</ItemGroup>
<ItemGroup>
<Folder Include="bin\" />
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
<ProjectExtensions>
<VisualStudio>

11
essentials-framework/Essentials Core/PepperDashEssentialsBase/Plugins/IPluginDeviceConfig.cs Normal file
View File

@@ -0,0 +1,11 @@
using PepperDash.Core;
using PepperDash.Essentials.Core.Config;
namespace PepperDash.Essentials.Core.Plugins
{
public interface IPluginDeviceConfig
{
string MinimumEssentialsFrameworkVersion { get; }
IKeyed BuildDevice(DeviceConfig dc);
}
}

19
essentials-framework/Essentials Core/PepperDashEssentialsBase/Plugins/PluginEntrypointAttribute.cs Normal file
View File

@@ -0,0 +1,19 @@
using System;
namespace PepperDash.Essentials.Core.Plugins
{
[AttributeUsage(AttributeTargets.Class)]
public sealed class PluginEntryPointAttribute : Attribute
{
private readonly string _uniqueKey;
public string UniqueKey {
get { return _uniqueKey; }
}
public PluginEntryPointAttribute(string key)
{
_uniqueKey = key;
}
}
}

14
essentials-framework/Essentials Core/PepperDashEssentialsBase/Properties/AssemblyInfo.cs
View File

@@ -1,7 +1,11 @@
using System.Reflection;
using Crestron.SimplSharp.Reflection;
[assembly: System.Reflection.AssemblyTitle("PepperDashEssentialsBase")]
[assembly: System.Reflection.AssemblyCompany("PepperDash Technology Corp")]
[assembly: System.Reflection.AssemblyProduct("PepperDashEssentials")]
[assembly: System.Reflection.AssemblyCopyright("Copyright © PepperDash Technology Corp 2020")]
[assembly: System.Reflection.AssemblyVersion("0.0.0.*")]
[assembly: System.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
[assembly: Crestron.SimplSharp.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
[assembly: AssemblyTitle("PepperDashEssentialsBase")]
[assembly: AssemblyCompany("PepperDash Technology Corp")]
[assembly: AssemblyProduct("PepperDashEssentialsBase")]
[assembly: AssemblyCopyright("Copyright © Ppperdash 2019")]
[assembly: AssemblyVersion("1.4.2.*")]

37
essentials-framework/Essentials Core/PepperDashEssentialsBase/REMOVE SigId.cs
View File

@@ -1,37 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using Crestron.SimplSharpPro;
//namespace PepperDash.Essentials.Core
//{
// public class SigId
// {
// public uint Number { get; private set; }
// public eSigType Type { get; private set; }
// public SigId(eSigType type, uint number)
// {
// Type = type;
// Number = number;
// }
// public override bool Equals(object id)
// {
// if (id is SigId)
// {
// var sigId = id as SigId;
// return this.Number == sigId.Number && this.Type == sigId.Type;
// }
// else
// return base.Equals(id);
// }
// public override int GetHashCode()
// {
// return base.GetHashCode();
// }
// }
//}

22
essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/EssentialsRoomBase.cs
View File

@@ -100,7 +100,8 @@ namespace PepperDash.Essentials.Core
ShutdownPromptTimer.HasFinished += (o, a) => Shutdown(); // Shutdown is triggered
ShutdownPromptSeconds = 60;
ShutdownVacancySeconds = 120;
ShutdownVacancySeconds = 120;
ShutdownType = eShutdownType.None;
RoomVacancyShutdownTimer = new SecondsCountdownTimer(Key + "-vacancyOffTimer");
@@ -140,7 +141,7 @@ namespace PepperDash.Essentials.Core
case eVacancyMode.InShutdownWarning:
{
StartShutdown(eShutdownType.Vacancy);
Debug.Console(0, this, "Shutting Down due to vacancy.");
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Shutting Down due to vacancy.");
break;
}
default:
@@ -163,7 +164,7 @@ namespace PepperDash.Essentials.Core
ShutdownType = type;
ShutdownPromptTimer.Start();
Debug.Console(0, this, "ShutdwonPromptTimer Started. Type: {0}. Seconds: {1}", ShutdownType, ShutdownPromptTimer.SecondsToCount);
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "ShutdownPromptTimer Started. Type: {0}. Seconds: {1}", ShutdownType, ShutdownPromptTimer.SecondsToCount);
}
public void StartRoomVacancyTimer(eVacancyMode mode)
@@ -177,7 +178,7 @@ namespace PepperDash.Essentials.Core
VacancyMode = mode;
RoomVacancyShutdownTimer.Start();
Debug.Console(0, this, "Vacancy Timer Started. Mode: {0}. Seconds: {1}", VacancyMode, RoomVacancyShutdownTimer.SecondsToCount);
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Vacancy Timer Started. Mode: {0}. Seconds: {1}", VacancyMode, RoomVacancyShutdownTimer.SecondsToCount);
}
/// <summary>
@@ -213,6 +214,9 @@ namespace PepperDash.Essentials.Core
return;
}
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Room Occupancy set to device: '{0}'", (statusProvider as Device).Key);
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Timeout Minutes from Config is: {0}", timeoutMinutes);
// If status provider is fusion, set flag to remote
if (statusProvider is Core.Fusion.EssentialsHuddleSpaceFusionSystemControllerBase)
OccupancyStatusProviderIsRemote = true;
@@ -220,16 +224,14 @@ namespace PepperDash.Essentials.Core
if(timeoutMinutes > 0)
RoomVacancyShutdownSeconds = timeoutMinutes * 60;
Debug.Console(1, this, "RoomVacancyShutdownSeconds set to {0}", RoomVacancyShutdownSeconds);
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "RoomVacancyShutdownSeconds set to {0}", RoomVacancyShutdownSeconds);
RoomOccupancy = statusProvider;
OnRoomOccupancyIsSet();
RoomOccupancy.RoomIsOccupiedFeedback.OutputChange -= RoomIsOccupiedFeedback_OutputChange;
RoomOccupancy.RoomIsOccupiedFeedback.OutputChange += RoomIsOccupiedFeedback_OutputChange;
Debug.Console(0, this, "Room Occupancy set to device: '{0}'", (statusProvider as Device).Key);
OnRoomOccupancyIsSet();
}
void OnRoomOccupancyIsSet()
@@ -254,13 +256,13 @@ namespace PepperDash.Essentials.Core
{
if (RoomOccupancy.RoomIsOccupiedFeedback.BoolValue == false)
{
Debug.Console(1, this, "Notice: Vacancy Detected");
Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Notice: Vacancy Detected");
// Trigger the timer when the room is vacant
StartRoomVacancyTimer(eVacancyMode.InInitialVacancy);
}
else
{
Debug.Console(1, this, "Notice: Occupancy Detected");
Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Notice: Occupancy Detected");
// Reset the timer when the room is occupied
RoomVacancyShutdownTimer.Cancel();
}

61
essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/RoomCues.cs
View File

@@ -1,61 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials
{
public static class RoomCue
{
// Commands/
//bools
public static readonly Cue RoomOnToggle = Cue.BoolCue("RoomOnToggle", 2001);
public static readonly Cue RoomOn = Cue.BoolCue("RoomOn", 2002);
public static readonly Cue RoomOff = Cue.BoolCue("RoomOff", 2003);
public static readonly Cue VolumeUp = Cue.BoolCue("VolumeUp", 2011);
public static readonly Cue VolumeDown = Cue.BoolCue("VolumeDown", 2012);
public static readonly Cue VolumeDefault = Cue.BoolCue("VolumeDefault", 2013);
public static readonly Cue MuteToggle = Cue.BoolCue("MuteToggle", 2014);
public static readonly Cue MuteOn = Cue.BoolCue("MuteOn", 2015);
public static readonly Cue MuteOff = Cue.BoolCue("MuteOff", 2016);
//ushorts
public static readonly Cue SelectSourceByNumber = Cue.UShortCue("SelectSourceByNumber", 2001);
public static readonly Cue VolumeLevel = Cue.UShortCue("VolumeLevel", 2011);
public static readonly Cue VolumeLevelPercent = Cue.UShortCue("VolumeLevelPercent", 2012);
//strings
public static readonly Cue SelectSourceByKey = Cue.StringCue("SelectSourceByKey", 2001);
// Outputs
//Bools
public static readonly Cue RoomIsOn = Cue.BoolCue("RoomIsOn", 2002);
public static readonly Cue RoomIsOnStandby = Cue.BoolCue("RoomIsOnStandby", 2003);
public static readonly Cue RoomIsWarmingUp = Cue.BoolCue("RoomIsWarmingUp", 2004);
public static readonly Cue RoomIsCoolingDown = Cue.BoolCue("RoomIsCoolingDown", 2005);
public static readonly Cue RoomIsOccupied = Cue.BoolCue("RoomIsOccupied", 2006);
//Ushorts
public static readonly Cue SourcesCount = Cue.UShortCue("SourcesCount", 2001);
public static readonly Cue CurrentSourceNumber = Cue.UShortCue("CurrentSourceNumber", 2002);
public static readonly Cue CurrentSourceType = Cue.UShortCue("CurrentSourceType", 2003);
//Strings
public static readonly Cue CurrentSourceKey = Cue.StringCue("CurrentSourceKey", 2001);
public static readonly Cue CurrentSourceName = Cue.StringCue("CurrentSourceName", 2002);
public static readonly Cue VolumeLevelText = Cue.StringCue("VolumeLevelText", 2012);
public static readonly Cue Key = Cue.StringCue("RoomKey", 2021);
public static readonly Cue Name = Cue.StringCue("RoomName", 2022);
public static readonly Cue Description = Cue.StringCue("Description", 2023);
public static readonly Cue HelpMessage = Cue.StringCue("HelpMessage", 2024);
//Special
public static readonly Cue Source = new Cue("Source", 0, eCueType.Other);
}
}

128
essentials-framework/Essentials Core/PepperDashEssentialsBase/SmartObjects/SmartObjectHelper.cs
View File

@@ -1,128 +0,0 @@
using System;
using System.Linq;
using System.Collections.Generic;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Core;
namespace PepperDash.Essentials.Core
{
public class SmartObjectHelper
{
public static uint GetSmartObjectJoinForTypeAndObject(uint sourceType, uint typeOffset)
{
return (uint)(10000 + (sourceType * 100) + typeOffset);
}
//public static void DumpSmartObject(SmartGraphicsTouchpanelControllerBase tp, uint id)
//{
// if (!tp.TriList.SmartObjects.Contains(id))
// {
// Debug.Console(0, tp, "does not contain smart object ID {0}", id);
// return;
// }
// var so = tp.TriList.SmartObjects[id];
// Debug.Console(0, tp, "Signals for smart object ID {0}", id);
// Debug.Console(0, "BooleanInput -------------------------------");
// foreach (var s in so.BooleanInput)
// Debug.Console(0, " {0,5} {1}", s.Number, s.Name);
// Debug.Console(0, "UShortInput -------------------------------");
// foreach (var s in so.UShortInput)
// Debug.Console(0, " {0,5} {1}", s.Number, s.Name);
// Debug.Console(0, "StringInput -------------------------------");
// foreach (var s in so.StringInput)
// Debug.Console(0, " {0,5} {1}", s.Number, s.Name);
// Debug.Console(0, "BooleanOutput -------------------------------");
// foreach (var s in so.BooleanOutput)
// Debug.Console(0, " {0,5} {1}", s.Number, s.Name);
// Debug.Console(0, "UShortOutput -------------------------------");
// foreach (var s in so.UShortOutput)
// Debug.Console(0, " {0,5} {1}", s.Number, s.Name);
// Debug.Console(0, "StringOutput -------------------------------");
// foreach (var s in so.StringOutput)
// Debug.Console(0, " {0,5} {1}", s.Number, s.Name);
//}
///// <summary>
///// Inserts/removes the appropriate UO's onto sigs
///// </summary>
///// <param name="triList"></param>
///// <param name="smartObjectId"></param>
///// <param name="deviceUserObjects"></param>
///// <param name="state"></param>
//public static void LinkNumpadWithUserObjects(BasicTriListWithSmartObject triList,
// uint smartObjectId, List<CueActionPair> deviceUserObjects, Cue Misc_1Function, Cue Misc_2Function, bool state)
//{
// var sigDict = new Dictionary<string, Cue>
// {
// { "0", CommonBoolCue.Digit0 },
// { "1", CommonBoolCue.Digit1 },
// { "2", CommonBoolCue.Digit2 },
// { "3", CommonBoolCue.Digit3 },
// { "4", CommonBoolCue.Digit4 },
// { "5", CommonBoolCue.Digit5 },
// { "6", CommonBoolCue.Digit6 },
// { "7", CommonBoolCue.Digit7 },
// { "8", CommonBoolCue.Digit8 },
// { "9", CommonBoolCue.Digit9 },
// { "Misc_1", Misc_1Function },
// { "Misc_2", Misc_2Function },
// };
// LinkSmartObjectWithUserObjects(triList, smartObjectId, deviceUserObjects, sigDict, state);
//}
//public static void LinkDpadWithUserObjects(BasicTriListWithSmartObject triList,
// uint smartObjectId, List<CueActionPair> deviceUserObjects, bool state)
//{
// var sigDict = new Dictionary<string, Cue>
// {
// { "Up", CommonBoolCue.Up },
// { "Down", CommonBoolCue.Down },
// { "Left", CommonBoolCue.Left },
// { "Right", CommonBoolCue.Right },
// { "OK", CommonBoolCue.Select },
// };
// LinkSmartObjectWithUserObjects(triList, smartObjectId, deviceUserObjects, sigDict, state);
//}
///// <summary>
///// MOVE TO HELPER CLASS
///// </summary>
///// <param name="triList"></param>
///// <param name="smartObjectId"></param>
///// <param name="deviceUserObjects"></param>
///// <param name="smartObjectSigMap"></param>
///// <param name="state"></param>
//public static void LinkSmartObjectWithUserObjects(BasicTriListWithSmartObject triList,
// uint smartObjectId, List<CueActionPair> deviceUserObjects, Dictionary<string, Cue> smartObjectSigMap, bool state)
//{
// // Hook up smart objects if applicable
// if (triList.SmartObjects.Contains(smartObjectId))
// {
// var smartObject = triList.SmartObjects[smartObjectId];
// foreach (var kvp in smartObjectSigMap)
// {
// if (smartObject.BooleanOutput.Contains(kvp.Key))
// {
// if (state)
// {
// // look for a user object and if so, attach/detach it to/from the sig.
// var uo = deviceUserObjects.FirstOrDefault(ao => ao.Cue == kvp.Value);
// if (uo != null)
// smartObject.BooleanOutput[kvp.Key].UserObject = uo;
// }
// else
// smartObject.BooleanOutput[kvp.Key].UserObject = null;
// }
// else
// Debug.Console(0, "Smart object {0} does not contain Sig {1}", smartObject.ID, kvp.Key);
// }
// }
// else
// Debug.Console(0, "ERROR Smart object {0} not found on {1:X2}", smartObjectId, triList.ID);
//}
}
}

12
essentials-framework/Essentials Core/PepperDashEssentialsBase/Timers/CountdownTimer.cs
View File

@@ -23,6 +23,10 @@ namespace PepperDash.Essentials.Core
public StringFeedback TimeRemainingFeedback { get; private set; }
public bool CountsDown { get; set; }
/// <summary>
/// The number of seconds to countdown
/// </summary>
public int SecondsToCount { get; set; }
public DateTime StartTime { get; private set; }
@@ -31,7 +35,7 @@ namespace PepperDash.Essentials.Core
CTimer SecondTimer;
/// <summary>
///
/// Constructor
/// </summary>
/// <param name="key"></param>
public SecondsCountdownTimer(string key)
@@ -61,7 +65,7 @@ namespace PepperDash.Essentials.Core
}
/// <summary>
///
/// Starts the Timer
/// </summary>
public void Start()
{
@@ -82,7 +86,7 @@ namespace PepperDash.Essentials.Core
}
/// <summary>
///
/// Restarts the timer
/// </summary>
public void Reset()
{
@@ -91,7 +95,7 @@ namespace PepperDash.Essentials.Core
}
/// <summary>
///
/// Cancels the timer (without triggering it to finish)
/// </summary>
public void Cancel()
{

275
essentials-framework/Essentials Core/PepperDashEssentialsBase/Touchpanels/MOVED LargeTouchpanelControllerBase.cs
View File

@@ -1,275 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.DeviceSupport;
//using PepperDash.Core;
//namespace PepperDash.Essentials.Core
//{
// /// <summary>
// ///
// /// </summary>
// public class LargeTouchpanelControllerBase : SmartGraphicsTouchpanelControllerBase
// {
// public string PresentationShareButtonInVideoText = "Share";
// public string PresentationShareButtonNotInVideoText = "Presentation";
// SourceListSubpageReferenceList SourceSelectSRL;
// DevicePageControllerBase CurrentPresentationSourcePageController;
// public LargeTouchpanelControllerBase(string key, string name,
// BasicTriListWithSmartObject triList, string sgdFilePath)
// : base(key, name, triList, sgdFilePath)
// {
// }
// public override bool CustomActivate()
// {
// var baseSuccess = base.CustomActivate();
// if (!baseSuccess) return false;
// SourceSelectSRL = new SourceListSubpageReferenceList(this.TriList, n =>
// { if (CurrentRoom != null) CurrentRoom.SelectSource(n); });
// var lm = Global.LicenseManager;
// if (lm != null)
// {
// lm.LicenseIsValid.LinkInputSig(TriList.BooleanInput[UiCue.ShowLicensed.Number]);
// //others
// }
// // Temp things -----------------------------------------------------------------------
// TriList.StringInput[UiCue.SplashMessage.Number].StringValue = SplashMessage;
// //------------------------------------------------------------------------------------
// // Initialize initial view
// ShowSplashOrMain();
// return true;
// }
// /// <summary>
// /// In Essentials, this should NEVER be called, since it's a one-room solution
// /// </summary>
// protected override void HideRoomUI()
// {
// // UI Cleanup here????
// //SwapAudioDeviceControls(CurrentRoom.CurrentAudioDevice, null);
// //CurrentRoom.AudioDeviceWillChange -= CurrentRoom_AudioDeviceWillChange;
// CurrentRoom.IsCoolingDown.OutputChange -= CurrentRoom_IsCoolingDown_OutputChange;
// CurrentRoom.IsWarmingUp.OutputChange -= CurrentRoom_IsWarmingUp_OutputChange;
// SourceSelectSRL.DetachFromCurrentRoom();
// }
// /// <summary>
// /// Ties this panel controller to the Room and gets updates.
// /// </summary>
// protected override void ShowRoomUI()
// {
// Debug.Console(1, this, "connecting to system '{0}'", CurrentRoom.Key);
// TriList.StringInput[RoomCue.Name.Number].StringValue = CurrentRoom.Name;
// TriList.StringInput[RoomCue.Description.Number].StringValue = CurrentRoom.Description;
// CurrentRoom.IsCoolingDown.OutputChange -= CurrentRoom_IsCoolingDown_OutputChange;
// CurrentRoom.IsWarmingUp.OutputChange -= CurrentRoom_IsWarmingUp_OutputChange;
// CurrentRoom.IsCoolingDown.OutputChange += CurrentRoom_IsCoolingDown_OutputChange;
// CurrentRoom.IsWarmingUp.OutputChange += CurrentRoom_IsWarmingUp_OutputChange;
// SourceSelectSRL.AttachToRoom(CurrentRoom);
// }
// void CurrentRoom_IsCoolingDown_OutputChange(object sender, EventArgs e)
// {
// Debug.Console(2, this, "Received room in cooldown={0}", CurrentRoom.IsCoolingDown.BoolValue);
// if (CurrentRoom.IsCoolingDown.BoolValue) // When entering cooldown
// {
// // Do we need to check for an already-running cooldown - like in the case of room switches?
// new ModalDialog(TriList).PresentModalTimerDialog(0, "Power Off", "Power", "Please wait, shutting down",
// "", "", CurrentRoom.CooldownTime, true, b =>
// {
// ShowSplashOrMain();
// });
// }
// }
// void CurrentRoom_IsWarmingUp_OutputChange(object sender, EventArgs e)
// {
// Debug.Console(2, this, "Received room in warmup={0}", CurrentRoom.IsWarmingUp.BoolValue);
// if (CurrentRoom.IsWarmingUp.BoolValue) // When entering warmup
// {
// // Do we need to check for an already-running cooldown - like in the case of room switches?
// new ModalDialog(TriList).PresentModalTimerDialog(0, "Power On", "Power", "Please wait, powering on",
// "", "", CurrentRoom.WarmupTime, false, b =>
// {
// // Reveal sources - or has already been done behind modal
// });
// }
// }
// // Handler for source change events.
// void CurrentRoom_PresentationSourceChange(object sender, EssentialsRoomSourceChangeEventArgs args)
// {
// // Put away the old source and set up the new source.
// Debug.Console(2, this, "Received source change={0}", args.NewSource != null ? args.NewSource.Key : "none");
// // If we're in tech, don't switch screen modes. Add any other modes we may want to switch away from
// // inside the if below.
// if (MainMode == eMainModeType.Splash)
// setMainMode(eMainModeType.Presentation);
// SetControlSource(args.NewSource);
// }
// //***********************************************************************
// //** UI Manipulation
// //***********************************************************************
// /// <summary>
// /// Shows the splash page or the main presentation page, depending on config setting
// /// </summary>
// void ShowSplashOrMain()
// {
// if (UsesSplashPage)
// setMainMode(eMainModeType.Splash);
// else
// setMainMode(eMainModeType.Presentation);
// }
// /// <summary>
// /// Switches between main modes
// /// </summary>
// void setMainMode(eMainModeType mode)
// {
// MainMode = mode;
// switch (mode)
// {
// case eMainModeType.Presentation:
// TriList.BooleanInput[UiCue.VisibleCommonFooter.Number].BoolValue = true;
// TriList.BooleanInput[UiCue.VisibleCommonHeader.Number].BoolValue = true;
// TriList.BooleanInput[UiCue.VisibleSplash.Number].BoolValue = false;
// TriList.BooleanInput[UiCue.VisiblePresentationSourceList.Number].BoolValue = true;
// ShowCurrentPresentationSourceUi();
// break;
// case eMainModeType.Splash:
// TriList.BooleanInput[UiCue.VisibleCommonFooter.Number].BoolValue = false;
// TriList.BooleanInput[UiCue.VisibleCommonHeader.Number].BoolValue = false;
// TriList.BooleanInput[UiCue.VisiblePresentationSourceList.Number].BoolValue = false;
// TriList.BooleanInput[UiCue.VisibleSplash.Number].BoolValue = true;
// HideCurrentPresentationSourceUi();
// break;
// case eMainModeType.Tech:
// new ModalDialog(TriList).PresentModalTimerDialog(1, "Tech page", "Info",
// "Tech page will be here soon!<br>I promise",
// "Bueno!", "", 0, false, null);
// MainMode = eMainModeType.Presentation;
// break;
// default:
// break;
// }
// }
// void PowerOffWithConfirmPressed()
// {
// if (!CurrentRoom.RoomIsOn.BoolValue) return;
// // Timeout or button 1 press will shut down
// var modal = new ModalDialog(TriList);
// uint seconds = CurrentRoom.UnattendedShutdownTimeMs / 1000;
// var message = string.Format("Meeting will end in {0} seconds", seconds);
// modal.PresentModalTimerDialog(2, "End Meeting", "Info", message,
// "End Meeting Now", "Cancel", CurrentRoom.UnattendedShutdownTimeMs, true,
// but => { if (but != 2) CurrentRoom.RoomOff(); });
// }
// /// <summary>
// /// Reveals the basic UI for the current device
// /// </summary>
// protected override void ShowCurrentPresentationSourceUi()
// {
// if (MainMode == eMainModeType.Splash && CurrentRoom.RoomIsOn.BoolValue)
// setMainMode(eMainModeType.Presentation);
// if (CurrentPresentationControlDevice == null)
// {
// // If system is off, do one thing
// // Otherwise, do something else - shouldn't be in this condition
// return;
// }
// // If a controller is already loaded, use it
// if (LoadedPageControllers.ContainsKey(CurrentPresentationControlDevice))
// CurrentPresentationSourcePageController = LoadedPageControllers[CurrentPresentationControlDevice];
// else
// {
// // This is by no means optimal, but for now....
// if (CurrentPresentationControlDevice.Type == PresentationSourceType.SetTopBox
// && CurrentPresentationControlDevice is IHasSetTopBoxProperties)
// CurrentPresentationSourcePageController = new PageControllerLargeSetTopBoxGeneric(TriList,
// CurrentPresentationControlDevice as IHasSetTopBoxProperties);
// else if (CurrentPresentationControlDevice.Type == PresentationSourceType.Laptop)
// CurrentPresentationSourcePageController = new PageControllerLaptop(TriList);
// // separate these...
// else if (CurrentPresentationControlDevice.Type == PresentationSourceType.Dvd)
// CurrentPresentationSourcePageController =
// new PageControllerLargeDvd(TriList, CurrentPresentationControlDevice as IHasCueActionList);
// else
// CurrentPresentationSourcePageController = null;
// // Save it.
// if (CurrentPresentationSourcePageController != null)
// LoadedPageControllers[CurrentPresentationControlDevice] = CurrentPresentationSourcePageController;
// }
// if (CurrentPresentationSourcePageController != null)
// CurrentPresentationSourcePageController.SetVisible(true);
// }
// protected override void HideCurrentPresentationSourceUi()
// {
// if (CurrentPresentationControlDevice != null && CurrentPresentationSourcePageController != null)
// CurrentPresentationSourcePageController.SetVisible(false);
// }
// void ShowHelp()
// {
// new ModalDialog(TriList).PresentModalTimerDialog(1, "Help", "Help", CurrentRoom.HelpMessage,
// "OK", "", 0, false, null);
// }
// protected void ListSmartObjects()
// {
// Debug.Console(0, this, "Smart objects IDs:");
// var list = TriList.SmartObjects.OrderBy(s => s.Key);
// foreach (var kvp in list)
// Debug.Console(0, " {0}", kvp.Key);
// }
// public override List<CueActionPair> FunctionList
// {
// get
// {
// return new List<CueActionPair>
// {
// new BoolCueActionPair(UiCue.PressSplash, b => { if(!b) setMainMode(eMainModeType.Presentation); }),
// new BoolCueActionPair(UiCue.PressRoomOffWithConfirm, b => { if(!b) PowerOffWithConfirmPressed(); }),
// new BoolCueActionPair(UiCue.PressModePresentationShare, b => { if(!b) setMainMode(eMainModeType.Presentation); }),
// new BoolCueActionPair(UiCue.PressHelp, b => { if(!b) ShowHelp(); }),
// new BoolCueActionPair(UiCue.PressSettings, b => { if(!b) setMainMode(eMainModeType.Tech); }),
// };
// }
// }
// //#endregion
// }
//}

244
essentials-framework/Essentials Core/PepperDashEssentialsBase/Touchpanels/MOVED UIControllers/DevicePageControllerBase.cs
View File

@@ -1,244 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.DeviceSupport;
//using PepperDash.Essentials.Core.Presets;
//using PepperDash.Core;
//namespace PepperDash.Essentials.Core
//{
// /// <summary>
// ///
// /// </summary>
// public abstract class DevicePageControllerBase
// {
// protected BasicTriListWithSmartObject TriList;
// protected List<BoolInputSig> FixedObjectSigs;
// public DevicePageControllerBase(BasicTriListWithSmartObject triList)
// {
// TriList = triList;
// }
// public void SetVisible(bool state)
// {
// foreach (var sig in FixedObjectSigs)
// {
// Debug.Console(2, "set visible {0}={1}", sig.Number, state);
// sig.BoolValue = state;
// }
// CustomSetVisible(state);
// }
// /// <summary>
// /// Add any specialized show/hide logic here - beyond FixedObjectSigs. Overriding
// /// methods do not need to call this base method
// /// </summary>
// protected virtual void CustomSetVisible(bool state)
// {
// }
// }
// //public class InterlockedDevicePageController
// //{
// // public List<uint> ObjectBoolJoins { get; set; }
// // public uint DefaultJoin { get; set; }
// //}
// ///// <summary>
// /////
// ///// </summary>
// //public interface IHasSetTopBoxProperties
// //{
// // bool HasDpad { get; }
// // bool HasPreset { get; }
// // bool HasDvr { get; }
// // bool HasNumbers { get; }
// // DevicePresetsModel PresetsModel { get; }
// // void LoadPresets(string filePath);
// //}
// public class PageControllerLaptop : DevicePageControllerBase
// {
// public PageControllerLaptop(BasicTriListWithSmartObject tl)
// : base(tl)
// {
// FixedObjectSigs = new List<BoolInputSig>
// {
// tl.BooleanInput[10092], // well
// tl.BooleanInput[11001] // Laptop info
// };
// }
// }
// ///// <summary>
// /////
// ///// </summary>
// //public class PageControllerLargeDvd : DevicePageControllerBase
// //{
// // IHasCueActionList Device;
// // public PageControllerLargeDvd(BasicTriListWithSmartObject tl, IHasCueActionList device)
// // : base(tl)
// // {
// // Device = device;
// // FixedObjectSigs = new List<BoolInputSig>
// // {
// // tl.BooleanInput[10093], // well
// // tl.BooleanInput[10411], // DVD Dpad
// // tl.BooleanInput[10412] // everything else
// // };
// // }
// // protected override void CustomSetVisible(bool state)
// // {
// // // Hook up smart objects if applicable
// // if (Device != null)
// // {
// // var uos = (Device as IHasCueActionList).CueActionList;
// // SmartObjectHelper.LinkDpadWithUserObjects(TriList, 10411, uos, state);
// // }
// // }
// //}
// /// <summary>
// ///
// /// </summary>
// //public class PageControllerLargeSetTopBoxGeneric : DevicePageControllerBase
// //{
// // // To-DO: Add properties for component subpage names. DpadPos1, DpadPos2...
// // // Derived classes can then insert special subpages for variations on given
// // // device types. Like DirecTV vs Comcast
// // public uint DpadSmartObjectId { get; set; }
// // public uint NumberPadSmartObjectId { get; set; }
// // public uint PresetsSmartObjectId { get; set; }
// // public uint Position5TabsId { get; set; }
// // IHasSetTopBoxProperties Device;
// // DevicePresetsView PresetsView;
// // bool ShowPosition5Tabs;
// // uint CurrentVisiblePosition5Item = 1;
// // Dictionary<uint, uint> Position5SubpageJoins = new Dictionary<uint, uint>
// // {
// // { 1, 10053 },
// // { 2, 10054 }
// // };
// // public PageControllerLargeSetTopBoxGeneric(BasicTriListWithSmartObject tl, IHasSetTopBoxProperties device)
// // : base(tl)
// // {
// // Device = device;
// // DpadSmartObjectId = 10011;
// // NumberPadSmartObjectId = 10014;
// // PresetsSmartObjectId = 10012;
// // Position5TabsId = 10081;
// // bool dpad = device.HasDpad;
// // bool preset = device.HasPreset;
// // bool dvr = device.HasDvr;
// // bool numbers = device.HasNumbers;
// // uint[] joins = null;
// // if (dpad && !preset && !dvr && !numbers) joins = new uint[] { 10031, 10091 };
// // else if (!dpad && preset && !dvr && !numbers) joins = new uint[] { 10032, 10091 };
// // else if (!dpad && !preset && dvr && !numbers) joins = new uint[] { 10033, 10091 };
// // else if (!dpad && !preset && !dvr && numbers) joins = new uint[] { 10034, 10091 };
// // else if (dpad && preset && !dvr && !numbers) joins = new uint[] { 10042, 10021, 10092 };
// // else if (dpad && !preset && dvr && !numbers) joins = new uint[] { 10043, 10021, 10092 };
// // else if (dpad && !preset && !dvr && numbers) joins = new uint[] { 10044, 10021, 10092 };
// // else if (!dpad && preset && dvr && !numbers) joins = new uint[] { 10043, 10022, 10092 };
// // else if (!dpad && preset && !dvr && numbers) joins = new uint[] { 10044, 10022, 10092 };
// // else if (!dpad && !preset && dvr && numbers) joins = new uint[] { 10044, 10023, 10092 };
// // else if (dpad && preset && dvr && !numbers) joins = new uint[] { 10053, 10032, 10011, 10093 };
// // else if (dpad && preset && !dvr && numbers) joins = new uint[] { 10054, 10032, 10011, 10093 };
// // else if (dpad && !preset && dvr && numbers) joins = new uint[] { 10054, 10033, 10011, 10093 };
// // else if (!dpad && preset && dvr && numbers) joins = new uint[] { 10054, 10033, 10012, 10093 };
// // else if (dpad && preset && dvr && numbers)
// // {
// // joins = new uint[] { 10081, 10032, 10011, 10093 }; // special case
// // ShowPosition5Tabs = true;
// // }
// // // Project the joins into corresponding sigs.
// // FixedObjectSigs = joins.Select(u => TriList.BooleanInput[u]).ToList();
// // // Build presets
// // if (device.HasPreset)
// // {
// // PresetsView = new DevicePresetsView(tl, device.PresetsModel);
// // }
// // }
// // protected override void CustomSetVisible(bool state)
// // {
// // if (ShowPosition5Tabs)
// // {
// // // Show selected tab
// // TriList.BooleanInput[Position5SubpageJoins[CurrentVisiblePosition5Item]].BoolValue = state;
// // var tabSo = TriList.SmartObjects[Position5TabsId];
// // if (state) // Link up the tab object
// // {
// // tabSo.BooleanOutput["Tab Button 1 Press"].UserObject = new BoolCueActionPair(b => ShowTab(1));
// // tabSo.BooleanOutput["Tab Button 2 Press"].UserObject = new BoolCueActionPair(b => ShowTab(2));
// // }
// // else // Disco tab object
// // {
// // tabSo.BooleanOutput["Tab Button 1 Press"].UserObject = null;
// // tabSo.BooleanOutput["Tab Button 2 Press"].UserObject = null;
// // }
// // }
// // // Hook up smart objects if applicable
// // if (Device is IHasCueActionList)
// // {
// // var uos = (Device as IHasCueActionList).CueActionList;
// // SmartObjectHelper.LinkDpadWithUserObjects(TriList, DpadSmartObjectId, uos, state);
// // SmartObjectHelper.LinkNumpadWithUserObjects(TriList, NumberPadSmartObjectId,
// // uos, CommonBoolCue.Dash, CommonBoolCue.Last, state);
// // }
// // // Link, unlink presets
// // if (Device.HasPreset && state)
// // PresetsView.Attach();
// // else if (Device.HasPreset && !state)
// // PresetsView.Detach();
// // }
// // void ShowTab(uint number)
// // {
// // // Ignore re-presses
// // if (CurrentVisiblePosition5Item == number) return;
// // // Swap subpage
// // var bi = TriList.BooleanInput;
// // if(CurrentVisiblePosition5Item > 0)
// // bi[Position5SubpageJoins[CurrentVisiblePosition5Item]].BoolValue = false;
// // CurrentVisiblePosition5Item = number;
// // bi[Position5SubpageJoins[CurrentVisiblePosition5Item]].BoolValue = true;
// // // Show feedback on buttons
// // }
// //}
//}

135
essentials-framework/Essentials Core/PepperDashEssentialsBase/Touchpanels/REMOVE Tsr302Controller.cs
View File

@@ -1,135 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.DeviceSupport;
//using Crestron.SimplSharpPro.UI;
//using PepperDash.Core;
//namespace PepperDash.Essentials.Core
//{
//[Obsolete("Replaced, initially with CrestronTsr302Controller in Resissentials")]
// public class Tsr302Controller : SmartGraphicsTouchpanelControllerBase
// {
// //public override List<CueActionPair> FunctionList
// //{
// // get
// // {
// // return new List<CueActionPair>
// // {
// // };
// // }
// //}
// public Tsr302 Remote { get; private set; }
// SourceListSubpageReferenceList SourceSelectSRL;
// DevicePageControllerBase CurrentPresentationSourcePageController;
// CTimer VolumeFeedbackTimer;
// public Tsr302Controller(string key, string name, Tsr302 device, string sgdFilePath) :
// base(key, name, device, sgdFilePath)
// {
// // Base takes care of TriList
// Remote = device;
// Remote.Home.UserObject = new BoolCueActionPair(b => { if (!b) PressHome(); });
// Remote.VolumeUp.UserObject = new BoolCueActionPair(b => { if (!b) PressHome(); });
// Remote.ButtonStateChange += Remote_ButtonStateChange;
// }
// public override bool CustomActivate()
// {
// var baseSuccess = base.CustomActivate();
// if (!baseSuccess) return false;
// SourceSelectSRL = new SourceListSubpageReferenceList(this.TriList, n =>
// { if (CurrentRoom != null) CurrentRoom.SelectSource(n); });
// return true;
// }
// protected override void SwapAudioDeviceControls(IVolumeFunctions oldDev, IVolumeFunctions newDev)
// {
// // stop presses
// if (oldDev != null)
// {
// ReleaseAudioPresses();
// if (oldDev is IVolumeTwoWay)
// {
// (newDev as IVolumeTwoWay).VolumeLevelFeedback.OutputChange -= VolumeLevelOutput_OutputChange;
// (oldDev as IVolumeTwoWay).VolumeLevelFeedback
// .UnlinkInputSig(TriList.UShortInput[CommonIntCue.MainVolumeLevel.Number]);
// }
// }
// if (newDev != null)
// {
// Remote.VolumeDown.UserObject = newDev.VolumeDownCueActionPair;
// Remote.VolumeUp.UserObject = newDev.VolumeUpCueActionPair;
// Remote.Mute.UserObject = newDev.MuteToggleCueActionPair;
// if (newDev is IVolumeTwoWay)
// {
// var vOut = (newDev as IVolumeTwoWay).VolumeLevelFeedback;
// vOut.OutputChange += VolumeLevelOutput_OutputChange;
// TriList.UShortInput[CommonIntCue.MainVolumeLevel.Number].UShortValue = vOut.UShortValue;
// }
// }
// else
// {
// Remote.VolumeDown.UserObject = null;
// Remote.VolumeUp.UserObject = null;
// Remote.Mute.UserObject = null;
// }
// base.SwapAudioDeviceControls(oldDev, newDev);
// }
// void PressHome()
// {
// }
// void VolumeLevelOutput_OutputChange(object sender, EventArgs e)
// {
// // Set level and show popup on timer
// TriList.UShortInput[CommonIntCue.MainVolumeLevel.Number].UShortValue =
// (sender as IntFeedback).UShortValue;
// if (VolumeFeedbackTimer == null)
// {
// TriList.BooleanInput[CommonBoolCue.ShowVolumeSlider.Number].BoolValue = true;
// VolumeFeedbackTimer = new CTimer(o => {
// TriList.BooleanInput[CommonBoolCue.ShowVolumeSlider.Number].BoolValue = false;
// }, 1000);
// }
// }
// void ReleaseAudioPresses()
// {
// if (Remote.VolumeDown.UserObject is BoolCueActionPair && Remote.VolumeDown.State == eButtonState.Pressed)
// (Remote.VolumeDown.UserObject as BoolCueActionPair).Invoke(false);
// if (Remote.VolumeUp.UserObject is BoolCueActionPair && Remote.VolumeUp.State == eButtonState.Pressed)
// (Remote.VolumeUp.UserObject as BoolCueActionPair).Invoke(false);
// if (Remote.Mute.UserObject is BoolCueActionPair && Remote.Mute.State == eButtonState.Pressed)
// (Remote.Mute.UserObject as BoolCueActionPair).Invoke(false);
// }
// /// <summary>
// /// Handler. Run UO's stored in buttons
// /// </summary>
// void Remote_ButtonStateChange(GenericBase device, ButtonEventArgs args)
// {
// Debug.Console(2, this, "{0}={1}", args.Button.Name, args.Button.State);
// var uo = args.Button.UserObject as BoolCueActionPair;
// if (uo != null)
// uo.Invoke(args.NewButtonState == eButtonState.Pressed);
// }
// }
//}

309
essentials-framework/Essentials Core/PepperDashEssentialsBase/Touchpanels/SmartGraphicsTouchpanelControllerBase.cs
View File

@@ -1,309 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.DeviceSupport;
//namespace PepperDash.Essentials.Core
//{
// public abstract class SmartGraphicsTouchpanelControllerBase : CrestronGenericBaseDevice
// {
// public BasicTriListWithSmartObject TriList { get; protected set; }
// public bool UsesSplashPage { get; set; }
// public string SplashMessage { get; set; }
// public bool ShowDate
// {
// set { TriList.BooleanInput[UiCue.ShowDate.Number].BoolValue = value; }
// }
// public bool ShowTime
// {
// set { TriList.BooleanInput[UiCue.ShowTime.Number].BoolValue = value; }
// }
// public abstract List<CueActionPair> FunctionList { get; }
// protected eMainModeType MainMode;
// protected IPresentationSource CurrentPresentationControlDevice;
// /// <summary>
// /// Defines the signal offset for the presentation device. Defaults to 100
// /// </summary>
// public uint PresentationControlDeviceJoinOffset { get { return 100; } }
// public enum eMainModeType
// {
// Presentation, Splash, Tech
// }
// protected string SgdFilePath;
// public EssentialsRoom CurrentRoom { get; protected set; }
// protected Dictionary<IPresentationSource, DevicePageControllerBase> LoadedPageControllers
// = new Dictionary<IPresentationSource, DevicePageControllerBase>();
// static object RoomChangeLock = new object();
// /// <summary>
// /// Constructor
// /// </summary>
// public SmartGraphicsTouchpanelControllerBase(string key, string name, BasicTriListWithSmartObject triList,
// string sgdFilePath)
// : base(key, name, triList)
// {
// TriList = triList;
// if (string.IsNullOrEmpty(key)) throw new ArgumentNullException("key");
// if (string.IsNullOrEmpty(sgdFilePath)) throw new ArgumentNullException("sgdFilePath");
// SgdFilePath = sgdFilePath;
// TriList.LoadSmartObjects(SgdFilePath);
// UsesSplashPage = true;
// SplashMessage = "Welcome";
// TriList.SigChange += Tsw_AnySigChange;
// foreach (var kvp in TriList.SmartObjects)
// kvp.Value.SigChange += this.Tsw_AnySigChange;
// }
// public override bool CustomActivate()
// {
// var baseSuccess = base.CustomActivate();
// if (!baseSuccess) return false;
// // Wiring up the buttons with UOs
// foreach (var uo in this.FunctionList)
// {
// if (uo.Cue.Number == 0) continue;
// if (uo is BoolCueActionPair)
// TriList.BooleanOutput[uo.Cue.Number].UserObject = uo;
// else if (uo is UShortCueActionPair)
// TriList.UShortOutput[uo.Cue.Number].UserObject = uo;
// else if (uo is StringCueActionPair)
// TriList.StringOutput[uo.Cue.Number].UserObject = uo;
// }
// return true;
// }
// //public void SetCurrentRoom(EssentialsRoom room)
// //{
// // if (CurrentRoom != null)
// // HideRoomUI();
// // CurrentRoom = room;
// // ShowRoomUI();
// //}
// /// <summary>
// ///
// /// </summary>
// /// <param name="room"></param>
// public void SetCurrentRoom(EssentialsRoom room)
// {
// if (CurrentRoom == room) return;
// IVolumeFunctions oldAudio = null;
// //Disconnect current room and audio device
// if (CurrentRoom != null)
// {
// HideRoomUI();
// CurrentRoom.AudioDeviceWillChange -= CurrentRoom_AudioDeviceWillChange;
// CurrentRoom.PresentationSourceChange -= CurrentRoom_PresentationSourceChange;
// oldAudio = CurrentRoom.CurrentAudioDevice;
// }
// CurrentRoom = room;
// IVolumeFunctions newAudio = null;
// if (CurrentRoom != null)
// {
// CurrentRoom.AudioDeviceWillChange += this.CurrentRoom_AudioDeviceWillChange;
// CurrentRoom.PresentationSourceChange += this.CurrentRoom_PresentationSourceChange;
// SetControlSource(CurrentRoom.CurrentPresentationSource);
// newAudio = CurrentRoom.CurrentAudioDevice;
// ShowRoomUI();
// }
// SwapAudioDeviceControls(oldAudio, newAudio);
// }
// /// <summary>
// /// Detaches and attaches an IVolumeFunctions device to the appropriate TP TriList signals.
// /// This will also add IVolumeNumeric if the device implements it.
// /// Overriding classes should call this. Overriding classes are responsible for
// /// linking up to hard keys, etc.
// /// </summary>
// /// <param name="oldDev">May be null</param>
// /// <param name="newDev">May be null</param>
// protected virtual void SwapAudioDeviceControls(IVolumeFunctions oldDev, IVolumeFunctions newDev)
// {
// // Disconnect
// if (oldDev != null)
// {
// TriList.BooleanOutput[CommonBoolCue.VolumeDown.Number].UserObject = null;
// TriList.BooleanOutput[CommonBoolCue.VolumeUp.Number].UserObject = null;
// TriList.BooleanOutput[CommonBoolCue.MuteToggle.Number].UserObject = null;
// TriList.BooleanInput[CommonBoolCue.ShowVolumeButtons.Number].BoolValue = false;
// TriList.BooleanInput[CommonBoolCue.ShowVolumeSlider.Number].BoolValue = false;
// if (oldDev is IVolumeTwoWay)
// {
// TriList.UShortOutput[CommonIntCue.MainVolumeLevel.Number].UserObject = null;
// (oldDev as IVolumeTwoWay).IsMutedFeedback
// .UnlinkInputSig(TriList.BooleanInput[CommonBoolCue.MuteOn.Number]);
// (oldDev as IVolumeTwoWay).VolumeLevelFeedback
// .UnlinkInputSig(TriList.UShortInput[CommonIntCue.MainVolumeLevel.Number]);
// }
// }
// if (newDev != null)
// {
// TriList.BooleanInput[CommonBoolCue.ShowVolumeSlider.Number].BoolValue = true;
// TriList.BooleanOutput[CommonBoolCue.VolumeDown.Number].UserObject = newDev.VolumeDownCueActionPair;
// TriList.BooleanOutput[CommonBoolCue.VolumeUp.Number].UserObject = newDev.VolumeUpCueActionPair;
// TriList.BooleanOutput[CommonBoolCue.MuteToggle.Number].UserObject = newDev.MuteToggleCueActionPair;
// if (newDev is IVolumeTwoWay)
// {
// TriList.BooleanInput[CommonBoolCue.ShowVolumeSlider.Number].BoolValue = true;
// var numDev = newDev as IVolumeTwoWay;
// TriList.UShortOutput[CommonIntCue.MainVolumeLevel.Number].UserObject = numDev.VolumeLevelCueActionPair;
// numDev.VolumeLevelFeedback
// .LinkInputSig(TriList.UShortInput[CommonIntCue.MainVolumeLevel.Number]);
// }
// }
// }
// /// <summary>
// /// Does nothing. Override to add functionality when calling SetCurrentRoom
// /// </summary>
// protected virtual void HideRoomUI() { }
// /// <summary>
// /// Does nothing. Override to add functionality when calling SetCurrentRoom
// /// </summary>
// protected virtual void ShowRoomUI() { }
// /// <summary>
// /// Sets up the current presentation device and updates statuses if the device is capable.
// /// </summary>
// protected void SetControlSource(IPresentationSource newSource)
// {
// if (CurrentPresentationControlDevice != null)
// {
// HideCurrentPresentationSourceUi();
// // Unhook presses and things
// if (CurrentPresentationControlDevice is IHasCueActionList)
// {
// foreach (var uo in (CurrentPresentationControlDevice as IHasCueActionList).CueActionList)
// {
// if (uo.Cue.Number == 0) continue;
// if (uo is BoolCueActionPair)
// {
// var bSig = TriList.BooleanOutput[uo.Cue.Number];
// // Disconnection should also clear bool sigs in case they are pressed and
// // might be orphaned
// if (bSig.BoolValue)
// (bSig.UserObject as BoolCueActionPair).Invoke(false);
// bSig.UserObject = null;
// }
// else if (uo is UShortCueActionPair)
// TriList.UShortOutput[uo.Cue.Number].UserObject = null;
// else if (uo is StringCueActionPair)
// TriList.StringOutput[uo.Cue.Number].UserObject = null;
// }
// }
// // unhook outputs
// if (CurrentPresentationControlDevice is IHasFeedback)
// {
// foreach (var output in (CurrentPresentationControlDevice as IHasFeedback).Feedbacks)
// {
// if (output.Cue.Number == 0) continue;
// if (output is BoolFeedback)
// (output as BoolFeedback).UnlinkInputSig(TriList.BooleanInput[output.Cue.Number]);
// else if (output is IntFeedback)
// (output as IntFeedback).UnlinkInputSig(TriList.UShortInput[output.Cue.Number]);
// else if (output is StringFeedback)
// (output as StringFeedback).UnlinkInputSig(TriList.StringInput[output.Cue.Number]);
// }
// }
// }
// CurrentPresentationControlDevice = newSource;
// //connect presses and things
// if (newSource is IHasCueActionList) // This has functions, get 'em
// {
// foreach (var ao in (newSource as IHasCueActionList).CueActionList)
// {
// if (ao.Cue.Number == 0) continue;
// if (ao is BoolCueActionPair)
// TriList.BooleanOutput[ao.Cue.Number].UserObject = ao;
// else if (ao is UShortCueActionPair)
// TriList.UShortOutput[ao.Cue.Number].UserObject = ao;
// else if (ao is StringCueActionPair)
// TriList.StringOutput[ao.Cue.Number].UserObject = ao;
// }
// }
// // connect outputs (addInputSig should update sig)
// if (CurrentPresentationControlDevice is IHasFeedback)
// {
// foreach (var output in (CurrentPresentationControlDevice as IHasFeedback).Feedbacks)
// {
// if (output.Cue.Number == 0) continue;
// if (output is BoolFeedback)
// (output as BoolFeedback).LinkInputSig(TriList.BooleanInput[output.Cue.Number]);
// else if (output is IntFeedback)
// (output as IntFeedback).LinkInputSig(TriList.UShortInput[output.Cue.Number]);
// else if (output is StringFeedback)
// (output as StringFeedback).LinkInputSig(TriList.StringInput[output.Cue.Number]);
// }
// }
// ShowCurrentPresentationSourceUi();
// }
// /// <summary>
// /// Reveals the basic UI for the current device
// /// </summary>
// protected virtual void ShowCurrentPresentationSourceUi()
// {
// }
// /// <summary>
// /// Hides the UI for the current device and calls for a feedback signal cleanup
// /// </summary>
// protected virtual void HideCurrentPresentationSourceUi()
// {
// }
// /// <summary>
// ///
// /// </summary>
// void CurrentRoom_PresentationSourceChange(object sender, EssentialsRoomSourceChangeEventArgs args)
// {
// SetControlSource(args.NewSource);
// }
// /// <summary>
// ///
// /// </summary>
// void CurrentRoom_AudioDeviceWillChange(object sender, EssentialsRoomAudioDeviceChangeEventArgs e)
// {
// SwapAudioDeviceControls(e.OldDevice, e.NewDevice);
// }
// /// <summary>
// /// Panel event handler
// /// </summary>
// void Tsw_AnySigChange(object currentDevice, SigEventArgs args)
// {
// // plugged in commands
// object 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);
// }
// }
//}

20
essentials-framework/Essentials Core/PepperDashEssentialsBase/VideoStatus/VideoStatusCues.cs
View File

@@ -1,20 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
namespace PepperDash.Essentials.Core
{
public static class VideoStatusCues
{
public static readonly Cue HasVideoStatusFeedback = Cue.BoolCue("HasVideoStatusFeedback", 1);
public static readonly Cue VideoSyncFeedback = Cue.BoolCue("VideoSyncFeedback", 2);
public static readonly Cue HdcpActiveFeedback = Cue.BoolCue("HdcpActiveFeedback", 3);
public static readonly Cue HdcpStateFeedback = Cue.StringCue("HdcpStateFeedback", 3);
public static readonly Cue VideoResolutionFeedback = Cue.StringCue("VideoResolutionFeedback", 2);
public static readonly Cue VideoStatusDeviceKey = Cue.StringCue("VideoStatusDeviceKey", 0);
public static readonly Cue VideoStatusDeviceName = Cue.StringCue("VideoStatusDeviceName", 4);
}
}

62
essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/DmInputCardBase.cs
View File

@@ -1,62 +0,0 @@
//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.Cards;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.DM;
//namespace PepperDash.Essentials.DM.Cards
//{
// public class DmInputCardControllerBase : IRoutingInputsOutputs
// {
// public string Key { get; private set; }
// public uint Slot { get; private set; }
// public abstract eDmInputCardType Type { get; }
// //public RoutingOutputPort BackplaneVideoOut { get; private set; }
// //public RoutingOutputPort BackplaneAudioOut { get; private set; }
// public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
// public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
// public DmInputCardControllerBase(string key, uint slot)
// {
// Key = key;
// Slot = slot;
// //BackplaneAudioOut = new RoutingOutputPort("backplaneAudioOut", eRoutingSignalType.Audio,
// // eRoutingPortConnectionType.BackplaneOnly, slot, this);
// //BackplaneVideoOut = new RoutingOutputPort("backplaneVideoOut", eRoutingSignalType.Video,
// // eRoutingPortConnectionType.BackplaneOnly, slot, this);
// //InputPorts = new RoutingPortCollection<RoutingInputPort>();
// //OutputPorts = new RoutingPortCollection<RoutingOutputPort> { BackplaneAudioOut, BackplaneVideoOut };
// }
// ///// <summary>
// ///// Gets a physical port by name. Returns null if doesn't exist
// ///// </summary>
// //public RoutingInputPort GetInputPort(string key)
// //{
// // return InputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
// //}
// ///// <summary>
// ///// Gets a physical port by name. Returns null if doesn't exist
// ///// </summary>
// //public RoutingOutputPort GetOutputPort(string key)
// //{
// // return OutputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
// //}
// }
// public enum eDmInputCardType
// {
// None, DmcHd, DmcHdDsp, Dmc4kHd, Dmc4kHdDsp, Dmc4kC, Dmc4kCDsp
// }
//}

79
essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/DmOutputCardBase.cs
View File

@@ -1,79 +0,0 @@
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.Cards;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.DM;
namespace PepperDash.Essentials.DM.Cards
{
/// <summary>
///
/// </summary>
public abstract class DmSingleOutputCardControllerBase// : IRoutingInputsOutputs
{
public string Key { get; private set; }
public uint Slot { get; private set; }
public abstract eDmOutputCardType Type { get; }
//public RoutingInputPort BackplaneAudioIn1 { get; private set; }
//public RoutingInputPort BackplaneVideoIn1 { get; private set; }
//public RoutingInputPort BackplaneAudioIn2 { get; private set; }
//public RoutingInputPort BackplaneVideoIn2 { get; private set; }
//public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
//public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
public DmSingleOutputCardControllerBase(string key, uint cardSlot)
{
Key = key;
Slot = cardSlot;
//BackplaneAudioIn1 = new RoutingInputPort("backplaneAudioIn1", eRoutingSignalType.Audio,
// eRoutingPortConnectionType.BackplaneOnly, cardSlot, this);
//BackplaneVideoIn1 = new RoutingInputPort("backplaneVideoIn1", eRoutingSignalType.Video,
// eRoutingPortConnectionType.BackplaneOnly, cardSlot, this);
//BackplaneAudioIn2 = new RoutingInputPort("backplaneAudioIn2", eRoutingSignalType.Audio,
// eRoutingPortConnectionType.BackplaneOnly, cardSlot + 1, this);
//BackplaneVideoIn2 = new RoutingInputPort("backplaneVideoIn2", eRoutingSignalType.Video,
// eRoutingPortConnectionType.BackplaneOnly, cardSlot + 1, this);
//InputPorts = new RoutingPortCollection<RoutingInputPort>
//{
// BackplaneAudioIn1,
// BackplaneAudioIn2,
// BackplaneVideoIn1,
// BackplaneVideoIn2
//};
//OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
}
///// <summary>
///// Gets a physical port by name. Returns null if doesn't exist
///// </summary>
//public RoutingInputPort GetInputPort(string key)
//{
// return InputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
//}
///// <summary>
///// Gets a physical port by name. Returns null if doesn't exist
///// </summary>
//public RoutingOutputPort GetOutputPort(string key)
//{
// return OutputPorts.FirstOrDefault(p => p.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
//}
}
/// <summary>
///
/// </summary>
public enum eDmOutputCardType
{
None, Dmc4kCoHd, Dmc4kHdo, DmcCoHd, DmcSoHd
}
}

43
essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/Dmc4kCoHdSingleOutputCard.cs
View File

@@ -1,43 +0,0 @@
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.Cards;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.DM;
namespace PepperDash.Essentials.DM.Cards
{
public class Dmc4kCoHdSingleOutputCard : DmSingleOutputCardControllerBase
{
public override eDmOutputCardType Type
{
get { return eDmOutputCardType.Dmc4kCoHd; }
}
public Dmc4kCoHdSingle Card { get; private set; }
//public RoutingOutputPort DmOut1 { get; private set; }
//public RoutingOutputPort DmOut2 { get; private set; }
//public RoutingOutputPort HdmiOut1 { get; private set; }
public Dmc4kCoHdSingleOutputCard(string key, Dmc4kCoHdSingle card, uint slot)
: base(key, slot)
{
Card = card;
//DmOut1 = new RoutingOutputPort(DmPortName.DmOut1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// eRoutingPortConnectionType.DmCat, null, this);
//DmOut2 = new RoutingOutputPort(DmPortName.DmOut2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// eRoutingPortConnectionType.DmCat, null, this);
//HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// eRoutingPortConnectionType.Hdmi, null, this);
//OutputPorts.AddRange(new[] { DmOut1, DmOut2, HdmiOut1 });
}
}
}

46
essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/Dmc4kHdoSingleOutputCard.cs
View File

@@ -1,46 +0,0 @@
//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.Cards;
//using PepperDash.Core;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.DM;
//namespace PepperDash.Essentials.DM.Cards
//{
// public class Dmc4kHdoSingleOutputCard : DmSingleOutputCardControllerBase
// {
// public override eDmOutputCardType Type
// {
// get { return eDmOutputCardType.Dmc4kHdo; }
// }
// public Dmc4kHdoSingle Card { get; private set; }
// //public RoutingOutputPort AudioOut1 { get; private set; }
// //public RoutingOutputPort AudioOut2 { get; private set; }
// //public RoutingOutputPort HdmiOut1 { get; private set; }
// //public RoutingOutputPort HdmiOut2 { get; private set; }
// public Dmc4kHdoSingleOutputCard(string key, Dmc4kHdoSingle card, uint slot)
// : base(key, slot)
// {
// Card = card;
// //AudioOut1 = new RoutingOutputPort(DmPortName.BalancedAudioOut1, eRoutingSignalType.Audio,
// // eRoutingPortConnectionType.LineAudio, null, this);
// //AudioOut2 = new RoutingOutputPort(DmPortName.BalancedAudioOut2, eRoutingSignalType.Audio,
// // eRoutingPortConnectionType.LineAudio, null, this);
// //HdmiOut1 = new RoutingOutputPort(DmPortName.HdmiOut1, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// // eRoutingPortConnectionType.Hdmi, null, this);
// //HdmiOut2 = new RoutingOutputPort(DmPortName.HdmiOut2, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// // eRoutingPortConnectionType.Hdmi, null, this);
// //OutputPorts.AddRange(new[] { AudioOut1, AudioOut2, HdmiOut1, HdmiOut2 });
// }
// }
//}

76
essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/DmcC4kInputCard.cs
View File

@@ -1,76 +0,0 @@
//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.Cards;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.DM;
//namespace PepperDash.Essentials.DM.Cards
//{
// public class Dmc4kCController : DmInputCardControllerBase
// {
// public override eDmInputCardType Type
// {
// get { return eDmInputCardType.Dmc4kC; }
// }
// public Dmc4kC Card { get; private set; }
// //public RoutingInputPortWithVideoStatuses DmIn { get; private set; }
// //public RoutingOutputPort HdmiLoopOut { get; private set; }
// //public RoutingOutputPort AudioLoopOut { get; private set; }
// public Dmc4kCController(string key, Dmc4kC card, uint slot)
// : base(key, slot)
// {
// Card = card;
// //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// // eRoutingPortConnectionType.DmCat, null, this,
// // VideoStatusHelper.GetDmInputStatusFuncs(Card.DmInput));
// //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// // eRoutingPortConnectionType.Hdmi, null, this);
// //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
// // eRoutingPortConnectionType.Hdmi, null, this);
// //InputPorts.Add(DmIn);
// //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
// }
// }
// public class Dmc4kCDspController : DmInputCardControllerBase
// {
// public override eDmInputCardType Type
// {
// get { return eDmInputCardType.Dmc4kCDsp; }
// }
// public Dmc4kCDsp Card { get; private set; }
// //public RoutingInputPortWithVideoStatuses DmIn { get; private set; }
// //public RoutingOutputPort HdmiLoopOut { get; private set; }
// //public RoutingOutputPort AudioLoopOut { get; private set; }
// public Dmc4kCDspController(string key, Dmc4kCDsp card, uint slot)
// : base(key, slot)
// {
// Card = card;
// //DmIn = new RoutingInputPortWithVideoStatuses(DmPortName.DmIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// // eRoutingPortConnectionType.DmCat, null, this,
// // VideoStatusHelper.GetDmInputStatusFuncs(Card.DmInput));
// //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// // eRoutingPortConnectionType.Hdmi, null, this);
// //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
// // eRoutingPortConnectionType.Hdmi, null, this);
// //InputPorts.Add(DmIn);
// //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
// }
// }
//}

82
essentials-framework/Essentials DM/Essentials_DM/Cards REMOVE/DmcHD4kInputCard.cs
View File

@@ -1,82 +0,0 @@
//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.Cards;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.DM;
//namespace PepperDash.Essentials.DM.Cards
//{
// /// <summary>
// ///
// /// </summary>
// public class Dmc4kHdController : DmInputCardControllerBase
// {
// public Dmc4kHd Card { get; private set; }
// public override eDmInputCardType Type
// {
// get { return eDmInputCardType.Dmc4kHd; }
// }
// public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
// public RoutingOutputPort HdmiLoopOut { get; private set; }
// public RoutingOutputPort AudioLoopOut { get; private set; }
// public Dmc4kHdController(string key, Dmc4kHd card, uint slot)
// : base(key, slot)
// {
// Card = card;
// HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// eRoutingPortConnectionType.Hdmi, null, this,
// VideoStatusHelper.GetHdmiInputStatusFuncs(Card.HdmiInput));
// HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// eRoutingPortConnectionType.Hdmi, null, this);
// AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
// eRoutingPortConnectionType.Hdmi, null, this);
// InputPorts.Add(HdmiIn);
// OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
// }
// }
// /// <summary>
// ///
// /// </summary>
// public class Dmc4kHdDspController : DmInputCardControllerBase
// {
// public Dmc4kHdDsp Card { get; private set; }
// public override eDmInputCardType Type
// {
// get { return eDmInputCardType.Dmc4kHdDsp; }
// }
// //public RoutingInputPortWithVideoStatuses HdmiIn { get; private set; }
// //public RoutingOutputPort HdmiLoopOut { get; private set; }
// //public RoutingOutputPort AudioLoopOut { get; private set; }
// public Dmc4kHdDspController(string key, Dmc4kHdDsp card, uint slot)
// : base(key, slot)
// {
// Card = card;
// //HdmiIn = new RoutingInputPortWithVideoStatuses(DmPortName.HdmiIn, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// // eRoutingPortConnectionType.Hdmi, null, this,
// // VideoStatusHelper.GetHdmiInputStatusFuncs(Card.HdmiInput));
// //HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
// // eRoutingPortConnectionType.Hdmi, null, this);
// //AudioLoopOut = new RoutingOutputPort(DmPortName.AudioLoopOut, eRoutingSignalType.Audio,
// // eRoutingPortConnectionType.Hdmi, null, this);
// //InputPorts.Add(HdmiIn);
// //OutputPorts.AddRange(new[] { HdmiLoopOut, AudioLoopOut });
// }
// }
//}

83
essentials-framework/Essentials DM/Essentials_DM/Chassis/Config/Schema/DmChassisControllerPropertiesConfigSchema.json Normal file
View File

@@ -0,0 +1,83 @@
{
"$schema": "http://json-schema.org/draft-03/schema#",
"title": "DmChassisController Properties Config Schema",
"description": "",
"$ref": "EssentialsConfigSchema.json#definitions/Device",
"properties": {
"properties": {
"$ref": "#/propertiesConfig"
}
},
"propertiesConfig": {
"type": "object",
"additionalProperties": true,
"properties": {
"control": {
"required":true,
"type": "object",
"$ref": "../../ControlPropertiesConfigSchema.json#/ControlPropertiesConfig"
},
"volumeControls": {
"title": "Volume Controls",
"type": "object",
"additionalProperties": {
"type": "object",
"$ref": "#/dmAudioCardPropertiesConfig"
}
},
"inputSlots": {
"required":true,
"title": "Input Slots",
"type": "object",
"additionalProperties": {
"type": "string"
}
},
"outputSlots": {
"required":true,
"title": "Output Slots",
"type": "object",
"additionalProperties": {
"type": "string"
}
},
"inputNames": {
"title": "Input Names",
"type": "object",
"additionalProperties": {
"type": "string"
}
},
"outputNames": {
"title": "Output Names",
"type": "object",
"additionalProperties": {
"type": "string"
}
},
"noRouteText": {
"title": "No Route Text",
"type": "string"
},
"inputSlotSupportsHdcp2": {
"type": "object",
"additionalProperties": {
"type": "boolean"
}
}
}
},
"dmAudioCardPropertiesConfig": {
"type": "object",
"properties": {
"OutLevel": {
"title": "Output Level",
"type": "integer"
},
"isVolumeControlPoint": {
"title": "Volume Control Point?",
"type": "boolean"
}
}
}
}

114
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmChassisController.cs
View File

@@ -66,6 +66,11 @@ namespace PepperDash.Essentials.DM
public const int RouteOffTime = 500;
Dictionary<PortNumberType, CTimer> RouteOffTimers = new Dictionary<PortNumberType, CTimer>();
/// <summary>
/// Text that represents when an output has no source routed to it
/// </summary>
public string NoRouteText = "";
/// <summary>
/// Factory method to create a new chassis controller from config data. Limited to 8x8 right now
/// </summary>
@@ -99,9 +104,12 @@ namespace PepperDash.Essentials.DM
}
var controller = new DmChassisController(key, name, chassis);
// add the cards and port names
foreach (var kvp in properties.InputSlots)
controller.AddInputCard(kvp.Value, kvp.Key);
foreach (var kvp in properties.InputSlots)
{
controller.AddInputCard(kvp.Value, kvp.Key);
}
foreach (var kvp in properties.OutputSlots)
{
controller.AddOutputCard(kvp.Value, kvp.Key);
@@ -128,6 +136,15 @@ namespace PepperDash.Essentials.DM
controller.InputNames = properties.InputNames;
controller.OutputNames = properties.OutputNames;
if (!string.IsNullOrEmpty(properties.NoRouteText))
{
controller.NoRouteText = properties.NoRouteText;
Debug.Console(1, controller, "Setting No Route Text value to: {0}", controller.NoRouteText);
}
else
Debug.Console(1, controller, "NoRouteText not specified. Defaulting to blank string.", controller.NoRouteText);
controller.PropertiesConfig = properties;
return controller;
}
@@ -174,11 +191,18 @@ namespace PepperDash.Essentials.DM
SystemIdBusyFeedback = new BoolFeedback(() => { return (Chassis as DmMDMnxn).SystemIdBusy.BoolValue; });
InputCardHdcpCapabilityFeedbacks = new Dictionary<uint, IntFeedback>();
InputCardHdcpCapabilityTypes = new Dictionary<uint, eHdcpCapabilityType>();
}
public override bool CustomActivate()
{
Debug.Console(2, this, "Setting up feedbacks.");
for (uint x = 1; x <= Chassis.NumberOfOutputs; x++)
// Setup Output Card Feedbacks
for (uint x = 1; x <= Chassis.NumberOfOutputs; x++)
{
var tempX = x;
var tempX = x;
Debug.Console(2, this, "Setting up feedbacks for output slot: {0}", tempX);
if (Chassis.Outputs[tempX] != null)
{
@@ -217,30 +241,45 @@ namespace PepperDash.Essentials.DM
}
else
{
return "";
return NoRouteText;
}
});
OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() =>
{
if (Chassis.Outputs[tempX].AudioOutFeedback != null)
{
if (Chassis.Outputs[tempX].AudioOutFeedback != null)
{
return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
}
else
{
return "";
return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
}
else
{
return NoRouteText;
}
});
}
});
OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() =>
OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() =>
{
return Chassis.Outputs[tempX].EndpointOnlineFeedback;
});
}
else
{
Debug.Console(2, this, "No Output Card defined in slot: {0}", tempX);
}
};
// Setup Input Card Feedbacks
for (uint x = 1; x <= Chassis.NumberOfInputs; x++)
{
var tempX = x;
Debug.Console(2, this, "Setting up feedbacks for input slot: {0}", tempX);
CheckForHdcp2Property(tempX);
if (Chassis.Inputs[tempX] != null)
{
UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() =>
{
if (Chassis.Inputs[tempX].USBRoutedToFeedback != null) { return (ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number; }
@@ -265,7 +304,7 @@ namespace PepperDash.Essentials.DM
}
});
InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() =>
InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() =>
{
return Chassis.Inputs[tempX].EndpointOnlineFeedback;
});
@@ -274,6 +313,8 @@ namespace PepperDash.Essentials.DM
{
var inputCard = Chassis.Inputs[tempX];
Debug.Console(2, this, "Adding InputCardHdcpCapabilityFeedback for slot: {0}", inputCard);
if (inputCard.Card is DmcHd)
{
InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
@@ -328,8 +369,32 @@ namespace PepperDash.Essentials.DM
return 0;
});
}
}
}
else
{
Debug.Console(2, this, "No Input Card defined in slot: {0}", tempX);
}
}
return base.CustomActivate();
}
/// <summary>
/// Checks for presence of config property defining if the input card supports HDCP2.
/// If not found, assumes false.
/// </summary>
/// <param name="inputSlot">Input Slot</param>
void CheckForHdcp2Property(uint inputSlot)
{
if (!PropertiesConfig.InputSlotSupportsHdcp2.ContainsKey(inputSlot))
{
Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
@"Properties Config does not define inputSlotSupportsHdcp2 entry for input card: {0}. Assuming false.
If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", inputSlot);
PropertiesConfig.InputSlotSupportsHdcp2.Add(inputSlot, false);
}
else
Debug.Console(2, this, "inputSlotSupportsHdcp2 for input card: {0} = {1}", inputSlot, PropertiesConfig.InputSlotSupportsHdcp2[inputSlot]);
}
/// <summary>
///
@@ -552,6 +617,13 @@ namespace PepperDash.Essentials.DM
var cecPort2 = outputCard.Card2.HdmiOutput;
AddDmcHdoPorts(number, cecPort1, cecPort2);
}
else if (type == "dmc4kzhdo")
{
var outputCard = new Dmc4kzHdoSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
var cecPort2 = outputCard.Card2.HdmiOutput;
AddDmcHdoPorts(number, cecPort1, cecPort2);
}
else if (type == "dmchdo")
{
var outputCard = new DmcHdoSingle(number, Chassis);
@@ -565,13 +637,13 @@ namespace PepperDash.Essentials.DM
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
else if (type == "dmc4kzcohd")
{
else if (type == "dmc4kzcohd")
{
var outputCard = new Dmc4kzCoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;
AddDmcCoPorts(number, cecPort1);
}
else if (type == "dmccohd")
else if (type == "dmccohd")
{
var outputCard = new DmcCoHdSingle(number, Chassis);
var cecPort1 = outputCard.Card1.HdmiOutput;

12
essentials-framework/Essentials DM/Essentials_DM/Chassis/DmpsRoutingController.cs
View File

@@ -48,6 +48,11 @@ namespace PepperDash.Essentials.DM
public const int RouteOffTime = 500;
Dictionary<PortNumberType, CTimer> RouteOffTimers = new Dictionary<PortNumberType, CTimer>();
/// <summary>
/// Text that represents when an output has no source routed to it
/// </summary>
public string NoRouteText = "";
public static DmpsRoutingController GetDmpsRoutingController(string key, string name,
DmpsRoutingPropertiesConfig properties)
{
@@ -67,6 +72,9 @@ namespace PepperDash.Essentials.DM
controller.InputNames = properties.InputNames;
controller.OutputNames = properties.OutputNames;
if (!string.IsNullOrEmpty(properties.NoRouteText))
controller.NoRouteText = properties.NoRouteText;
return controller;
}
@@ -191,7 +199,7 @@ namespace PepperDash.Essentials.DM
}
else
{
return "";
return NoRouteText;
}
});
OutputAudioRouteNameFeedbacks[outputCard.Number] = new StringFeedback(() =>
@@ -202,7 +210,7 @@ namespace PepperDash.Essentials.DM
}
else
{
return "";
return NoRouteText;
}
});

4
essentials-framework/Essentials DM/Essentials_DM/Config/DMChassisConfig.cs
View File

@@ -5,7 +5,6 @@ using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.DM.Cards;
namespace PepperDash.Essentials.DM.Config
{
@@ -32,6 +31,9 @@ namespace PepperDash.Essentials.DM.Config
[JsonProperty("outputNames")]
public Dictionary<uint, string> OutputNames { get; set; }
[JsonProperty("noRouteText")]
public string NoRouteText { get; set; }
[JsonProperty("inputSlotSupportsHdcp2")]
public Dictionary<uint, bool> InputSlotSupportsHdcp2 { get; set; }

1
essentials-framework/Essentials DM/Essentials_DM/Config/DmRmcConfig.cs
View File

@@ -4,7 +4,6 @@ using Crestron.SimplSharpPro.DM;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PepperDash.Core;
using PepperDash.Essentials.DM.Cards;
namespace PepperDash.Essentials.DM.Config
{

1
essentials-framework/Essentials DM/Essentials_DM/Config/DmTxConfig.cs
View File

@@ -4,7 +4,6 @@ using Crestron.SimplSharpPro.DM;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PepperDash.Core;
using PepperDash.Essentials.DM.Cards;
namespace PepperDash.Essentials.DM.Config
{

4
essentials-framework/Essentials DM/Essentials_DM/Config/DmpsRoutingConfig.cs
View File

@@ -5,7 +5,6 @@ using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.DM.Cards;
namespace PepperDash.Essentials.DM.Config
{
@@ -20,6 +19,9 @@ namespace PepperDash.Essentials.DM.Config
[JsonProperty("outputNames")]
public Dictionary<uint, string> OutputNames { get; set; }
[JsonProperty("noRouteText")]
public string NoRouteText { get; set; }
public DmpsRoutingPropertiesConfig()
{
InputNames = new Dictionary<uint, string>();

19
essentials-framework/Essentials DM/Essentials_DM/Endpoints/NVX/DmNvx35xController.cs
View File

@@ -1,19 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro.DM.Streaming;
//using PepperDash.Core;
//using PepperDash.Essentials.Core;
//namespace PepperDash.Essentials.DM.Endpoints.NVX
//{
// public class DmNvx35xController: DmNvxControllerBase
// {
// }
//}

30
essentials-framework/Essentials DM/Essentials_DM/Endpoints/NVX/DmNvxConfig.cs
View File

@@ -1,30 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro.DM.Streaming;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PepperDash.Core;
namespace PepperDash.Essentials.DM.Endpoints.NVX
{
/// <summary>
/// Represents the "properties" property of a DM NVX device config
/// </summary>
public class DmNvxConfig
{
[JsonProperty("control")]
public ControlPropertiesConfig Control { get; set; }
[JsonProperty("parrentDeviceKey")]
public string ParentDeviceKey { get; set; }
[JsonProperty("deviceMode")]
public eDeviceMode DeviceMode { get; set; }
}
}

30
essentials-framework/Essentials DM/Essentials_DM/Endpoints/NVX/DmNvxControllerBase.cs
View File

@@ -1,30 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DM.Streaming;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM.Endpoints.NVX
{
public abstract class DmNvxControllerBase: CrestronGenericBaseDevice
{
public DmNvx35x DmNvx { get; private set; }
public abstract StringFeedback ActiveVideoInputFeedback { get; protected set; }
public RoutingInputPortWithVideoStatuses AnyVideoInput { get; protected set; }
public DmNvxControllerBase(string key, string name, DmNvxBaseClass hardware)
: base(key, name, hardware)
{
AddToFeedbackList(ActiveVideoInputFeedback);
}
}
}

67
essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx200Controller.cs
View File

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.DM
/// <summary>
/// Controller class for all DM-TX-201C/S/F transmitters
/// </summary>
public class DmTx200Controller : DmTxControllerBase, ITxRouting, IHasFeedback
public class DmTx200Controller : DmTxControllerBase, ITxRouting, IHasFeedback, IHasFreeRun, IVgaBrightnessContrastControls
{
public DmTx200C2G Tx { get; private set; }
@@ -32,8 +32,10 @@ namespace PepperDash.Essentials.DM
public IntFeedback AudioSourceNumericFeedback { get; protected set; }
public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; }
//public override IntFeedback HdcpSupportAllFeedback { get; protected set; }
//public override ushort HdcpSupportCapability { get; protected set; }
public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
public IntFeedback VgaBrightnessFeedback { get; protected set; }
public IntFeedback VgaContrastFeedback { get; protected set; }
/// <summary>
/// Helps get the "real" inputs, including when in Auto
@@ -115,7 +117,7 @@ namespace PepperDash.Essentials.DM
HdmiInHdcpCapabilityFeedback = new IntFeedback("HdmiInHdcpCapability", () =>
{
if (tx.HdmiInput.HdpcSupportOnFeedback.BoolValue)
if (tx.HdmiInput.HdcpSupportOnFeedback.BoolValue)
return 1;
else
return 0;
@@ -123,6 +125,14 @@ namespace PepperDash.Essentials.DM
HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
var combinedFuncs = new VideoStatusFuncsWrapper
{
HdcpActiveFeedbackFunc = () =>
@@ -170,6 +180,21 @@ namespace PepperDash.Essentials.DM
DmOutput.Port = Tx.DmOutput;
}
void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
{
var id = args.EventId;
Debug.Console(2, this, "EventId {0}", args.EventId);
if (id == VideoControlsEventIds.BrightnessFeedbackEventId)
{
VgaBrightnessFeedback.FireUpdate();
}
else if (id == VideoControlsEventIds.ContrastFeedbackEventId)
{
VgaContrastFeedback.FireUpdate();
}
}
void Tx_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
{
ActiveVideoInputFeedback.FireUpdate();
@@ -191,6 +216,40 @@ namespace PepperDash.Essentials.DM
return base.CustomActivate();
}
/// <summary>
/// Enables or disables free run
/// </summary>
/// <param name="enable"></param>
public void SetFreeRunEnabled(bool enable)
{
if (enable)
{
Tx.VgaInput.FreeRun = eDmFreeRunSetting.Enabled;
}
else
{
Tx.VgaInput.FreeRun = eDmFreeRunSetting.Disabled;
}
}
/// <summary>
/// Sets the VGA brightness level
/// </summary>
/// <param name="level"></param>
public void SetVgaBrightness(ushort level)
{
Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
}
/// <summary>
/// Sets the VGA contrast level
/// </summary>
/// <param name="level"></param>
public void SetVgaContrast(ushort level)
{
Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
}
public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
{
Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);

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

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.DM
/// <summary>
/// Controller class for all DM-TX-201C/S/F transmitters
/// </summary>
public class DmTx201XController : DmTxControllerBase, ITxRouting, IHasFeedback
public class DmTx201XController : DmTxControllerBase, ITxRouting, IHasFeedback, IHasFreeRun, IVgaBrightnessContrastControls
{
public DmTx201S Tx { get; private set; } // uses the 201S class as it is the base class for the 201C
@@ -33,8 +33,10 @@ namespace PepperDash.Essentials.DM
public IntFeedback AudioSourceNumericFeedback { get; protected set; }
public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; }
//public override IntFeedback HdcpSupportAllFeedback { get; protected set; }
//public override ushort HdcpSupportCapability { get; protected set; }
public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
public IntFeedback VgaBrightnessFeedback { get; protected set; }
public IntFeedback VgaContrastFeedback { get; protected set; }
/// <summary>
/// Helps get the "real" inputs, including when in Auto
@@ -116,12 +118,19 @@ namespace PepperDash.Essentials.DM
HdmiInHdcpCapabilityFeedback = new IntFeedback("HdmiInHdcpCapability", () =>
{
if (tx.HdmiInput.HdpcSupportOnFeedback.BoolValue)
if (tx.HdmiInput.HdcpSupportOnFeedback.BoolValue)
return 1;
else
return 0;
});
FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
var combinedFuncs = new VideoStatusFuncsWrapper
@@ -156,7 +165,7 @@ namespace PepperDash.Essentials.DM
};
AnyVideoInput = new RoutingInputPortWithVideoStatuses(DmPortName.AnyVideoIn,
eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.None, 0, this, combinedFuncs);
DmOutput = new RoutingOutputPort(DmPortName.DmOut, eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, null, this);
HdmiLoopOut = new RoutingOutputPort(DmPortName.HdmiLoopOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
@@ -174,6 +183,21 @@ namespace PepperDash.Essentials.DM
DmOutput.Port = Tx.DmOutput;
}
void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
{
var id = args.EventId;
Debug.Console(2, this, "EventId {0}", args.EventId);
if (id == VideoControlsEventIds.BrightnessFeedbackEventId)
{
VgaBrightnessFeedback.FireUpdate();
}
else if (id == VideoControlsEventIds.ContrastFeedbackEventId)
{
VgaContrastFeedback.FireUpdate();
}
}
void Tx_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
{
ActiveVideoInputFeedback.FireUpdate();
@@ -183,8 +207,7 @@ namespace PepperDash.Essentials.DM
}
public override bool CustomActivate()
{
{
Tx.HdmiInput.InputStreamChange += (o, a) => FowardInputStreamChange(HdmiInput, a.EventId);
Tx.HdmiInput.VideoAttributes.AttributeChange += (o, a) => FireVideoAttributeChange(HdmiInput, a.EventId);
@@ -195,6 +218,46 @@ namespace PepperDash.Essentials.DM
return base.CustomActivate();
}
/// <summary>
/// Enables or disables free run
/// </summary>
/// <param name="enable"></param>
public void SetFreeRunEnabled(bool enable)
{
if (enable)
{
Tx.VgaInput.FreeRun = eDmFreeRunSetting.Enabled;
}
else
{
Tx.VgaInput.FreeRun = eDmFreeRunSetting.Disabled;
}
}
/// <summary>
/// Sets the VGA brightness level
/// </summary>
/// <param name="level"></param>
public void SetVgaBrightness(ushort level)
{
Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
}
/// <summary>
/// Sets the VGA contrast level
/// </summary>
/// <param name="level"></param>
public void SetVgaContrast(ushort level)
{
Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
}
/// <summary>
/// Switches the audio/video source based on the integer value (0-Auto, 1-HDMI, 2-VGA, 3-Disable)
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="type"></param>
public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
{
Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);
@@ -250,6 +313,7 @@ namespace PepperDash.Essentials.DM
Debug.Console(2, this, " Audio Source: {0}", Tx.AudioSourceFeedback);
AudioSourceNumericFeedback.FireUpdate();
}
}
void InputStreamChangeEvent(EndpointInputStream inputStream, EndpointInputStreamEventArgs args)
@@ -264,6 +328,10 @@ namespace PepperDash.Essentials.DM
{
HdmiInHdcpCapabilityFeedback.FireUpdate();
}
else if (args.EventId == EndpointInputStreamEventIds.FreeRunFeedbackEventId)
{
FreeRunEnabledFeedback.FireUpdate();
}
}
/// <summary>

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

@@ -17,7 +17,7 @@ namespace PepperDash.Essentials.DM
{
using eVst = DmTx401C.eSourceSelection;
public class DmTx401CController : DmTxControllerBase, ITxRouting, IHasFeedback, IIROutputPorts, IComPorts
public class DmTx401CController : DmTxControllerBase, ITxRouting, IHasFeedback, IIROutputPorts, IComPorts, IHasFreeRun, IVgaBrightnessContrastControls
{
public DmTx401C Tx { get; private set; }
@@ -34,6 +34,11 @@ namespace PepperDash.Essentials.DM
public IntFeedback AudioSourceNumericFeedback { get; protected set; }
public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; }
public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
public IntFeedback VgaBrightnessFeedback { get; protected set; }
public IntFeedback VgaContrastFeedback { get; protected set; }
/// <summary>
/// Helps get the "real" inputs, including when in Auto
/// </summary>
@@ -122,7 +127,7 @@ namespace PepperDash.Essentials.DM
HdmiInHdcpCapabilityFeedback = new IntFeedback("HdmiInHdcpCapability", () =>
{
if (tx.HdmiInput.HdpcSupportOnFeedback.BoolValue)
if (tx.HdmiInput.HdcpSupportOnFeedback.BoolValue)
return 1;
else
return 0;
@@ -130,6 +135,13 @@ namespace PepperDash.Essentials.DM
HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
var combinedFuncs = new VideoStatusFuncsWrapper
{
HdcpActiveFeedbackFunc = () =>
@@ -269,6 +281,55 @@ namespace PepperDash.Essentials.DM
}
}
void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
{
var id = args.EventId;
Debug.Console(2, this, "EventId {0}", args.EventId);
if (id == VideoControlsEventIds.BrightnessFeedbackEventId)
{
VgaBrightnessFeedback.FireUpdate();
}
else if (id == VideoControlsEventIds.ContrastFeedbackEventId)
{
VgaContrastFeedback.FireUpdate();
}
}
/// <summary>
/// Enables or disables free run
/// </summary>
/// <param name="enable"></param>
public void SetFreeRunEnabled(bool enable)
{
if (enable)
{
Tx.VgaInput.FreeRun = eDmFreeRunSetting.Enabled;
}
else
{
Tx.VgaInput.FreeRun = eDmFreeRunSetting.Disabled;
}
}
/// <summary>
/// Sets the VGA brightness level
/// </summary>
/// <param name="level"></param>
public void SetVgaBrightness(ushort level)
{
Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
}
/// <summary>
/// Sets the VGA contrast level
/// </summary>
/// <param name="level"></param>
public void SetVgaContrast(ushort level)
{
Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
}
/// <summary>
/// Relays the input stream change to the appropriate RoutingInputPort.
/// </summary>

66
essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4k302CController.cs
View File

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.DM
using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
public class DmTx4k302CController : DmTxControllerBase, ITxRouting, IHasFeedback,
IIROutputPorts, IComPorts
IIROutputPorts, IComPorts, IHasFreeRun, IVgaBrightnessContrastControls
{
public DmTx4k302C Tx { get; private set; }
@@ -35,8 +35,10 @@ namespace PepperDash.Essentials.DM
public IntFeedback HdmiIn1HdcpCapabilityFeedback { get; protected set; }
public IntFeedback HdmiIn2HdcpCapabilityFeedback { get; protected set; }
//public override IntFeedback HdcpSupportAllFeedback { get; protected set; }
//public override ushort HdcpSupportCapability { get; protected set; }
public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
public IntFeedback VgaBrightnessFeedback { get; protected set; }
public IntFeedback VgaContrastFeedback { get; protected set; }
/// <summary>
/// Helps get the "real" inputs, including when in Auto
@@ -122,6 +124,13 @@ namespace PepperDash.Essentials.DM
HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
var combinedFuncs = new VideoStatusFuncsWrapper
{
@@ -181,6 +190,21 @@ namespace PepperDash.Essentials.DM
DmOut.Port = Tx.DmOutput;
}
void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
{
var id = args.EventId;
Debug.Console(2, this, "EventId {0}", args.EventId);
if (id == VideoControlsEventIds.BrightnessFeedbackEventId)
{
VgaBrightnessFeedback.FireUpdate();
}
else if (id == VideoControlsEventIds.ContrastFeedbackEventId)
{
VgaContrastFeedback.FireUpdate();
}
}
public override bool CustomActivate()
@@ -199,6 +223,42 @@ namespace PepperDash.Essentials.DM
return base.CustomActivate();
}
/// <summary>
/// Enables or disables free run
/// </summary>
/// <param name="enable"></param>
public void SetFreeRunEnabled(bool enable)
{
if (enable)
{
Tx.VgaInput.FreeRun = eDmFreeRunSetting.Enabled;
}
else
{
Tx.VgaInput.FreeRun = eDmFreeRunSetting.Disabled;
}
}
/// <summary>
/// Sets the VGA brightness level
/// </summary>
/// <param name="level"></param>
public void SetVgaBrightness(ushort level)
{
Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
}
/// <summary>
/// Sets the VGA contrast level
/// </summary>
/// <param name="level"></param>
public void SetVgaContrast(ushort level)
{
Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
}
public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
{
Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);

32
essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/TxInterfaces.cs Normal file
View File

@@ -0,0 +1,32 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM
{
/// <summary>
/// Defines a device capable of setting the Free Run state of a VGA input and reporting feedback
/// </summary>
public interface IHasFreeRun
{
BoolFeedback FreeRunEnabledFeedback { get; }
void SetFreeRunEnabled(bool enable);
}
/// <summary>
/// Defines a device capable of adjusting VGA settings
/// </summary>
public interface IVgaBrightnessContrastControls
{
IntFeedback VgaBrightnessFeedback { get; }
IntFeedback VgaContrastFeedback { get; }
void SetVgaBrightness(ushort level);
void SetVgaContrast(ushort level);
}
}

18
essentials-framework/Essentials DM/Essentials_DM/Essentials_DM.csproj
View File

@@ -82,6 +82,10 @@
<HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpPro.exe</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="SimplSharpReflectionInterface, Version=1.0.5583.25238, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
<SpecificVersion>False</SpecificVersion>
<HintPath>..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpReflectionInterface.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Data" />
@@ -89,12 +93,6 @@
<ItemGroup>
<Compile Include="AirMedia\AirMediaPropertiesConfig.cs" />
<Compile Include="AirMedia\AirMediaController.cs" />
<Compile Include="Cards REMOVE\Dmc4kHdoSingleOutputCard.cs" />
<Compile Include="Cards REMOVE\Dmc4kCoHdSingleOutputCard.cs" />
<Compile Include="Cards REMOVE\DmOutputCardBase.cs" />
<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" />
@@ -102,6 +100,7 @@
<Compile Include="Chassis\DmpsInternalVirtualDmTxController.cs" />
<Compile Include="Chassis\DmpsRoutingController.cs" />
<Compile Include="Chassis\HdMdNxM4kEController.cs" />
<Compile Include="Endpoints\Transmitters\TxInterfaces.cs" />
<Compile Include="IDmSwitch.cs" />
<Compile Include="Config\DmpsRoutingConfig.cs" />
<Compile Include="Config\DmRmcConfig.cs" />
@@ -110,9 +109,6 @@
<Compile Include="Config\HdMdNxM4kEPropertiesConfig.cs" />
<Compile Include="Config\InputPropertiesConfig.cs" />
<Compile Include="DmPortName.cs" />
<Compile Include="Endpoints\NVX\DmNvx35xController.cs" />
<Compile Include="Endpoints\NVX\DmNvxConfig.cs" />
<Compile Include="Endpoints\NVX\DmNvxControllerBase.cs" />
<Compile Include="Endpoints\DGEs\DgeController.cs" />
<Compile Include="Endpoints\DGEs\DgePropertiesConfig.cs" />
<Compile Include="DmLite\HdMdxxxCEController.cs" />
@@ -141,10 +137,6 @@
<Compile Include="Extensions.cs" />
<Compile Include="Config\DeviceFactory.cs" />
<Compile Include="IDmHdmiInputExtensions.cs" />
<Compile Include="MOVE IBasicVideoStatusFeedbacks.cs" />
<Compile Include="Nvx\NvxDirectorController.cs">
<SubType>Code</SubType>
</Compile>
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="VideoStatusHelpers.cs" />
<None Include="app.config" />

19
essentials-framework/Essentials DM/Essentials_DM/MOVE IBasicVideoStatusFeedbacks.cs
View File

@@ -1,19 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.DM
{
public interface IBasicVideoStatusFeedbacks
{
BoolFeedback HasVideoStatusFeedback { get; }
BoolFeedback HdcpActiveFeedback { get; }
StringFeedback HdcpStateFeedback { get; }
StringFeedback VideoResolutionFeedback { get; }
BoolFeedback VideoSyncFeedback { get; }
}
}

746
essentials-framework/Essentials DM/Essentials_DM/Nvx/NvxDirectorController.cs
View File

@@ -1,746 +0,0 @@
//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.Streaming;
//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
//{
// /// <summary>
// /// Builds a controller for basic DM-RMCs with Com and IR ports and no control functions
// ///
// /// </summary>
// public class NvxDirectorController : CrestronGenericBaseDevice, IRoutingInputsOutputs, IRouting, IHasFeedback//, ICardPortsDevice
// {
// public NvxDirectorController 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; }
// // 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 NvxDirectorController GetNvxDirectorController(string key, string name,
// string type, DMChassisPropertiesConfig properties)
// {
// try
// {
// type = type.ToLower();
// uint ipid = properties.Control.IpIdInt; // Convert.ToUInt16(properties.Id, 16);
// NvxDirectorController controller = null;
// if (type == "dmmd8x8")
// {
// controller = new NvxDirectorController(key, name, new DmMd8x8(ipid, Global.ControlSystem));
// // add the cards and port names
// foreach (var kvp in properties.InputSlots)
// controller.AddInputCard(kvp.Value, kvp.Key);
// foreach (var kvp in properties.OutputSlots) {
// controller.AddOutputCard(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 DmcHdo)
// audio = (card as DmcHdo).Audio;
// else if (card is Dmc4kHdo)
// audio = (card as Dmc4kHdo).Audio;
// if (audio == null)
// continue;
// // wire up the audio to something here...
// controller.AddVolumeControl(outNum, audio);
// }
// controller.InputNames = properties.InputNames;
// controller.OutputNames = properties.OutputNames;
// return controller;
// }
// else if (type == "dmmd16x16") {
// controller = new NvxDirectorController(key, name, new DmMd16x16(ipid, Global.ControlSystem));
// // add the cards and port names
// foreach (var kvp in properties.InputSlots)
// controller.AddInputCard(kvp.Value, kvp.Key);
// foreach (var kvp in properties.OutputSlots) {
// controller.AddOutputCard(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 DmcHdo)
// audio = (card as DmcHdo).Audio;
// else if (card is Dmc4kHdo)
// audio = (card as Dmc4kHdo).Audio;
// if (audio == null)
// continue;
// // wire up the audio to something here...
// controller.AddVolumeControl(outNum, audio);
// }
// controller.InputNames = properties.InputNames;
// controller.OutputNames = properties.OutputNames;
// 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 NvxDirectorController(string key, string name, DmMDMnxn 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);
// //IsOnline.OutputChange += new EventHandler<EventArgs>(this.IsOnline_OutputChange);
// Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
// //Chassis.DMSystemChange += new DMSystemEventHandler(Chassis_DMSystemChange);
// Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
// VideoOutputFeedbacks = new Dictionary<uint, IntFeedback>();
// AudioOutputFeedbacks = 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>();
// for (uint x = 1; x <= Chassis.NumberOfOutputs; x++)
// {
// var tempX = x;
// VideoOutputFeedbacks[tempX] = new IntFeedback(() => {
// if (Chassis.Outputs[tempX].VideoOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number;}
// else { return 0; };
// });
// AudioOutputFeedbacks[tempX] = new IntFeedback(() => {
// if (Chassis.Outputs[tempX].AudioOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number; }
// else { return 0; };
// });
// VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {
// return Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue;
// });
// InputNameFeedbacks[tempX] = new StringFeedback(() => {
// if (Chassis.Inputs[tempX].NameFeedback.StringValue != null)
// {
// return Chassis.Inputs[tempX].NameFeedback.StringValue;
// }
// else
// {
// return "";
// }
// });
// OutputNameFeedbacks[tempX] = new StringFeedback(() => {
// if (Chassis.Outputs[tempX].NameFeedback.StringValue != 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 "";
// }
// });
// OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() =>
// {
// if (Chassis.Outputs[tempX].AudioOutFeedback != null)
// {
// return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
// }
// else
// {
// return "";
// }
// });
// InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Inputs[tempX].EndpointOnlineFeedback; });
// OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Outputs[tempX].EndpointOnlineFeedback; });
// }
// }
// /// <summary>
// ///
// /// </summary>
// /// <param name="type"></param>
// /// <param name="number"></param>
// public void AddInputCard(string type, uint number)
// {
// Debug.Console(2, this, "Adding input card '{0}', slot {1}", type, number);
// if (type == "dmcHd")
// {
// var inputCard = new DmcHd(number, this.Chassis);
// var cecPort = inputCard.HdmiInput as ICec;
// AddHdmiInCardPorts(number, cecPort);
// }
// else if (type == "dmcHdDsp")
// {
// var inputCard = new DmcHdDsp(number, this.Chassis);
// var cecPort = inputCard.HdmiInput as ICec;
// AddHdmiInCardPorts(number, cecPort);
// }
// else if (type == "dmc4kHd")
// {
// var inputCard = new Dmc4kHd(number, this.Chassis);
// var cecPort = inputCard.HdmiInput as ICec;
// AddHdmiInCardPorts(number, cecPort);
// }
// else if (type == "dmc4kHdDsp")
// {
// var inputCard = new Dmc4kHdDsp(number, this.Chassis);
// var cecPort = inputCard.HdmiInput as ICec;
// AddHdmiInCardPorts(number, cecPort);
// }
// else if (type == "dmc4kzHd")
// {
// var inputCard = new Dmc4kzHd(number, this.Chassis);
// var cecPort = inputCard.HdmiInput as ICec;
// AddHdmiInCardPorts(number, cecPort);
// }
// else if (type == "dmc4kzHdDsp")
// {
// var inputCard = new Dmc4kzHdDsp(number, this.Chassis);
// var cecPort = inputCard.HdmiInput as ICec;
// AddHdmiInCardPorts(number, cecPort);
// }
// else if (type == "dmcC")
// {
// new DmcC(number, this.Chassis);
// AddDmInCardPorts(number);
// }
// else if (type == "dmcCDsp")
// {
// new DmcCDsp(number, this.Chassis);
// AddDmInCardPorts(number);
// }
// else if (type == "dmc4kC")
// {
// new Dmc4kC(number, this.Chassis);
// AddDmInCardPorts(number);
// }
// else if (type == "dmc4kCDsp")
// {
// new Dmc4kCDsp(number, this.Chassis);
// AddDmInCardPorts(number);
// }
// else if (type == "dmc4kzC")
// {
// new Dmc4kzC(number, this.Chassis);
// AddDmInCardPorts(number);
// }
// else if (type == "dmc4kzCDsp")
// {
// new Dmc4kzCDsp(number, this.Chassis);
// AddDmInCardPorts(number);
// }
// else if (type == "dmcCat")
// {
// new DmcCat(number, this.Chassis);
// AddDmInCardPorts(number);
// }
// else if (type == "dmcCatDsp")
// {
// new DmcCatDsp(number, this.Chassis);
// AddDmInCardPorts(number);
// }
// else if (type == "dmcS")
// {
// new DmcS(number, Chassis);
// AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
// AddInCardHdmiAndAudioLoopPorts(number);
// }
// else if (type == "dmcSDsp")
// {
// new DmcSDsp(number, Chassis);
// AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber);
// AddInCardHdmiAndAudioLoopPorts(number);
// }
// else if (type == "dmcS2")
// {
// new DmcS2(number, Chassis);
// AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber);
// AddInCardHdmiAndAudioLoopPorts(number);
// }
// else if (type == "dmcS2Dsp")
// {
// new DmcS2Dsp(number, Chassis);
// AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber);
// AddInCardHdmiAndAudioLoopPorts(number);
// }
// else if (type == "dmcSdi")
// {
// new DmcSdi(number, Chassis);
// AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi);
// AddOutputPortWithDebug(number, "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi, null);
// AddInCardHdmiAndAudioLoopPorts(number);
// }
// else if (type == "dmcDvi")
// {
// new DmcDvi(number, Chassis);
// AddInputPortWithDebug(number, "dviIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Dvi);
// AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
// AddInCardHdmiLoopPort(number);
// }
// else if (type == "dmcVga")
// {
// new DmcVga(number, Chassis);
// AddInputPortWithDebug(number, "vgaIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Vga);
// AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
// AddInCardHdmiLoopPort(number);
// }
// else if (type == "dmcVidBnc")
// {
// new DmcVidBnc(number, Chassis);
// AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
// AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
// AddInCardHdmiLoopPort(number);
// }
// else if (type == "dmcVidRcaA")
// {
// new DmcVidRcaA(number, Chassis);
// AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
// AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio);
// AddInCardHdmiLoopPort(number);
// }
// else if (type == "dmcVidRcaD")
// {
// new DmcVidRcaD(number, Chassis);
// AddInputPortWithDebug(number, "componentIn", eRoutingSignalType.Video, eRoutingPortConnectionType.Component);
// AddInputPortWithDebug(number, "audioIn", eRoutingSignalType.Audio, eRoutingPortConnectionType.DigitalAudio);
// AddInCardHdmiLoopPort(number);
// }
// else if (type == "dmcVid4")
// {
// new DmcVid4(number, Chassis);
// AddInputPortWithDebug(number, "compositeIn1", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
// AddInputPortWithDebug(number, "compositeIn2", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
// AddInputPortWithDebug(number, "compositeIn3", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
// AddInputPortWithDebug(number, "compositeIn4", eRoutingSignalType.Video, eRoutingPortConnectionType.Composite);
// AddInCardHdmiLoopPort(number);
// }
// else if (type == "dmcStr")
// {
// new DmcStr(number, Chassis);
// AddInputPortWithDebug(number, "streamIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming);
// AddInCardHdmiAndAudioLoopPorts(number);
// }
// }
// void AddDmInCardPorts(uint number)
// {
// AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat);
// AddInCardHdmiAndAudioLoopPorts(number);
// }
// void AddHdmiInCardPorts(uint number, ICec cecPort)
// {
// AddInputPortWithDebug(number, "hdmiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, cecPort);
// AddInCardHdmiAndAudioLoopPorts(number);
// }
// void AddInCardHdmiAndAudioLoopPorts(uint number)
// {
// AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
// AddOutputPortWithDebug(number, "audioLoopOut", eRoutingSignalType.Audio, eRoutingPortConnectionType.Hdmi, null);
// }
// void AddInCardHdmiLoopPort(uint number)
// {
// AddOutputPortWithDebug(number, "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
// }
// /// <summary>
// ///
// /// </summary>
// /// <param name="type"></param>
// /// <param name="number"></param>
// public void AddOutputCard(string type, uint number)
// {
// Debug.Console(2, this, "Adding output card '{0}', slot {1}", type, number);
// if (type == "dmc4kHdo")
// {
// var outputCard = new Dmc4kHdoSingle(number, Chassis);
// var cecPort1 = outputCard.Card1.HdmiOutput;
// var cecPort2 = outputCard.Card2.HdmiOutput;
// AddDmcHdoPorts(number, cecPort1, cecPort2);
// }
// else if (type == "dmcHdo")
// {
// var outputCard = new DmcHdoSingle(number, Chassis);
// var cecPort1 = outputCard.Card1.HdmiOutput;
// var cecPort2 = outputCard.Card2.HdmiOutput;
// AddDmcHdoPorts(number, cecPort1, cecPort2);
// }
// else if (type == "dmc4kCoHd")
// {
// var outputCard = new Dmc4kCoHdSingle(number, Chassis);
// var cecPort1 = outputCard.Card1.HdmiOutput;
// AddDmcCoPorts(number, cecPort1);
// }
// else if (type == "dmc4kzCoHd")
// {
// var outputCard = new Dmc4kzCoHdSingle(number, Chassis);
// var cecPort1 = outputCard.Card1.HdmiOutput;
// AddDmcCoPorts(number, cecPort1);
// }
// else if (type == "dmcCoHd")
// {
// var outputCard = new DmcCoHdSingle(number, Chassis);
// var cecPort1 = outputCard.Card1.HdmiOutput;
// AddDmcCoPorts(number, cecPort1);
// }
// else if (type == "dmCatoHd")
// {
// var outputCard = new DmcCatoHdSingle(number, Chassis);
// var cecPort1 = outputCard.Card1.HdmiOutput;
// AddDmcCoPorts(number, cecPort1);
// }
// else if (type == "dmcSoHd")
// {
// var outputCard = new DmcSoHdSingle(number, Chassis);
// var cecPort1 = outputCard.Card1.HdmiOutput;
// AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
// AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
// AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
// }
// else if (type == "dmcS2oHd")
// {
// var outputCard = new DmcS2oHdSingle(number, Chassis);
// var cecPort1 = outputCard.Card1.HdmiOutput;
// AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
// AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
// AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
// }
// else if (type == "dmcStro")
// {
// var outputCard = new DmcStroSingle(number, Chassis);
// AddOutputPortWithDebug(number, "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
// }
// else
// Debug.Console(1, this, " WARNING: Output card type '{0}' is not available", type);
// }
// void AddDmcHdoPorts(uint number, ICec cecPort1, ICec cecPort2)
// {
// AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
// AddOutputPortWithDebug(number, "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 1);
// AddOutputPortWithDebug(number, "hdmiOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2);
// AddOutputPortWithDebug(number, "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 2);
// }
// void AddDmcCoPorts(uint number, ICec cecPort1)
// {
// AddOutputPortWithDebug(number, "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
// AddOutputPortWithDebug(number, "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
// AddOutputPortWithDebug(number, "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
// }
// /// <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 (cecPort != null)
// inputPort.Port = cecPort;
// InputPorts.Add(inputPort);
// }
// /// <summary>
// /// Adds OutputPort
// /// </summary>
// void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector)
// {
// var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
// Debug.Console(2, this, "Adding output port '{0}'", portKey);
// OutputPorts.Add(new RoutingOutputPort(portKey, sigType, portType, selector, this));
// }
// /// <summary>
// /// Adds OutputPort and sets Port as ICec object
// /// </summary>
// void AddOutputPortWithDebug(uint cardNum, string portName, eRoutingSignalType sigType, eRoutingPortConnectionType portType, object selector, ICec cecPort)
// {
// var portKey = string.Format("outputCard{0}--{1}", cardNum, portName);
// Debug.Console(2, this, "Adding output port '{0}'", portKey);
// var outputPort = new RoutingOutputPort(portKey, sigType, portType, selector, this);
// if (cecPort != null)
// outputPort.Port = cecPort;
// OutputPorts.Add(outputPort);
// }
// /// <summary>
// ///
// /// </summary>
// void AddVolumeControl(uint number, Audio.Output audio)
// {
// VolumeControls.Add(number, new DmCardAudioOutputController(audio));
// }
// //public void SetInputHdcpSupport(uint input, ePdtHdcpSupport hdcpSetting)
// //{
// //}
// void Chassis_DMSystemChange(Switch device, DMSystemEventArgs args) {
// }
// void Chassis_DMInputChange(Switch device, DMInputEventArgs args) {
// //Debug.Console(2, this, "DMSwitch:{0} Input:{1} Event:{2}'", this.Name, args.Number, args.EventId.ToString());
// switch (args.EventId) {
// case (DMInputEventIds.OnlineFeedbackEventId): {
// Debug.Console(2, this, "DMINput 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;
// }
// }
// }
// ///
// /// </summary>
// void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
// {
// //This should be a switch case JTA 2018-07-02
// var output = args.Number;
// if (args.EventId == DMOutputEventIds.VolumeEventId &&
// VolumeControls.ContainsKey(output))
// {
// VolumeControls[args.Number].VolumeEventFromChassis();
// }
// else if (args.EventId == DMOutputEventIds.OnlineFeedbackEventId)
// {
// OutputEndpointOnlineFeedbacks[output].FireUpdate();
// }
// else if (args.EventId == 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();
// }
// }
// else if (args.EventId == DMOutputEventIds.AudioOutEventId)
// {
// if (Chassis.Outputs[output].AudioOutFeedback != null)
// {
// Debug.Console(2, this, "DMSwitchAudio:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].AudioOutFeedback.Number, output);
// }
// if (AudioOutputFeedbacks.ContainsKey(output))
// {
// AudioOutputFeedbacks[output].FireUpdate();
// }
// }
// else if (args.EventId == DMOutputEventIds.OutputNameEventId)
// {
// Debug.Console(2, this, "DM Output {0} NameFeedbackEventId", output);
// OutputNameFeedbacks[output].FireUpdate();
// }
// }
// /// <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)
// {
// 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);
// }
// }
// Card.DMICard inCard = input == 0 ? null : Chassis.Inputs[input];
// // NOTE THAT THESE ARE NOTS - TO CATCH THE AudioVideo TYPE
// if (sigType != eRoutingSignalType.Audio)
// {
// Chassis.VideoEnter.BoolValue = true;
// Chassis.Outputs[output].VideoOut = inCard;
// }
// if (sigType != eRoutingSignalType.Video)
// {
// Chassis.AudioEnter.BoolValue = true;
// Chassis.Outputs[output].AudioOut = 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;
// // }
// //}
//}

13
essentials-framework/Essentials DM/Essentials_DM/Properties/AssemblyInfo.cs
View File

@@ -1,7 +1,10 @@
using System.Reflection;
using Crestron.SimplSharp.Reflection;
[assembly: AssemblyTitle("Essentials_DM")]
[assembly: AssemblyCompany("PepperDash Technology Corp")]
[assembly: AssemblyProduct("Essentials_DM")]
[assembly: AssemblyCopyright("Copyright © 2019")]
[assembly: AssemblyVersion("1.3.*")]
[assembly: System.Reflection.AssemblyTitle("Essentials_DM")]
[assembly: System.Reflection.AssemblyCompany("PepperDash Technology Corp")]
[assembly: System.Reflection.AssemblyProduct("PepperDashEssentials")]
[assembly: System.Reflection.AssemblyCopyright("Copyright © PepperDash Technology Corp 2020")]
[assembly: System.Reflection.AssemblyVersion("0.0.0.*")]
[assembly: System.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
[assembly: Crestron.SimplSharp.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]

5
essentials-framework/Essentials Devices Common/Essentials Devices Common/Codec/iHasScheduleAwareness.cs
View File

@@ -73,17 +73,18 @@ namespace PepperDash.Essentials.Devices.Common.Codec
{
// Iterate the meeting list and check if any meeting need to do anythingk
const double meetingTimeEpsilon = 0.0001;
foreach (Meeting m in Meetings)
{
eMeetingEventChangeType changeType = eMeetingEventChangeType.Unkown;
if (m.TimeToMeetingStart.TotalMinutes <= m.MeetingWarningMinutes.TotalMinutes) // Meeting is about to start
changeType = eMeetingEventChangeType.MeetingStartWarning;
else if (m.TimeToMeetingStart.TotalMinutes == 0) // Meeting Start
else if (Math.Abs(m.TimeToMeetingStart.TotalMinutes) < meetingTimeEpsilon) // Meeting Start
changeType = eMeetingEventChangeType.MeetingStart;
else if (m.TimeToMeetingEnd.TotalMinutes <= m.MeetingWarningMinutes.TotalMinutes) // Meeting is about to end
changeType = eMeetingEventChangeType.MeetingEndWarning;
else if (m.TimeToMeetingEnd.TotalMinutes == 0) // Meeting has ended
else if (Math.Abs(m.TimeToMeetingEnd.TotalMinutes) < meetingTimeEpsilon) // Meeting has ended
changeType = eMeetingEventChangeType.MeetingEnd;
if (changeType != eMeetingEventChangeType.Unkown)

22
essentials-framework/Essentials Devices Common/Essentials Devices Common/DSP/DspBase.cs
View File

@@ -49,4 +49,26 @@ namespace PepperDash.Essentials.Devices.Common.DSP
{
}
// Main program
// VTC
// ATC
// Mics, unusual
public interface IBiampTesiraDspLevelControl : IBasicVolumeWithFeedback
{
/// <summary>
/// In BiAmp: Instance Tag, QSC: Named Control, Polycom:
/// </summary>
string ControlPointTag { get; }
int Index1 { get; }
int Index2 { get; }
bool HasMute { get; }
bool HasLevel { get; }
bool AutomaticUnmuteOnVolumeUp { get; }
}
}

21
essentials-framework/Essentials Devices Common/Essentials Devices Common/Display/NecPaSeriesProjector.cs
View File

@@ -218,26 +218,5 @@ namespace PepperDash.Essentials.Devices.Displays
}
#region INonStandardControls Members
public Dictionary<Cue, Action<object>> GetNonStandardControls()
{
return new Dictionary<Cue, Action<object>>
{
{ CommonBoolCue.PowerOn, o => PowerOn() },
{ CommonBoolCue.PowerOff, o => PowerOff() },
{ Cue.BoolCue("PictureMute", 0), o =>
{
if((bool)o)
PictureMuteOn();
else
PictureMuteOff(); } },
{ Cue.UShortCue("GetLampRemaining", 0), o => GetLampRemaining((int) o) },
{ Cue.StringCue("SelectInput", 0), o => SelectInput((String)o) }
};
}
#endregion
}
}

138
essentials-framework/Essentials Devices Common/Essentials Devices Common/Display/SamsungMDCDisplay.cs
View File

@@ -167,84 +167,91 @@ namespace PepperDash.Essentials.Devices.Displays
/// <param name="sender"></param>
void Communication_BytesReceived(object sender, GenericCommMethodReceiveBytesArgs e)
{
// This is probably not thread-safe buffering
// Append the incoming bytes with whatever is in the buffer
var newBytes = new byte[IncomingBuffer.Length + e.Bytes.Length];
IncomingBuffer.CopyTo(newBytes, 0);
e.Bytes.CopyTo(newBytes, IncomingBuffer.Length);
if (Debug.Level == 2) // This check is here to prevent following string format from building unnecessarily on level 0 or 1
Debug.Console(2, this, "Received:{0}", ComTextHelper.GetEscapedText(newBytes));
// Need to find AA FF and have
for (int i = 0; i < newBytes.Length; i++)
try
{
if (newBytes[i] == 0xAA && newBytes[i + 1] == 0xFF)
// This is probably not thread-safe buffering
// Append the incoming bytes with whatever is in the buffer
var newBytes = new byte[IncomingBuffer.Length + e.Bytes.Length];
IncomingBuffer.CopyTo(newBytes, 0);
e.Bytes.CopyTo(newBytes, IncomingBuffer.Length);
if (Debug.Level == 2) // This check is here to prevent following string format from building unnecessarily on level 0 or 1
Debug.Console(2, this, "Received:{0}", ComTextHelper.GetEscapedText(newBytes));
// Need to find AA FF and have
for (int i = 0; i < newBytes.Length; i++)
{
newBytes = newBytes.Skip(i).ToArray(); // Trim off junk if there's "dirt" in the buffer
// parse it
// If it's at least got the header, then process it,
while (newBytes.Length > 4 && newBytes[0] == 0xAA && newBytes[1] == 0xFF)
if (newBytes[i] == 0xAA && newBytes[i + 1] == 0xFF)
{
var msgLen = newBytes[3];
// if the buffer is shorter than the header (3) + message (msgLen) + checksum (1),
// give and save it for next time
if (newBytes.Length < msgLen + 4)
break;
newBytes = newBytes.Skip(i).ToArray(); // Trim off junk if there's "dirt" in the buffer
// Good length, grab the message
var message = newBytes.Skip(4).Take(msgLen).ToArray();
// At this point, the ack/nak is the first byte
if (message[0] == 0x41)
// parse it
// If it's at least got the header, then process it,
while (newBytes.Length > 4 && newBytes[0] == 0xAA && newBytes[1] == 0xFF)
{
switch (message[1]) // type byte
var msgLen = newBytes[3];
// if the buffer is shorter than the header (3) + message (msgLen) + checksum (1),
// give and save it for next time
if (newBytes.Length < msgLen + 4)
break;
// Good length, grab the message
var message = newBytes.Skip(4).Take(msgLen).ToArray();
// At this point, the ack/nak is the first byte
if (message[0] == 0x41)
{
case 0x00: // General status
//UpdatePowerFB(message[2], message[5]); // "power" can be misrepresented when the display sleeps
switch (message[1]) // type byte
{
case 0x00: // General status
//UpdatePowerFB(message[2], message[5]); // "power" can be misrepresented when the display sleeps
// Handle the first power on fb when waiting for it.
if (IsPoweringOnIgnorePowerFb && message[2] == 0x01)
IsPoweringOnIgnorePowerFb = false;
// Ignore general-status power off messages when powering up
if (!(IsPoweringOnIgnorePowerFb && message[2] == 0x00))
UpdatePowerFB(message[2]);
UpdateVolumeFB(message[3]);
UpdateMuteFb(message[4]);
UpdateInputFb(message[5]);
break;
// Handle the first power on fb when waiting for it.
if (IsPoweringOnIgnorePowerFb && message[2] == 0x01)
IsPoweringOnIgnorePowerFb = false;
// Ignore general-status power off messages when powering up
if (!(IsPoweringOnIgnorePowerFb && message[2] == 0x00))
UpdatePowerFB(message[2]);
UpdateVolumeFB(message[3]);
UpdateMuteFb(message[4]);
UpdateInputFb(message[5]);
break;
case 0x11:
UpdatePowerFB(message[2]);
break;
case 0x11:
UpdatePowerFB(message[2]);
break;
case 0x12:
UpdateVolumeFB(message[2]);
break;
case 0x12:
UpdateVolumeFB(message[2]);
break;
case 0x13:
UpdateMuteFb(message[2]);
break;
case 0x13:
UpdateMuteFb(message[2]);
break;
case 0x14:
UpdateInputFb(message[2]);
break;
case 0x14:
UpdateInputFb(message[2]);
break;
default:
break;
default:
break;
}
}
// Skip over what we've used and save the rest for next time
newBytes = newBytes.Skip(5 + msgLen).ToArray();
}
// Skip over what we've used and save the rest for next time
newBytes = newBytes.Skip(5 + msgLen).ToArray();
}
break; // parsing will mean we can stop looking for header in loop
}
}
// Save whatever partial message is here
IncomingBuffer = newBytes;
break; // parsing will mean we can stop looking for header in loop
}
}
// Save whatever partial message is here
IncomingBuffer = newBytes;
}
catch (Exception err)
{
Debug.Console(2, this, "Error parsing feedback: {0}", err);
}
}
/// <summary>
@@ -256,6 +263,7 @@ namespace PepperDash.Essentials.Devices.Displays
if (newVal != _PowerIsOn)
{
_PowerIsOn = newVal;
Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Feedback Power State: {0}", _PowerIsOn);
PowerIsOnFeedback.FireUpdate();
}
}
@@ -364,6 +372,8 @@ namespace PepperDash.Essentials.Devices.Displays
/// </summary>
public override void PowerOn()
{
Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Powering On Display");
IsPoweringOnIgnorePowerFb = true;
//Send(PowerOnCmd);
SendBytes(new byte[] { 0xAA, 0x11, 0x00, 0x01, 0x01, 0x00 });
@@ -387,6 +397,8 @@ namespace PepperDash.Essentials.Devices.Displays
/// </summary>
public override void PowerOff()
{
Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Powering Off Display");
IsPoweringOnIgnorePowerFb = false;
// If a display has unreliable-power off feedback, just override this and
// remove this check.

5
essentials-framework/Essentials Devices Common/Essentials Devices Common/Essentials Devices Common.csproj
View File

@@ -113,11 +113,6 @@
<Compile Include="Occupancy\GlsOdtOccupancySensorController.cs" />
<Compile Include="Power Controllers\Digitallogger.cs" />
<Compile Include="Power Controllers\DigitalLoggerPropertiesConfig.cs" />
<Compile Include="Evertz\EvertsEndpointStatusServer.cs" />
<Compile Include="Evertz\EvertzEndpointVarIds.cs" />
<Compile Include="Evertz\EvertzEndpoint.cs" />
<Compile Include="Evertz\EvertzEndpointPropertiesConfig.cs" />
<Compile Include="Evertz\GenericHttpClient.cs" />
<Compile Include="ImageProcessors\AnalogWay\AnalongWayLiveCore.cs" />
<Compile Include="ImageProcessors\AnalogWay\AnalogWayLiveCorePropertiesConfig.cs" />
<Compile Include="SoftCodec\BlueJeansPc.cs" />

152
essentials-framework/Essentials Devices Common/Essentials Devices Common/Evertz/EvertsEndpointStatusServer.cs
View File

@@ -1,152 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using System.Text.RegularExpressions;
using Crestron.SimplSharp.Net.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
using Crestron.SimplSharp.CrestronSockets;
namespace PepperDash.Essentials.Devices.Common
{
/*****
* TODO JTA: Add Polling
* TODO JTA: Move all the registration commnads to the EvertEndpoint class.
*
*
*
*
*
*/
public class EvertzEndpointStatusServer : Device
{
public IBasicCommunication Communication { get; private set; }
public CommunicationGather PortGather { get; private set; }
public StatusMonitorBase CommunicationMonitor { get; private set; }
public bool isSubscribed;
public string Address;
public GenericUdpServer Server;
/// <summary>
/// Shows received lines as hex
/// </summary>
public bool ShowHexResponse { get; set; }
public Dictionary<string, EvertzEndpoint> Endpoints;
public Dictionary<string, string> ServerIdByEndpointIp;
public EvertzEndpointStatusServer(string key, string name, GenericUdpServer server, EvertzEndpointStatusServerPropertiesConfig props) :
base(key, name)
{
Server = server;
Address = props.serverHostname;
Server.DataRecievedExtra += new EventHandler<GenericUdpReceiveTextExtraArgs>(_Server_DataRecievedExtra);
Server.Connect();
Endpoints = new Dictionary<string,EvertzEndpoint>();
//CrestronEnvironment.ProgramStatusEventHandler += new ProgramStatusEventHandler(CrestronEnvironment_ProgramStatusEventHandler);
}
//TODO JTA: Move this method and process over to the endpoint itself. return a bool.
public bool RegisterEvertzEndpoint (EvertzEndpoint device)
{
if (Endpoints.ContainsKey(device.Address) == false)
{
Endpoints.Add(device.Address, device);
}
return true;
}
void _Server_DataRecievedExtra(object sender, GenericUdpReceiveTextExtraArgs e)
{
Debug.Console(2, this, "_Server_DataRecievedExtra:\nIP:{0}\nPort:{1}\nText{2}\nBytes:{3} ", e.IpAddress, e.Port, e.Text, e.Bytes);
}
public override bool CustomActivate()
{
/*
Communication.Connect();
CommunicationMonitor.StatusChange += (o, a) => { Debug.Console(2, this, "Communication monitor state: {0}", CommunicationMonitor.Status); };
CommunicationMonitor.Start();
*/
return true;
}
}
public class EvertzPortRestResponse
{
public string id;
public string name;
public string type;
public string value;
}
public class EvertsStatusRequesstResponse
{
public EvertzStatusDataResponse data;
public string error;
}
public class EvertzStatusDataResponse
{
public List<EvertzServerStatusResponse> servers;
}
public class EvertzServerStatusResponse
{
public string id;
public string name;
public EvertsServerStausNotificationsResponse notify;
}
public class EvertsServerStausNotificationsResponse
{
public string ip;
public List<string> parameters;
public string port;
public string protocol;
}
public class EvertzEndpointStatusServerPropertiesConfig
{
public ControlPropertiesConfig control { get; set; }
public string serverHostname { get; set; }
}
}

337
essentials-framework/Essentials Devices Common/Essentials Devices Common/Evertz/EvertzEndpoint.cs
View File

@@ -1,337 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using System.Text.RegularExpressions;
using Crestron.SimplSharp.Net.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace PepperDash.Essentials.Devices.Common
{
public class EvertzEndpoint : Device
{
public IBasicCommunication Communication { get; private set; }
public CommunicationGather PortGather { get; private set; }
public GenericCommunicationMonitor CommunicationMonitor { get; private set; }
private GenericHttpClient Client;
public string userName;
public string password;
public string Address;
private bool OnlineStatus;
public BoolFeedback OnlineFeedback;
public IntFeedback PresetFeedback;
public bool isSubscribed;
CrestronQueue CommandQueue;
public Dictionary<string, EvertzEndpointPort> Ports;
private string _ControllerKey;
private EvertzEndpointStatusServer StatusServer;
private String StatusServerId;
/// <summary>
/// Shows received lines as hex
/// </summary>
public bool ShowHexResponse { get; set; }
public EvertzEndpoint(string key, string name, EvertzEndpointPropertiesConfig props, string type) :
base(key, name)
{
this.Address = props.address;
Client = new GenericHttpClient(string.Format("{0}-GenericWebClient", name), string.Format("{0}-GenericWebClient", name), this.Address);
Client.ResponseRecived += new EventHandler<GenericHttpClientEventArgs>(Client_ResponseRecived);
Ports = new Dictionary<string, EvertzEndpointPort>();
if (type.ToLower() == "mma10g-trs4k")
{
//create port hdmi 01
EvertzEndpointPort hdmi1 = new EvertzEndpointPort("HDMI01", "131.0@s", "136.0@s");
EvertzEndpointPort hdmi2 = new EvertzEndpointPort("HDMI02", "131.1@s", "136.1@s");
// add to dictionay with all keys
addPortToDictionary(hdmi1);
addPortToDictionary(hdmi2);
}
_ControllerKey = null;
if (props.controllerKey != null)
{
_ControllerKey = props.controllerKey;
}
AddPostActivationAction( () => {PostActivation();});
CrestronEnvironment.ProgramStatusEventHandler += new ProgramStatusEventHandler(CrestronEnvironment_ProgramStatusEventHandler);
if (props.CommunicationMonitorProperties != null)
{
CommunicationMonitor = new GenericCommunicationMonitor(this, Client, props.CommunicationMonitorProperties);
}
else
{
CommunicationMonitor = new GenericCommunicationMonitor(this, Client, 40000, 120000, 300000, "v.api/apis/EV/SERVERSTATUS");
}
}
/// <summary>
/// Helper method
/// </summary>
/// <param name="port"></param>
private void addPortToDictionary(EvertzEndpointPort port)
{
Ports.Add(port.PortName, port);
Ports.Add(port.ResolutionVarID, port);
Ports.Add(port.SyncVarID, port);
//PollForState(port.SyncVarID);
//PollForState(port.ResolutionVarID);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override bool CustomActivate()
{
// Create Device -> Constructor fires
// PreActivations get called
// CustomActivate Gets Called Anything that is involved with this single class Ex: Connection, Setup Feedback, Etc.
// After this point all devices are ready for interaction
// PostActivation gets called. Use this for interClass activation.
CommunicationMonitor.Start();
OnlineFeedback = new BoolFeedback(() => { return OnlineStatus; });
//CrestronConsole.AddNewConsoleCommand(SendLine, "send" + Key, "", ConsoleAccessLevelEnum.AccessOperator);
return true;
}
/// <summary>
///
/// </summary>
private void PostActivation()
{
Debug.Console(2, this, "EvertzEndpoint Post Activation");
if (_ControllerKey != null)
{
StatusServer = DeviceManager.GetDeviceForKey(_ControllerKey) as EvertzEndpointStatusServer;
StatusServer.RegisterEvertzEndpoint(this);
// RegisterStatusServer();
// SendStatusRequest();
}
// PollAll();
}
void CrestronEnvironment_ProgramStatusEventHandler(eProgramStatusEventType programEventType)
{
if (programEventType == eProgramStatusEventType.Stopping)
{
Debug.Console(1, this, "Program stopping. Disabling EvertzStatusServer");
if (StatusServerId != null)
{
//UnregisterServer();
}
}
}
private void ProcessServerStatusRequest(EvertsStatusRequesstResponse status)
{
// var status = JsonConvert.DeserializeObject<EvertsStatusRequesstResponse>(SendStatusRequest());
if (status.error != null)
{
}
else if (status.data != null)
{
foreach (var server in status.data.servers)
{
if (server.name == string.Format("{0}-{1}", this.Name, StatusServer.Address))
{
StatusServerId = server.id;
Debug.Console(2, this, "EvertzEndpoint {0} StatusServer {1} Registered ID {2}", Name, StatusServer.Name, StatusServerId);
/*
foreach (var port in Ports)
{
// TODO JTA: This needs a better check
// you get a {"status": "success"} or "error": "error to register notification- Variable exists.."
if (!server.notify.parameters.Contains(port.Value.ResolutionVarID))
{
RegisterForNotification(StatusServerId, port.Value.ResolutionVarID);
}
if (!server.notify.parameters.Contains(port.Value.ResolutionVarID))
{
RegisterForNotification(StatusServerId, port.Value.SyncVarID);
}
}
*/
break;
}
}
StatusServerId = null;
}
}
private void RegisterServerWithEndpoint()
{
/*
var registrationResult = RegisterServer(StatusServer.Address, string.Format("{0}-{1}", this.Name, StatusServer.Address), StatusServer.Server.Port.ToString());
Debug.Console(2, this, "EvertzEndpointStatusServer Registration Result with device {0}\n{1}", Address, registrationResult);
if (registrationResult.Contains("success"))
{
RegisterStatusServer();
}
else
{
Debug.Console(0, this, "EvertzEndpointStatusServer RegisterServerWithEndpoint with device {0}\n{1}", Address, registrationResult);
}
* */
}
public void PollAll()
{
string collection = "";
foreach (var parameter in Ports)
{
if (parameter.Key.Contains("@"))
{
collection = collection + parameter.Key + ",";
}
}
collection = collection.Substring(0, collection.Length - 1);
SendGetRequest(collection);
}
public void PollForState(string varId)
{
try
{
SendGetRequest(varId);
//var returnState = JsonConvert.DeserializeObject<EvertzPortRestResponse>(SendGetRequest(varId));
}
catch (Exception e)
{
Debug.Console(0, this, "PollForState {0}", e);
}
}
public void ProcessGetParameterResponse(EvertzPortRestResponse response)
{
var PortObject = Ports[response.id];
if (response.name == "Input Status")
{
if (response.value == "Missing") { PortObject.SyncDetected = false; }
else { PortObject.SyncDetected = true; }
}
}
public void SendGetRequest(string s)
{
Client.SendText("v.api/apis/EV/GET/parameter/{0}", s);
}
public void SendStatusRequest()
{
Client.SendText("/v.api/apis/EV/SERVERSTATUS");
}
public void RegisterServer(string hostname, string servername, string port)
{
Client.SendText("v.api/apis/EV/SERVERADD/server/{0}/{1}/{2}/udp", hostname, servername, port);
}
public void UnregisterServer()
{
if (StatusServerId != null)
{
Client.SendTextNoResponse("v.api/apis/EV/SERVERDEL/server/{0}", StatusServerId);
}
}
// TODO JTA: Craete a UnregisterServerFast using DispatchASync.
public void RegisterForNotification(string varId)
{
Client.SendText("v.api/apis/EV/NOTIFYADD/parameter/{0}/{1}", StatusServerId, varId);
}
void Client_ResponseRecived(object sender, GenericHttpClientEventArgs e)
{
if (e.Error == HTTP_CALLBACK_ERROR.COMPLETED)
{
if (e.RequestPath.Contains("GET/parameter/"))
{
// Get Parameter response
if (!e.ResponseText.Contains("["))
ProcessGetParameterResponse(JsonConvert.DeserializeObject<EvertzPortRestResponse>(e.ResponseText));
else if (e.ResponseText.Contains("["))
{
List<EvertzPortRestResponse> test = JsonConvert.DeserializeObject<List<EvertzPortRestResponse>>(e.ResponseText);
foreach (var thing in test)
{
ProcessGetParameterResponse(thing);
}
}
}
else if (e.RequestPath.Contains("SERVERSTATUS"))
{
PollAll();
ProcessServerStatusRequest(JsonConvert.DeserializeObject<EvertsStatusRequesstResponse>(e.ResponseText));
}
}
}
public class EvertzPortsRestResponse
{
List<EvertzPortRestResponse> test;
}
public class EvertzPortRestResponse
{
public string id;
public string name;
public string type;
public string value;
}
public class EvertzEndpointPort
{
public string PortName;
public string SyncVarID;
public string ResolutionVarID;
public bool SyncDetected;
public string Resolution;
public BoolFeedback SyncDetectedFeedback;
public EvertzEndpointPort (string portName, string syncVarId, string resolutionVarId)
{
PortName = portName;
SyncVarID = syncVarId;
ResolutionVarID = resolutionVarId;
SyncDetectedFeedback = new BoolFeedback(() => { return SyncDetected; });
}
}
}
}

26
essentials-framework/Essentials Devices Common/Essentials Devices Common/Evertz/EvertzEndpointPropertiesConfig.cs
View File

@@ -1,26 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common
{
/// <summary>
///
/// </summary>
public class EvertzEndpointPropertiesConfig
{
public CommunicationMonitorConfig CommunicationMonitorProperties { get; set; }
public ControlPropertiesConfig Control { get; set; }
public string userName { get; set; }
public string password { get; set; }
public string address { get; set; }
public string controllerKey { get; set; }
}
}

13
essentials-framework/Essentials Devices Common/Essentials Devices Common/Evertz/EvertzEndpointVarIds.cs
View File

@@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
namespace PepperDash.Essentials.Devices.Common
{
public class EvertzEndpointVarIds
{
private string HdmiPort01SyncStatus = "136.0";
}
}

22
essentials-framework/Essentials Devices Common/Essentials Devices Common/Factory/DeviceFactory.cs
View File

@@ -107,21 +107,6 @@ namespace PepperDash.Essentials.Devices.Common
properties.ToString());
return new DigitalLogger(key, name, props);
}
else if (groupName == "evertzendpoint")
{
// var comm = CommFactory.CreateCommForDevice(dc);
var props = JsonConvert.DeserializeObject<EvertzEndpointPropertiesConfig>(
properties.ToString());
return new EvertzEndpoint(key, name, props, typeName);
}
else if (typeName == "evertzendpointstatusserver")
{
var server = CommFactory.CreateCommForDevice(dc) as GenericUdpServer;
var props = JsonConvert.DeserializeObject<EvertzEndpointStatusServerPropertiesConfig>(
properties.ToString());
return new EvertzEndpointStatusServer(key, name, server, props);
}
else if (typeName == "genericaudiooutwithvolume")
{
var zone = dc.Properties.Value<uint>("zone");
@@ -400,13 +385,6 @@ namespace PepperDash.Essentials.Devices.Common
}
}
//else if (typeName == "qscdsp")
//{
// var comm = CommFactory.CreateCommForDevice(dc);
// var props = JsonConvert.DeserializeObject<QscDspPropertiesConfig>(
// properties.ToString());
// return new QscDsp(key, name, comm, props);
//}
return null;
}

45
essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/GlsOdtOccupancySensorController.cs
View File

@@ -24,7 +24,11 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
public IntFeedback UltrasonicSensitivityInVacantStateFeedback { get; private set; }
public IntFeedback UltrasonicSensitivityInOccupiedStateFeedback { get; private set; }
public IntFeedback UltrasonicSensitivityInOccupiedStateFeedback { get; private set; }
public BoolFeedback RawOccupancyPirFeedback { get; private set; }
public BoolFeedback RawOccupancyUsFeedback { get; private set; }
public GlsOdtOccupancySensorController(string key, string name, GlsOdtCCn sensor)
@@ -38,11 +42,15 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
UltrasonicAEnabledFeedback = new BoolFeedback(() => OccSensor.UsAEnabledFeedback.BoolValue);
UltrasonicBEnabledFeedback = new BoolFeedback(() => OccSensor.UsBEnabledFeedback.BoolValue);
UltrasonicBEnabledFeedback = new BoolFeedback(() => OccSensor.UsBEnabledFeedback.BoolValue);
RawOccupancyPirFeedback = new BoolFeedback(() => OccSensor.RawOccupancyPirFeedback.BoolValue);
RawOccupancyUsFeedback = new BoolFeedback(() => OccSensor.RawOccupancyUsFeedback.BoolValue);
UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInVacantStateFeedback.UShortValue);
UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInOccupiedStateFeedback.UShortValue);
UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInOccupiedStateFeedback.UShortValue);
}
/// <summary>
@@ -52,20 +60,23 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
/// <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();
{
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.RawOccupancyPirFeedbackEventId)
RawOccupancyPirFeedback.FireUpdate();
else if (args.EventId == GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId)
RawOccupancyUsFeedback.FireUpdate();
else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInOccupiedStateFeedbackEventId)
UltrasonicSensitivityInOccupiedStateFeedback.FireUpdate();
else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInVacantStateFeedbackEventId)
UltrasonicSensitivityInVacantStateFeedback.FireUpdate();
base.OccSensor_GlsOccupancySensorChange(device, args);
}

6
essentials-framework/Essentials Devices Common/Essentials Devices Common/Power Controllers/Digitallogger.cs
View File

@@ -26,7 +26,7 @@ namespace PepperDash.Essentials.Devices.Common
public string address;
private bool OnlineStatus;
public BoolFeedback OnlineFeedback;
private ushort CurrentPreset;
//private ushort CurrentPreset;
public IntFeedback PresetFeedback;
public Dictionary<uint, DigitalLoggerCircuit> CircuitStatus;
@@ -103,7 +103,7 @@ namespace PepperDash.Essentials.Devices.Common
});
CircuitIsCritical[circuit] = new BoolFeedback(() =>
{
if (CircuitStatus[circuit] != null)
if (CircuitStatus.ContainsKey(circuit))
{
return CircuitStatus[circuit].critical;
}
@@ -114,7 +114,7 @@ namespace PepperDash.Essentials.Devices.Common
});
CircuitState[circuit] = new BoolFeedback(() =>
{
if (CircuitStatus[circuit] != null)
if (CircuitStatus.ContainsKey(circuit))
{
return CircuitStatus[circuit].state;
}

13
essentials-framework/Essentials Devices Common/Essentials Devices Common/Properties/AssemblyInfo.cs
View File

@@ -1,7 +1,10 @@
using System.Reflection;
using Crestron.SimplSharp.Reflection;
[assembly: AssemblyTitle("Essentials_Devices_Common")]
[assembly: AssemblyCompany("PepperDash Technology Corp")]
[assembly: AssemblyProduct("Essentials_Devices_Common")]
[assembly: AssemblyCopyright("Copyright © 2019")]
[assembly: AssemblyVersion("1.4.*")]
[assembly: System.Reflection.AssemblyTitle("Essentials_Devices_Common")]
[assembly: System.Reflection.AssemblyCompany("PepperDash Technology Corp")]
[assembly: System.Reflection.AssemblyProduct("PepperDashEssentials")]
[assembly: System.Reflection.AssemblyCopyright("Copyright © PepperDash Technology Corp 2020")]
[assembly: System.Reflection.AssemblyVersion("0.0.0.*")]
[assembly: System.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
[assembly: Crestron.SimplSharp.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]

2
essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/BookingsDataClasses.cs
View File

@@ -336,8 +336,10 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
if(b.Agenda != null)
meeting.Agenda = b.Agenda.Value;
if(b.Time != null)
{
meeting.StartTime = b.Time.StartTime.Value;
meeting.EndTime = b.Time.EndTime.Value;
}
if(b.Privacy != null)
meeting.Privacy = CodecCallPrivacy.ConvertToDirectionEnum(b.Privacy.Value);

4
essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ZoomRoom.cs
View File

@@ -43,8 +43,8 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
public bool CommDebuggingIsOn;
CTimer LoginMessageReceivedTimer;
CTimer RetryConnectionTimer;
//CTimer LoginMessageReceivedTimer;
//CTimer RetryConnectionTimer;
/// <summary>
/// Gets and returns the scaled volume of the codec

4
essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ZoomRoomCamera.cs
View File

@@ -47,13 +47,13 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
private bool isZooming;
private bool isFocusing;
//private bool isFocusing;
private bool isMoving
{
get
{
return isPanning || isTilting || isZooming || isFocusing;
return isPanning || isTilting || isZooming;
}
}

2
essentials-framework/pepperdashcore-builds

Submodule essentials-framework/pepperdashcore-builds updated: 2d9c383db0...15206840b3