Compare commits

...

1 Commits

Author SHA1 Message Date
Trevor Payne
3c9d7bb28c feat: removed Tesira and Soundstructure DSPs 2022-10-30 01:17:10 -05:00
8 changed files with 5 additions and 1036 deletions

View File

@@ -34,6 +34,7 @@ namespace PepperDash.Essentials
public string Label { get; set; }
public int Level { get; set; }
/*
/// <summary>
/// Helper to get the device associated with key - one timer.
/// </summary>
@@ -55,6 +56,7 @@ namespace PepperDash.Essentials
return null;
}
/*
// DSP format: deviceKey--levelName, biampTesira-1--master
match = Regex.Match(DeviceKey, @"([-_\w]+)--(.+)");
if (match.Success)
@@ -70,8 +72,11 @@ namespace PepperDash.Essentials
// No volume for some reason. We have failed as developers
return null;
}
return null;
}
*/
}
}

View File

@@ -1,396 +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.Core.Config;
using System.Text.RegularExpressions;
namespace PepperDash.Essentials.Devices.Common.DSP
{
// QUESTIONS:
//
// When subscribing, just use the Instance ID for Custom Name?
// Verbose on subscriptions?
// Example subscription feedback responses
// ! "publishToken":"name" "value":-77.0
// ! "myLevelName" -77
public class BiampTesiraForteDsp : DspBase
{
public IBasicCommunication Communication { get; private set; }
public CommunicationGather PortGather { get; private set; }
public StatusMonitorBase CommunicationMonitor { get; private set; }
public new Dictionary<string, TesiraForteLevelControl> LevelControlPoints { get; private set; }
public bool isSubscribed;
private CTimer SubscriptionTimer;
private CrestronQueue CommandQueue;
private bool CommandQueueInProgress = false;
//new public Dictionary<string, DspControlPoint> DialerControlPoints { get; private set; }
//new public Dictionary<string, DspControlPoint> SwitcherControlPoints { get; private set; }
/// <summary>
/// Shows received lines as hex
/// </summary>
public bool ShowHexResponse { get; set; }
public BiampTesiraForteDsp(string key, string name, IBasicCommunication comm,
BiampTesiraFortePropertiesConfig props) :
base(key, name)
{
CommandQueue = new CrestronQueue(100);
Communication = comm;
var socket = comm as ISocketStatus;
if (socket != null)
{
// This instance uses IP control
socket.ConnectionChange += new EventHandler<GenericSocketStatusChageEventArgs>(socket_ConnectionChange);
}
else
{
// This instance uses RS-232 control
}
PortGather = new CommunicationGather(Communication, "\x0d\x0a");
PortGather.LineReceived += this.Port_LineReceived;
if (props.CommunicationMonitorProperties != null)
{
CommunicationMonitor = new GenericCommunicationMonitor(this, Communication,
props.CommunicationMonitorProperties);
}
else
{
//#warning Need to deal with this poll string
CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, 120000, 120000, 300000,
"SESSION get aliases\x0d\x0a");
}
LevelControlPoints = new Dictionary<string, TesiraForteLevelControl>();
foreach (KeyValuePair<string, BiampTesiraForteLevelControlBlockConfig> block in props.LevelControlBlocks)
{
this.LevelControlPoints.Add(block.Key, new TesiraForteLevelControl(block.Key, block.Value, this));
}
}
public override bool CustomActivate()
{
Communication.Connect();
CommunicationMonitor.StatusChange +=
(o, a) => { Debug.Console(2, this, "Communication monitor state: {0}", CommunicationMonitor.Status); };
CommunicationMonitor.Start();
CrestronConsole.AddNewConsoleCommand(SendLine, "send" + Key, "", ConsoleAccessLevelEnum.AccessOperator);
CrestronConsole.AddNewConsoleCommand(s => Communication.Connect(), "con" + Key, "",
ConsoleAccessLevelEnum.AccessOperator);
return true;
}
private void socket_ConnectionChange(object sender, GenericSocketStatusChageEventArgs e)
{
Debug.Console(2, this, "Socket Status Change: {0}", e.Client.ClientStatus.ToString());
if (e.Client.IsConnected)
{
// Tasks on connect
}
else
{
// Cleanup items from this session
if (SubscriptionTimer != null)
{
SubscriptionTimer.Stop();
SubscriptionTimer = null;
}
isSubscribed = false;
CommandQueue.Clear();
CommandQueueInProgress = false;
}
}
/// <summary>
/// Initiates the subscription process to the DSP
/// </summary>
private void SubscribeToAttributes()
{
SendLine("SESSION set verbose true");
foreach (KeyValuePair<string, TesiraForteLevelControl> level in LevelControlPoints)
{
level.Value.Subscribe();
}
if (!CommandQueueInProgress)
SendNextQueuedCommand();
ResetSubscriptionTimer();
}
/// <summary>
/// Resets or Sets the subscription timer
/// </summary>
private void ResetSubscriptionTimer()
{
isSubscribed = true;
if (SubscriptionTimer != null)
{
SubscriptionTimer = new CTimer(o => SubscribeToAttributes(), 30000);
SubscriptionTimer.Reset();
}
}
/// <summary>
/// Handles a response message from the DSP
/// </summary>
/// <param name="dev"></param>
/// <param name="args"></param>
private void Port_LineReceived(object dev, GenericCommMethodReceiveTextArgs args)
{
try
{
if (args.Text.IndexOf("Welcome to the Tesira Text Protocol Server...") > -1)
{
// Indicates a new TTP session
SubscribeToAttributes();
}
else if (args.Text.IndexOf("publishToken") > -1)
{
// response is from a subscribed attribute
string pattern = "! \"publishToken\":[\"](.*)[\"] \"value\":(.*)";
Match match = Regex.Match(args.Text, pattern);
if (match.Success)
{
string key;
string customName;
string value;
customName = match.Groups[1].Value;
// Finds the key (everything before the '~' character
key = customName.Substring(0, customName.IndexOf("~", 0) - 1);
value = match.Groups[2].Value;
foreach (KeyValuePair<string, TesiraForteLevelControl> controlPoint in LevelControlPoints)
{
if (customName == controlPoint.Value.LevelCustomName ||
customName == controlPoint.Value.MuteCustomName)
{
controlPoint.Value.ParseSubscriptionMessage(customName, value);
return;
}
}
}
/// same for dialers
/// same for switchers
}
else if (args.Text.IndexOf("+OK") > -1)
{
if (args.Text == "+OK" || args.Text.IndexOf("list\":") > -1)
// Check for a simple "+OK" only 'ack' repsonse or a list response and ignore
return;
// response is not from a subscribed attribute. From a get/set/toggle/increment/decrement command
if (!CommandQueue.IsEmpty)
{
if (CommandQueue.Peek() is QueuedCommand)
{
// Expected response belongs to a child class
QueuedCommand tempCommand = (QueuedCommand) CommandQueue.TryToDequeue();
//Debug.Console(1, this, "Command Dequeued. CommandQueue Size: {0}", CommandQueue.Count);
tempCommand.ControlPoint.ParseGetMessage(tempCommand.AttributeCode, args.Text);
}
else
{
// Expected response belongs to this class
string temp = (string) CommandQueue.TryToDequeue();
//Debug.Console(1, this, "Command Dequeued. CommandQueue Size: {0}", CommandQueue.Count);
}
if (CommandQueue.IsEmpty)
CommandQueueInProgress = false;
else
SendNextQueuedCommand();
}
}
else if (args.Text.IndexOf("-ERR") > -1)
{
// Error response
switch (args.Text)
{
case "-ERR ALREADY_SUBSCRIBED":
{
ResetSubscriptionTimer();
break;
}
default:
{
Debug.Console(0, this, "Error From DSP: '{0}'", args.Text);
break;
}
}
}
}
catch (Exception e)
{
if (Debug.Level == 2)
Debug.Console(2, this, "Error parsing response: '{0}'\n{1}", args.Text, e);
}
}
/// <summary>
/// Sends a command to the DSP (with delimiter appended)
/// </summary>
/// <param name="s">Command to send</param>
public void SendLine(string s)
{
Communication.SendText(s + "\x0a");
}
/// <summary>
/// Adds a command from a child module to the queue
/// </summary>
/// <param name="command">Command object from child module</param>
public void EnqueueCommand(QueuedCommand commandToEnqueue)
{
CommandQueue.Enqueue(commandToEnqueue);
//Debug.Console(1, this, "Command (QueuedCommand) Enqueued '{0}'. CommandQueue has '{1}' Elements.", commandToEnqueue.Command, CommandQueue.Count);
if (!CommandQueueInProgress)
SendNextQueuedCommand();
}
/// <summary>
/// Adds a raw string command to the queue
/// </summary>
/// <param name="command"></param>
public void EnqueueCommand(string command)
{
CommandQueue.Enqueue(command);
//Debug.Console(1, this, "Command (string) Enqueued '{0}'. CommandQueue has '{1}' Elements.", command, CommandQueue.Count);
if (!CommandQueueInProgress)
SendNextQueuedCommand();
}
/// <summary>
/// Sends the next queued command to the DSP
/// </summary>
private void SendNextQueuedCommand()
{
//Debug.Console(2, this, "Attempting to send next queued command. CommandQueueInProgress: {0} Communication isConnected: {1}", CommandQueueInProgress, Communication.IsConnected);
//if (CommandQueue.IsEmpty)
// CommandQueueInProgress = false;
//Debug.Console(1, this, "CommandQueue has {0} Elements:\n", CommandQueue.Count);
//foreach (object o in CommandQueue)
//{
// if (o is string)
// Debug.Console(1, this, "{0}", o);
// else if(o is QueuedCommand)
// {
// var item = (QueuedCommand)o;
// Debug.Console(1, this, "{0}", item.Command);
// }
//}
//Debug.Console(1, this, "End of CommandQueue");
if (Communication.IsConnected && !CommandQueue.IsEmpty)
{
CommandQueueInProgress = true;
if (CommandQueue.Peek() is QueuedCommand)
{
QueuedCommand nextCommand = new QueuedCommand();
nextCommand = (QueuedCommand) CommandQueue.Peek();
SendLine(nextCommand.Command);
}
else
{
string nextCommand = (string) CommandQueue.Peek();
SendLine(nextCommand);
}
}
}
/// <summary>
/// Sends a command to execute a preset
/// </summary>
/// <param name="name">Preset Name</param>
public void RunPreset(string name)
{
SendLine(string.Format("DEVICE recallPreset {0}", name));
}
public class QueuedCommand
{
public string Command { get; set; }
public string AttributeCode { get; set; }
public TesiraForteControlPoint ControlPoint { get; set; }
}
}
public class BiampTesiraForteDspFactory : EssentialsDeviceFactory<BiampTesiraForteDsp>
{
public BiampTesiraForteDspFactory()
{
TypeNames = new List<string>() {"biamptesira"};
}
public override EssentialsDevice BuildDevice(DeviceConfig dc)
{
Debug.Console(1, "Factory Attempting to create new BiampTesira Device");
var comm = CommFactory.CreateCommForDevice(dc);
var props = Newtonsoft.Json.JsonConvert.DeserializeObject<BiampTesiraFortePropertiesConfig>(
dc.Properties.ToString());
return new BiampTesiraForteDsp(dc.Key, dc.Name, comm, props);
}
}
}

