feat: removed Tesira and Soundstructure DSPs

2026-02-05 15:55:02 +00:00 · 2022-10-30 01:17:10 -05:00
8 changed files with 5 additions and 1036 deletions
--- a/PepperDashEssentials/Audio/EssentialsVolumeLevelConfig.cs
+++ b/PepperDashEssentials/Audio/EssentialsVolumeLevelConfig.cs
@@ -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)
@@ -71,7 +73,10 @@ namespace PepperDash.Essentials
                return null;
            }
            return null;
        }
         */
    }
 }
--- a/Common/DSP/BiampTesira/BiampTesiraForteDsp.cs
+++ b/Common/DSP/BiampTesira/BiampTesiraForteDsp.cs
@@ -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);
        }
    }
 }
--- a/Common/DSP/BiampTesira/BiampTesiraForteDspLevel.cs
+++ b/Common/DSP/BiampTesira/BiampTesiraForteDspLevel.cs
@@ -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;
        }
    }
 }
--- a/Common/DSP/BiampTesira/BiampTesiraFortePropertiesConfig.cs
+++ b/Common/DSP/BiampTesira/BiampTesiraFortePropertiesConfig.cs
@@ -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; }
    }
 }
--- a/Common/DSP/BiampTesira/TesiraForteControlPoint.cs
+++ b/Common/DSP/BiampTesira/TesiraForteControlPoint.cs
@@ -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);
        }
 	}
 }
--- a/Common/DSP/BiampTesira/TesiraForteMuteControl.cs
+++ b/Common/DSP/BiampTesira/TesiraForteMuteControl.cs
@@ -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();
    //    }
    //}
 }
--- a/Common/DSP/PolycomSoundStructure/SoundStructureBasics.cs
+++ b/Common/DSP/PolycomSoundStructure/SoundStructureBasics.cs
@@ -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; }
 	}
 }
--- a/essentials-framework/Essentials
+++ b/essentials-framework/Essentials
@@ -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" />