pepperdash/Essentials
1
0
Fork 0
mirror of https://github.com/PepperDash/Essentials.git synced 2026-02-13 03:35:00 +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

10
PepperDashEssentials/Bridges/BridgeBase.cs
View File

@@ -168,6 +168,16 @@ namespace PepperDash.Essentials.Bridges
(device as PepperDash.Essentials.Devices.Common.Occupancy.GlsOccupancySensorBaseController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
continue;
}
else if (device is StatusSignController)
{
(device as StatusSignController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
continue;
}
else if (device is C2nRthsController)
{
(device as C2nRthsController).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
continue;
}
}
}

38
PepperDashEssentials/Bridges/C2nRthsControllerBridge.cs Normal file
View File

@@ -0,0 +1,38 @@
using Crestron.SimplSharpPro.DeviceSupport;
using Newtonsoft.Json;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.CrestronIO;
namespace PepperDash.Essentials.Bridges
{
public static class C2nRthsControllerApiExtensions
{
public static void LinkToApi(this C2nRthsController device, BasicTriList triList, uint joinStart,
string joinMapKey)
{
var joinMap = new C2nRthsControllerJoinMap();
var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
if (!string.IsNullOrEmpty(joinMapSerialized))
joinMap = JsonConvert.DeserializeObject<C2nRthsControllerJoinMap>(joinMapSerialized);
joinMap.OffsetJoinNumbers(joinStart);
Debug.Console(1, device, "Linking to Trilist '{0}'", triList.ID.ToString("X"));
triList.SetBoolSigAction(joinMap.TemperatureFormat, device.SetTemperatureFormat);
device.IsOnline.LinkInputSig(triList.BooleanInput[joinMap.IsOnline]);
device.TemperatureFeedback.LinkInputSig(triList.UShortInput[joinMap.Temperature]);
device.HumidityFeedback.LinkInputSig(triList.UShortInput[joinMap.Humidity]);
triList.StringInput[joinMap.Name].StringValue = device.Name;
}
}
}

12
PepperDashEssentials/Bridges/DmChassisControllerBridge.cs
View File

@@ -16,7 +16,7 @@ using Newtonsoft.Json;
namespace PepperDash.Essentials.Bridges
{
public static class DmChassisControllerApiExtentions
public static class DmChassisControllerApiExtensions
{
public static void LinkToApi(this DmChassisController dmChassis, BasicTriList trilist, uint joinStart, string joinMapKey)
{
@@ -81,14 +81,14 @@ namespace PepperDash.Essentials.Bridges
}
}
if (basicTxDevice != null && advancedTxDevice == null)
trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
if (advancedTxDevice != null)
if (advancedTxDevice != null) // Advanced TX device
{
advancedTxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
// Flag if the TX is an advanced endpoint type
trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
}
else if(advancedTxDevice == null || basicTxDevice != null)
else if(advancedTxDevice == null || basicTxDevice != null) // Basic TX device
{
Debug.Console(1, "Setting up actions and feedbacks on input card {0}", ioSlot);
dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);

20
PepperDashEssentials/Bridges/DmTxControllerBridge.cs
View File

@@ -57,7 +57,7 @@ namespace PepperDash.Essentials.Bridges
trilist.UShortInput[joinMap.HdcpSupportCapability].UShortValue = (ushort)tx.HdcpSupportCapability;
if(txR.InputPorts[DmPortName.HdmiIn] != null)
if (txR.InputPorts[DmPortName.HdmiIn] != null)
{
var inputPort = txR.InputPorts[DmPortName.HdmiIn];
@@ -71,7 +71,7 @@ namespace PepperDash.Essentials.Bridges
SetHdcpCapabilityAction(hdcpTypeSimple, port, joinMap.Port1HdcpState, trilist);
}
}
if (txR.InputPorts[DmPortName.HdmiIn1] != null)
{
var inputPort = txR.InputPorts[DmPortName.HdmiIn1];
@@ -103,6 +103,22 @@ namespace PepperDash.Essentials.Bridges
}
}
var txFreeRun = tx as IHasFreeRun;
if (txFreeRun != null)
{
txFreeRun.FreeRunEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.FreeRunEnabled]);
trilist.SetBoolSigAction(joinMap.FreeRunEnabled, new Action<bool>(b => txFreeRun.SetFreeRunEnabled(b)));
}
var txVga = tx as IVgaBrightnessContrastControls;
{
txVga.VgaBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.VgaBrightness]);
txVga.VgaContrastFeedback.LinkInputSig(trilist.UShortInput[joinMap.VgaContrast]);
trilist.SetUShortSigAction(joinMap.VgaBrightness, new Action<ushort>(u => txVga.SetVgaBrightness(u)));
trilist.SetUShortSigAction(joinMap.VgaContrast, new Action<ushort>(u => txVga.SetVgaContrast(u)));
}
}
static void SetHdcpCapabilityAction(bool hdcpTypeSimple, EndpointHdmiInput port, uint join, BasicTriList trilist)

222
PepperDashEssentials/Bridges/GlsOccupancySensorBaseControllerBridge.cs
View File

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

43
PepperDashEssentials/Bridges/JoinMaps/C2nRthsControllerJoinMap.cs Normal file
View File

@@ -0,0 +1,43 @@
using System.Linq;
using Crestron.SimplSharp.Reflection;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Bridges
{
public class C2nRthsControllerJoinMap:JoinMapBase
{
public uint IsOnline { get; set; }
public uint Name { get; set; }
public uint Temperature { get; set; }
public uint Humidity { get; set; }
public uint TemperatureFormat { get; set; }
public C2nRthsControllerJoinMap()
{
//digital
IsOnline = 1;
TemperatureFormat = 2;
//Analog
Temperature = 2;
Humidity = 3;
//serial
Name = 1;
}
public override void OffsetJoinNumbers(uint joinStart)
{
var joinOffset = joinStart - 1;
var properties =
GetType().GetCType().GetProperties().Where(p => p.PropertyType == typeof(uint)).ToList();
foreach (var propertyInfo in properties)
{
propertyInfo.SetValue(this, (uint)propertyInfo.GetValue(this, null) + joinOffset, null);
}
}
}
}

1
PepperDashEssentials/Bridges/JoinMaps/DmChassisControllerJoinMap.cs
View File

@@ -139,6 +139,7 @@ namespace PepperDash.Essentials.Bridges
OutputEndpointOnline = OutputEndpointOnline + joinOffset;
HdcpSupportState = HdcpSupportState + joinOffset;
HdcpSupportCapability = HdcpSupportCapability + joinOffset;
TxAdvancedIsPresent = TxAdvancedIsPresent + joinOffset;
}
}
}

20
PepperDashEssentials/Bridges/JoinMaps/DmTxControllerJoinMap.cs
View File

@@ -18,6 +18,10 @@ namespace PepperDash.Essentials.Bridges
/// High when video sync is detected
/// </summary>
public uint VideoSyncStatus { get; set; }
/// <summary>
///
/// </summary>
public uint FreeRunEnabled { get; set; }
#endregion
#region Analogs
@@ -41,6 +45,16 @@ namespace PepperDash.Essentials.Bridges
/// Sets and reports the current HDCP state for the corresponding input port
/// </summary>
public uint Port2HdcpState { get; set; }
/// <summary>
/// Sets and reports the current VGA Brightness level
/// </summary>
public uint VgaBrightness { get; set; }
/// <summary>
/// Sets and reports the current VGA Contrast level
/// </summary>
public uint VgaContrast { get; set; }
#endregion
#region Serials
@@ -56,6 +70,7 @@ namespace PepperDash.Essentials.Bridges
// Digital
IsOnline = 1;
VideoSyncStatus = 2;
FreeRunEnabled = 3;
// Serial
CurrentInputResolution = 1;
// Analog
@@ -64,6 +79,8 @@ namespace PepperDash.Essentials.Bridges
HdcpSupportCapability = 3;
Port1HdcpState = 4;
Port2HdcpState = 5;
VgaBrightness = 6;
VgaContrast = 7;
}
public override void OffsetJoinNumbers(uint joinStart)
@@ -72,12 +89,15 @@ namespace PepperDash.Essentials.Bridges
IsOnline = IsOnline + joinOffset;
VideoSyncStatus = VideoSyncStatus + joinOffset;
FreeRunEnabled = FreeRunEnabled + joinOffset;
CurrentInputResolution = CurrentInputResolution + joinOffset;
VideoInput = VideoInput + joinOffset;
AudioInput = AudioInput + joinOffset;
HdcpSupportCapability = HdcpSupportCapability + joinOffset;
Port1HdcpState = Port1HdcpState + joinOffset;
Port2HdcpState = Port2HdcpState + joinOffset;
VgaBrightness = VgaBrightness + joinOffset;
VgaContrast = VgaContrast + joinOffset;
}
}
}

449
PepperDashEssentials/Bridges/JoinMaps/GlsOccupancySensorBaseJoinMap.cs
View File

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

49
PepperDashEssentials/Bridges/JoinMaps/StatusSignControllerJoinMap.cs Normal file
View File

@@ -0,0 +1,49 @@
using System.Linq;
using Crestron.SimplSharp.Reflection;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Bridges
{
public class StatusSignControllerJoinMap:JoinMapBase
{
public uint IsOnline { get; set; }
public uint Name { get; set; }
public uint RedLed { get; set; }
public uint GreenLed { get; set; }
public uint BlueLed { get; set; }
public uint RedControl { get; set; }
public uint GreenControl { get; set; }
public uint BlueControl { get; set; }
public StatusSignControllerJoinMap()
{
//digital
IsOnline = 1;
RedControl = 2;
GreenControl = 3;
BlueControl = 4;
//Analog
RedLed = 2;
GreenLed = 3;
BlueLed = 4;
//string
Name = 1;
}
public override void OffsetJoinNumbers(uint joinStart)
{
var joinOffset = joinStart - 1;
var properties =
GetType().GetCType().GetProperties().Where(p => p.PropertyType == typeof (uint)).ToList();
foreach (var propertyInfo in properties)
{
propertyInfo.SetValue(this, (uint) propertyInfo.GetValue(this, null) + joinOffset, null);
}
}
}
}

65
PepperDashEssentials/Bridges/StatusSignControllerBridge.cs Normal file
View File

@@ -0,0 +1,65 @@
using Crestron.SimplSharpPro.DeviceSupport;
using Newtonsoft.Json;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.CrestronIO;
namespace PepperDash.Essentials.Bridges
{
public static class StatusSignDeviceApiExtensions
{
public static void LinkToApi(this StatusSignController ssDevice, BasicTriList trilist, uint joinStart,
string joinMapKey)
{
var joinMap = new StatusSignControllerJoinMap();
var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
if (!string.IsNullOrEmpty(joinMapSerialized))
joinMap = JsonConvert.DeserializeObject<StatusSignControllerJoinMap>(joinMapSerialized);
joinMap.OffsetJoinNumbers(joinStart);
Debug.Console(1, ssDevice, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
trilist.SetBoolSigAction(joinMap.RedControl, b => EnableControl(trilist, joinMap, ssDevice));
trilist.SetBoolSigAction(joinMap.GreenControl, b => EnableControl(trilist, joinMap, ssDevice));
trilist.SetBoolSigAction(joinMap.BlueControl, b => EnableControl(trilist, joinMap, ssDevice));
trilist.SetUShortSigAction(joinMap.RedLed, u => SetColor(trilist, joinMap, ssDevice));
trilist.SetUShortSigAction(joinMap.GreenLed, u => SetColor(trilist, joinMap, ssDevice));
trilist.SetUShortSigAction(joinMap.BlueLed, u => SetColor(trilist, joinMap, ssDevice));
trilist.StringInput[joinMap.Name].StringValue = ssDevice.Name;
ssDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
ssDevice.RedLedEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RedControl]);
ssDevice.BlueLedEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.BlueControl]);
ssDevice.GreenLedEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.GreenControl]);
ssDevice.RedLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.RedLed]);
ssDevice.BlueLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.BlueLed]);
ssDevice.GreenLedBrightnessFeedback.LinkInputSig(trilist.UShortInput[joinMap.GreenLed]);
}
private static void EnableControl(BasicTriList triList, StatusSignControllerJoinMap joinMap,
StatusSignController device)
{
var redEnable = triList.BooleanOutput[joinMap.RedControl].BoolValue;
var greenEnable = triList.BooleanOutput[joinMap.GreenControl].BoolValue;
var blueEnable = triList.BooleanOutput[joinMap.BlueControl].BoolValue;
device.EnableLedControl(redEnable, greenEnable, blueEnable);
}
private static void SetColor(BasicTriList triList, StatusSignControllerJoinMap joinMap,
StatusSignController device)
{
var redBrightness = triList.UShortOutput[joinMap.RedLed].UShortValue;
var greenBrightness = triList.UShortOutput[joinMap.GreenLed].UShortValue;
var blueBrightness = triList.UShortOutput[joinMap.BlueLed].UShortValue;
device.SetColor(redBrightness, greenBrightness, blueBrightness);
}
}
}

10
PepperDashEssentials/Bridges/SystemMonitorBridge.cs
View File

@@ -61,6 +61,16 @@ namespace PepperDash.Essentials.Bridges
(b => SystemMonitor.ProgramCollection[programNumber].RegistrationState = eProgramRegistrationState.Unregister));
p.Value.ProgramUnregisteredFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramUnregister]);
p.Value.ProgramNameFeedback.LinkInputSig(trilist.StringInput[programSlotJoinStart + joinMap.ProgramName]);
p.Value.ProgramCompileTimeFeedback.LinkInputSig(
trilist.StringInput[programSlotJoinStart + joinMap.ProgramCompiledTime]);
p.Value.CrestronDataBaseVersionFeedback.LinkInputSig(
trilist.StringInput[programSlotJoinStart + joinMap.ProgramCrestronDatabaseVersion]);
p.Value.EnvironmentVersionFeedback.LinkInputSig(
trilist.StringInput[programSlotJoinStart + joinMap.ProgramEnvironmentVersion]);
p.Value.AggregatedProgramInfoFeedback.LinkInputSig(
trilist.StringInput[programSlotJoinStart + joinMap.AggregatedProgramInfo]);
programSlotJoinStart = programSlotJoinStart + joinMap.ProgramOffsetJoin;
}
}

72
PepperDashEssentials/Configuration Original/Builders/TPConfig.cs
View File

@@ -1,72 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Core.Config;
namespace PepperDash.Essentials
{
//public class TPConfig : DeviceConfig
//{
// new public TPConfigProperties Properties { get; set; }
//}
//public class TPConfigProperties
//{
// /*
// "properties": {
// "ipId": "aa",
// "defaultSystemKey": "system1",
// "sgdPath": "\\NVRAM\\Program1\\Sgds\\PepperDash Essentials TSW1050_v0.9.sgd",
// "usesSplashPage": true,
// "showDate": true,
// "showTime": false
// }
// */
// public uint IpId { get; set; }
// public string deafultSystemKey { get; set; }
// public string SgdPath { get; set; }
// public bool UsesSplashPage { get; set; }
// public bool ShowDate { get; set; }
// public bool ShowTime { get; set; }
//}
///// <summary>
///// The gist of this converter: The comspec JSON comes in with normal values that need to be converted
///// into enum names. This converter takes the value and applies the appropriate enum's name prefix to the value
///// and then returns the enum value using Enum.Parse
///// </summary>
//public class TPPropertiesConverter : JsonConverter
//{
// public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
// {
// return JObject.Load(reader);
// }
// /// <summary>
// /// This will be hit with every value in the ComPortConfig class. We only need to
// /// do custom conversion on the comspec items.
// /// </summary>
// public override bool CanConvert(Type objectType)
// {
// return true;
// }
// public override bool CanRead { get { return true; } }
// public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
// {
// throw new NotImplementedException();
// }
//}
}

82
PepperDashEssentials/Configuration Original/ConfigTieLine.cs
View File