View File

@@ -1,379 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Core;
using PepperDash.Essentials.Core;
using System.Text.RegularExpressions;
namespace PepperDash.Essentials.Devices.Common.DSP
{
public interface IBiampTesiraDspLevelControl : IBasicVolumeWithFeedback
{
/// <summary>
/// In BiAmp: Instance Tag, QSC: Named Control, Polycom:
/// </summary>
string ControlPointTag { get; }
int Index1 { get; }
int Index2 { get; }
bool HasMute { get; }
bool HasLevel { get; }
bool AutomaticUnmuteOnVolumeUp { get; }
}
public class TesiraForteLevelControl : TesiraForteControlPoint, IBiampTesiraDspLevelControl, IKeyed
{
bool _IsMuted;
ushort _VolumeLevel;
public BoolFeedback MuteFeedback { get; private set; }
public IntFeedback VolumeLevelFeedback { get; private set; }
public bool Enabled { get; set; }
public string ControlPointTag { get { return base.InstanceTag; } }
/// <summary>
/// Used for to identify level subscription values
/// </summary>
public string LevelCustomName { get; private set; }
/// <summary>
/// Used for to identify mute subscription values
/// </summary>
public string MuteCustomName { get; private set; }
/// <summary>
/// Minimum fader level
/// </summary>
double MinLevel;
/// <summary>
/// Maximum fader level
/// </summary>
double MaxLevel;
/// <summary>
/// Checks if a valid subscription string has been recieved for all subscriptions
/// </summary>
public bool IsSubsribed
{
get
{
bool isSubscribed = false;
if (HasMute && MuteIsSubscribed)
isSubscribed = true;
if (HasLevel && LevelIsSubscribed)
isSubscribed = true;
return isSubscribed;
}
}
public bool AutomaticUnmuteOnVolumeUp { get; private set; }
public bool HasMute { get; private set; }
public bool HasLevel { get; private set; }
bool MuteIsSubscribed;
bool LevelIsSubscribed;
//public TesiraForteLevelControl(string label, string id, int index1, int index2, bool hasMute, bool hasLevel, BiampTesiraForteDsp parent)
// : base(id, index1, index2, parent)
//{
// Initialize(label, hasMute, hasLevel);
//}
public TesiraForteLevelControl(string key, BiampTesiraForteLevelControlBlockConfig config, BiampTesiraForteDsp parent)
: base(config.InstanceTag, config.Index1, config.Index2, parent)
{
Initialize(key, config.Label, config.HasMute, config.HasLevel);
}
/// <summary>
/// Initializes this attribute based on config values and generates subscriptions commands and adds commands to the parent's queue.
/// </summary>
public void Initialize(string key, string label, bool hasMute, bool hasLevel)
{
Key = string.Format("{0}--{1}", Parent.Key, key);
DeviceManager.AddDevice(this);
Debug.Console(2, this, "Adding LevelControl '{0}'", Key);
this.IsSubscribed = false;
MuteFeedback = new BoolFeedback(() => _IsMuted);
VolumeLevelFeedback = new IntFeedback(() => _VolumeLevel);
HasMute = hasMute;
HasLevel = hasLevel;
}
public void Subscribe()
{
// Do subscriptions and blah blah
// Subscribe to mute
if (this.HasMute)
{
MuteCustomName = string.Format("{0}~mute{1}", this.InstanceTag, this.Index1);
SendSubscriptionCommand(MuteCustomName, "mute", 500);
}
// Subscribe to level
if (this.HasLevel)
{
LevelCustomName = string.Format("{0}~level{1}", this.InstanceTag, this.Index1);
SendSubscriptionCommand(LevelCustomName, "level", 250);
SendFullCommand("get", "minLevel", null);
SendFullCommand("get", "maxLevel", null);
}
}
/// <summary>
/// Parses the response from the DspBase
/// </summary>
/// <param name="customName"></param>
/// <param name="value"></param>
public void ParseSubscriptionMessage(string customName, string value)
{
// Check for valid subscription response
if (this.HasMute && customName == MuteCustomName)
{
//if (value.IndexOf("+OK") > -1)
//{
// int pointer = value.IndexOf(" +OK");
// MuteIsSubscribed = true;
// // Removes the +OK
// value = value.Substring(0, value.Length - (value.Length - (pointer - 1)));
//}
if (value.IndexOf("true") > -1)
{
_IsMuted = true;
MuteIsSubscribed = true;
}
else if (value.IndexOf("false") > -1)
{
_IsMuted = false;
MuteIsSubscribed = true;
}
MuteFeedback.FireUpdate();
}
else if (this.HasLevel && customName == LevelCustomName)
{
//if (value.IndexOf("+OK") > -1)
//{
// int pointer = value.IndexOf(" +OK");
// LevelIsSubscribed = true;
//}
var _value = Double.Parse(value);
_VolumeLevel = (ushort)Scale(_value, MinLevel, MaxLevel, 0, 65535);
LevelIsSubscribed = true;
VolumeLevelFeedback.FireUpdate();
}
}
/// <summary>
/// Parses a non subscription response
/// </summary>
/// <param name="attributeCode">The attribute code of the command</param>
/// <param name="message">The message to parse</param>
public override void ParseGetMessage(string attributeCode, string message)
{
try
{
// Parse an "+OK" message
string pattern = @"\+OK ""value"":(.*)";
Match match = Regex.Match(message, pattern);
if (match.Success)
{
string value = match.Groups[1].Value;
Debug.Console(1, this, "Response: '{0}' Value: '{1}'", attributeCode, value);
if (message.IndexOf("\"value\":") > -1)
{
switch (attributeCode)
{
case "minLevel":
{
MinLevel = Double.Parse(value);
Debug.Console(1, this, "MinLevel is '{0}'", MinLevel);
break;
}
case "maxLevel":
{
MaxLevel = Double.Parse(value);
Debug.Console(1, this, "MaxLevel is '{0}'", MaxLevel);
break;
}
default:
{
Debug.Console(2, "Response does not match expected attribute codes: '{0}'", message);
break;
}
}
}
}
}
catch (Exception e)
{
Debug.Console(2, "Unable to parse message: '{0}'\n{1}", message, e);
}
}
/// <summary>
/// Turns the mute off
/// </summary>
public void MuteOff()
{
SendFullCommand("set", "mute", "false");
}
/// <summary>
/// Turns the mute on
/// </summary>
public void MuteOn()
{
SendFullCommand("set", "mute", "true");
}
/// <summary>
/// Sets the volume to a specified level
/// </summary>
/// <param name="level"></param>
public void SetVolume(ushort level)
{
Debug.Console(1, this, "volume: {0}", level);
// Unmute volume if new level is higher than existing
if (level > _VolumeLevel && AutomaticUnmuteOnVolumeUp)
if(_IsMuted)
MuteOff();
double volumeLevel = Scale(level, 0, 65535, MinLevel, MaxLevel);
SendFullCommand("set", "level", string.Format("{0:0.000000}", volumeLevel));
}
/// <summary>
/// Toggles mute status
/// </summary>
public void MuteToggle()
{
SendFullCommand("toggle", "mute", "");
}
/// <summary>
/// Decrements volume level
/// </summary>
/// <param name="pressRelease"></param>
public void VolumeDown(bool pressRelease)
{
SendFullCommand("decrement", "level", "");
}
/// <summary>
/// Increments volume level
/// </summary>
/// <param name="pressRelease"></param>
public void VolumeUp(bool pressRelease)
{
SendFullCommand("increment", "level", "");
if (AutomaticUnmuteOnVolumeUp)
if (!_IsMuted)
MuteOff();
}
///// <summary>
///// Scales the input from the input range to the output range
///// </summary>
///// <param name="input"></param>
///// <param name="inMin"></param>
///// <param name="inMax"></param>
///// <param name="outMin"></param>
///// <param name="outMax"></param>
///// <returns></returns>
//int Scale(int input, int inMin, int inMax, int outMin, int outMax)
//{
// Debug.Console(1, this, "Scaling (int) input '{0}' with min '{1}'/max '{2}' to output range min '{3}'/max '{4}'", input, inMin, inMax, outMin, outMax);
// int inputRange = inMax - inMin;
// int outputRange = outMax - outMin;
// var output = (((input-inMin) * outputRange) / inputRange ) - outMin;
// Debug.Console(1, this, "Scaled output '{0}'", output);
// return output;
//}
/// <summary>
/// Scales the input from the input range to the output range
/// </summary>
/// <param name="input"></param>
/// <param name="inMin"></param>
/// <param name="inMax"></param>
/// <param name="outMin"></param>
/// <param name="outMax"></param>
/// <returns></returns>
double Scale(double input, double inMin, double inMax, double outMin, double outMax)
{
Debug.Console(1, this, "Scaling (double) input '{0}' with min '{1}'/max '{2}' to output range min '{3}'/max '{4}'",input ,inMin ,inMax ,outMin, outMax);
double inputRange = inMax - inMin;
if (inputRange <= 0)
{
throw new ArithmeticException(string.Format("Invalid Input Range '{0}' for Scaling. Min '{1}' Max '{2}'.", inputRange, inMin, inMax));
}
double outputRange = outMax - outMin;
var output = (((input - inMin) * outputRange) / inputRange) + outMin;
Debug.Console(1, this, "Scaled output '{0}'", output);
return output;
}
}
}