@@ -1,82 +0,0 @@
using System.Linq;
using Newtonsoft.Json;
using PepperDash.Essentials.Core;
using PepperDash.Core;
namespace PepperDash.Essentials
{
public class ConfigTieLine
{
[JsonProperty(Required=Required.Always)]
public string SourceDeviceKey { get; set; }
[JsonProperty(Required = Required.Always)]
public string SourcePortKey { get; set; }
[JsonProperty(Required = Required.Always)]
public string DestinationDeviceKey { get; set; }
[JsonProperty(Required = Required.Always)]
public string DestinationPortKey { get; set; }
public override string ToString()
{
return string.Format("Tie line: [{0}]{1} --> [{2}]{3}", SourceDeviceKey, SourcePortKey, DestinationDeviceKey, DestinationPortKey);
}
/// <summary>
/// Returns a tie line if one can be constructed between the two devices and ports
/// </summary>
/// <returns>TieLine or null if devices or ports don't exist</returns>
public TieLine GetTieLine()
{
var sourceDevice = (IRoutingOutputs)DeviceManager.GetDeviceForKey(SourceDeviceKey);
var destinationDevice = (IRoutingInputs)DeviceManager.GetDeviceForKey(DestinationDeviceKey);
if (sourceDevice == null)
{
Debug.Console(0, " Cannot create TieLine. Source device '{0}' not found or does not have outputs",
SourceDeviceKey);
return null;
}
else if (destinationDevice == null)
{
Debug.Console(0, " Cannot create TieLine. Destination device '{0}' not found or does not have inputs",
DestinationDeviceKey);
return null;
}
else
{
// Get the ports by key name from the lists
RoutingOutputPort sourcePort = sourceDevice.OutputPorts.FirstOrDefault(
p => p.Key.Equals(SourcePortKey, System.StringComparison.OrdinalIgnoreCase));
//RoutingOutputPort sourcePort = null;
//sourceDevice.OutputPorts.TryGetValue(SourcePortKey, out sourcePort);
if (sourcePort == null)
{
Debug.Console(0, " Cannot create TieLine {0}-->{1}. Source device does not have output port '{2}'",
sourceDevice.Key, destinationDevice.Key, SourcePortKey);
return null;
}
RoutingInputPort destinationPort = destinationDevice.InputPorts.FirstOrDefault(
p => p.Key.Equals(DestinationPortKey, System.StringComparison.OrdinalIgnoreCase));
//RoutingInputPort destinationPort = null;
//destinationDevice.InputPorts.TryGetValue(DestinationPortKey, out destinationPort);
if (destinationPort == null)
{
Debug.Console(0, " Cannot create TieLine {0}-->{1}. Destination device does not have input port '{2}'",
sourceDevice.Key, destinationDevice.Key, DestinationPortKey);
return null;
}
var tl = new TieLine(sourcePort, destinationPort);
Debug.Console(1, " Created {0}", this);
return tl;
}
}
}
}

287
PepperDashEssentials/Configuration Original/Configuration.cs
View File

@@ -1,287 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Crestron.SimplSharp;
using Crestron.SimplSharp.CrestronIO;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
using Crestron.SimplSharpPro.CrestronThread;
using Crestron.SimplSharpPro.Diagnostics;
using Crestron.SimplSharpPro.EthernetCommunication;
using Crestron.SimplSharpPro.UI;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Devices;
//using PepperDash.Essentials.Core.Devices.Dm;
//using PepperDash.Essentials.Fusion;
using PepperDash.Core;
namespace PepperDash.Essentials
{
public static class Configuration
{
public static string LastPath { get; private set; }
public static CrestronControlSystem ControlSystem { get; private set; }
public static void Initialize(CrestronControlSystem cs)
{
CrestronConsole.AddNewConsoleCommand(ReloadFromConsole, "configreload", "Reloads configuration file",
ConsoleAccessLevelEnum.AccessOperator);
ControlSystem = cs;
}
public static bool ReadConfiguration(string filePath)
{
try
{
// Read file
if (File.Exists(filePath))
{
LastPath = filePath;
string json = File.ReadToEnd(filePath, System.Text.Encoding.ASCII);
JObject jo = JObject.Parse(json);
var info = JsonConvert.DeserializeObject<ConfigInfo>(jo["info"].ToString());
Debug.Console(0, "\r[Config] file read:");
Debug.Console(0, " File: {0}", filePath);
Debug.Console(0, " Name: {0}", info.Name);
Debug.Console(0, " Type: {0}", info.SystemTemplateType);
Debug.Console(0, " Date: {0}", info.EditDate);
Debug.Console(0, " ConfigVersion: {0}", info.Version);
Debug.Console(0, " EditedBy: {0}", info.EditedBy);
Debug.Console(0, " Comment: {0}\r", info.Comment);
// Get the main config object
var jConfig = jo["configuration"];
// Devices
var jDevices = (JArray)jConfig["devices"];
CreateDevices(jDevices);
// TieLines
var jRouting = jConfig["routing"];
CreateRouting(jRouting);
/// Parse the available source list(s)
var jSourceLists = (JArray)jConfig["sourceLists"];
var jSourceListJson = jSourceLists.ToString();
List<ConfigSourceList> sourceLists = JsonConvert.DeserializeObject<List<ConfigSourceList>>(jSourceListJson);
// System
var jSystems = (JArray)jConfig["systems"];
CreateSystems(jSystems, sourceLists);
// Activate everything
DeviceManager.ActivateAll();
}
else
{
Debug.Console(0, "[Config] file not found '{0}'", filePath);
return false;
}
}
catch (Exception e)
{
Debug.Console(0, "Configuration read error: \r {0}", e);
return false;
}
return true;
}
static void CreateDevices(JArray jDevices)
{
//Debug.Console(0, " Creating {0} devices", jDevices.Count);
//for (int i = 0; i < jDevices.Count; i++)
//{
// var jDev = jDevices[i];
// //var devConfig = JsonConvert.DeserializeObject<DeviceConfig>(jDev.ToString());
// //Debug.Console(0, "++++++++++++{0}", devConfig);
// var group = jDev["group"].Value<string>();
// Debug.Console(0, " [{0}], creating {1}:{2}", jDev["key"].Value<string>(),
// group, jDev["type"].Value<string>());
// Device dev = null;
// if (group.Equals("Display", StringComparison.OrdinalIgnoreCase))
// dev = DisplayFactory.CreateDisplay(jDev);
// else if (group.Equals("DeviceMonitor", StringComparison.OrdinalIgnoreCase))
// dev = DeviceManagerFactory.Create(jDev);
// //else if (group.Equals("Pc", StringComparison.OrdinalIgnoreCase))
// // dev = PcFactory.Create(jDev);
// //else if (group.Equals("SetTopBox", StringComparison.OrdinalIgnoreCase))
// // dev = SetTopBoxFactory.Create(jDev);
// //else if (group.Equals("DiscPlayer", StringComparison.OrdinalIgnoreCase))
// // dev = DiscPlayerFactory.Create(jDev);
// //else if (group.Equals("Touchpanel", StringComparison.OrdinalIgnoreCase))
// // dev = TouchpanelFactory.Create(jDev);
// else if (group.Equals("dmEndpoint", StringComparison.OrdinalIgnoreCase)) // Add Transmitter and Receiver
// dev = DmFactory.Create(jDev);
// else if (group.Equals("dmChassic", StringComparison.OrdinalIgnoreCase))
// dev = DmFactory.CreateChassis(jDev);
// else if (group.Equals("processor", StringComparison.OrdinalIgnoreCase))
// continue; // ignore it. Has no value right now.
// //else if (group.Equals("remote", StringComparison.OrdinalIgnoreCase))
// // dev = RemoteFactory.Create(jDev);
// else
// {
// Debug.Console(0, " ERROR: Device [{0}] has unknown Group '{1}'. Skipping",
// jDev["key"].Value<string>(), group);
// continue;
// }
// if (dev != null)
// DeviceManager.AddDevice(dev);
// else
// Debug.Console(0, " ERROR: failed to create device {0}",
// jDev["key"].Value<string>());
//}
}
static void CreateSystems(JArray jSystems, List<ConfigSourceList> sourceLists)
{
// // assuming one system
// var jSystem = jSystems[0];
// var name = jSystem.Value<string>("name");
// var key = FactoryHelper.KeyOrConvertName(jSystem.Value<string>("key"), name);
// if (jSystem.Value<string>("type").Equals("EssentialsHuddleSpace", StringComparison.OrdinalIgnoreCase))
// {
// var sys = new HuddleSpaceRoom(key, name);
// var props = jSystem["properties"];
// var displayKey = props["displayKey"].Value<string>();
// if (displayKey != null)
// sys.DefaultDisplay = (DisplayBase)DeviceManager.GetDeviceForKey(displayKey);
// // Add sources from passed in config list
// var myList = sourceLists.FirstOrDefault(
// l => l.Key.Equals(props.Value<string>("sourceListKey"), StringComparison.OrdinalIgnoreCase));
// if (myList != null)
// AddSourcesToSystem(sys, myList);
// DeviceManager.AddDevice(sys);
// //spin up a fusion thing too
//#warning add this fusion connector back in later
// //DeviceManager.AddDevice(new EssentialsHuddleSpaceFusionSystemController(sys, 0xf1));
//}
}
//static void AddSourcesToSystem(Room system, ConfigSourceList configList)
//{
//foreach (var configItem in configList.PresentationSources)
//{
// var src = (IPresentationSource)DeviceManager.GetDeviceForKey(configItem.SourceKey);
// if (src != null)
// system.Sources.Add(configItem.Number, src);
// else
// Debug.Console(0, system, "cannot find source '{0}' from list {1}",
// configItem.SourceKey, configList.Name);
//}
//}
/// <summary>
/// Links up routing, creates tie lines
/// </summary>
/// <param name="jRouting">The "Routing" JArray from configuration</param>
static void CreateRouting(JToken jRouting)
{
var jsonTieLines = jRouting["tieLines"].ToString();
var tieLineConfigs = JsonConvert.DeserializeObject<List<ConfigTieLine>>(jsonTieLines);
foreach (var c in tieLineConfigs)
{
var tl = c.GetTieLine();
if (tl != null)
TieLineCollection.Default.Add(tl);
}
}
/// <summary>
/// Returns the IIROutputPorts device (control system, etc) that contains a given IR port
/// </summary>
/// <param name="propsToken"></param>
static IROutputPort GetIrPort(JToken propsToken)
{
var portDevName = propsToken.Value<string>("IrPortDevice");
var portNum = propsToken.Value<uint>("IrPortNumber");
if (portDevName.Equals("controlSystem", StringComparison.OrdinalIgnoreCase))
{
IIROutputPorts irDev = ControlSystem;
if (portNum <= irDev.NumberOfIROutputPorts)
return ControlSystem.IROutputPorts[portNum];
else
Debug.Console(0, "[Config] ERROR: IR Port {0} out of range. Range 0-{1} on {2}", portNum,
ControlSystem.IROutputPorts.Count, irDev.ToString());
}
return null;
}
static void HandleUnknownType(JToken devToken, string type)
{
Debug.Console(0, "[Config] ERROR: Type '{0}' not found in group '{1}'", type,
devToken.Value<string>("Group"));
}
static void HandleDeviceCreationError(JToken devToken, Exception e)
{
Debug.Console(0, "[Config] ERROR creating device [{0}]: \r{1}",
devToken["Key"].Value<string>(), e);
}
/// <summary>
/// Console helper to reload
/// </summary>
static void ReloadFromConsole(string s)
{
// Gotta tear down everything first!
if (!string.IsNullOrEmpty(LastPath))
{
ReadConfiguration(LastPath);
}
}
}
public class ConfigSourceList
{
[JsonProperty(Required = Required.Always)]
public string Key { get; set; }
[JsonProperty(Required = Required.Always)]
public string Name { get; set; }
[JsonProperty(Required = Required.Always)]
public List<ConfigSourceItem> PresentationSources { get; set; }
}
public class ConfigSourceItem
{
[JsonProperty(Required = Required.Always)]
public uint Number { get; set; }
[JsonProperty(Required = Required.Always)]
public string SourceKey { get; set; }
public string AlternateName { get; set; }
}
public class ConfigInfo
{
public string SystemTemplateType { get; set; }
public string ProcessorType { get; set; }
public string Name { get; set; }
public uint ProgramSlotNumber { get; set; }
public string Version { get; set; }
public string EditedBy { get; set; }
public string EditDate { get; set; }
public string Comment { get; set; }
}
}

20
PepperDashEssentials/Configuration Original/ConfigurationHelpers.cs
View File

@@ -1,20 +0,0 @@
using Newtonsoft.Json;
namespace PepperDash.Essentials
{
public class SourceListConfigProperties
{
[JsonProperty(Required= Required.Always)]
public uint Number { get; set; }
[JsonProperty(Required= Required.Always)]
public string SourceKey { get; set; }
public string AltName { get; set; }
public string AltIcon { get; set; }
public SourceListConfigProperties()
{
AltName = "";
AltIcon = "";
}
}
}

54
PepperDashEssentials/Configuration Original/Factories/CommFactory.cs
View File

@@ -1,54 +0,0 @@
//using System;
//using Crestron.SimplSharpPro;
//using Newtonsoft.Json;
//using Newtonsoft.Json.Linq;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Devices;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// public class CommFactory
// {
// public static IBasicCommunication CreateCommForDevice(JToken devToken)
// {
// var devKey = devToken.Value<string>("key");
// IBasicCommunication comm = null;
// try
// {
// var control = devToken["properties"]["control"];
// var commMethod = control["method"].Value<string>();
// if (commMethod == "com")
// {
// var comConfig = JsonConvert.DeserializeObject<ComPortConfig>(
// control["comParams"].ToString(),
// new JsonSerializerSettings
// {
// // Needs ObjectCreationHandling to make the ComSpec struct populate
// ObjectCreationHandling = ObjectCreationHandling.Replace,
// Converters = new JsonConverter[] { new ComSpecJsonConverter() }
// });
// comm = new ComPortController(devKey + "-com", comConfig.GetComPort(), comConfig.ComSpec);
// }
// else if (commMethod == "tcpIp")
// {
// var tcpConfig = JsonConvert.DeserializeObject<TcpIpConfig>(control["tcpParams"].ToString());
// comm = new GenericTcpIpClient(devKey + "-tcp", tcpConfig.Address, tcpConfig.Port, tcpConfig.BufferSize);
// }
// }
// catch (Exception e)
// {
// Debug.Console(0, "Cannot create communication from JSON:\r{0}\r\rException:\r{1}", devToken.ToString(), e);
// }
// // put it in the device manager if it's the right flavor
// var comDev = comm as Device;
// if (comDev != null)
// DeviceManager.AddDevice(comDev);
// return comm;
// }
// }
//}

38
PepperDashEssentials/Configuration Original/Factories/DeviceMonitorFactory.cs
View File

@@ -1,38 +0,0 @@
//using System;
//using Crestron.SimplSharpPro;
//using Newtonsoft.Json.Linq;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Core.Devices;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// public class DeviceManagerFactory
// {
// public static Device Create(JToken devToken)
// {
// Device dev = null;
// try
// {
// var devType = devToken.Value<string>("type");
// var devKey = devToken.Value<string>("key");
// var devName = devToken.Value<string>("name");
// if (devType.Equals("DeviceMonitor", StringComparison.OrdinalIgnoreCase))
// {
// var comm = CommFactory.CreateCommForDevice(devToken);
// if (comm == null) return null;
// dev = new GenericCommunicationMonitoredDevice(devKey, devName, comm, devToken["properties"]["pollString"].Value<string>());
// }
// else
// FactoryHelper.HandleUnknownType(devToken, devType);
// }
// catch (Exception e)
// {
// FactoryHelper.HandleDeviceCreationError(devToken, e);
// }
// return dev;
// }
// }
//}

122
PepperDashEssentials/Configuration Original/Factories/DisplayFactory.cs
View File

@@ -1,122 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using Crestron.SimplSharp;
//using Newtonsoft.Json;
//using Newtonsoft.Json.Linq;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Devices;
//using PepperDash.Essentials.Displays;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// public class DisplayFactory
// {
// public static DisplayBase CreateDisplay(JToken devToken)
// {
// DisplayBase dev = null;
// try
// {
// var devType = devToken.Value<string>("type");
// var devKey = devToken.Value<string>("key");
// var devName = devToken.Value<string>("name");
// var properties = devToken["properties"];
// if (devType.Equals("MockDisplay", StringComparison.OrdinalIgnoreCase))
// dev = new MockDisplay(devKey, devName);
// else if (devType.Equals("NecMPSX", StringComparison.OrdinalIgnoreCase))
// {
// var comm = CommFactory.CreateCommForDevice(devToken);
// if (comm == null) return null;
// dev = new NecPSXMDisplayCom(devKey, devName, comm);
// //var commMethod = properties["control"]["method"].Value<string>();
// //// Helper-ize this?
// //if(commMethod == "com")
// //{
// // // Move some of this up above???
// // var comConfig = JsonConvert.DeserializeObject<ComPortConfig>(
// // properties["control"]["comParams"].ToString(),
// // new JsonSerializerSettings {
// // // Needs ObjectCreationHandling to make the ComSpec struct populate
// // ObjectCreationHandling = ObjectCreationHandling.Replace,
// // Converters = new JsonConverter[] { new ComSpecJsonConverter() }
// // });
// // dev = new NecPSXMDisplayCom(devKey, devName, comConfig.GetComPort(), comConfig.ComSpec);
// //}
// //else if (commMethod == "tcpIp")
// //{
// // var spec = properties["control"]["tcpSpec"];
// // var host = spec["address"].Value<string>();
// // var port = spec["port"].Value<int>();
// // dev = new NecPSXMDisplayCom(devKey, devName, host, port);
// //}
// }
// else if (devType.Equals("NecNpPa550", StringComparison.OrdinalIgnoreCase))
// {
// var proj = new NecPaSeriesProjector(devKey, devName);
// var comm = CreateCommunicationFromPropertiesToken(
// devKey + "-comm", properties, 3000);
// proj.CommunicationMethod = comm;
// dev = proj;
// }
// else
// FactoryHelper.HandleUnknownType(devToken, devType);
// }
// catch (Exception e)
// {
// FactoryHelper.HandleDeviceCreationError(devToken, e);
// }
// return dev;
// }
// public static IBasicCommunication CreateCommunicationFromPropertiesToken(
// string commKey, JToken properties, int bufferSize)
// {
// Debug.Console(2, "Building port from: {0}", properties.ToString());
// var tcpToken = properties["TcpIp"];
// if (tcpToken != null)
// {
// // Convert the Tcp property
// var spec = JsonConvert.DeserializeObject<TcpIpConfig>(tcpToken.ToString());
// var tcp = new GenericTcpIpClient(commKey, spec.Address, spec.Port, bufferSize);
// DeviceManager.AddDevice(tcp);
// return tcp;
// }
// var com = properties["Com"];
// if (com != null)
// {
// // Make the interim config object
// var comConfig = JsonConvert.DeserializeObject<ComPortConfig>(com.ToString(),
// new JsonSerializerSettings { ObjectCreationHandling = ObjectCreationHandling.Replace });
// // Get the IComPorts hardware device from the Device or Control System
// var comDev = comConfig.GetIComPortsDeviceFromManagedDevice();
// if (comDev != null)
// {
// var controller = new ComPortController(commKey, comDev.ComPorts[comConfig.ComPortNumber], comConfig.ComSpec);
// DeviceManager.AddDevice(controller);
// return controller;
// }
// }
// Debug.Console(0, "No Tcp or Com port information for port {0}", commKey);
// return null;
// }
// }
//}

101
PepperDashEssentials/Configuration Original/Factories/DmFactory.cs
View File

@@ -1,101 +0,0 @@
using System;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DM;
using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
using Newtonsoft.Json.Linq;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Devices;
//using PepperDash.Essentials.Devices.Dm;
using PepperDash.Core;
namespace PepperDash.Essentials
{
public class DmFactory
{
public static Device Create(JToken devToken)
{
Device dev = null;
try
{
var devType = devToken.Value<string>("type");
var devKey = devToken.Value<string>("key");
var devName = devToken.Value<string>("name");
// Catch all 200 series TX
var devprops = devToken["properties"];
var ipId = Convert.ToUInt32(devprops.Value<string>("ipId"), 16);
var parent = devprops.Value<string>("parent");
if (parent == null)
parent = "controlSystem";
if (devType.StartsWith("DmTx2", StringComparison.OrdinalIgnoreCase))
{
DmTx201C tx;
if (parent.Equals("controlSystem", StringComparison.OrdinalIgnoreCase))
{
tx = new DmTx201C(ipId, Global.ControlSystem);
//dev = new DmTx201SBasicController(devKey, devName, tx);
}
}
else if (devType.StartsWith("DmRmc", StringComparison.OrdinalIgnoreCase))
{
DmRmc100C rmc;
if (parent.Equals("controlSystem", StringComparison.OrdinalIgnoreCase))
{
rmc = new DmRmc100C(ipId, Global.ControlSystem);
//dev = new DmRmcBaseController(devKey, devName, rmc);
}
}
else
FactoryHelper.HandleUnknownType(devToken, devType);
}
catch (Exception e)
{
FactoryHelper.HandleDeviceCreationError(devToken, e);
}
return dev;
}
public static Device CreateChassis(JToken devToken)
{
Device dev = null;
try
{
var devType = devToken.Value<string>("type");
var devKey = devToken.Value<string>("key");
var devName = devToken.Value<string>("name");
// Catch all 200 series TX
var devprops = devToken["properties"];
var ipId = Convert.ToUInt32(devprops.Value<string>("ipId"), 16);
var parent = devprops.Value<string>("parent");
if (parent == null)
parent = "controlSystem";
if (devType.Equals("dmmd8x8", StringComparison.OrdinalIgnoreCase))
{
var dm = new DmMd8x8(ipId, Global.ControlSystem);
//dev = new DmChassisController(devKey, devName, dm);
}
else if (devType.Equals("dmmd16x16", StringComparison.OrdinalIgnoreCase))
{
var dm = new DmMd16x16(ipId, Global.ControlSystem);
//dev = new DmChassisController(devKey, devName, dm);
}
else if (devType.Equals("dmmd32x32", StringComparison.OrdinalIgnoreCase))
{
var dm = new DmMd32x32(ipId, Global.ControlSystem);
//dev = new DmChassisController(devKey, devName, dm);
}
}
catch (Exception e)
{
FactoryHelper.HandleDeviceCreationError(devToken, e);
}
return dev;
}
}
}

124
PepperDashEssentials/Configuration Original/Factories/FactoryHelper.cs
View File

@@ -1,124 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using PepperDash.Essentials.Core;
using PepperDash.Essentials.Devices;
using PepperDash.Core;
namespace PepperDash.Essentials
{
public static class FactoryHelper
{
public static string IrDriverPathPrefix = Global.FilePathPrefix + "IR" + Global.DirectorySeparator;
public static void HandleUnknownType(JToken devToken, string type)
{
Debug.Console(0, "[Config] ERROR: Type '{0}' not found in group '{1}'", type,
devToken.Value<string>("group"));
}
public static void HandleDeviceCreationError(JToken devToken, Exception e)
{
Debug.Console(0, "[Config] ERROR creating device [{0}]: \r{1}",
devToken["key"].Value<string>(), e);
Debug.Console(0, "Relevant config:\r{0}", devToken.ToString(Newtonsoft.Json.Formatting.Indented));
}
/// <summary>
/// Finds either the ControlSystem or a device controller that contains IR ports and
/// returns a port from the hardware device
/// </summary>
/// <param name="propsToken"></param>
/// <returns>Crestron IrPort or null if device doesn't have IR or is not found</returns>
public static IrOutPortConfig GetIrPort(JToken propsToken)
{
var irSpec = propsToken["control"]["irSpec"];
var portDevKey = irSpec.Value<string>("portDeviceKey");
var portNum = irSpec.Value<uint>("portNumber");
IIROutputPorts irDev = null;
if (portDevKey.Equals("controlSystem", StringComparison.OrdinalIgnoreCase)
|| portDevKey.Equals("processor", StringComparison.OrdinalIgnoreCase))
irDev = Global.ControlSystem;
else
irDev = DeviceManager.GetDeviceForKey(portDevKey) as IIROutputPorts;
if (irDev == null)
{
Debug.Console(0, "[Config] Error, device with IR ports '{0}' not found", portDevKey);
return null;
}
if (portNum <= irDev.NumberOfIROutputPorts) // success!
{
var file = IrDriverPathPrefix + irSpec["file"].Value<string>();
return new IrOutPortConfig { Port = irDev.IROutputPorts[portNum], FileName = file };
}
else
{
Debug.Console(0, "[Config] Error, device '{0}' IR port {1} out of range",
portDevKey, portNum);
return null;
}
}
/// <summary>
/// Finds either the ControlSystem or a device controller that contains com ports and
/// returns a port from the hardware device
/// </summary>
/// <param name="propsToken">The Properties token from the device's config</param>
/// <returns>Crestron ComPort or null if device doesn't have IR or is not found</returns>
public static ComPort GetComPort(JToken propsToken)
{
var portDevKey = propsToken.Value<string>("comPortDevice");
var portNum = propsToken.Value<uint>("comPortNumber");
IComPorts comDev = null;
if (portDevKey.Equals("controlSystem", StringComparison.OrdinalIgnoreCase))
comDev = Global.ControlSystem;
else
comDev = DeviceManager.GetDeviceForKey(portDevKey) as IComPorts;
if (comDev == null)
{
Debug.Console(0, "[Config] Error, device with com ports '{0}' not found", portDevKey);
return null;
}
if (portNum <= comDev.NumberOfComPorts) // success!
return comDev.ComPorts[portNum];
else
{
Debug.Console(0, "[Config] Error, device '{0}' com port {1} out of range",
portDevKey, portNum);
return null;
}
}
/// <summary>
/// Returns the key if it exists or converts the name into a key
/// </summary>
public static string KeyOrConvertName(string key, string name)
{
if (string.IsNullOrEmpty(key))
return name.Replace(' ', '-');
return key;
}
}
/// <summary>
/// Wrapper to help in IR port creation
/// </summary>
public class IrOutPortConfig
{
public IROutputPort Port { get; set; }
public string FileName { get; set; }
}
}

52
PepperDashEssentials/Configuration Original/Factories/MAYBE SetTopBoxFactory.cs
View File

@@ -1,52 +0,0 @@
//using System;
//using Crestron.SimplSharpPro;
//using Newtonsoft.Json.Linq;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Devices;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// public class SetTopBoxFactory
// {
// public static Device Create(JToken devToken)
// {
// Device dev = null;
// try
// {
// var devType = devToken.Value<string>("type");
// var devKey = devToken.Value<string>("key");
// var devName = devToken.Value<string>("name");
// var props = devToken["properties"];
// var portConfig = FactoryHelper.GetIrPort(props);
// if (portConfig != null)
// {
// if (devType.EndsWith("-generic"))
// {
// var stb = new IrSetTopBoxBase(devKey, devName, portConfig.Port, portConfig.FileName);
// // Do this a better way?
// stb.HasDpad = props["hasDpad"].Value<bool>();
// stb.HasDvr = props["hasDvr"].Value<bool>();
// stb.HasNumbers = props["hasNumbers"].Value<bool>();
// stb.HasPreset = props["hasPresets"].Value<bool>();
// dev = stb;
// }
// else
// FactoryHelper.HandleUnknownType(devToken, devType);
// var preDev = dev as IHasSetTopBoxProperties;
// if(preDev.HasPreset)
// preDev.LoadPresets(props["presetListName"].Value<string>());
// }
// }
// catch (Exception e)
// {
// FactoryHelper.HandleDeviceCreationError(devToken, e);
// }
// return dev;
// }
// }
//}

34
PepperDashEssentials/Configuration Original/Factories/PcFactory.cs
View File

@@ -1,34 +0,0 @@
//using System;
//using Crestron.SimplSharpPro;
//using Newtonsoft.Json.Linq;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Devices;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// public class PcFactory
// {
// public static Device Create(JToken devToken)
// {
// Device dev = null;
// //try
// //{
// // var devType = devToken.Value<string>("type");
// // var devKey = devToken.Value<string>("key");
// // var devName = devToken.Value<string>("name");
// // if (devType.Equals("laptop", StringComparison.OrdinalIgnoreCase))
// // dev = new Laptop(devKey, devName);
// // else
// // FactoryHelper.HandleUnknownType(devToken, devType);
// //}
// //catch (Exception e)
// //{
// // FactoryHelper.HandleDeviceCreationError(devToken, e);
// //}
// return dev;
// }
// }
//}

46
PepperDashEssentials/Configuration Original/Factories/REMOVE DiscPlayerFactory.cs
View File

@@ -1,46 +0,0 @@
//using System;
//using Crestron.SimplSharpPro;
//using Newtonsoft.Json.Linq;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Devices;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// public class DiscPlayerFactory
// {
// public static Device Create(JToken devToken)
// {
// Device dev = null;
// try
// {
// var devType = devToken.Value<string>("type");
// var devKey = devToken.Value<string>("key");
// var devName = devToken.Value<string>("name");
// // Filter out special (Pioneer
// //(devType.Equals("genericIr", StringComparison.OrdinalIgnoreCase))
// var props = devToken["properties"];
// var portConfig = FactoryHelper.GetIrPort(props);
// if (portConfig != null)
// {
// if (devType.EndsWith("-generic"))
// dev = new IrDvdBase(devKey, devName, portConfig.Port, portConfig.FileName);
// else
// FactoryHelper.HandleUnknownType(devToken, devType);
// }
// // NO PORT ERROR HERE??
// }
// catch (Exception e)
// {
// FactoryHelper.HandleDeviceCreationError(devToken, e);
// }
// return dev;
// }
// }
//}

127
PepperDashEssentials/Configuration Original/Factories/RemoteFactory.cs
View File

@@ -1,127 +0,0 @@
//using System;
//using System.Collections.Generic;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.Remotes;
//using Crestron.SimplSharpPro.UI;
//using Newtonsoft.Json;
//using Newtonsoft.Json.Linq;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Devices;
////using PepperDash.Essentials.Remotes;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// //public class RemoteFactory
// //{
// // public static Device Create(JToken devToken)
// // {
// // Hr150Controller dev = null;
// // try
// // {
// // var devType = devToken.Value<string>("type");
// // var devKey = devToken.Value<string>("key");
// // var devName = devToken.Value<string>("name");
// // var props = devToken["properties"];
// // if (devType.Equals("hr150", StringComparison.OrdinalIgnoreCase))
// // {
// // uint id = Convert.ToUInt32(props.Value<string>("rfId"), 16);
// // var parent = props.Value<string>("rfGateway");
// // RFExGateway rf = GetGateway(parent);
// // var hw = new Hr150(id, rf);
// // dev = new Hr150Controller(devKey, devName, hw);
// // // Have to add the buttons and default source after all devices are spun up
// // dev.AddPostActivationAction(() =>
// // {
// // var defaultSystemKey = props.Value<string>("defaultSystemKey");
// // dev.SetCurrentRoom((EssentialsRoom)DeviceManager.GetDeviceForKey(defaultSystemKey));
// // // Link custom buttons
// // var buttonProps = JsonConvert.DeserializeObject<Dictionary<uint, string>>(props["buttons"].ToString());
// // foreach (var kvp in buttonProps)
// // {
// // var split = kvp.Value.Split(':');
// // if (split[0].Equals("source"))
// // {
// // var src = DeviceManager.GetDeviceForKey(split[1]) as IPresentationSource;
// // if (src == null)
// // {
// // Debug.Console(0, dev, "Error: Cannot add source key '{0}'", split[1]);
// // continue;
// // }
// // dev.SetCustomButtonAsSource(kvp.Key, src);
// // }
// // else if (split[0] == "room")
// // {
// // if (split[1] == "off")
// // dev.SetCustomButtonAsRoomOff(kvp.Key);
// // }
// // }
// // });
// // }
// // else if (devType.Equals("tsr302", StringComparison.OrdinalIgnoreCase))
// // {
// // uint id = Convert.ToUInt32(props.Value<string>("rfId"), 16);
// // var parent = props.Value<string>("rfGateway");
// // RFExGateway rf = GetGateway(parent);
// // var sgd = props.Value<string>("sgdPath");
// // var hw = new Tsr302(id, rf);
// // //dev = new Hr150Controller(devKey, devName, hw);
// // //// Have to add the buttons and default source after all devices are spun up
// // //dev.AddPostActivationAction(() =>
// // //{
// // // var defaultSystemKey = props.Value<string>("defaultSystemKey");
// // // dev.SetCurrentRoom((EssentialsRoom)DeviceManager.GetDeviceForKey(defaultSystemKey));
// // // // Link custom buttons
// // // var buttonProps = JsonConvert.DeserializeObject<Dictionary<uint, string>>(props["buttons"].ToString());
// // // foreach (var kvp in buttonProps)
// // // {
// // // var split = kvp.Value.Split(':');
// // // if (split[0].Equals("source"))
// // // {
// // // var src = DeviceManager.GetDeviceForKey(split[1]) as IPresentationSource;
// // // if (src == null)
// // // {
// // // Debug.Console(0, dev, "Error: Cannot add source key '{0}'", split[1]);
// // // continue;
// // // }
// // // dev.SetCustomButtonAsSource(kvp.Key, src);
// // // }
// // // else if (split[0] == "room")
// // // {
// // // if (split[1] == "off")
// // // dev.SetCustomButtonAsRoomOff(kvp.Key);
// // // }
// // // }
// // //});
// // }
// // }
// // catch (Exception e)
// // {
// // FactoryHelper.HandleDeviceCreationError(devToken, e);
// // }
// // return dev;
// // }
// // public static RFExGateway GetGateway(string parent)
// // {
// // if (parent == null)
// // parent = "controlSystem";
// // RFExGateway rf = null;
// // if (parent.Equals("controlSystem", StringComparison.OrdinalIgnoreCase)
// // || parent.Equals("processor", StringComparison.OrdinalIgnoreCase))
// // {
// // rf = Global.ControlSystem.ControllerRFGatewayDevice;
// // }
// // return rf;
// // }
// //}
//}

48
PepperDashEssentials/Configuration Original/Factories/TouchpanelFactory.cs
View File