View File

@@ -1,40 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common.DSP
{
/// <summary>
///
/// </summary>
public class BiampTesiraFortePropertiesConfig
{
public CommunicationMonitorConfig CommunicationMonitorProperties { get; set; }
public ControlPropertiesConfig Control { get; set; }
/// <summary>
/// These are key-value pairs, string id, string type.
/// Valid types are level and mute.
/// Need to include the index values somehow
/// </summary>
public Dictionary<string, BiampTesiraForteLevelControlBlockConfig> LevelControlBlocks { get; set; }
// public Dictionary<string, BiampTesiraForteDialerControlBlockConfig> DialerControlBlocks {get; set;}
}
public class BiampTesiraForteLevelControlBlockConfig
{
public bool Enabled { get; set; }
public string Label { get; set; }
public string InstanceTag { get; set; }
public int Index1 { get; set; }
public int Index2 { get; set; }
public bool HasMute { get; set; }
public bool HasLevel { get; set; }
}
}

View File

@@ -1,115 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
namespace PepperDash.Essentials.Devices.Common.DSP
{
public abstract class TesiraForteControlPoint : DspControlPoint
{
public string Key { get; protected set; }
public string InstanceTag { get; set; }
public int Index1 { get; private set; }
public int Index2 { get; private set; }
public BiampTesiraForteDsp Parent { get; private set; }
public bool IsSubscribed { get; protected set; }
protected TesiraForteControlPoint(string id, int index1, int index2, BiampTesiraForteDsp parent)
{
InstanceTag = id;
Index1 = index1;
Index2 = index2;
Parent = parent;
}
virtual public void Initialize()
{
}
/// <summary>
/// Sends a command to the DSP
/// </summary>
/// <param name="command">command</param>
/// <param name="attribute">attribute code</param>
/// <param name="value">value (use "" if not applicable)</param>
public virtual void SendFullCommand(string command, string attributeCode, string value)
{
// Command Format: InstanceTag get/set/toggle/increment/decrement/subscribe/unsubscribe attributeCode [index] [value]
// Ex: "RoomLevel set level 1.00"
string cmd;
if (attributeCode == "level" || attributeCode == "mute" || attributeCode == "minLevel" || attributeCode == "maxLevel" || attributeCode == "label" || attributeCode == "rampInterval" || attributeCode == "rampStep")
{
//Command requires Index
if (String.IsNullOrEmpty(value))
{
// format command without value
cmd = string.Format("{0} {1} {2} {3}", InstanceTag, command, attributeCode, Index1);
}
else
{
// format commadn with value
cmd = string.Format("{0} {1} {2} {3} {4}", InstanceTag, command, attributeCode, Index1, value);
}
}
else
{
//Command does not require Index
if (String.IsNullOrEmpty(value))
{
cmd = string.Format("{0} {1} {2} {3}", InstanceTag, command, attributeCode, value);
}
else
{
cmd = string.Format("{0} {1} {2}", InstanceTag, command, attributeCode);
}
}
if (command == "get")
{
// This command will generate a return value response so it needs to be queued
Parent.EnqueueCommand(new BiampTesiraForteDsp.QueuedCommand{ Command = cmd, AttributeCode = attributeCode, ControlPoint = this });
}
else
{
// This command will generate a simple "+OK" response and doesn't need to be queued
Parent.SendLine(cmd);
}
}
virtual public void ParseGetMessage(string attributeCode, string message)
{
}
public virtual void SendSubscriptionCommand(string customName, string attributeCode, int responseRate)
{
// Subscription string format: InstanceTag subscribe attributeCode Index1 customName responseRate
// Ex: "RoomLevel subscribe level 1 MyRoomLevel 500"
string cmd;
if (responseRate > 0)
{
cmd = string.Format("{0} subscribe {1} {2} {3} {4}", InstanceTag, attributeCode, Index1, customName, responseRate);
}
else
{
cmd = string.Format("{0} subscribe {1} {2} {3}", InstanceTag, attributeCode, Index1, customName);
}
Parent.SendLine(cmd);
}
}
}