@@ -1,48 +0,0 @@
//using System;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.UI;
//using Newtonsoft.Json.Linq;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Devices;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// public class TouchpanelFactory
// {
// public static Device Create(JToken devToken)
// {
// SmartGraphicsTouchpanelControllerBase dev = null;
// try
// {
// var devType = devToken.Value<string>("type");
// var devKey = devToken.Value<string>("key");
// var devName = devToken.Value<string>("name");
// var props = devToken["properties"];
// if (devType.Equals("Tsw1052", StringComparison.OrdinalIgnoreCase))
// {
// uint ipId = Convert.ToUInt32(props.Value<string>("ipId"), 16);
// var hw = new Tsw1052(ipId, Global.ControlSystem);
// dev = TouchpanelControllerFactory.Create(devKey, devName, hw, props.Value<string>("sgdPath"));
// dev.UsesSplashPage = props.Value<bool>("usesSplashPage");
// dev.ShowDate = props.Value<bool>("showDate");
// dev.ShowTime = props.Value<bool>("showTime");
// // This plugs the system key into the tp, but it won't be linked up until later
// dev.AddPostActivationAction(() =>
// {
// var defaultSystemKey = props.Value<string>("defaultSystemKey");
// dev.SetCurrentRoom((EssentialsRoom)DeviceManager.GetDeviceForKey(defaultSystemKey));
// });
// }
// }
// catch (Exception e)
// {
// FactoryHelper.HandleDeviceCreationError(devToken, e);
// }
// return dev;
// }
// }
//}

93
PepperDashEssentials/ControlSystem.cs
View File

@@ -25,8 +25,6 @@ namespace PepperDash.Essentials
{
HttpLogoServer LogoServer;
List<object> FactoryObjects = new List<object>();
public ControlSystem()
: base()
{
@@ -36,7 +34,7 @@ namespace PepperDash.Essentials
}
/// <summary>
/// Git 'er goin'
/// Entry point for the program
/// </summary>
public override void InitializeSystem()
{
@@ -95,17 +93,19 @@ namespace PepperDash.Essentials
var dirSeparator = Global.DirectorySeparator;
var version = Crestron.SimplSharp.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
var versionString = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build);
string directoryPrefix;
directoryPrefix = Crestron.SimplSharp.CrestronIO.Directory.GetApplicationRootDirectory();
if (CrestronEnvironment.DevicePlatform != eDevicePlatform.Server) // Handles 3-series running Windows OS
var fullVersion = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false);
AssemblyInformationalVersionAttribute fullVersionAtt = fullVersion[0] as AssemblyInformationalVersionAttribute;
Global.SetAssemblyVersion(fullVersionAtt.InformationalVersion);
if (CrestronEnvironment.DevicePlatform != eDevicePlatform.Server) // Handles 3-series running Windows CE OS
{
Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on 3-series Appliance", versionString);
Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on 3-series Appliance", Global.AssemblyVersion);
// Check if User/ProgramX exists
if (Directory.Exists(directoryPrefix + dirSeparator + "User"
@@ -133,7 +133,7 @@ namespace PepperDash.Essentials
}
else // Handles Linux OS (Virtual Control)
{
Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on Virtual Control Server", versionString);
Debug.Console(0, Debug.ErrorLogLevel.Notice, "Starting Essentials v{0} on Virtual Control Server", Global.AssemblyVersion);
// Set path to User/
filePathPrefix = directoryPrefix + dirSeparator + "User" + dirSeparator;
@@ -148,7 +148,7 @@ namespace PepperDash.Essentials
}
/// <summary>
/// Do it, yo
/// Begins the process of loading resources including plugins and configuration data
/// </summary>
public void GoWithLoad()
{
@@ -175,23 +175,21 @@ namespace PepperDash.Essentials
else
{
Debug.Console(0,
"------------------------------------------------\r" +
"------------------------------------------------\r" +
"------------------------------------------------\r" +
"Essentials file structure setup completed.\r" +
"Please load config, sgd and ir files and\r" +
"restart program.\r" +
"------------------------------------------------\r" +
"------------------------------------------------\r" +
"------------------------------------------------");
@"----------------------------------------------
------------------------------------------------
------------------------------------------------
Essentials file structure setup completed.
Please load config, sgd and ir files and
restart program.
------------------------------------------------
------------------------------------------------
------------------------------------------------");
}
}
catch (Exception e)
{
Debug.Console(0, "FATAL INITIALIZE ERROR. System is in an inconsistent state:\r{0}", e);
}
// Notify the OS that the program intitialization has completed
@@ -200,7 +198,7 @@ namespace PepperDash.Essentials
}
/// <summary>
/// Initial simple implementation. Reads user/programN/plugins folder and
/// Initial simple implementation. Reads user/programXX/plugins folder and
/// use
/// </summary>
void LoadPlugins()
@@ -254,7 +252,42 @@ namespace PepperDash.Essentials
var loadPlugin = methods.FirstOrDefault(m => m.Name.Equals("LoadPlugin"));
if (loadPlugin != null)
{
Debug.Console(0, Debug.ErrorLogLevel.Notice, "Adding type {0}", assy.Key, type.FullName);
Debug.Console(2, "LoadPlugin method found in {0}", type.Name);
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Static);
var minimumVersion = fields.FirstOrDefault(p => p.Name.Equals("MinimumEssentialsFrameworkVersion"));
if (minimumVersion != null)
{
Debug.Console(2, "MinimumEssentialsFrameworkVersion found");
var minimumVersionString = minimumVersion.GetValue(null) as string;
if (!string.IsNullOrEmpty(minimumVersionString))
{
var passed = Global.IsRunningMinimumVersionOrHigher(minimumVersionString);
if (!passed)
{
Debug.Console(0, Debug.ErrorLogLevel.Error, "Plugin indicates minimum Essentials version {0}. Dependency check failed. Skipping Plugin", minimumVersionString);
continue;
}
else
{
Debug.Console(0, Debug.ErrorLogLevel.Notice, "Passed plugin passed dependency check (required version {0})", minimumVersionString);
}
}
else
{
Debug.Console(0, Debug.ErrorLogLevel.Warning, "MinimumEssentialsFrameworkVersion found but not set. Loading plugin, but your mileage may vary.");
}
}
else
{
Debug.Console(0, Debug.ErrorLogLevel.Warning, "MinimumEssentialsFrameworkVersion not found. Loading plugin, but your mileage may vary.");
}
Debug.Console(0, Debug.ErrorLogLevel.Notice, "Adding plugin: {0}", assy.Key);
loadPlugin.Invoke(null, null);
}
}
@@ -303,18 +336,6 @@ namespace PepperDash.Essentials
return configExists;
}
///// <summary>
/////
///// </summary>
///// <param name="s"></param>
//public void EnablePortalSync(string s)
//{
// if (s.ToLower() == "enable")
// {
// CrestronConsole.ConsoleCommandResponse("Portal Sync features enabled");
// }
//}
/// <summary>
///
/// </summary>

42
PepperDashEssentials/Devices/DiscPlayer/OppoExtendedBdp.cs
View File

@@ -1,42 +0,0 @@
using System;
using System.Linq;
using System.Collections.Generic;
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Crestron.SimplSharpPro.DeviceSupport;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices
{
///// <summary>
///// This DVD class should cover most IR, one-way DVD and Bluray fuctions
///// </summary>
//public class OppoBluray : IrDvdBase, IDvdControls, IExtendedOutputs
//{
// public OppoBluray(string key, string name, IROutputPort port, string irDriverFilepath) : base(key, name, port, irDriverFilepath) { }
// public OutputsToTriListBridge GetExtendedOutputsToTriListBridge()
// {
// return new ExtendedDvdTriListBridge();
// }
//}
//public class ExtendedDvdTriListBridge : OutputsToTriListBridge
//{
// public override void Link()
// {
// throw new NotImplementedException();
// }
// public override void UnLink()
// {
// throw new NotImplementedException();
// }
//}
}

45
PepperDashEssentials/Devices/NUMERIC AppleTV.cs
View File

@@ -1,45 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using Crestron.SimplSharp;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.DeviceSupport;
//using PepperDash.Essentials.Core;
//namespace PepperDash.Essentials.Devices
//{
// public class AppleTV : Device, IHasCueActionList
// {
// public IrOutputPortController IrPort { get; private set; }
// public AppleTV(string key, string name, IROutputPort port, string irDriverFilepath)
// : base(key, name)
// {
// IrPort = new IrOutputPortController("ir" + key, port, irDriverFilepath);
// }
// #region IFunctionList Members
// public List<CueActionPair> CueActionList
// {
// get
// {
// var numToIr = new Dictionary<Cue, string>
// {
// { CommonBoolCue.Menu, IROutputStandardCommands.IROut_MENU },
// { CommonBoolCue.Up, IROutputStandardCommands.IROut_UP_ARROW },
// { CommonBoolCue.Down, IROutputStandardCommands.IROut_DN_ARROW },
// { CommonBoolCue.Left, IROutputStandardCommands.IROut_LEFT_ARROW },
// { CommonBoolCue.Right, IROutputStandardCommands.IROut_RIGHT_ARROW },
// { CommonBoolCue.Select, IROutputStandardCommands.IROut_ENTER }
// };
// var funcs = new List<CueActionPair>(numToIr.Count);
// foreach (var kvp in numToIr)
// funcs.Add(new BoolCueActionPair(kvp.Key, b => IrPort.PressRelease(kvp.Value, b)));
// return funcs;
// }
// }
// #endregion
// }
//}

232
PepperDashEssentials/Example Configuration/EssentialsHuddleSpaceRoom/configurationFile-HuddleSpace-2-Source.json Normal file
View File

@@ -0,0 +1,232 @@
{
"system": {},
"system_url": "",
"template_url": "",
"template": {
"sourceLists": {
"default": {
"source-2": {
"order": 6,
"type": "route",
"altIcon": "Blank",
"icon": "",
"sourceKey": "wePresent-1",
"includeInSourceList": true,
"volumeControlKey": "$defaultAudio",
"routeList": [
{
"sourceKey": "wePresent-1",
"type": "audioVideo",
"destinationKey": "$defaultAll"
}
]
},
"source-1": {
"order": 5,
"type": "route",
"altIcon": "Blank",
"icon": "",
"sourceKey": "inRoomPc-1",
"includeInSourceList": true,
"volumeControlKey": "$defaultAudio",
"routeList": [
{
"sourceKey": "inRoomPc-1",
"type": "audioVideo",
"destinationKey": "$defaultAll"
}
]
},
"roomOff": {
"sourceKey": "$off",
"type": "off",
"routeList": [
{
"sourceKey": "$off",
"type": "audioVideo",
"destinationKey": "$defaultAll"
}
]
}
}
},
"devices": [
{
"name": "RMC3",
"group": "processor",
"properties": {
"numberOfIrPorts": 2,
"numberOfComPorts": 1
},
"supportedSystemTypes": [
"hudType",
"presType",
"vtcType",
"custom"
],
"type": "rmc3",
"supportedConfigModes": [
"compliance",
"essentials"
],
"supportsCompliance": true,
"key": "processor",
"uid": 0
},
{
"name": "Room PC",
"key": "inRoomPc-1",
"type": "inRoomPc",
"group": "pc",
"uid": 8,
"properties": {
"hasAudio": true,
"hasControls": false,
"isDefault": true
}
},
{
"name": "Wireless Video",
"key": "wePresent-1",
"type": "wePresent",
"group": "genericSource",
"uid": 9,
"properties": {
"isDefault": false
}
},
{
"name": "Samsung QM Series Display",
"key": "display-1",
"type": "samsungmdc",
"group": "display",
"uid": 11,
"properties": {
"id": "01",
"control": {
"controlPortDevKey": "processor",
"comParams": {
"parity": "None",
"protocol": "RS232",
"baudRate": 9600,
"softwareHandshake": "None",
"dataBits": 8,
"hardwareHandshake": "None",
"stopBits": 1
},
"controlPortNumber": 1,
"method": "com"
}
}
},
{
"name": "TSW-760",
"key": "tsw760-1",
"type": "tsw760",
"group": "touchpanel",
"uid": 14,
"properties": {
"control": {
"method": "ipid",
"ipid": "03",
"params": {
"deviceReadyResponsePattern": ".*>",
"endOfLineString": "\n"
}
},
"showVolumeGauge": true,
"roomListKey": "",
"showDate": true,
"headerStyle": "Verbose",
"sgdFile": "PepperDash Essentials TSW-760.sgd",
"showTime": true,
"sourcesOverflowCount": 4,
"usesSplashPage": false,
"defaultRoomKey": "room1"
}
},
{
"name": "iPad",
"key": "crestronApp-1",
"type": "crestronApp",
"group": "touchpanel",
"uid": 15,
"properties": {
"control": {
"method": "ipid",
"ipid": "04",
"params": {
"deviceReadyResponsePattern": ".*>",
"endOfLineString": "\n"
}
},
"showVolumeGauge": true,
"roomListKey": "",
"showDate": false,
"headerStyle": "Verbose",
"sgdFile": "PepperDash Essentials iPad.sgd",
"showTime": false,
"sourcesOverflowCount": 5,
"projectName": "PepperDash Essentials iPad",
"defaultRoomKey": "room1",
"usesSplashPage": false
}
}
],
"info": {
"processorType": "rmc3",
"lastUid": 16,
"lastModifiedDate": "2018-02-16T17:54:41.315Z",
"systemType": "huddle",
"comment": "",
"requiredControlSofwareVersion": ""
},
"tieLines": [
{
"sourceKey": "inRoomPc-1",
"sourcePort": "anyVideoOut",
"destinationKey": "display-1",
"destinationPort": "HdmiIn1",
"type": "audioVideo"
},
{
"sourceKey": "wePresent-1",
"sourcePort": "anyOut",
"destinationKey": "display-1",
"destinationPort": "HdmiIn2",
"type": "audioVideo"
}
],
"rooms": [
{
"type": "huddle",
"name": "Essentials Huddle 2 Inputs",
"key": "room1",
"properties": {
"defaultDisplayKey": "display-1",
"logo": {
"type": "system",
"url": ""
},
"description": "Huddle Space with 2 sources. RMC3 processor. iPad + TSW-560",
"defaultSourceItem": "source-1",
"hasDsp": false,
"helpMessage": "",
"sourceListKey": "default",
"volumes": {
"master": {
"level": 40,
"deviceKey": "display-1",
"label": "Volume"
}
},
"defaultAudioKey": "display-1",
"defaultVideoBehavior": "basic",
"tech": {
"password": "1234"
}
}
}
]
}
}

387
PepperDashEssentials/Example Configuration/EssentialsHuddleVtc1Room/configurationFile-mockVideoCodec_din-ap3_-_dm4x1.json Normal file
View File

@@ -0,0 +1,387 @@
{
"system": {
"rooms": [
{
"name": "Example Room",
"key": "room1",
"properties": {
"occupancy": {
"timeoutMinutes": "60"
}
}
}
],
"devices": [
{
"key": "hdMd4x14kE-1",
"uid": 4,
"properties": {
"control": {
"tcpSshProperties": {
"address": "0.0.0.0"
}
}
}
},
{
"key": "mockCodec-1",
"uid": 5,
"properties": {
"control": {
"tcpSshProperties": {
"address": "0.0.0.0"
}
}
}
}
],
"info": {
"lastModifiedDate": "2019-02-26T21:08:09.195Z"
}
},
"system_url": "",
"template_url": "",
"template": {
"rooms": [
{
"type": "huddleVtc1",
"name": "Essentials DIN-AP3 - DM4x1",
"key": "room1",
"properties": {
"defaultDisplayKey": "display-1",
"description": "",
"helpMessage": "",
"sourceListKey": "default",
"defaultVideoBehavior": "basic",
"logo": {
"type": "system",
"url": ""
},
"occupancy": {
"timeoutMinutes": "60",
"deviceKey": "glsOdtCCn-1"
},
"defaultSourceItem": "source-1",
"videoCodecKey": "mockCodec-1",
"hasDsp": false,
"volumes": {
"master": {
"level": 40,
"deviceKey": "mockCodec-1",
"label": "Volume"
}
},
"defaultAudioKey": "display-1",
"tech": {
"password": "1234"
}
}
}
],
"devices": [
{
"name": "DIN-AP3",
"key": "processor",
"type": "dinAp3",
"group": "processor",
"uid": 0,
"properties": {
}
},
{
"name": "Room PC",
"key": "inRoomPc-1",
"type": "inRoomPc",
"properties": {
"hasAudio": true,
"hasControls": false,
"isDefault": true
},
"group": "pc",
"uid": 1
},
{
"name": "Laptop",
"key": "laptop-1",
"type": "laptop",
"properties": {
"hasAudio": true,
"hasControls": false
},
"group": "pc",
"uid": 2
},
{
"name": "Wireless Video",
"key": "wePresent-1",
"type": "wePresent",
"properties": {},
"group": "genericSource",
"uid": 3
},
{
"name": "HD-MD4x1-4k-E HDMI Switch 1",
"key": "hdMd4x14kE-1",
"type": "hdMd4x14kE",
"properties": {
"control": {
"params": {
"deviceReadyResponsePattern": ".*>",
"endOfLineString": "\n"
},
"ipid": "10",
"method": "ipidTcp",
"tcpSshProperties": {
"port": 0,
"address": ""
}
},
"parentDeviceKey": "processor",
"inputs": {
"hdmiIn2": {
"disableHdcp": true
},
"hdmiIn3": {
"disableHdcp": true
},
"hdmiIn4": {
"disableHdcp": true
},
"hdmiIn1": {
"disableHdcp": true
}
}
},
"group": "hdMdSwitch",
"uid": 4
},
{
"name": "Mock Video Codec 1",
"key": "mockCodec-1",
"type": "mockVc",
"properties": {
"favorites": [
{
"name": "Corporate WebEx",
"number": "5555555555"
}
]
},
"group": "videoCodec",
"uid": 5
},
{
"name": "Samsung MDC Protocol 1",
"key": "display-1",
"type": "samsungmdc",
"properties": {
"id": "01",
"control": {
"controlPortDevKey": "processor",
"controlPortNumber": 1,
"method": "com",
"comParams": {
"protocol": "RS232",
"baudRate": 9600,
"hardwareHandshake": "None",
"softwareHandshake": "None",
"dataBits": 8,
"parity": "None",
"stopBits": 1
}
}
},
"group": "display",
"uid": 6
},
{
"name": "Crestron GLS-ODT-C-CN 1",
"key": "glsOdtCCn-1",
"type": "glsOdtCCn",
"properties": {
"control": {
"method": "cresnet",
"cresnetId": "97"
}
},
"group": "occupancy",
"uid": 7
},
{
"name": "TSW-760",
"key": "tsw760-1",
"type": "tsw760",
"properties": {
"control": {
"params": {
"deviceReadyResponsePattern": ".*>",
"endOfLineString": "\n"
},
"ipid": "03",
"method": "ipid"
},
"showVolumeGauge": true,
"sourcesOverflowCount": 4,
"showDate": true,
"headerStyle": "Verbose",
"sgdFile": "PepperDash Essentials TSW-760.sgd",
"showTime": true,
"roomListKey": "",
"usesSplashPage": false,
"defaultRoomKey": "room1"
},
"group": "touchpanel",
"uid": 8
},
{
"name": "Crestron XPanel",
"key": "crestronApp-1",
"type": "crestronApp",
"properties": {
"control": {
"params": {
"deviceReadyResponsePattern": ".*>",
"endOfLineString": "\n"
},
"ipid": "04",
"method": "ipid"
},
"showVolumeGauge": true,
"sourcesOverflowCount": 5,
"showDate": true,
"headerStyle": "Verbose",
"sgdFile": "PepperDash Essentials iPad.sgd",
"showTime": true,
"roomListKey": "",
"projectName": "PepperDash Essentials iPad",
"defaultRoomKey": "room1",
"usesSplashPage": false
},
"group": "touchpanel",
"uid": 9
}
],
"info": {
"comment": "",
"lastUid": 10,
"lastModifiedDate": "2018-07-02T17:41:06.550Z",
"systemType": "huddle",
"processorType": "dinAp3",
"requiredControlSofwareVersion": ""
},
"tieLines": [
{
"type": "audioVideo",
"sourceKey": "hdMd4x14kE-1",
"destinationKey": "mockCodec-1",
"destinationPort": "HdmiIn2",
"sourcePort": "hdmiOut"
},
{
"type": "audioVideo",
"sourceKey": "mockCodec-1",
"destinationKey": "display-1",
"destinationPort": "HdmiIn1",
"sourcePort": "HdmiOut1"
},
{
"type": "audioVideo",
"sourceKey": "laptop-1",
"destinationKey": "hdMd4x14kE-1",
"destinationPort": "hdmiIn1",
"sourcePort": "anyOut"
},
{
"type": "audioVideo",
"sourceKey": "inRoomPc-1",
"destinationKey": "mockCodec-1",
"destinationPort": "HdmiIn3",
"sourcePort": "anyVideoOut"
},
{
"type": "audioVideo",
"sourceKey": "wePresent-1",
"destinationKey": "hdMd4x14kE-1",
"destinationPort": "hdmiIn2",
"sourcePort": "anyOut"
}
],
"sourceLists": {
"default": {
"source-2": {
"order": 6,
"icon": "",
"altIcon": "Blank",
"type": "route",
"sourceKey": "laptop-1",
"includeInSourceList": true,
"volumeControlKey": "$defaultAudio",
"routeList": [
{
"type": "audioVideo",
"sourceKey": "laptop-1",
"destinationKey": "$defaultAll"
}
]
},
"source-3": {
"order": 7,
"icon": "",
"altIcon": "Blank",
"type": "route",
"sourceKey": "wePresent-1",
"includeInSourceList": true,
"volumeControlKey": "$defaultAudio",
"routeList": [
{
"type": "audioVideo",
"sourceKey": "wePresent-1",
"destinationKey": "$defaultAll"
}
]
},
"source-1": {
"order": 5,
"icon": "",
"altIcon": "Blank",
"type": "route",
"sourceKey": "inRoomPc-1",
"includeInSourceList": true,
"volumeControlKey": "$defaultAudio",
"routeList": [
{
"type": "audioVideo",
"sourceKey": "inRoomPc-1",
"destinationKey": "$defaultAll"
}
]
},
"roomOff": {
"type": "off",
"sourceKey": "$off",
"routeList": [
{
"type": "audioVideo",
"sourceKey": "$off",
"destinationKey": "$defaultAll"
}
]
},
"codecOsd": {
"order": 1,
"name": "None",
"type": "route",
"includeInSourceList": true,
"sourceKey": "",
"routeList": [
{
"type": "audioVideo",
"sourceKey": "mockCodec-1[osd]",
"destinationKey": "$defaultAll"
}
]
}
}
}
}
}

439
PepperDashEssentials/Example Configuration/SIMPLBridging/SIMPLBridgeExample_configurationFile.json Normal file
View File

@@ -0,0 +1,439 @@
{
"system_url": "",
"template": {
"info": {
"comment": "",
"requiredControlSofwareVersion": "",
"systemType": "huddle",
"lastModifiedDate": "2018-07-09T20:00:47.873Z",
"lastUid": 23,
"processorType": "rmc3"
},
"devices": [
{
"key": "processor",
"group": "processor",
"uid": 0,
"supportsCompliance": true,
"type": "rmc3",
"properties": {},
"name": "RMC3"
},
{
"key": "comm-1",
"uid": 1,
"name": "Generic comm 1",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"comParams": {
"hardwareHandshake": "None",
"parity": "None",
"protocol": "RS232",
"baudRate": 9600,
"dataBits": 8,
"softwareHandshake": "None",
"stopBits": 1
},
"controlPortNumber": 1,
"controlPortDevKey": "processor",
"method": "Com"
}
}
},
{
"key": "tcp-1",
"uid": 2,
"name": "Generic TCP 1",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"tcpSshProperties": {
"username": "",
"autoReconnect": true,
"AutoReconnectIntervalMs": 2000,
"port": 23,
"address": "0.0.0.0",
"password": ""
},
"method": "Tcpip"
}
}
},
{
"key": "ssh-1",
"uid": 3,
"name": "Generic SSH 1",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"tcpSshProperties": {
"username": "crestron",
"autoReconnect": true,
"AutoReconnectIntervalMs": 2000,
"port": 22,
"address": "10.11.50.135",
"password": "2H3Zu&OvgXp6"
},
"method": "Ssh"
}
}
},
{
"key": "eisc-1A",
"uid": 4,
"type": "eiscApi",
"group": "api",
"properties": {
"control": {
"tcpSshProperties": {
"address": "127.0.0.2",
"port": 0
},
"ipId": "1A"
},
"devices": [
{
"deviceKey": "comm-1",
"joinStart": 3001
},
{
"deviceKey": "tcp-1",
"joinStart": 3011
},
{
"deviceKey": "ssh-1",
"joinStart": 3021
},
{
"deviceKey": "dmMd8x8-1",
"joinStart": 1
},
{
"deviceKey": "dmTx201C-1",
"joinStart": 3051
},
{
"deviceKey": "dmRmc4kScalerC-1",
"joinStart": 3061
},
{
"deviceKey": "dmRmc200C-1",
"joinStart": 3071
},
{
"deviceKey": "dmRmc100C-1",
"joinStart": 3081
},
{
"deviceKey": "comm-2",
"joinStart": 2501
},
{
"deviceKey": "comm-3",
"joinStart": 2511
},
{
"deviceKey": "comm-4",
"joinStart": 2521
},
{
"deviceKey": "cec-1",
"joinStart": 2531
},
{
"deviceKey": "cec-2",
"joinStart": 2541
},
{
"deviceKey": "cec-3",
"joinStart": 2551
},
{
"deviceKey": "cec-4",
"joinStart": 2561
},
{
"deviceKey": "cec-5",
"joinStart": 2571
},
{
"deviceKey": "cec-6",
"joinStart": 2581
},
{
"deviceKey": "cec-7",
"joinStart": 2591
},
{
"deviceKey": "gls-oir-1",
"joinStart": 2701
},
{
"deviceKey": "gls-odt-1",
"joinStart": 2751
}
]
}
},
{
"key": "dmMd8x8-1",
"uid": 5,
"name": "DM-MD8x8 Chassis 1",
"type": "dmMd8x8",
"group": "dmChassis",
"properties": {
"control": {
"method": "ipid",
"ipid": "40",
"params": {
"endOfLineString": "\n",
"deviceReadyResponsePattern": ".*>"
}
},
"volumeControls": {},
"inputSlots": {
"1": "dmcHdDsp",
"2": "dmcHdDsp",
"3": "dmcDvi",
"4": "dmcDvi",
"5": "dmcC",
"6": "dmcCDsp"
},
"outputSlots": {
"1": "dmcCoHd",
"2": "dmcCoHd"
},
"inputNames": {
"1": "Input 1",
"2": "Input 2",
"3": "Input 3",
"4": "Input 4",
"5": "Input 5",
"6": "Input 6"
},
"parentDeviceKey": "processor",
"outputNames": {
"1": "Output 1",
"2": "Output 2",
"3": "Output 3",
"4": "Output 4"
}
}
},
{
"key": "dmTx201C-1",
"uid": 6,
"name": "DM-TX-201C 1",
"type": "dmTx201C",
"group": "dmEndpoint",
"properties": {
"control": {
"method": "ipid",
"ipid": "45",
"params": {
"endOfLineString": "\n",
"deviceReadyResponsePattern": ".*>"
}
},
"parentDeviceKey": "dmMd8x8-1",
"parentInputNumber": "5"
}
},
{
"key": "dmRmc4kScalerC-1",
"uid": 7,
"name": "DM-RMC-4K-SCALER-C Out 1",
"type": "dmRmc4kScalerC",
"group": "dmEndpoint",
"properties": {
"control": {
"method": "ipid",
"ipid": "61",
"params": {
"endOfLineString": "\n",
"deviceReadyResponsePattern": ".*>"
}
},
"parentDeviceKey": "dmMd8x8-1",
"parentOutputNumber": "1"
}
},
{
"key": "dmRmc200C-1",
"uid": 8,
"name": "DM-RMC-200-C Out 2",
"type": "dmRmc200C",
"group": "dmEndpoint",
"properties": {
"control": {
"method": "ipid",
"ipid": "62",
"params": {
"endOfLineString": "\n",
"deviceReadyResponsePattern": ".*>"
}
},
"parentDeviceKey": "dmMd8x8-1",
"parentOutputNumber": "2"
}
},
{
"key": "dmRmc100C-1",
"uid": 9,
"name": "DM-RMC-100-C Out 3",
"type": "dmRmc100C",
"group": "dmEndpoint",
"properties": {
"control": {
"method": "ipid",
"ipid": "63",
"params": {
"endOfLineString": "\n",
"deviceReadyResponsePattern": ".*>"
}
},
"parentDeviceKey": "dmMd8x8-1",
"parentOutputNumber": "3"
}
},
{
"key": "comm-2",
"uid": 10,
"name": "Rmc comm 1",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"comParams": {
"hardwareHandshake": "None",
"parity": "None",
"protocol": "RS232",
"baudRate": 9600,
"dataBits": 8,
"softwareHandshake": "None",
"stopBits": 1
},
"controlPortNumber": 1,
"controlPortDevKey": "dmRmc4kScalerC-1",
"method": "Com"
}
}
},
{
"key": "comm-3",
"uid": 11,
"name": "Rmc comm 2",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"comParams": {
"hardwareHandshake": "None",
"parity": "None",
"protocol": "RS232",
"baudRate": 9600,
"dataBits": 8,
"softwareHandshake": "None",
"stopBits": 1
},
"controlPortNumber": 1,
"controlPortDevKey": "dmRmc200C-1",
"method": "Com"
}
}
},
{
"key": "cec-1",
"uid": 13,
"name": "Tx 5 cec 1",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"controlPortName": "HdmiIn",
"controlPortDevKey": "dmTx201C-1",
"method": "Cec"
}
}
},
{
"key": "cec-5",
"uid": 17,
"name": "Rmc 1 cec 1",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"controlPortName": "HdmiOut",
"controlPortDevKey": "dmRmc4kScalerC-1",
"method": "Cec"
}
}
},
{
"key": "cec-6",
"uid": 18,
"name": "Dm Chassis In 1 cec 1",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"controlPortName": "inputCard1--hdmiIn",
"controlPortDevKey": "dmMd8x8-1",
"method": "Cec"
}
}
},
{
"key": "cec-7",
"uid": 19,
"name": "Dm Chassis Out 1 cec 1",
"type": "genericComm",
"group": "comm",
"properties": {
"control": {
"controlPortName": "outputCard1--hdmiOut1",
"controlPortDevKey": "dmMd8x8-1",
"method": "Cec"
}
}
},
{
"key": "gls-oir-1",
"uid": 19,
"name": "GLS-OIR-CN 1",
"type": "glsoirccn",
"group": "occupancy",
"properties": {
"control": {
"cresnetId": "41",
"method": "cresnet"
}
}
},
{
"key": "gls-odt-1",
"uid": 19,
"name": "GLS-ODT-CN 1",
"type": "glsodtccn",
"group": "occupancy",
"properties": {
"control": {
"cresnetId": "42",
"method": "cresnet"
}
}
}
],
"rooms": [],
"sourceLists": {},
"tieLines": []
},
"template_url": "",
"system": {
}
}

70
PepperDashEssentials/Example Configuration/SIMPLBridging/configurationFile-dmps3300c-avRouting.json Normal file
View File

@@ -0,0 +1,70 @@
{
"system_url": "",
"template": {
"info": {
"comment": "",
"requiredControlSofwareVersion": "",
"systemType": "huddle",
"lastModifiedDate": "2018-07-09T20:00:47.873Z",
"lastUid": 23,
"processorType": "dmps3300c"
},
"devices": [
{
"key": "processor",
"group": "processor",
"uid": 0,
"supportsCompliance": true,
"type": "dmps3300c",
"properties": {
},
"name": "DMPS3-300-C"
},
{
"key": "eisc-A",
"uid":4,
"type": "eiscApi",
"group":"api",
"properties": {
"control":{
"tcpSshProperties":{
"address":"127.0.0.2",
"port":0
},
"ipId":"1A"
},
"devices": [
{
"deviceKey":"processor-avRouting",
"joinStart":1
},
{
"deviceKey":"processor-programAudioOutput",
"joinStart":3001
},
{
"deviceKey":"processor-aux1AudioOutput",
"joinStart":3011
},
{
"deviceKey":"processor-aux2AudioOutput",
"joinStart":3021
}
]
}
}
],
"rooms": [
],
"sourceLists": {
},
"tieLines": [
]
},
"template_url": "",
"system": {
}
}

47
PepperDashEssentials/FOR REFERENCE UI/PageControllers/DevicePageControllerBase.cs
View File

@@ -1,47 +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.Core;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Core.Presets;
//namespace PepperDash.Essentials
//{
// /// <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)
// {
// }
// }
//}

308
PepperDashEssentials/FOR REFERENCE UI/PageControllers/LargeTouchpanelControllerBase.cs
View File