View File

@@ -1,79 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Core;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common.DSP
{
//QUESTIONS:
//When subscribing, just use the Instance ID for Custom Name?
//Verbose on subscriptions?
//! "publishToken":"name" "value":-77.0
//! "myLevelName" -77
//public class TesiraForteMuteControl : IDspLevelControl
//{
// BiampTesiraForteDsp Parent;
// bool _IsMuted;
// ushort _VolumeLevel;
// public TesiraForteMuteControl(string id, BiampTesiraForteDsp parent)
// : base(id)
// {
// Parent = parent;
// }
// public void Initialize()
// {
// }
// protected override Func<bool> MuteFeedbackFunc
// {
// get { return () => _IsMuted; }
// }
// protected override Func<int> VolumeLevelFeedbackFunc
// {
// get { return () => _VolumeLevel; }
// }
// public override void MuteOff()
// {
// throw new NotImplementedException();
// }
// public override void MuteOn()
// {
// throw new NotImplementedException();
// }
// public override void SetVolume(ushort level)
// {
// throw new NotImplementedException();
// }
// public override void MuteToggle()
// {
// }
// public override void VolumeDown(bool pressRelease)
// {
// throw new NotImplementedException();
// }
// public override void VolumeUp(bool pressRelease)
// {
// throw new NotImplementedException();
// }
//}
}