@@ -1,308 +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
//{
// /// <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)
// {
// }
// /// <summary>
// /// Static factory method
// /// </summary>
// public static LargeTouchpanelControllerBase GetController(string key, string name,
// string type, CrestronTswPropertiesConfig props)
// {
// var id = Convert.ToUInt32(props.IpId, 16);
// type = type.ToLower();
// Tswx52ButtonVoiceControl tsw = null;
// if (type == "tsw752")
// tsw = new Tsw752(id, Global.ControlSystem);
// else if (type == "tsw1052")
// tsw = new Tsw1052(id, Global.ControlSystem);
// else
// {
// Debug.Console(0, "WARNING: Cannot create TSW controller with type '{0}'", type);
// return null;
// }
// var sgdPath = string.Format(@"\NVRAM\Program{0}\SGD\{1}",
// InitialParametersClass.ApplicationNumber, props.SgdFile);
// var controller = new LargeTouchpanelControllerBase(key, name, tsw, sgdPath);
// controller.UsesSplashPage = props.UsesSplashPage;
// // Get the room and add it after everthing is ready
// var room = DeviceManager.GetDeviceForKey(props.DefaultRoomKey) as EssentialsRoom;
// controller.AddPostActivationAction(() =>
// {
// controller.SetCurrentRoom(room);
// });
// return controller;
// }
// 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
// }
// // Wire up buttons
// TriList.SetSigFalseAction(15003, () => SetMainMode(eMainModeType.Presentation));
// TriList.SetSigFalseAction(15008, PowerOffWithConfirmPressed);
// TriList.SetSigFalseAction(15101, () => SetMainMode(eMainModeType.Presentation));
// TriList.SetSigFalseAction(15013, ShowHelp);
// TriList.SetSigFalseAction(15014, () => SetMainMode(eMainModeType.Tech));
// // 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.IsCoolingDownFeedback.OutputChange -= CurrentRoom_IsCoolingDown_OutputChange;
// CurrentRoom.IsWarmingUpFeedback.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.IsCoolingDownFeedback.OutputChange -= CurrentRoom_IsCoolingDown_OutputChange;
// CurrentRoom.IsWarmingUpFeedback.OutputChange -= CurrentRoom_IsWarmingUp_OutputChange;
// CurrentRoom.IsCoolingDownFeedback.OutputChange += CurrentRoom_IsCoolingDown_OutputChange;
// CurrentRoom.IsWarmingUpFeedback.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.IsCoolingDownFeedback.BoolValue);
// if (CurrentRoom.IsCoolingDownFeedback.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.IsWarmingUpFeedback.BoolValue);
// if (CurrentRoom.IsWarmingUpFeedback.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.SourceKey : "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;
// }
// }
// /// <summary>
// ///
// /// </summary>
// void PowerOffWithConfirmPressed()
// {
// if (CurrentRoom == null)
// return;
// if (!CurrentRoom.RoomIsOnFeedback.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.RoomIsOnFeedback.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 ISetTopBoxControls)
// CurrentPresentationSourcePageController = new PageControllerLargeSetTopBoxGeneric(TriList,
// CurrentPresentationControlDevice as ISetTopBoxControls);
// else if (CurrentPresentationControlDevice.Type == PresentationSourceType.Laptop)
// CurrentPresentationSourcePageController = new PageControllerLaptop(TriList);
// // separate these...
// else if (CurrentPresentationControlDevice.Type == PresentationSourceType.Dvd)
// CurrentPresentationSourcePageController =
// new PageControllerLargeDvd(TriList, CurrentPresentationControlDevice as IDiscPlayerControls);
// 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);
// }
// }
//}

28
PepperDashEssentials/FOR REFERENCE UI/PageControllers/PageControllerLaptop.cs
View File

@@ -1,28 +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.Core;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Core.Presets;
//namespace PepperDash.Essentials
//{
// public class PageControllerLaptop : DevicePageControllerBase
// {
// public PageControllerLaptop(BasicTriListWithSmartObject tl)
// : base(tl)
// {
// FixedObjectSigs = new List<BoolInputSig>
// {
// tl.BooleanInput[10092], // well
// tl.BooleanInput[11001] // Laptop info
// };
// }
// }
//}

46
PepperDashEssentials/FOR REFERENCE UI/PageControllers/PageControllerLargeDvd.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 PepperDash.Core;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Core.Presets;
//namespace PepperDash.Essentials
//{
// /// <summary>
// ///
// /// </summary>
// public class PageControllerLargeDvd : DevicePageControllerBase
// {
// IDiscPlayerControls Device;
// public PageControllerLargeDvd(BasicTriListWithSmartObject tl, IDiscPlayerControls 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)
// {
//#warning rewire this
// //var uos = (Device as IHasCueActionList).CueActionList;
// //SmartObjectHelper.LinkDpadWithUserObjects(TriList, 10411, uos, state);
// }
// }
// }
//}

139
PepperDashEssentials/FOR REFERENCE UI/PageControllers/PageControllerLargeSetTopBoxGeneric.cs
View File

@@ -1,139 +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;
//using PepperDash.Essentials.Core;
//namespace PepperDash.Essentials
//{
// 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; }
// ISetTopBoxControls Device;
// DevicePresetsView PresetsView;
// bool ShowPosition5Tabs;
// uint CurrentVisiblePosition5Item = 1;
// Dictionary<uint, uint> Position5SubpageJoins = new Dictionary<uint, uint>
// {
// { 1, 10053 },
// { 2, 10054 }
// };
// public PageControllerLargeSetTopBoxGeneric(BasicTriListWithSmartObject tl, ISetTopBoxControls device)
// : base(tl)
// {
// Device = device;
// DpadSmartObjectId = 10011;
// NumberPadSmartObjectId = 10014;
// PresetsSmartObjectId = 10012;
// Position5TabsId = 10081;
// bool dpad = device is IDPad;
// bool preset = device.HasPresets;
// bool dvr = device.HasDvr;
// bool numbers = device is INumericKeypad;
// 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.HasPresets)
// {
// 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 Action<bool>(b => ShowTab(1));
// tabSo.BooleanOutput["Tab Button 2 Press"].UserObject = new Action<bool>(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
//#warning hook these up
// //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.HasPresets && state)
// PresetsView.Attach();
// else if (Device.HasPresets && !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
// }
// }
//}

43
PepperDashEssentials/FOR REFERENCE UI/Panels/REMOVE UiCue.cs
View File

@@ -1,43 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using Crestron.SimplSharp;
//namespace PepperDash.Essentials.Core
//{
// public class UiCue
// {
// public static readonly Cue VisibleSystemInit = Cue.BoolCue("VisibleSystemInit", 15001);
// public static readonly Cue VisibleSplash = Cue.BoolCue("VisibleSplash", 15002);
// public static readonly Cue PressSplash = Cue.BoolCue("PressSplash", 15003);
// public static readonly Cue PressRoomOn = Cue.BoolCue("PressRoomOn", 15006);
// public static readonly Cue PressRoomOff = Cue.BoolCue("PressRoomOff", 15007);
// public static readonly Cue PressRoomOffWithConfirm = Cue.BoolCue("PressRoomOffWithConfirm", 15008);
// public static readonly Cue VisibleCommonHeader = Cue.BoolCue("PressPowerOffConfirm", 15011);
// public static readonly Cue VisibleCommonFooter = Cue.BoolCue("VisibleCommonFooter", 15012);
// public static readonly Cue PressHelp = Cue.BoolCue("PressHelp", 15013);
// public static readonly Cue PressSettings = Cue.BoolCue("PressSettings", 15014);
// public static readonly Cue ShowDate = Cue.BoolCue("PressSettings", 15015);
// public static readonly Cue ShowTime = Cue.BoolCue("PressSettings", 15016);
// public static readonly Cue ShowLicensed = Cue.BoolCue("PressSettings", 15017);
// public static readonly Cue ShowUnLicensed = Cue.BoolCue("PressSettings", 15018);
// public static readonly Cue PressModePresentationShare = Cue.BoolCue("PressModePresentationShare", 15101);
// public static readonly Cue PressModeVideoConf = Cue.BoolCue("PressModeVideoConf", 15102);
// public static readonly Cue PressModeAudioConf = Cue.BoolCue("PressModeAudioConf", 15103);
// public static readonly Cue VisiblePresentationSourceList = Cue.BoolCue("VisiblePresentationSourceList", 15111);
// public static readonly Cue VisibleSystemIsOff = Cue.BoolCue("VisibleSystemIsOff", 15112);
// public static readonly Cue VisibleAudioConfPopover = Cue.BoolCue("VisibleAudioConfPopover", 15201);
// public static readonly Cue VisibleVideoConfPopover = Cue.BoolCue("VisibleVideoConfPopover", 15251);
// public static readonly Cue TextRoomName = Cue.BoolCue("TextRoomName", 4001);
// public static readonly Cue TextPresentationShareButton = Cue.BoolCue("TextPresentationShareButton", 4011);
// public static readonly Cue SplashMessage = Cue.StringCue("SplashMessage", 2101);
// }
//}

318
PepperDashEssentials/FOR REFERENCE UI/Panels/SmartGraphicsTouchpanelControllerBase.cs
View File

@@ -1,318 +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 SourceListItem 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<SourceListItem, DevicePageControllerBase> LoadedPageControllers
// = new Dictionary<SourceListItem, 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;
// }
//#warning wire UI manipulating presses up here, typically in child classes...
// //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;
// IBasicVolumeControls 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;
// IBasicVolumeControls newAudio = null;
// if (CurrentRoom != null)
// {
// CurrentRoom.AudioDeviceWillChange += this.CurrentRoom_AudioDeviceWillChange;
// CurrentRoom.PresentationSourceChange += this.CurrentRoom_PresentationSourceChange;
// SetControlSource(CurrentRoom.CurrentPresentationSourceInfo);
// 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(IBasicVolumeControls oldDev, IBasicVolumeControls 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 IBasicVolumeWithFeedback)
// {
// var fbDev = oldDev as IBasicVolumeWithFeedback;
// TriList.UShortOutput[401].UserObject = null;
// fbDev.MuteFeedback.UnlinkInputSig(TriList.BooleanInput[403]);
// fbDev.VolumeLevelFeedback.UnlinkInputSig(TriList.UShortInput[401]);
// }
// }
// if (newDev != null)
// {
// TriList.BooleanInput[CommonBoolCue.ShowVolumeSlider.Number].BoolValue = true;
// TriList.SetBoolSigAction(401, newDev.VolumeUp);
// TriList.SetBoolSigAction(402, newDev.VolumeDown);
// TriList.SetSigFalseAction(405, newDev.MuteToggle);
// if (newDev is IBasicVolumeWithFeedback) // Show slider
// {
// var fbDev = newDev as IBasicVolumeWithFeedback;
// TriList.BooleanInput[406].BoolValue = false;
// TriList.BooleanInput[407].BoolValue = true;
// TriList.UShortOutput[401].UserObject = new Action<ushort>(fbDev.SetVolume);
// fbDev.VolumeLevelFeedback.LinkInputSig(TriList.UShortInput[401]);
// }
// else // Show buttons only
// {
// TriList.BooleanInput[406].BoolValue = true;
// TriList.BooleanInput[407].BoolValue = false;
// }
// }
// }
// /// <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(SourceListItem newSource)
// {
// if (CurrentPresentationControlDevice != null)
// {
// HideCurrentPresentationSourceUi();
//#warning Get button methods from RESI, and find a more-well-defined way to wire up feedbacks
// // 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 fb in (CurrentPresentationControlDevice as IHasFeedback).Feedbacks)
// {
// if (fb.Cue.Number == 0) continue;
// if (fb is BoolFeedback)
// (fb as BoolFeedback).UnlinkInputSig(TriList.BooleanInput[fb.Cue.Number]);
// else if (fb is IntFeedback)
// (fb as IntFeedback).UnlinkInputSig(TriList.UShortInput[fb.Cue.Number]);
// else if (fb is StringFeedback)
// (fb as StringFeedback).UnlinkInputSig(TriList.StringInput[fb.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 fb in (CurrentPresentationControlDevice as IHasFeedback).Feedbacks)
// {
// if (fb.Cue.Number == 0) continue;
// if (fb is BoolFeedback)
// (fb as BoolFeedback).LinkInputSig(TriList.BooleanInput[fb.Cue.Number]);
// else if (fb is IntFeedback)
// (fb as IntFeedback).LinkInputSig(TriList.UShortInput[fb.Cue.Number]);
// else if (fb is StringFeedback)
// (fb as StringFeedback).LinkInputSig(TriList.StringInput[fb.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);
// }
// }
//}

164
PepperDashEssentials/FOR REFERENCE UI/SRL/SourceListSubpageReferenceList.cs
View File

@@ -1,164 +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.UI;
//using PepperDash.Core;
//using PepperDash.Essentials.Core;
//namespace PepperDash.Essentials
//{
// //*****************************************************************************
// /// <summary>
// /// Wrapper class for subpage reference list. Contains helpful methods to get at the various signal groupings
// /// and to get individual signals using an index and a join.
// /// </summary>
// public class SourceListSubpageReferenceList : SubpageReferenceList
// {
// public const uint SmartObjectJoin = 3801;
// Action<uint> SourceSelectCallback;
// EssentialsRoom CurrentRoom;
// public SourceListSubpageReferenceList(BasicTriListWithSmartObject tl,
// Action<uint> sourceSelectCallback)
// : base(tl, SmartObjectJoin, 3, 1, 3)
// {
// SourceSelectCallback = sourceSelectCallback;
// }
// void SetSourceList(Dictionary<uint, SourceListItem> dict)
// {
// // Iterate all positions, including ones missing from the dict.
// var max = dict.Keys.Max();
// for (uint i = 1; i <= max; i++)
// {
// // Add the source if it's in the dict
// if (dict.ContainsKey(i))
// {
// Items.Add(new SourceListSubpageReferenceListItem(i, dict[i], this, SourceSelectCallback));
// // Plug the callback function into the buttons
// }
// // Blank the line
// else
// Items.Add(new SourceListSubpageReferenceListItem(i, null,
// this, SourceSelectCallback));
// }
// Count = (ushort)max;
// }
// /// <summary>
// /// Links the SRL to the Room's PresentationSourceChange event for updating of the UI
// /// </summary>
// /// <param name="room"></param>
// public void AttachToRoom(EssentialsRoom room)
// {
// CurrentRoom = room;
// SetSourceList(room.Sources);
// CurrentRoom.PresentationSourceChange -= CurrentRoom_PresentationSourceChange;
// CurrentRoom.PresentationSourceChange += CurrentRoom_PresentationSourceChange;
// SetPresentationSourceFb(CurrentRoom.CurrentPresentationSource);
// }
// /// <summary>
// /// Disconnects the SRL from a Room's PresentationSourceChange
// /// </summary>
// public void DetachFromCurrentRoom()
// {
// ClearPresentationSourceFb(CurrentRoom.CurrentPresentationSource);
// if(CurrentRoom != null)
// CurrentRoom.PresentationSourceChange -= CurrentRoom_PresentationSourceChange;
// CurrentRoom = null;
// }
// // Handler to route source changes into list feedback
// void CurrentRoom_PresentationSourceChange(object sender, EssentialsRoomSourceChangeEventArgs args)
// {
// Debug.Console(2, "SRL received source change");
// ClearPresentationSourceFb(args.OldSource);
// SetPresentationSourceFb(args.NewSource);
// }
// void ClearPresentationSourceFb(IPresentationSource source)
// {
// if (source == null) return;
// var oldSourceItem = (SourceListSubpageReferenceListItem)Items.FirstOrDefault(
// i => ((SourceListSubpageReferenceListItem)i).SourceDevice == source);
// if (oldSourceItem != null)
// oldSourceItem.ClearFeedback();
// }
// void SetPresentationSourceFb(SourceListItem source)
// {
// if (source == null) return;
// // Now set the new source to light up
// var newSourceItem = (SourceListSubpageReferenceListItem)Items.FirstOrDefault(
// i => ((SourceListSubpageReferenceListItem)i).SourceDevice == source);
// if (newSourceItem != null)
// newSourceItem.SetFeedback();
// }
// }
// public class SourceListSubpageReferenceListItem : SubpageReferenceListItem
// {
// public readonly IPresentationSource SourceDevice;
// public const uint ButtonPressJoin = 1;
// public const uint SelectedFeedbackJoin = 2;
// public const uint ButtonTextJoin = 1;
// public const uint IconNameJoin = 2;
// public SourceListSubpageReferenceListItem(uint index, SourceListItem srcDeviceItem,
// SubpageReferenceList owner, Action<uint> sourceSelectCallback)
// : base(index, owner)
// {
// if (srcDeviceItem == null) throw new ArgumentNullException("srcDeviceItem");
// if (owner == null) throw new ArgumentNullException("owner");
// if (sourceSelectCallback == null) throw new ArgumentNullException("sourceSelectCallback");
// SourceDevice = srcDeviceItem;
// var nameSig = owner.StringInputSig(index, ButtonTextJoin);
// // Should be able to see if there is not enough buttons right here
// if (nameSig == null)
// {
// Debug.Console(0, "ERROR: Item {0} does not exist on source list SRL", index);
// return;
// }
// nameSig.StringValue = srcDeviceItem.Name;
// owner.StringInputSig(index, IconNameJoin).StringValue = srcDeviceItem.Icon;
// // Assign a source selection action to the appropriate button's UserObject - on release
// owner.GetBoolFeedbackSig(index, ButtonPressJoin).UserObject = new Action<bool>(b =>
// { if (!b) sourceSelectCallback(index); });
// // hook up the video icon
// var videoDev = srcDeviceItem as IAttachVideoStatus;
// if (videoDev != null)
// {
// var status = videoDev.GetVideoStatuses();
// if (status != null)
// {
// Debug.Console(1, "Linking {0} video status to SRL", videoDev.Key);
// videoDev.GetVideoStatuses().VideoSyncFeedback.LinkInputSig(owner.BoolInputSig(index, 3));
// }
// }
// }
// public void SetFeedback()
// {
// Owner.BoolInputSig(Index, SelectedFeedbackJoin).BoolValue = true;
// }
// public void ClearFeedback()
// {
// Owner.BoolInputSig(Index, SelectedFeedbackJoin).BoolValue = false;
// }
// }
//}

45
PepperDashEssentials/PepperDashEssentials.csproj
View File

@@ -127,9 +127,11 @@
<Compile Include="Bridges\AppleTvBridge.cs" />
<Compile Include="Bridges\BridgeBase.cs" />
<Compile Include="Bridges\BridgeFactory.cs" />
<Compile Include="Bridges\C2nRthsControllerBridge.cs" />
<Compile Include="Bridges\CameraControllerBridge.cs" />
<Compile Include="Bridges\AirMediaControllerBridge.cs" />
<Compile Include="Bridges\DmBladeChassisControllerBridge.cs" />
<Compile Include="Bridges\JoinMaps\C2nRthsControllerJoinMap.cs" />
<Compile Include="Bridges\JoinMaps\DmBladeChassisControllerJoinMap.cs" />
<Compile Include="Bridges\DmpsAudioOutputControllerBridge.cs" />
<Compile Include="Bridges\DmpsRoutingControllerBridge.cs" />
@@ -161,30 +163,15 @@
<Compile Include="Bridges\JoinMaps\IBasicCommunicationJoinMap.cs" />
<Compile Include="Bridges\JoinMaps\IDigitalInputJoinMap.cs" />
<Compile Include="Bridges\JoinMaps\GlsOccupancySensorBaseJoinMap.cs" />
<Compile Include="Bridges\JoinMaps\StatusSignControllerJoinMap.cs" />
<Compile Include="Bridges\JoinMaps\SystemMonitorJoinMap.cs" />
<Compile Include="Bridges\StatusSignControllerBridge.cs" />
<Compile Include="Bridges\SystemMonitorBridge.cs" />
<Compile Include="Configuration ORIGINAL\Builders\TPConfig.cs" />
<Compile Include="Configuration ORIGINAL\Configuration.cs" />
<Compile Include="Configuration ORIGINAL\ConfigurationHelpers.cs" />
<Compile Include="Configuration ORIGINAL\ConfigTieLine.cs" />
<Compile Include="Configuration ORIGINAL\Factories\CommFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\RemoteFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\DeviceMonitorFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\DmFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\TouchpanelFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\PcFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\REMOVE DiscPlayerFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\MAYBE SetTopBoxFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\DisplayFactory.cs" />
<Compile Include="Configuration ORIGINAL\Factories\FactoryHelper.cs" />
<Compile Include="Factory\DeviceFactory.cs" />
<Compile Include="Devices\Amplifier.cs" />
<Compile Include="Devices\DiscPlayer\OppoExtendedBdp.cs" />
<Compile Include="Devices\NUMERIC AppleTV.cs" />
<Compile Include="ControlSystem.cs" />
<Compile Include="Factory\UiDeviceFactory.cs" />
<Compile Include="Fusion\EssentialsHuddleVtc1FusionController.cs" />
<Compile Include="REMOVE EssentialsApp.cs" />
<Compile Include="HttpApiHandler.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Room\Config\EssentialsDualDisplayRoomPropertiesConfig.cs" />
@@ -214,14 +201,7 @@
<Compile Include="Room\Types\EssentialsDualDisplayRoom.cs" />
<Compile Include="Room\Types\EssentialsHuddleVtc1Room.cs" />
<Compile Include="Room\Types\EssentialsNDisplayRoomBase.cs" />
<Compile Include="Room\Types\EssentialsPresentationRoom.cs" />
<Compile Include="Room\Config\EssentialsRoomConfig.cs" />
<Compile Include="FOR REFERENCE UI\PageControllers\DevicePageControllerBase.cs" />
<Compile Include="FOR REFERENCE UI\PageControllers\PageControllerLaptop.cs" />
<Compile Include="FOR REFERENCE UI\PageControllers\PageControllerLargeDvd.cs" />
<Compile Include="FOR REFERENCE UI\PageControllers\PageControllerLargeSetTopBoxGeneric.cs" />
<Compile Include="FOR REFERENCE UI\PageControllers\LargeTouchpanelControllerBase.cs" />
<Compile Include="FOR REFERENCE UI\Panels\SmartGraphicsTouchpanelControllerBase.cs" />
<Compile Include="UIDrivers\Environment Drivers\EssentialsEnvironmentDriver.cs" />
<Compile Include="UIDrivers\Environment Drivers\EssentialsLightingDriver.cs" />
<Compile Include="UIDrivers\Environment Drivers\EssentialsShadeDriver.cs" />
@@ -251,12 +231,22 @@
<Compile Include="AppServer\MobileControlSystemController.cs" />
<Compile Include="UI\DualDisplaySourceSRLController.cs" />
<Compile Include="UI\SubpageReferenceListActivityItem.cs" />
<Compile Include="FOR REFERENCE UI\Panels\REMOVE UiCue.cs" />
<Compile Include="FOR REFERENCE UI\SRL\SourceListSubpageReferenceList.cs" />
<Compile Include="Room\Types\EssentialsHuddleSpaceRoom.cs" />
<Compile Include="UI\EssentialsTouchpanelController.cs" />
<Compile Include="UI\SubpageReferenceListSourceItem.cs" />
<None Include="app.config" />
<EmbeddedResource Include="Example Configuration\EssentialsHuddleSpaceRoom\configurationFile-HuddleSpace-2-Source.json">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</EmbeddedResource>
<EmbeddedResource Include="Example Configuration\EssentialsHuddleVtc1Room\configurationFile-mockVideoCodec_din-ap3_-_dm4x1.json">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</EmbeddedResource>
<EmbeddedResource Include="Example Configuration\SIMPLBridging\configurationFile-dmps3300c-avRouting.json">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</EmbeddedResource>
<EmbeddedResource Include="Example Configuration\SIMPLBridging\SIMPLBridgeExample_configurationFile.json">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</EmbeddedResource>
<None Include="Properties\ControlSystem.cfg" />
<EmbeddedResource Include="SGD\PepperDash Essentials iPad.sgd">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
@@ -278,9 +268,6 @@
<Name>Essentials Devices Common</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="FOR REFERENCE UI\OTHER\" />
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
<ProjectExtensions>
<VisualStudio>

14
PepperDashEssentials/Properties/AssemblyInfo.cs
View File

@@ -1,8 +1,10 @@
using System.Reflection;
using Crestron.SimplSharp.Reflection;
[assembly: AssemblyTitle("PepperDashEssentials")]
[assembly: AssemblyCompany("PepperDash Technology Corp")]
[assembly: AssemblyProduct("PepperDashEssentials")]
[assembly: AssemblyCopyright("Copyright © PepperDash Technology Corp 2018")]
[assembly: AssemblyVersion("1.4.0.*")]
[assembly: System.Reflection.AssemblyTitle("PepperDashEssentials")]
[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")]

19
PepperDashEssentials/Properties/UpdateAssemblyVersion.ps1
View File

@@ -1,13 +1,23 @@
function Update-SourceVersion
{
Param ([string]$Version)
$NewVersion = ‘AssemblyVersion("‘ + $Version + ‘.*")’;
$fullVersion = $Version
$baseVersion = [regex]::Match($Version, "(\d+.\d+.\d+).*").captures.groups[1].value
$NewAssemblyVersion = ‘AssemblyVersion("‘ + $baseVersion + ‘.*")’
echo "AssemblyVersion = $NewAssemblyVersion"
$NewAssemblyInformationalVersion = ‘AssemblyInformationalVersion("‘ + $Version + ‘")’
echo "AssemblyInformationalVersion = $NewAssemblyInformationalVersion"
foreach ($o in $input)
{
{
Write-output $o.FullName
$TmpFile = $o.FullName + “.tmp”
get-content $o.FullName |
%{$_ -replace ‘AssemblyVersion\("(\d+\.\d+\.\d+)\.\*"\)’, $NewVersion } > $TmpFile
%{
$_ -replace ‘AssemblyVersion\(".*"\)’, $NewAssemblyVersion} |
%{
$_ -replace ‘AssemblyInformationalVersion\(".*"\)’, $NewAssemblyInformationalVersion
} > $TmpFile
move-item $TmpFile $o.FullName -force
}
}
@@ -21,9 +31,10 @@ function Update-AllAssemblyInfoFiles ( $version )
}
# validate arguments
$r= [System.Text.RegularExpressions.Regex]::Match($args[0], "^\d+\.\d+\.\d+$");
$r= [System.Text.RegularExpressions.Regex]::Match($args[0], "\d+\.\d+\.\d+.*");
if ($r.Success)
{
echo "Updating Assembly Version to $args ...";
Update-AllAssemblyInfoFiles $args[0];
}
else

69
PepperDashEssentials/REMOVE EssentialsApp.cs
View File

@@ -1,69 +0,0 @@
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using Crestron.SimplSharp;
//using Crestron.SimplSharp.CrestronIO;
//using Crestron.SimplSharpPro;
//using Crestron.SimplSharpPro.DeviceSupport;
//using Crestron.SimplSharpPro.CrestronThread;
//using Crestron.SimplSharpPro.Diagnostics;
//using Crestron.SimplSharpPro.EthernetCommunication;
//using Crestron.SimplSharpPro.UI;
//using Crestron.SimplSharpPro.DM;
//using Crestron.SimplSharpPro.DM.Cards;
//using Crestron.SimplSharpPro.DM.Endpoints.Transmitters;
//using PepperDash.Essentials.Core;
//using PepperDash.Essentials.Core.Devices;
////using PepperDash.Essentials.Core.Devices.Dm;
//using PepperDash.Essentials.Displays;
////using PepperDash.Essentials.Core.Http;
//using PepperDash.Core;
//namespace PepperDash.Essentials
//{
// public class EssentialsApp
// {
// public string ConfigPath { get; set; }
// public Dictionary<string, Room> Rooms { get; private set; }
// //EssentialsHttpApiHandler ApiHandler; // MOVE ???????????????????
// public EssentialsApp(CrestronControlSystem cs)
// {
// // Use a fake license manager for now
// Global.LicenseManager = PepperDash.Essentials.License.MockEssentialsLicenseManager.Manager;
// // ---------------------------------- Make this configurable
// //var server = Global.HttpConfigServer;
// //server.Start(8081, "HttpConfigServer");
// //ConfigPath = string.Format(@"\NVRAM\Program{0}\EssentialsConfiguration.json",
// // InitialParametersClass.ApplicationNumber);
// //ApiHandler = new EssentialsHttpApiHandler(server, ConfigPath, @"\HTML\presets\lists\");
// Debug.Console(0, "\r\r--------------------CONFIG BEGIN--------------------\r");
// Configuration.Initialize(cs);
// Configuration.ReadConfiguration(ConfigPath);
// Debug.Console(0, "\r--------------------CONFIG END----------------------\r\r");
// }
// }
// public class ResponseToken
// {
// public string Token { get; private set; }
// public DateTime Expires { get; private set; }
// public bool IsExpired { get { return Expires < DateTime.Now; } }
// public ResponseToken(int timeoutMinutes)
// {
// Expires = DateTime.Now.AddMinutes(timeoutMinutes);
// Token = Guid.NewGuid().ToString();
// }
// }
//}

24
PepperDashEssentials/Room/Types/EssentialsHuddleSpaceRoom.cs
View File

@@ -223,7 +223,9 @@ namespace PepperDash.Essentials
CrestronEnvironment.Sleep(1000);
RunRouteAction("roomOff", SourceListKey);
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Shutting down room");
RunRouteAction("roomOff");
}
/// <summary>
@@ -237,7 +239,7 @@ namespace PepperDash.Essentials
return false;
}
RunRouteAction(DefaultSourceItem, SourceListKey);
RunRouteAction(DefaultSourceItem);
return true;
}
@@ -260,9 +262,9 @@ namespace PepperDash.Essentials
///
/// </summary>
/// <param name="routeKey"></param>
public void RunRouteAction(string routeKey, string sourceListKey)
public void RunRouteAction(string routeKey)
{
RunRouteAction(routeKey, sourceListKey, null);
RunRouteAction(routeKey, null);
}
/// <summary>
@@ -270,16 +272,16 @@ namespace PepperDash.Essentials
/// route or commands
/// </summary>
/// <param name="name"></param>
public void RunRouteAction(string routeKey, string sourceListKey, Action successCallback)
public void RunRouteAction(string routeKey, Action successCallback)
{
// Run this on a separate thread
new CTimer(o =>
{
Debug.Console(1, this, "Run route action '{0}'", routeKey);
var dict = ConfigReader.ConfigObject.GetSourceListForKey(sourceListKey);
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Run route action '{0}'", routeKey);
var dict = ConfigReader.ConfigObject.GetSourceListForKey(SourceListKey);
if(dict == null)
{
Debug.Console(1, this, "WARNING: Config source list '{0}' not found", sourceListKey);
Debug.Console(1, this, "WARNING: Config source list '{0}' not found", SourceListKey);
return;
}
@@ -287,7 +289,7 @@ namespace PepperDash.Essentials
if (!dict.ContainsKey(routeKey))
{
Debug.Console(1, this, "WARNING: No item '{0}' found on config list '{1}'",
routeKey, sourceListKey);
routeKey, SourceListKey);
return;
}
@@ -426,7 +428,7 @@ namespace PepperDash.Essentials
{
if (!EnablePowerOnToLastSource || LastSourceKey == null)
return;
RunRouteAction(LastSourceKey, SourceListKey);
RunRouteAction(LastSourceKey);
}
/// <summary>
@@ -494,7 +496,7 @@ namespace PepperDash.Essentials
var allRooms = DeviceManager.AllDevices.Where(d =>
d is EssentialsHuddleSpaceRoom && !(d as EssentialsHuddleSpaceRoom).ExcludeFromGlobalFunctions);
foreach (var room in allRooms)
(room as EssentialsHuddleSpaceRoom).RunRouteAction("roomOff", (room as EssentialsHuddleSpaceRoom).SourceListKey);
(room as EssentialsHuddleSpaceRoom).RunRouteAction("roomOff");
}
}
}

27
PepperDashEssentials/Room/Types/EssentialsHuddleVtc1Room.cs
View File