View File

@@ -1,21 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Crestron.SimplSharp;
using PepperDash.Essentials.Core;
namespace PepperDash.Essentials.Devices.Common.DSP
{
public class SoundStructureBasics
{
// public Dictionary<string, IBiampTesiraDspLevelControl> Levels { get; private set; }
}
}

View File

@@ -147,13 +147,7 @@
<Compile Include="Display\SamsungMDCDisplay.cs" />
<Compile Include="Display\NecPaSeriesProjector.cs" />
<Compile Include="Display\NECPSXMDisplay.cs" />
<Compile Include="DSP\BiampTesira\BiampTesiraForteDspLevel.cs" />
<Compile Include="DSP\BiampTesira\TesiraForteControlPoint.cs" />
<Compile Include="DSP\BiampTesira\TesiraForteMuteControl.cs" />
<Compile Include="DSP\DspBase.cs" />
<Compile Include="DSP\BiampTesira\BiampTesiraForteDsp.cs" />
<Compile Include="DSP\BiampTesira\BiampTesiraFortePropertiesConfig.cs" />
<Compile Include="DSP\PolycomSoundStructure\SoundStructureBasics.cs" />
<Compile Include="Environment\Crestron Lighting\Din8sw8.cs" />
<Compile Include="Environment\Lutron\LutronQuantum.cs" />
<Compile Include="Environment\Somfy\RelayControlledShade.cs" />