@@ -334,8 +334,11 @@ namespace PepperDash.Essentials
{
// Add Occupancy object from config
if (PropertiesConfig.Occupancy != null)
{
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Setting Occupancy Provider for room");
this.SetRoomOccupancy(DeviceManager.GetDeviceForKey(PropertiesConfig.Occupancy.DeviceKey) as
IOccupancyStatusProvider, PropertiesConfig.Occupancy.TimeoutMinutes);
}
this.LogoUrl = PropertiesConfig.Logo.GetUrl();
this.SourceListKey = PropertiesConfig.SourceListKey;
@@ -359,7 +362,9 @@ namespace PepperDash.Essentials
CrestronEnvironment.Sleep(1000);
RunRouteAction("roomOff", SourceListKey);
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Shutting down room");
RunRouteAction("roomOff");
}
/// <summary>
@@ -368,7 +373,7 @@ namespace PepperDash.Essentials
public override bool RunDefaultPresentRoute()
{
if (DefaultSourceItem != null)
RunRouteAction(DefaultSourceItem, SourceListKey);
RunRouteAction(DefaultSourceItem);
return DefaultSourceItem != null;
}
@@ -379,7 +384,7 @@ namespace PepperDash.Essentials
/// <returns></returns>
public bool RunDefaultCallRoute()
{
RunRouteAction(DefaultCodecRouteString, SourceListKey);
RunRouteAction(DefaultCodecRouteString);
return true;
}
@@ -387,9 +392,9 @@ namespace PepperDash.Essentials
///
/// </summary>
/// <param name="routeKey"></param>
public void RunRouteAction(string routeKey, string sourceListKey)
public void RunRouteAction(string routeKey)
{
RunRouteAction(routeKey, sourceListKey, null);
RunRouteAction(routeKey, null);
}
/// <summary>
@@ -397,7 +402,7 @@ namespace PepperDash.Essentials
/// route or commands
/// </summary>
/// <param name="name"></param>
public void RunRouteAction(string routeKey, string sourceListKey, Action successCallback)
public void RunRouteAction(string routeKey, Action successCallback)
{
// Run this on a separate thread
new CTimer(o =>
@@ -408,11 +413,11 @@ namespace PepperDash.Essentials
try
{
Debug.Console(1, this, "Run route action '{0}'", routeKey);
var dict = ConfigReader.ConfigObject.GetSourceListForKey(sourceListKey);
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "Run route action '{0}'", routeKey);
var dict = ConfigReader.ConfigObject.GetSourceListForKey(SourceListKey);
if (dict == null)
{
Debug.Console(1, this, "WARNING: Config source list '{0}' not found", sourceListKey);
Debug.Console(1, this, "WARNING: Config source list '{0}' not found", SourceListKey);
return;
}
@@ -619,7 +624,7 @@ namespace PepperDash.Essentials
{
if (!EnablePowerOnToLastSource || LastSourceKey == null)
return;
RunRouteAction(LastSourceKey, SourceListKey);
RunRouteAction(LastSourceKey);
}
/// <summary>
@@ -630,7 +635,7 @@ namespace PepperDash.Essentials
var allRooms = DeviceManager.AllDevices.Where(d =>
d is EssentialsHuddleSpaceRoom && !(d as EssentialsHuddleSpaceRoom).ExcludeFromGlobalFunctions);
foreach (var room in allRooms)
(room as EssentialsHuddleSpaceRoom).RunRouteAction("roomOff", (room as EssentialsHuddleSpaceRoom).SourceListKey);
(room as EssentialsHuddleSpaceRoom).RunRouteAction("roomOff");
}
#region IPrivacy Members

437
PepperDashEssentials/Room/Types/EssentialsPresentationRoom.cs
View File

@@ -1,437 +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 PepperDash.Essentials.Room.Config;
//namespace PepperDash.Essentials
//{
// public class EssentialsPresentationRoom : EssentialsRoomBase, IHasCurrentSourceInfoChange
// {
// public event EventHandler<VolumeDeviceChangeEventArgs> CurrentVolumeDeviceChange;
// public event SourceInfoChangeHandler CurrentSingleSourceChange;
// public event SourceInfoChangeHandler CurrentDisplay1SourceChange;
// public event SourceInfoChangeHandler CurrentDisplay2SourceChange;
// protected override Func<bool> OnFeedbackFunc { get {
// return () => (CurrentSingleSourceInfo != null
// && CurrentSingleSourceInfo.Type != eSourceListItemType.Off)
// || (Display1SourceInfo != null
// && Display1SourceInfo.Type != eSourceListItemType.Off)
// || (Display2SourceInfo != null
// && Display2SourceInfo.Type != eSourceListItemType.Off); } }
// protected override Func<bool> IsWarmingFeedbackFunc { get { return () =>false;; } }
// protected override Func<bool> IsCoolingFeedbackFunc { get { return () => false; } }
// public EssentialsPresentationRoomPropertiesConfig Config { get; private set; }
// public Dictionary<uint, IRoutingSinkNoSwitching> Displays { get; private set; }
// public IRoutingSinkNoSwitching DefaultAudioDevice { get; private set; }
// public IBasicVolumeControls DefaultVolumeControls { get; private set; }C:\Working Directories\PD\essentials\PepperDashEssentials\Room\Types\EssentialsPresentationRoom.cs
// /// <summary>
// /// The config name of the source list
// /// </summary>
// public string SourceListKey { get; set; }
// /// <summary>
// /// If room is off, enables power on to last source. Default true
// /// </summary>
// public bool EnablePowerOnToLastSource { get; set; }
// string LastSourceKey;
// public enum eVideoRoutingMode
// {
// SelectSourceSelectDisplay, SourceToAllDisplays
// }
// public eVideoRoutingMode VideoRoutingMode { get; set; }
// public enum eAudioRoutingMode
// {
// AudioFollowsLastVideo, SelectAudioFromDisplay
// }
// /// <summary>
// ///
// /// </summary>
// public IBasicVolumeControls CurrentVolumeControls
// {
// get { return _CurrentAudioDevice; }
// set
// {
// if (value == _CurrentAudioDevice) return;
// var oldDev = _CurrentAudioDevice;
// // derigister this room from the device, if it can
// if (oldDev is IInUseTracking)
// (oldDev as IInUseTracking).InUseTracker.RemoveUser(this, "audio");
// var handler = CurrentVolumeDeviceChange;
// if (handler != null)
// CurrentVolumeDeviceChange(this, new VolumeDeviceChangeEventArgs(oldDev, value, ChangeType.WillChange));
// _CurrentAudioDevice = value;
// if (handler != null)
// CurrentVolumeDeviceChange(this, new VolumeDeviceChangeEventArgs(oldDev, value, ChangeType.DidChange));
// // register this room with new device, if it can
// if (_CurrentAudioDevice is IInUseTracking)
// (_CurrentAudioDevice as IInUseTracking).InUseTracker.AddUser(this, "audio");
// }
// }
// IBasicVolumeControls _CurrentAudioDevice;
// /// <summary>
// /// The SourceListItem last run - containing names and icons. The complex setter is
// /// to add/remove this room to the source's InUseTracking, if it is capable
// /// </summary>
// public SourceListItem CurrentSingleSourceInfo
// {
// get { return _CurrentSingleSourceInfo; }
// private set
// {
// if (value == _CurrentSingleSourceInfo) return;
// var handler = CurrentSingleSourceChange;
// // remove from in-use tracker, if so equipped
// if(_CurrentSingleSourceInfo != null && _CurrentSingleSourceInfo.SourceDevice is IInUseTracking)
// (_CurrentSingleSourceInfo.SourceDevice as IInUseTracking).InUseTracker.RemoveUser(this, "control");
// if (handler != null)
// handler(this, _CurrentSingleSourceInfo, ChangeType.WillChange);
// _CurrentSingleSourceInfo = value;
// // add to in-use tracking
// if (_CurrentSingleSourceInfo != null && _CurrentSingleSourceInfo.SourceDevice is IInUseTracking)
// (_CurrentSingleSourceInfo.SourceDevice as IInUseTracking).InUseTracker.AddUser(this, "control");
// if (handler != null)
// handler(this, _CurrentSingleSourceInfo, ChangeType.DidChange);
// }
// }
// SourceListItem _CurrentSingleSourceInfo;
// public SourceListItem Display1SourceInfo
// {
// get { return _Display1SourceInfo; }
// set
// {
// if (value == _Display1SourceInfo) return;
// var handler = CurrentDisplay1SourceChange;
// if (handler != null)
// handler(this, _Display1SourceInfo, ChangeType.WillChange);
// _Display1SourceInfo = value;
// if (handler != null)
// handler(this, _Display1SourceInfo, ChangeType.DidChange);
// }
// }
// SourceListItem _Display1SourceInfo;
// public SourceListItem Display2SourceInfo
// {
// get { return _Display2SourceInfo; }
// set
// {
// if (value == _Display2SourceInfo) return;
// var handler = CurrentDisplay2SourceChange;
// if (handler != null)
// handler(this, _Display2SourceInfo, ChangeType.WillChange);
// _Display2SourceInfo = value;
// if (handler != null)
// handler(this, _Display2SourceInfo, ChangeType.DidChange);
// }
// }
// SourceListItem _Display2SourceInfo;
// /// <summary>
// /// If an audio dialer is available for this room
// /// </summary>
// public bool HasAudioDialer { get { return false; } }
// /// <summary>
// ///
// /// </summary>
// /// <param name="key"></param>
// /// <param name="name"></param>
// public EssentialsPresentationRoom(string key, string name,
// Dictionary<uint, IRoutingSinkNoSwitching> displays,
// IBasicVolumeWithFeedback defaultVolume, EssentialsPresentationRoomPropertiesConfig config)
// : base(key, name)
// {
// Config = config;
// Displays = displays;
// DefaultVolumeControls = defaultVolume;
// CurrentVolumeControls = defaultVolume;
// //DefaultAudioDevice = defaultAudio;
// //if (defaultAudio is IBasicVolumeControls)
// // DefaultVolumeControls = defaultAudio as IBasicVolumeControls;
// //else if (defaultAudio is IHasVolumeDevice)
// // DefaultVolumeControls = (defaultAudio as IHasVolumeDevice).VolumeDevice;
// SourceListKey = "default";
// EnablePowerOnToLastSource = true;
// }
// /// <summary>
// /// Run the same source to all destinations
// /// </summary>
// /// <param name="sourceItem"></param>
// public void RouteSourceToAllDestinations(SourceListItem sourceItem)
// {
// if (Config.Volumes.Master != null)
// {
// var audioDev = DeviceManager.GetDeviceForKey(Config.Volumes.Master.DeviceKey);
// if (audioDev is IBasicVolumeWithFeedback)
// {
// }
// }
// foreach (var display in Displays.Values)
// {
// if (sourceItem != null)
// DoVideoRoute(sourceItem.SourceKey, display.Key);
// else
// DoVideoRoute("$off", display.Key);
// }
// Display1SourceInfo = sourceItem;
// Display2SourceInfo = sourceItem;
// CurrentSingleSourceInfo = sourceItem;
// OnFeedback.FireUpdate();
// }
// public void SourceToDisplay1(SourceListItem sourceItem)
// {
// DoVideoRoute(sourceItem.SourceKey, Displays[1].Key);
// Display1SourceInfo = sourceItem;
// OnFeedback.FireUpdate();
// }
// public void SourceToDisplay2(SourceListItem sourceItem)
// {
// DoVideoRoute(sourceItem.SourceKey, Displays[2].Key);
// Display2SourceInfo = sourceItem;
// OnFeedback.FireUpdate();
// }
// /// <summary>
// /// Basic source -> destination routing
// /// </summary>
// void DoVideoRoute(string sourceKey, string destinationKey)
// {
// new CTimer(o =>
// {
// var dest = DeviceManager.GetDeviceForKey(destinationKey) as IRoutingSinkNoSwitching;
// if (dest == null)
// {
// Debug.Console(1, this, "Cannot route. Destination '{0}' not found", destinationKey);
// return;
// }
// // off is special case
// if (sourceKey.Equals("$off", StringComparison.OrdinalIgnoreCase))
// {
// dest.ReleaseRoute();
// if (dest is IPower)
// (dest as IPower).PowerOff();
// return;
// }
// var source = DeviceManager.GetDeviceForKey(sourceKey) as IRoutingOutputs;
// if (source == null)
// {
// Debug.Console(1, this, "Cannot route. Source '{0}' not found", sourceKey);
// return;
// }
// dest.ReleaseAndMakeRoute(source, eRoutingSignalType.Video);
// }, 0);
// }
// /// <summary>
// ///
// /// </summary>
// protected override void EndShutdown()
// {
// RunRouteAction("roomoff");
// }
// /// <summary>
// ///
// /// </summary>
// /// <param name="routeKey"></param>
// public void RunRouteAction(string routeKey)
// {
// RunRouteAction(routeKey, null);
// }
// /// <summary>
// /// Gets a source from config list SourceListKey and dynamically build and executes the
// /// route or commands
// /// </summary>
// /// <param name="name"></param>
// public void RunRouteAction(string routeKey, Action successCallback)
// {
// // Run this on a separate thread
// new CTimer(o =>
// {
// Debug.Console(1, this, "Run room action '{0}'", routeKey);
// var dict = ConfigReader.ConfigObject.GetSourceListForKey(SourceListKey);
// if(dict == null)
// {
// Debug.Console(1, this, "WARNING: Config source list '{0}' not found", SourceListKey);
// return;
// }
// // Try to get the list item by it's string key
// if (!dict.ContainsKey(routeKey))
// {
// Debug.Console(1, this, "WARNING: No item '{0}' found on config list '{1}'",
// routeKey, SourceListKey);
// return;
// }
// var item = dict[routeKey];
// //Debug.Console(2, this, "Action {0} has {1} steps",
// // item.SourceKey, item.RouteList.Count);
// // Let's run it
// if (routeKey.ToLower() != "roomoff")
// LastSourceKey = routeKey;
// foreach (var route in item.RouteList)
// {
// // if there is a $defaultAll on route, run two separate
// if (route.DestinationKey.Equals("$defaultAll", StringComparison.OrdinalIgnoreCase))
// {
// var tempAudio = new SourceRouteListItem
// {
// DestinationKey = "$defaultDisplay",
// SourceKey = route.SourceKey,
// Type = eRoutingSignalType.Video
// };
// DoRoute(tempAudio);
// var tempVideo = new SourceRouteListItem
// {
// DestinationKey = "$defaultAudio",
// SourceKey = route.SourceKey,
// Type = eRoutingSignalType.Audio
// };
// DoRoute(tempVideo);
// continue;
// }
// else
// DoRoute(route);
// }
// // Set volume control on room, using default if non provided
// IBasicVolumeControls volDev = null;
// // Handle special cases for volume control
// if (string.IsNullOrEmpty(item.VolumeControlKey)
// || item.VolumeControlKey.Equals("$defaultAudio", StringComparison.OrdinalIgnoreCase))
// volDev = DefaultVolumeControls;
// //else if (item.VolumeControlKey.Equals("$defaultDisplay", StringComparison.OrdinalIgnoreCase))
// // volDev = DefaultDisplay as IBasicVolumeControls;
// // Or a specific device, probably rarely used.
// else
// {
// var dev = DeviceManager.GetDeviceForKey(item.VolumeControlKey);
// if (dev is IBasicVolumeControls)
// volDev = dev as IBasicVolumeControls;
// else if (dev is IHasVolumeDevice)
// volDev = (dev as IHasVolumeDevice).VolumeDevice;
// }
// CurrentVolumeControls = volDev;
// // store the name and UI info for routes
// if (item.SourceKey != null)
// CurrentSingleSourceInfo = item;
// // And finally, set the "control". This will trigger event
// //CurrentControlDevice = DeviceManager.GetDeviceForKey(item.SourceKey) as Device;
// OnFeedback.FireUpdate();
// // report back when done
// if (successCallback != null)
// successCallback();
// }, 0); // end of CTimer
// }
// /// <summary>
// /// Will power the room on with the last-used source
// /// </summary>
// public void PowerOnToDefaultOrLastSource()
// {
// if (!EnablePowerOnToLastSource || LastSourceKey == null)
// return;
// RunRouteAction(LastSourceKey);
// }
// /// <summary>
// /// Does what it says
// /// </summary>
// public override void SetDefaultLevels()
// {
// Debug.Console(0, this, "SetDefaultLevels not implemented");
// }
// /// <summary>
// ///
// /// </summary>
// /// <param name="route"></param>
// /// <returns></returns>
// bool DoRoute(SourceRouteListItem route)
// {
// IRoutingSinkNoSwitching dest = null;
// if (route.DestinationKey.Equals("$defaultaudio", StringComparison.OrdinalIgnoreCase))
// dest = DefaultAudioDevice;
// //else if (route.DestinationKey.Equals("$defaultDisplay", StringComparison.OrdinalIgnoreCase))
// // dest = DefaultDisplay;
// else
// dest = DeviceManager.GetDeviceForKey(route.DestinationKey) as IRoutingSinkNoSwitching;
// if (dest == null)
// {
// Debug.Console(1, this, "Cannot route, unknown destination '{0}'", route.DestinationKey);
// return false;
// }
// if (route.SourceKey.Equals("$off", StringComparison.OrdinalIgnoreCase))
// {
// dest.ReleaseRoute();
// if (dest is IPower)
// (dest as IPower).PowerOff();
// }
// else
// {
// var source = DeviceManager.GetDeviceForKey(route.SourceKey) as IRoutingOutputs;
// if (source == null)
// {
// Debug.Console(1, this, "Cannot route unknown source '{0}' to {1}", route.SourceKey, route.DestinationKey);
// return false;
// }
// dest.ReleaseAndMakeRoute(source, route.Type);
// }
// return true;
// }
// public override void RoomVacatedForTimeoutPeriod(object o)
// {
// //Implement this
// }
// }
//}

14
PepperDashEssentials/UI/EssentialsTouchpanelController.cs
View File

@@ -106,12 +106,18 @@ namespace PepperDash.Essentials
Debug.Console(0, this, Debug.ErrorLogLevel.Notice, "WARNING: Registration failed. Continuing, but panel may not function: {0}", Panel.RegistrationFailureReason);
// Give up cleanly if SGD is not present.
var sgdName = Global.FilePathPrefix
+ Global.DirectorySeparator + "sgd" + Global.DirectorySeparator + props.SgdFile;
var sgdName = Global.FilePathPrefix + "sgd" + Global.DirectorySeparator + props.SgdFile;
if (!File.Exists(sgdName))
{
Debug.Console(0, this, "ERROR: Smart object file '{0}' not present. Exiting TSW load", sgdName);
return;
Debug.Console(0, this, "Smart object file '{0}' not present in User folder. Looking for embedded file", sgdName);
sgdName = Global.ApplicationDirectoryPathPrefix + Global.DirectorySeparator + "SGD" + Global.DirectorySeparator + props.SgdFile;
if (!File.Exists(sgdName))
{
Debug.Console(0, this, "Unable to find SGD file '{0}' in User sgd or application SGD folder. Exiting touchpanel load.", sgdName);
return;
}
}
Panel.LoadSmartObjects(sgdName);