Combining repos

2026-02-10 02:05:08 +00:00 · 2017-03-21 08:36:26 -06:00
parent e196ad0419
commit b5444e3544
358 changed files with 17256 additions and 10215 deletions
--- a/Common/Essentials
+++ b/Common/Essentials
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Essentials Devices Common", "Essentials Devices Common\Essentials Devices Common.csproj", "{892B761C-E479-44CE-BD74-243E9214AF13}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{892B761C-E479-44CE-BD74-243E9214AF13}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{892B761C-E479-44CE-BD74-243E9214AF13}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{892B761C-E479-44CE-BD74-243E9214AF13}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{892B761C-E479-44CE-BD74-243E9214AF13}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
--- a/Common/Audio/GenericAudioOut.cs
+++ b/Common/Audio/GenericAudioOut.cs
@@ -0,0 +1,75 @@
+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.Routing;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	/// <summary>
+	/// Represents and audio endpoint
+	/// </summary>
+	public class GenericAudioOut : Device, IRoutingSinkNoSwitching
+	{
+		public RoutingInputPort AnyAudioIn { get; private set; }
+
+		public GenericAudioOut(string key, string name)
+			: base(key, name)
+		{
+			AnyAudioIn = new RoutingInputPort(RoutingPortNames.AnyAudioIn, eRoutingSignalType.Audio, 
+				eRoutingPortConnectionType.LineAudio, null, this);
+		}
+
+		#region IRoutingInputs Members
+
+		public RoutingPortCollection<RoutingInputPort> InputPorts
+		{
+			get { return new RoutingPortCollection<RoutingInputPort> { AnyAudioIn }; }
+		}
+
+		#endregion
+	}
+
+
+	/// <summary>
+	/// Allows a zone-device's audio control to be attached to the endpoint, for easy routing and
+	/// control switching.  Will also set the zone name on attached devices, like SWAMP or other
+	/// hardware with names built in.
+	/// </summary>
+	public class GenericAudioOutWithVolume : GenericAudioOut, IHasVolumeDevice
+	{
+		public string VolumeDeviceKey { get; private set; }
+		public uint VolumeZone { get; private set; }
+
+		public IBasicVolumeControls VolumeDevice
+		{ 
+			get
+			{
+				var dev = DeviceManager.GetDeviceForKey(VolumeDeviceKey);
+				if (dev is IAudioZones)
+					return (dev as IAudioZones).Zone[VolumeZone];
+				else return dev as IBasicVolumeControls;
+			} 
+		}
+
+		/// <summary>
+		/// Constructor - adds the name to the attached audio device, if appropriate.
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		/// <param name="audioDevice"></param>
+		/// <param name="zone"></param>
+		public GenericAudioOutWithVolume(string key, string name, string audioDevice, uint zone)
+			: base(key, name)
+		{
+			VolumeDeviceKey = audioDevice;
+			VolumeZone = zone;
+		}
+
+	}
+
+}
--- a/Common/Crestron/Gateways/CenRfgwController.cs
+++ b/Common/Crestron/Gateways/CenRfgwController.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using Crestron.SimplSharpPro.Gateways;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	public class CenRfgwController : CrestronGenericBaseDevice
+	{
+		public GatewayBase Gateway { get { return Hardware as GatewayBase; } }
+
+		/// <summary>
+		/// Constructor for the on-board gateway
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
+		public CenRfgwController(string key, string name, GatewayBase gateway) :
+			base(key, name, gateway)
+		{
+		}
+
+		public static CenRfgwController GetNewExGatewayController(string key, string name, string id, string gatewayType)
+		{
+			uint uid;
+			eExGatewayType type;
+			try
+			{
+				uid = Convert.ToUInt32(id, 16);
+				type = (eExGatewayType)Enum.Parse(typeof(eExGatewayType), gatewayType, true);
+				var cs = Global.ControlSystem;
+
+				GatewayBase gw = null;
+				switch (type)
+				{
+					case eExGatewayType.Ethernet:
+						gw = new CenRfgwEx(uid, cs);
+						break;
+					case eExGatewayType.EthernetShared:
+						gw = new CenRfgwExEthernetSharable(uid, cs);
+						break;
+					case eExGatewayType.Cresnet:
+						gw = new CenRfgwExCresnet(uid, cs);
+						break;
+				}
+				return new CenRfgwController(key, name, gw);
+			}
+			catch (Exception)
+			{
+				Debug.Console(0, "ERROR: Cannot create EX Gateway, id {0}, type {1}", id, gatewayType);
+				return null;
+			}
+		}
+		public static CenRfgwController GetNewErGatewayController(string key, string name, string id, string gatewayType)
+		{
+			uint uid;
+			eExGatewayType type;
+			try
+			{
+				uid = Convert.ToUInt32(id, 16);
+				type = (eExGatewayType)Enum.Parse(typeof(eExGatewayType), gatewayType, true);
+				var cs = Global.ControlSystem;
+
+				GatewayBase gw = null;
+				switch (type)
+				{
+					case eExGatewayType.Ethernet:
+						gw = new CenErfgwPoe(uid, cs);
+						break;
+					case eExGatewayType.EthernetShared:
+						gw = new CenErfgwPoeEthernetSharable(uid, cs);
+						break;
+					case eExGatewayType.Cresnet:
+						gw = new CenErfgwPoeCresnet(uid, cs);
+						break;
+				}
+				return new CenRfgwController(key, name, gw);
+			}
+			catch (Exception)
+			{
+				Debug.Console(0, "ERROR: Cannot create EX Gateway, id {0}, type {1}", id, gatewayType);
+				return null;
+			}
+		}
+
+
+		/// <summary>
+		/// Gets the actual Crestron EX gateway for a given key. "processor" or the key of
+		/// a CenRfgwExController in DeviceManager
+		/// </summary>
+		/// <param name="key"></param>
+		/// <returns>Either processor GW or Gateway property of CenRfgwExController</returns>
+		public static GatewayBase GetExGatewayBaseForKey(string key)
+		{
+			key = key.ToLower();
+			if (key == "processor" && Global.ControlSystem.SupportsInternalRFGateway)
+				return Global.ControlSystem.ControllerRFGatewayDevice;
+			var gwCont = DeviceManager.GetDeviceForKey(key) as CenRfgwController;
+			if (gwCont != null)
+				return gwCont.Gateway;
+
+			return null;
+		}
+	}
+
+	public enum eExGatewayType
+	{
+		Ethernet, EthernetShared, Cresnet
+	}
+}
--- a/Common/DSP/BiampTesira/BiampTesiraForteDsp.cs
+++ b/Common/DSP/BiampTesira/BiampTesiraForteDsp.cs
@@ -0,0 +1,304 @@
+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
+{
+
+	// QUESTIONS:
+	// 
+	// When subscribing, just use the Instance ID for Custom Name?
+	
+	// Verbose on subscriptions?
+
+	// ! "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; }
+
+        new public Dictionary<string, TesiraForteLevelControl> LevelControlPoints { get; private set; }
+
+        public bool isSubscribed;
+
+        CrestronQueue CommandQueue;
+
+        //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(20);
+
+			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, '\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, "");
+            }
+
+            LevelControlPoints = new Dictionary<string, TesiraForteLevelControl>();
+
+            foreach (KeyValuePair<string, BiampTesiraForteLevelControlBlockConfig> block in props.LevelControlBlocks)
+            {
+                this.LevelControlPoints.Add(block.Key, new TesiraForteLevelControl(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;
+		}
+
+        void socket_ConnectionChange(object sender, GenericSocketStatusChageEventArgs e)
+        {
+            if (e.Client.IsConnected)
+            {
+                Debug.Console(2, this, "Socket Status Change: {0}", e.Client.ClientStatus.ToString());
+                // Maybe wait for message indicating valid TTP session
+            }
+        }
+
+        /// <summary>
+        /// Initiates the subscription process to the DSP
+        /// </summary>
+        void SubscribeToAttributes()
+        {
+            EnqueueCommand("SESSION set verbose true");
+
+            foreach (KeyValuePair<string, TesiraForteLevelControl> level in LevelControlPoints)
+            {
+                level.Value.Subscribe();
+            }
+
+            ResetSubscriptionTimer();
+        }
+
+        
+
+        void ResetSubscriptionTimer()
+        {
+#warning Add code to create/reset a CTimer to periodically check for subscribtion status
+
+            isSubscribed = true;
+
+            //CTimer SubscribtionTimer = new CTimer(
+        }
+
+        /// <summary>
+        /// Handles a response message from the DSP
+        /// </summary>
+        /// <param name="dev"></param>
+        /// <param name="args"></param>
+		void Port_LineReceived(object dev, GenericCommMethodReceiveTextArgs args)
+		{
+			if (Debug.Level == 2)
+				Debug.Console(2, this, "RX: '{0}'",
+					ShowHexResponse ? ComTextHelper.GetEscapedText(args.Text) : args.Text);               
+
+                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.Length > 4)       // Check for a simple "+OK" only 'ack' repsonse
+                            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.Dequeue();
+
+                                tempCommand.ControlPoint.ParseGetMessage(tempCommand.AttributeCode, args.Text);
+                            }
+                            else
+                            {
+                                // Expected response belongs to this class
+                                string temp = (string)CommandQueue.Dequeue();
+
+                            }
+
+                            SendNextQueuedCommand();
+
+                        }
+
+
+                    }
+                    else if (args.Text.IndexOf("-ERR") > -1)
+                    {
+                        // Error response
+
+                        if (args.Text == "-ERR ALREADY_SUBSCRIBED")
+                        {
+                            // Subscription still valid
+                            ResetSubscriptionTimer();
+                        }
+                        else
+                        {
+                            SubscribeToAttributes();
+                        }
+
+                    }
+                }
+                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)
+		{
+            Debug.Console(2, this, "TX: '{0}'", 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);         
+        }
+
+        /// <summary>
+        /// Adds a raw string command to the queue
+        /// </summary>
+        /// <param name="command"></param>
+        public void EnqueueCommand(string command)
+        {
+            CommandQueue.Enqueue(command);
+        }
+
+        /// <summary>
+        /// Sends the next queued command to the DSP
+        /// </summary>
+        void SendNextQueuedCommand()
+        {
+            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 override 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; }
+        }
+	}
+}
--- a/Common/DSP/BiampTesira/BiampTesiraForteDspLevel.cs
+++ b/Common/DSP/BiampTesira/BiampTesiraForteDspLevel.cs
@@ -0,0 +1,360 @@
+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
+{
+
+    // QUESTIONS:
+    // 
+    // When subscribing, just use the Instance ID for Custom Name?
+
+    // Verbose on subscriptions?
+
+    // ! "publishToken":"name" "value":-77.0
+    // ! "myLevelName" -77
+
+#warning Working here when set aside for config editor work
+
+    public class TesiraForteLevelControl : TesiraForteControlPoint, IDspLevelControl, 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(BiampTesiraForteLevelControlBlockConfig config, BiampTesiraForteDsp parent)
+            : base(config.InstanceTag, config.Index1, config.Index2, parent)
+        {
+            Initialize(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 label, bool hasMute, bool hasLevel)
+        {
+            Key = string.Format("{0}-{1}", Parent.Key, label);
+
+            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, 65536);
+
+                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 a "+OK" message
+                string pattern = "+OK \"value\":(.*)";
+
+                Match match = Regex.Match(message, pattern);
+
+                if (match.Success)
+                {
+
+                    string value;
+
+                    if (message.IndexOf("\"value\":") > -1)
+                    {
+                        value = message.Substring(message.IndexOf(":"), message.Length - message.IndexOf(":"));
+
+                        switch (attributeCode)
+                        {
+                            case "minLevel":
+                                {
+                                    MinLevel = Double.Parse(value);
+
+                                    break;
+                                }
+                            case "maxLevel":
+                                {
+                                    MaxLevel = Double.Parse(value);
+
+                                    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)
+        {
+            // 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", volumeLevel.ToString());          
+        }
+
+        /// <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)
+        {
+            int inputRange = inMax - inMin;
+
+            int outputRange = outMax - outMin;
+
+            var output = (((input-inMin) * outputRange) / inputRange ) - outMin;
+
+            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)
+        {
+            double inputRange = inMax - inMin;
+
+            double outputRange = outMax - outMin;
+
+            var output = (((input - inMin) * outputRange) / inputRange) - outMin;
+
+            return output;
+        }
+    }
+}
--- a/Common/DSP/BiampTesira/BiampTesiraFortePropertiesConfig.cs
+++ b/Common/DSP/BiampTesira/BiampTesiraFortePropertiesConfig.cs
@@ -0,0 +1,40 @@
+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
@@ -0,0 +1,106 @@
+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);
+                }
+            }
+               
+
+			Parent.EnqueueCommand(new BiampTesiraForteDsp.QueuedCommand{ Command = cmd, AttributeCode = attributeCode, ControlPoint = this });
+		}
+
+        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
@@ -0,0 +1,79 @@
+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/DspBase.cs
+++ b/Common/DSP/DspBase.cs
@@ -0,0 +1,124 @@
+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
+{
+	public abstract class DspBase : Device
+	{
+		public Dictionary<string, DspControlPoint> LevelControlPoints { get; private set; }
+
+        public Dictionary<string, DspControlPoint> DialerControlPoints { get; private set; }
+
+        public Dictionary<string, DspControlPoint> SwitcherControlPoints { get; private set; }
+
+		public abstract void RunPreset(string name);
+
+		public DspBase(string key, string name) :
+			base(key, name) { }
+
+
+		// in audio call feedback
+
+		// VOIP
+		// Phone dialer
+	}
+
+	// Fusion
+	// Privacy state
+	// Online state
+	// level/mutes ?
+	
+	// AC Log call stats
+	
+		// Typical presets:
+		// call default preset to restore levels and mutes
+
+	public abstract class DspControlPoint
+	{
+        //string Key { get; protected set; }
+	}
+
+
+
+	// Main program 
+	// VTC 
+	// ATC
+	// Mics, unusual
+
+    public interface IDspLevelControl : 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 abstract class DspLevelControl : DspControlPoint, IBasicVolumeWithFeedback
+    //{
+    //    protected abstract Func<bool> MuteFeedbackFunc { get; }
+    //    protected abstract Func<int> VolumeLevelFeedbackFunc { get; }
+
+    //    public DspLevelControl(string id)
+    //    {
+    //        MuteFeedback = new BoolFeedback(MuteFeedbackFunc);
+    //        VolumeLevelFeedback = new IntFeedback(VolumeLevelFeedbackFunc);
+    //    }
+
+    //    // Poll and listen for these
+    //    // Max value
+    //    // Min value
+    //    #region IBasicVolumeWithFeedback Members
+
+    //    public BoolFeedback MuteFeedback { get; private set; }
+
+    //    public abstract void MuteOff();
+
+    //    public abstract void MuteOn();
+
+    //    public abstract void SetVolume(ushort level);
+
+    //    public IntFeedback VolumeLevelFeedback { get; private set; }
+
+    //    #endregion
+
+    //    #region IBasicVolumeControls Members
+
+    //    public abstract void MuteToggle();
+
+    //    public abstract void VolumeDown(bool pressRelease);
+
+    //    public abstract void VolumeUp(bool pressRelease);
+
+    //    #endregion
+    //}
+
+	// Privacy mute
+	public abstract class DspMuteControl : DspControlPoint
+	{
+		protected abstract Func<bool> MuteFeedbackFunc { get; }
+
+		public DspMuteControl(string id)
+		{
+			MuteFeedback = new BoolFeedback(MuteFeedbackFunc);
+		}
+
+		public BoolFeedback MuteFeedback { get; private set; }
+
+		public abstract void MuteOff();
+
+		public abstract void MuteOn();
+		
+		public abstract void MuteToggle();
+	}
+}
--- a/Common/DSP/PolycomSoundStructure/SoundStructureBasics.cs
+++ b/Common/DSP/PolycomSoundStructure/SoundStructureBasics.cs
@@ -0,0 +1,21 @@
+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, IDspLevelControl> Levels { get; private set; }
+
+
+	}
+
+
+
+}
+
--- a/Common/DiscPlayer/IRDiscPlayerBase.cs
+++ b/Common/DiscPlayer/IRDiscPlayerBase.cs
@@ -0,0 +1,308 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Routing;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	public class IRBlurayBase : Device, IDiscPlayerControls, IUiDisplayInfo, IRoutingOutputs
+	{
+		public IrOutputPortController IrPort { get; private set; }
+
+		public uint DisplayUiType { get { return DisplayUiConstants.TypeBluray; } }
+
+		public IRBlurayBase(string key, string name, IrOutputPortController portCont)
+			: base(key, name)
+		{
+			IrPort = portCont;
+			DeviceManager.AddDevice(portCont);
+
+			HasKeypadAccessoryButton1 = true;
+			KeypadAccessoryButton1Command = "Clear";
+			KeypadAccessoryButton1Label = "Clear";
+
+			HasKeypadAccessoryButton2 = true;
+			KeypadAccessoryButton2Command = "NumericEnter";
+			KeypadAccessoryButton2Label = "Enter";
+
+			PowerIsOnFeedback = new BoolFeedback(() => _PowerIsOn);
+
+			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.Hdmi, null, this);
+			AnyAudioOut = new RoutingOutputPort(RoutingPortNames.AnyAudioOut, eRoutingSignalType.Audio, 
+				eRoutingPortConnectionType.DigitalAudio, null, this);
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut, AnyAudioOut };
+		}
+
+
+		#region IDPad Members
+
+		public void Up(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_UP_ARROW, pressRelease);
+		}
+
+		public void Down(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_DN_ARROW, pressRelease);
+		}
+
+		public void Left(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_LEFT_ARROW, pressRelease);
+		}
+
+		public void Right(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RIGHT_ARROW, pressRelease);
+		}
+
+		public void Select(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_ENTER, pressRelease);
+		}
+
+		public void Menu(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_MENU, pressRelease);
+		}
+
+		public void Exit(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_EXIT, pressRelease);
+		}
+
+		#endregion
+
+		#region INumericKeypad Members
+
+		public void Digit0(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_0, pressRelease);
+		}
+
+		public void Digit1(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_1, pressRelease);
+		}
+
+		public void Digit2(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_2, pressRelease);
+		}
+
+		public void Digit3(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_3, pressRelease);
+		}
+
+		public void Digit4(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_4, pressRelease);
+		}
+
+		public void Digit5(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_5, pressRelease);
+		}
+
+		public void Digit6(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_6, pressRelease);
+		}
+
+		public void Digit7(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_7, pressRelease);
+		}
+
+		public void Digit8(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_8, pressRelease);
+		}
+
+		public void Digit9(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_9, pressRelease);
+		}
+
+		/// <summary>
+		/// Defaults to true
+		/// </summary>
+		public bool HasKeypadAccessoryButton1 { get; set; }
+
+		/// <summary>
+		/// Defaults to "-"
+		/// </summary>
+		public string KeypadAccessoryButton1Label { get; set; }
+		
+
+		/// <summary>
+		/// Defaults to "Dash"
+		/// </summary>
+		public string KeypadAccessoryButton1Command { get; set; }
+
+		public void KeypadAccessoryButton1(bool pressRelease)
+		{
+			IrPort.PressRelease(KeypadAccessoryButton1Command, pressRelease);
+		}
+
+		/// <summary>
+		/// Defaults to true
+		/// </summary>
+		public bool HasKeypadAccessoryButton2 { get; set; }
+
+		/// <summary>
+		/// Defaults to "Enter"
+		/// </summary>
+		public string KeypadAccessoryButton2Label { get; set; }
+
+
+		/// <summary>
+		/// Defaults to "Enter"
+		/// </summary>
+		public string KeypadAccessoryButton2Command { get; set; }
+
+		public void KeypadAccessoryButton2(bool pressRelease)
+		{
+			IrPort.PressRelease(KeypadAccessoryButton2Command, pressRelease);
+		}
+
+		#endregion
+
+		#region IChannelFunctions Members
+
+		public void ChannelUp(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_CH_PLUS, pressRelease);
+		}
+
+		public void ChannelDown(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_CH_MINUS, pressRelease);
+		}
+
+		public void LastChannel(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_LAST, pressRelease);
+		}
+
+		public void Guide(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_GUIDE, pressRelease);
+		}
+
+		public void Info(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_INFO, pressRelease);
+		}
+
+		#endregion
+
+		#region IColorFunctions Members
+
+		public void Red(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RED, pressRelease);
+		}
+
+		public void Green(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_GREEN, pressRelease);
+		}
+
+		public void Yellow(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_YELLOW, pressRelease);
+		}
+
+		public void Blue(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_BLUE, pressRelease);
+		}
+
+		#endregion
+
+		#region IRoutingOutputs Members
+
+		public RoutingOutputPort HdmiOut { get; private set; }
+		public RoutingOutputPort AnyAudioOut { get; private set; }
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		#endregion
+
+		#region IPower Members
+
+		public void PowerOn()
+		{
+			IrPort.Pulse(IROutputStandardCommands.IROut_POWER_ON, 200);
+			_PowerIsOn = true;
+		}
+
+		public void PowerOff()
+		{
+			IrPort.Pulse(IROutputStandardCommands.IROut_POWER_OFF, 200);
+			_PowerIsOn = false;
+		}
+
+		public void PowerToggle()
+		{
+			IrPort.Pulse(IROutputStandardCommands.IROut_POWER, 200);
+			_PowerIsOn = false;
+		}
+
+		public BoolFeedback PowerIsOnFeedback { get; set; }
+		bool _PowerIsOn;
+
+		#endregion
+
+		#region ITransport Members
+
+		public void Play(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_PLAY, pressRelease);
+		}
+
+		public void Pause(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_PAUSE, pressRelease);
+		}
+
+		public void Rewind(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RSCAN, pressRelease);
+		}
+
+		public void FFwd(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_FSCAN, pressRelease);
+		}
+
+		public void ChapMinus(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_TRACK_MINUS, pressRelease);
+		}
+
+		public void ChapPlus(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_TRACK_PLUS, pressRelease);
+		}
+
+		public void Stop(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_STOP, pressRelease);
+		}
+
+		public void Record(bool pressRelease)
+		{
+		}
+
+		#endregion
+	}
+}
--- a/Common/Display/ComTcpDisplayBase.cs
+++ b/Common/Display/ComTcpDisplayBase.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+
+namespace PepperDash.Essentials.Devices.Displays
+{
+	public abstract class ComTcpDisplayBase : DisplayBase, IPower
+	{
+		/// <summary>
+		/// Sets the communication method for this - swaps out event handlers and output handlers
+		/// </summary>
+		public IBasicCommunication CommunicationMethod
+		{
+			get { return _CommunicationMethod; }
+			set
+			{
+				if (_CommunicationMethod != null)
+					_CommunicationMethod.BytesReceived -= this.CommunicationMethod_BytesReceived;
+				// Outputs???
+				_CommunicationMethod = value;
+				if (_CommunicationMethod != null)
+					_CommunicationMethod.BytesReceived += this.CommunicationMethod_BytesReceived;
+				// Outputs?
+			}
+		}
+		IBasicCommunication _CommunicationMethod;
+
+		public ComTcpDisplayBase(string key, string name)
+			: base(key, name)
+		{
+
+		}
+
+
+		protected abstract void CommunicationMethod_BytesReceived(object sender, GenericCommMethodReceiveBytesArgs args);
+	}
+}
--- a/Common/Display/DeviceFactory.cs
+++ b/Common/Display/DeviceFactory.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.CrestronIO;
+using Crestron.SimplSharpPro;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.Devices.Displays
+{
+	public class DisplayDeviceFactory
+	{
+		public static IKeyed GetDevice(DeviceConfig dc)
+		{
+			var key = dc.Key;
+			var name = dc.Name;
+			var type = dc.Type;
+			var properties = dc.Properties;
+
+			var typeName = dc.Type.ToLower();
+			//if (typeName == "dmmd8x8")
+			//{
+			//    var props = JsonConvert.DeserializeObject
+			//        <PepperDash.Essentials.DM.Config.DMChassisPropertiesConfig>(properties.ToString());
+			//    return PepperDash.Essentials.DM.DmChassisController.
+			//        GetDmChassisController(key, name, type, props);
+			//}
+
+			try
+			{
+				if (typeName == "necmpsx")
+				{
+					var comm = CommFactory.CreateCommForDevice(dc);
+					if (comm != null)
+						return new NecPSXMDisplay(dc.Key, dc.Name, comm);
+				}
+			}
+			catch (Exception e)
+			{
+				Debug.Console(0, "Displays factory: Exception creating device type {0}, key {1}: {2}", dc.Type, dc.Key, e.Message);
+				return null;
+			}
+
+			return null;
+		}
+	}
+}
--- a/Common/Display/NECPSXMDisplay.cs
+++ b/Common/Display/NECPSXMDisplay.cs
@@ -0,0 +1,354 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Routing;
+
+namespace PepperDash.Essentials.Devices.Displays
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	public class NecPSXMDisplay : TwoWayDisplayBase, IBasicVolumeWithFeedback, ICommunicationMonitor
+	{
+		public IBasicCommunication Communication { get; private set; }
+		public CommunicationGather PortGather { get; private set; }
+		public StatusMonitorBase CommunicationMonitor { get; private set; }
+
+		#region Command constants
+		public const string InputGetCmd = "\x01\x30\x41\x30\x43\x30\x36\x02\x30\x30\x36\x30\x03\x03\x0D";
+		public const string Hdmi1Cmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x31\x31\x03\x72\x0d";
+		public const string Hdmi2Cmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x31\x32\x03\x71\x0D";
+		public const string Hdmi3Cmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x38\x32\x03\x78\x0D";
+		public const string Hdmi4Cmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x38\x33\x03\x79\x0D";
+		public const string Dp1Cmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x30\x46\x03\x04\x0D";
+		public const string Dp2Cmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x31\x30\x03\x73\x0D";
+		public const string Dvi1Cmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x30\x33\x03\x71\x0d";
+		public const string Video1Cmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x30\x35\x03\x77\x0D";
+		public const string VgaCmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x30\x31\x03\x73\x0D";
+		public const string RgbCmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x30\x30\x30\x30\x32\x03\x70\x0D";
+
+		public const string PowerOnCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x30\x33\x44\x36\x30\x30\x30\x31\x03\x73\x0D";
+		public const string PowerOffCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x30\x33\x44\x36\x30\x30\x30\x34\x03\x76\x0D";
+		public const string PowerToggleIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x30\x33\x30\x33\x03\x02\x0D";
+
+		public const string MuteOffCmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x38\x44\x30\x30\x30\x30\x03\x08\x0D";
+		public const string MuteOnCmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x38\x44\x30\x30\x30\x31\x03\x09\x0D";
+		public const string MuteToggleIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x31\x42\x30\x33\x03\x72\x0D";
+		public const string MuteGetCmd = "\x01\x30\x41\x30\x43\x30\x36\x02\x30\x30\x38\x44\x03\x79\x0D";
+
+		public const string VolumeGetCmd = "\x01\x30\x41\x30\x43\x30\x36\x02\x30\x30\x36\x32\x03\x01\x0D";
+		public const string VolumeLevelPartialCmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x30\x30\x36\x32"; //\x46\x46\x46\x46\x03\xNN\x0D
+		public const string VolumeUpCmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x31\x30\x41\x44\x30\x30\x30\x31\x03\x71\x0D";
+		public const string VolumeDownCmd = "\x01\x30\x41\x30\x45\x30\x41\x02\x31\x30\x41\x44\x30\x30\x30\x32\x03\x72\x0D";
+
+		public const string MenuIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x32\x30\x30\x33\x03\x03\x0D";
+		public const string UpIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x31\x35\x30\x33\x03\x05\x0D";
+		public const string DownIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x31\x34\x30\x33\x03\x04\x0D";
+		public const string LeftIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x32\x31\x30\x33\x03\x02\x0D";
+		public const string RightIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x32\x32\x30\x33\x03\x01\x0D";
+		public const string SelectIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x32\x33\x30\x33\x03\x00\x0D";
+		public const string ExitIrCmd = "\x01\x30\x41\x30\x41\x30\x43\x02\x43\x32\x31\x30\x30\x30\x31\x46\x30\x33\x03\x76\x0D";
+		#endregion
+
+		bool _PowerIsOn;
+		bool _IsWarmingUp;
+		bool _IsCoolingDown;
+		ushort _VolumeLevel;
+		bool _IsMuted;
+
+		protected override Func<bool> PowerIsOnFeedbackFunc { get { return () => _PowerIsOn; } }
+		protected override Func<bool> IsCoolingDownFeedbackFunc { get { return () => _IsCoolingDown; } }
+		protected override Func<bool> IsWarmingUpFeedbackFunc { get { return () => _IsWarmingUp; } }
+
+		/// <summary>
+		/// Constructor for IBasicCommunication
+		/// </summary>
+		public NecPSXMDisplay(string key, string name, IBasicCommunication comm)
+			: base(key, name)
+		{
+			Communication = comm;
+			Init();
+		}
+		/// <summary>
+		/// Constructor for TCP
+		/// </summary>
+		public NecPSXMDisplay(string key, string name, string hostname, int port)
+			: base(key, name)
+		{
+			Communication = new GenericTcpIpClient(key + "-tcp", hostname, port, 5000);
+			Init();
+		}
+
+
+		/// <summary>
+		/// Constructor for COM
+		/// </summary>
+		public NecPSXMDisplay(string key, string name, ComPort port, ComPort.ComPortSpec spec)
+			: base(key, name)
+		{
+			Communication = new ComPortController(key + "-com", port, spec);
+			Init();
+		}
+
+		void Init()
+		{
+			PortGather = new CommunicationGather(Communication, '\x0d');
+			PortGather.LineReceived += this.Port_LineReceived;
+			CommunicationMonitor = new GenericCommunicationMonitor(this, Communication, 30000, 120000, 300000, "xx\x0d");
+
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn1, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, new Action(InputHdmi1), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn2, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.Hdmi, new Action(InputHdmi2), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn3, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi3), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.HdmiIn4, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Hdmi, new Action(InputHdmi4), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DisplayPortIn1, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DisplayPort, new Action(InputDisplayPort1), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DisplayPortIn2, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.DisplayPort, new Action(InputDisplayPort2), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.DviIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Dvi, new Action(InputDvi1), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.CompositeIn, eRoutingSignalType.AudioVideo,
+                eRoutingPortConnectionType.Composite, new Action(InputVideo1), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.VgaIn, eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Vga, new Action(InputVga), this));
+			InputPorts.Add(new RoutingInputPort(RoutingPortNames.RgbIn, eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Rgb, new Action(new Action(InputRgb)), this));
+
+			VolumeLevelFeedback = new IntFeedback(() => { return _VolumeLevel; });
+			MuteFeedback = new BoolFeedback(() => _IsMuted);
+
+			//    new BoolCueActionPair(CommonBoolCue.Menu, b => { if(b) Send(MenuIrCmd); }),
+			//    new BoolCueActionPair(CommonBoolCue.Up, b => { if(b) Send(UpIrCmd); }),
+			//    new BoolCueActionPair(CommonBoolCue.Down, b => { if(b) Send(DownIrCmd); }),
+			//    new BoolCueActionPair(CommonBoolCue.Left, b => { if(b) Send(LeftIrCmd); }),
+			//    new BoolCueActionPair(CommonBoolCue.Right, b => { if(b) Send(RightIrCmd); }),
+			//    new BoolCueActionPair(CommonBoolCue.Select, b => { if(b) Send(SelectIrCmd); }),
+			//    new BoolCueActionPair(CommonBoolCue.Exit, b => { if(b) Send(ExitIrCmd); }),
+			//};
+		}
+
+		~NecPSXMDisplay()
+		{
+			PortGather = null;
+		}
+
+		public override bool CustomActivate()
+		{
+			Communication.Connect();
+			CommunicationMonitor.StatusChange += (o, a) => { Debug.Console(2, this, "Communication monitor state: {0}", CommunicationMonitor.Status); };
+			CommunicationMonitor.Start();
+			return true;
+		}
+
+		public override List<Feedback> Feedbacks
+		{
+			get
+			{
+				var list = base.Feedbacks;
+				list.AddRange(new List<Feedback>
+				{
+
+				});
+				return list;
+			}
+		}
+
+		void Port_LineReceived(object dev, GenericCommMethodReceiveTextArgs args)
+		{
+			if (Debug.Level == 2)
+				Debug.Console(2, this, "Received: '{0}'", ComTextHelper.GetEscapedText(args.Text));
+
+			if (args.Text=="DO SOMETHING HERE EVENTUALLY")
+			{
+				_IsMuted = true;
+				MuteFeedback.FireUpdate();
+			}
+		}
+
+		void AppendChecksumAndSend(string s)
+		{
+			int x = 0;
+			for (int i = 1; i < s.Length; i++)
+				x = x ^ s[i];
+
+			string send = s + (char)x + '\x0d';
+			Send(send);
+		}
+
+		void Send(string s)
+		{
+			if (Debug.Level == 2)
+				Debug.Console(2, this, "Send: '{0}'", ComTextHelper.GetEscapedText(s));
+			Communication.SendText(s);
+		}
+
+
+		public override void PowerOn()
+		{
+			Send(PowerOnCmd);
+			if (!PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
+			{
+				_IsWarmingUp = true;
+				IsWarmingUpFeedback.FireUpdate();
+				// Fake power-up cycle
+				WarmupTimer = new CTimer(o =>
+					{
+						_IsWarmingUp = false;
+						_PowerIsOn = true;
+						IsWarmingUpFeedback.FireUpdate();
+						PowerIsOnFeedback.FireUpdate();
+					}, WarmupTime);
+			}
+		}
+
+		public override void PowerOff()
+		{
+			// If a display has unreliable-power off feedback, just override this and
+			// remove this check.
+			if (PowerIsOnFeedback.BoolValue && !_IsWarmingUp && !_IsCoolingDown)
+			{
+				Send(PowerOffCmd);
+				_IsCoolingDown = true;
+				_PowerIsOn = false;
+				PowerIsOnFeedback.FireUpdate();
+				IsCoolingDownFeedback.FireUpdate();
+				// Fake cool-down cycle
+				CooldownTimer = new CTimer(o =>
+					{
+						Debug.Console(2, this, "Cooldown timer ending");
+						_IsCoolingDown = false;
+						IsCoolingDownFeedback.FireUpdate();
+					}, CooldownTime);
+			}
+		}		
+		
+		public override void PowerToggle()
+		{
+			if (PowerIsOnFeedback.BoolValue && !IsWarmingUpFeedback.BoolValue)
+				PowerOff();
+			else if (!PowerIsOnFeedback.BoolValue && !IsCoolingDownFeedback.BoolValue)
+				PowerOn();
+		}
+
+		public void InputHdmi1()
+		{
+			Send(Hdmi1Cmd);
+		}
+
+		public void InputHdmi2()
+		{
+			Send(Hdmi2Cmd);
+		}
+
+		public void InputHdmi3()
+		{
+			Send(Hdmi3Cmd);
+		}
+
+		public void InputHdmi4()
+		{
+			Send(Hdmi4Cmd);
+		}
+
+		public void InputDisplayPort1()
+		{
+			Send(Dp1Cmd);
+		}
+
+		public void InputDisplayPort2()
+		{
+			Send(Dp2Cmd);
+		}
+
+		public void InputDvi1()
+		{
+			Send(Dvi1Cmd);
+		}
+
+		public void InputVideo1()
+		{
+			Send(Video1Cmd);
+		}
+
+		public void InputVga()
+		{
+			Send(VgaCmd);
+		}
+
+		public void InputRgb()
+		{
+			Send(RgbCmd);
+		}
+
+		public override void ExecuteSwitch(object selector)
+		{
+            if (selector is Action)
+                (selector as Action).Invoke();
+            else
+                Debug.Console(1, this, "WARNING: ExecuteSwitch cannot handle type {0}", selector.GetType());
+			//Send((string)selector);
+		}
+
+		void SetVolume(ushort level)
+		{
+			var levelString = string.Format("{0}{1:X4}\x03", VolumeLevelPartialCmd, level);
+			AppendChecksumAndSend(levelString);
+			//Debug.Console(2, this, "Volume:{0}", ComTextHelper.GetEscapedText(levelString));
+			_VolumeLevel = level;
+			VolumeLevelFeedback.FireUpdate();
+		}
+
+		#region IBasicVolumeWithFeedback Members
+	
+		public IntFeedback VolumeLevelFeedback { get; private set; }
+
+		public BoolFeedback MuteFeedback { get; private set; }
+
+		public void MuteOff()
+		{
+			Send(MuteOffCmd);
+		}
+
+		public void MuteOn()
+		{
+			Send(MuteOnCmd);
+		}
+
+		void IBasicVolumeWithFeedback.SetVolume(ushort level)
+		{
+			SetVolume(level);
+		}
+
+		#endregion
+
+		#region IBasicVolumeControls Members
+
+		public void MuteToggle()
+		{
+			Send(MuteToggleIrCmd);
+		}
+
+		public void VolumeDown(bool pressRelease)
+		{
+			throw new NotImplementedException();
+#warning need incrementer for these
+			//Send(VolumeDownCmd);
+		}
+
+		public void VolumeUp(bool pressRelease)
+		{
+			throw new NotImplementedException();
+			//Send(VolumeUpCmd);
+		}
+
+		#endregion
+	}
+}
--- a/Common/Display/NecPaSeriesProjector.cs
+++ b/Common/Display/NecPaSeriesProjector.cs
@@ -0,0 +1,243 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Devices.Displays
+{
+	public class NecPaSeriesProjector : ComTcpDisplayBase
+	{
+		public readonly IntFeedback Lamp1RemainingPercent;
+		int _Lamp1RemainingPercent;
+		public readonly IntFeedback Lamp2RemainingPercent;
+		int _Lamp2RemainingPercent;
+		protected override Func<bool> PowerIsOnFeedbackFunc
+		{
+			get { return () => _PowerIsOn; }
+		}
+		bool _PowerIsOn;
+
+		protected override Func<bool> IsCoolingDownFeedbackFunc
+		{
+			get { return () => false; }
+		}
+
+		protected override Func<bool> IsWarmingUpFeedbackFunc
+		{
+			get { return () => false; }
+		}
+
+		public override void PowerToggle()
+		{
+			throw new NotImplementedException();
+		}
+
+		public override void ExecuteSwitch(object selector)
+		{
+			throw new NotImplementedException();
+		}
+
+		Dictionary<string, string> InputMap;
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		public NecPaSeriesProjector(string key, string name)
+			: base(key, name)
+		{
+			Lamp1RemainingPercent = new IntFeedback(Cue.UShortCue("Lamp1RemainingPercent", 0), () => _Lamp1RemainingPercent);
+			Lamp2RemainingPercent = new IntFeedback(Cue.UShortCue("Lamp2RemainingPercent", 0), () => _Lamp2RemainingPercent);
+
+			InputMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+			{
+				{ "computer1", "\x02\x03\x00\x00\x02\x01\x01\x09" },
+				{ "computer2", "\x02\x03\x00\x00\x02\x01\x02\x0a" },
+				{ "computer3", "\x02\x03\x00\x00\x02\x01\x03\x0b" },
+				{ "hdmi", "\x02\x03\x00\x00\x02\x01\x1a\x22" },
+				{ "dp", "\x02\x03\x00\x00\x02\x01\x1b\x23" },
+				{ "video", "\x02\x03\x00\x00\x02\x01\x06\x0e" },
+				{ "viewer", "\x02\x03\x00\x00\x02\x01\x1f\x27" },
+				{ "network", "\x02\x03\x00\x00\x02\x01\x20\x28" },
+			};
+		}
+
+		void IsConnected_OutputChange(object sender, EventArgs e)
+		{
+
+		}
+
+		public void SetEnable(bool state)
+		{
+			var tcp = CommunicationMethod as GenericTcpIpClient;
+			if (tcp != null)
+			{
+				tcp.Connect();
+			}
+		}
+
+		public override void PowerOn()
+		{
+			SendText("\x02\x00\x00\x00\x00\x02");
+		}
+
+		public override void PowerOff()
+		{
+			SendText("\x02\x01\x00\x00\x00\x03");
+		}
+
+		public void PictureMuteOn()
+		{
+			SendText("\x02\x10\x00\x00\x00\x12");
+		}
+
+		public void PictureMuteOff()
+		{
+			SendText("\x02\x11\x00\x00\x00\x13");
+		}
+
+		public void GetRunningStatus()
+		{
+			SendText("\x00\x85\x00\x00\x01\x01\x87");
+		}
+
+		public void GetLampRemaining(int lampNum)
+		{
+			if (!_PowerIsOn) return;
+
+			var bytes = new byte[]{0x03,0x96,0x00,0x00,0x02,0x00,0x04};
+			if (lampNum == 2)
+				bytes[5] = 0x01;
+			SendBytes(AppendChecksum(bytes));
+		}
+
+		public void SelectInput(string inputKey)
+		{
+			if (InputMap.ContainsKey(inputKey))
+				SendText(InputMap[inputKey]);
+		}
+
+		void SendText(string text)
+		{
+			if (CommunicationMethod != null)
+				CommunicationMethod.SendText(text);
+		}
+
+		void SendBytes(byte[] bytes)
+		{
+			if (CommunicationMethod != null)
+				CommunicationMethod.SendBytes(bytes);
+		}
+
+		byte[] AppendChecksum(byte[] bytes)
+		{
+			byte sum = unchecked((byte)bytes.Sum(x => (int)x));
+			var retVal = new byte[bytes.Length + 1];
+			bytes.CopyTo(retVal, 0);
+			retVal[retVal.Length - 1] = sum;
+			return retVal;
+		}
+
+		protected override void CommunicationMethod_BytesReceived(object sender, GenericCommMethodReceiveBytesArgs args)
+		{
+			var bytes = args.Bytes;
+			ParseBytes(args.Bytes);
+		}
+
+		void ParseBytes(byte[] bytes)
+		{
+			if (bytes[0] == 0x22)
+			{
+				// Power on
+				if (bytes[1] == 0x00)
+				{
+					_PowerIsOn = true;
+					PowerIsOnFeedback.FireUpdate();
+				}
+				// Power off
+				else if (bytes[1] == 0x01)
+				{
+					_PowerIsOn = false;
+					PowerIsOnFeedback.FireUpdate();
+				}
+			}
+			// Running Status
+			else if (bytes[0] == 0x20 && bytes[1] == 0x85 && bytes[4] == 0x10)
+			{
+				var operationStates = new Dictionary<int, string>
+				{
+					{ 0x00, "Standby" },
+					{ 0x04, "Power On" },
+					{ 0x05, "Cooling" },
+					{ 0x06, "Standby (error)" },
+					{ 0x0f, "Standby (power saving" },
+					{ 0x10, "Network Standby" },
+					{ 0xff, "Not supported" }
+				};
+
+				var newPowerIsOn = bytes[7] == 0x01;
+				if (newPowerIsOn != _PowerIsOn)
+				{
+					_PowerIsOn = newPowerIsOn;
+					PowerIsOnFeedback.FireUpdate();
+				}
+
+				Debug.Console(2, this, "PowerIsOn={0}\rCooling={1}\rPowering on/off={2}\rStatus={3}",
+					_PowerIsOn, 
+					bytes[8] == 0x01,
+					bytes[9] == 0x01,
+					operationStates[bytes[10]]);
+				
+			}
+			// Lamp remaining
+			else if (bytes[0] == 0x23 && bytes[1] == 0x96 && bytes[4] == 0x06 && bytes[6] == 0x04)
+			{
+				var newValue = bytes[7];
+				if (bytes[5] == 0x00)
+				{
+					if (newValue != _Lamp1RemainingPercent)
+					{
+						_Lamp1RemainingPercent = newValue;
+						Lamp1RemainingPercent.FireUpdate();
+					}
+				}
+				else
+				{
+					if (newValue != _Lamp2RemainingPercent)
+					{
+						_Lamp2RemainingPercent = newValue;
+						Lamp2RemainingPercent.FireUpdate();
+					}
+				}
+				Debug.Console(0, this, "Lamp {0}, {1}% remaining", (bytes[5] + 1), bytes[7]);
+			}
+
+		}
+
+
+		#region INonStandardControls Members
+
+		public Dictionary<Cue, Action<object>> GetNonStandardControls()
+		{
+			return new Dictionary<Cue, Action<object>>
+			{
+				{ CommonBoolCue.PowerOn, o => PowerOn() },
+				{ CommonBoolCue.PowerOff, o => PowerOff() },
+				{ Cue.BoolCue("PictureMute", 0), o =>
+					{
+						if((bool)o)
+							PictureMuteOn();
+						else
+							PictureMuteOff(); } },
+				{ Cue.UShortCue("GetLampRemaining", 0), o => GetLampRemaining((int) o) },				
+				{ Cue.StringCue("SelectInput", 0), o => SelectInput((String)o) }
+			};
+		}
+
+		#endregion
+	}
+}
--- a/Common/Essentials
+++ b/Common/Essentials
@@ -0,0 +1,126 @@
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{892B761C-E479-44CE-BD74-243E9214AF13}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>PepperDash.Essentials.Devices.Common</RootNamespace>
+    <AssemblyName>Essentials Devices Common</AssemblyName>
+    <ProjectTypeGuids>{0B4745B0-194B-4BB6-8E21-E9057CA92300};{4D628B5B-2FBC-4AA6-8C16-197242AEB884};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <PlatformFamilyName>WindowsCE</PlatformFamilyName>
+    <PlatformID>E2BECB1F-8C8C-41ba-B736-9BE7D946A398</PlatformID>
+    <OSVersion>5.0</OSVersion>
+    <DeployDirSuffix>SmartDeviceProject1</DeployDirSuffix>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <NativePlatformName>Windows CE</NativePlatformName>
+    <FormFactorID>
+    </FormFactorID>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <AllowedReferenceRelatedFileExtensions>.allowedReferenceRelatedFileExtensions</AllowedReferenceRelatedFileExtensions>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE;</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <FileAlignment>512</FileAlignment>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <GenerateSerializationAssemblies>off</GenerateSerializationAssemblies>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <AllowedReferenceRelatedFileExtensions>.allowedReferenceRelatedFileExtensions</AllowedReferenceRelatedFileExtensions>
+    <DebugType>none</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <FileAlignment>512</FileAlignment>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <GenerateSerializationAssemblies>off</GenerateSerializationAssemblies>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Crestron.SimplSharpPro.DeviceSupport, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.DeviceSupport.dll</HintPath>
+    </Reference>
+    <Reference Include="Crestron.SimplSharpPro.Gateways, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SSPDevices\Crestron.SimplSharpPro.Gateways.dll</HintPath>
+    </Reference>
+    <Reference Include="mscorlib" />
+    <Reference Include="PepperDash_Core, Version=1.0.6284.20368, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\PepperDash.Core\Pepperdash Core\Pepperdash Core\bin\PepperDash_Core.dll</HintPath>
+    </Reference>
+    <Reference Include="PepperDash_Essentials_Core, Version=1.0.0.27415, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\essentials-core\PepperDashEssentialsBase\PepperDashEssentialsBase\bin\PepperDash_Essentials_Core.dll</HintPath>
+    </Reference>
+    <Reference Include="SimplSharpCustomAttributesInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpCustomAttributesInterface.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="SimplSharpHelperInterface, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpHelperInterface.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="SimplSharpNewtonsoft, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpNewtonsoft.dll</HintPath>
+    </Reference>
+    <Reference Include="SimplSharpPro, Version=1.5.2.4, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpPro.exe</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="SimplSharpReflectionInterface, Version=1.0.5583.25238, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpReflectionInterface.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Crestron\Gateways\CenRfgwController.cs" />
+    <Compile Include="Display\ComTcpDisplayBase.cs" />
+    <Compile Include="Display\DeviceFactory.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="Factory\DeviceFactory.cs" />
+    <Compile Include="PC\InRoomPc.cs" />
+    <Compile Include="PC\Laptop.cs" />
+    <Compile Include="SetTopBox\SetTopBoxPropertiesConfig.cs" />
+    <Compile Include="Streaming\AppleTV.cs" />
+    <Compile Include="Audio\GenericAudioOut.cs" />
+    <Compile Include="DiscPlayer\IRDiscPlayerBase.cs" />
+    <Compile Include="SetTopBox\IRSetTopBoxBase.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Streaming\Roku.cs" />
+    <None Include="Properties\ControlSystem.cfg" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CompactFramework.CSharp.targets" />
+  <ProjectExtensions>
+    <VisualStudio>
+    </VisualStudio>
+  </ProjectExtensions>
+  <PropertyGroup>
+    <PostBuildEvent>rem S# Pro preparation will execute after these operations</PostBuildEvent>
+  </PropertyGroup>
+</Project>
--- a/Common.projectinfo
+++ b/Common.projectinfo
--- a/Common/Factory/DeviceFactory.cs
+++ b/Common/Factory/DeviceFactory.cs
@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.CrestronIO;
+using Crestron.SimplSharpPro;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Config;
+
+using PepperDash.Essentials.Devices.Common.DSP;
+
+using PepperDash.Essentials.Devices.Common;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	public class DeviceFactory
+	{
+		public static IKeyed GetDevice(DeviceConfig dc)
+		{
+			var key = dc.Key;
+			var name = dc.Name;
+			var type = dc.Type;
+			var properties = dc.Properties;
+
+			var typeName = dc.Type.ToLower();
+			var groupName = dc.Group.ToLower();
+
+			if (typeName == "appletv")
+			{
+				//var ir = IRPortHelper.GetIrPort(properties);
+				//if (ir != null)
+				//    return new AppleTV(key, name, ir.Port, ir.FileName);
+
+				var irCont = IRPortHelper.GetIrOutputPortController(dc);
+				return new AppleTV(key, name, irCont);
+
+			}
+
+			else if (typeName == "basicirdisplay")
+			{
+				var ir = IRPortHelper.GetIrPort(properties);
+				if (ir != null)
+					return new BasicIrDisplay(key, name, ir.Port, ir.FileName);
+			}
+
+			else if (typeName == "cenrfgwex")
+			{
+				return CenRfgwController.GetNewExGatewayController(key, name,
+					properties.Value<string>("id"), properties.Value<string>("gatewayType"));
+			}
+
+			else if (typeName == "cenerfgwpoe")
+			{
+				return CenRfgwController.GetNewErGatewayController(key, name,
+					properties.Value<string>("id"), properties.Value<string>("gatewayType"));
+			}
+
+			else if (typeName == "genericaudiooutwithvolume")
+			{
+				var zone = dc.Properties.Value<uint>("zone");
+				return new GenericAudioOutWithVolume(key, name,
+					dc.Properties.Value<string>("volumeDeviceKey"), zone);
+			}
+
+			else if (groupName == "discplayer") // (typeName == "irbluray")
+			{
+				if (properties["control"]["method"].Value<string>() == "ir")
+				{
+					var irCont = IRPortHelper.GetIrOutputPortController(dc);
+					return new IRBlurayBase(key, name, irCont);
+
+					//var ir = IRPortHelper.GetIrPort(properties);
+					//if (ir != null)
+					//    return new IRBlurayBase(key, name, ir.Port, ir.FileName);
+				}
+				else if (properties["control"]["method"].Value<string>() == "com")
+				{
+					Debug.Console(0, "[{0}] COM Device type not implemented YET!", key);
+				}
+			}
+
+			else if (groupName == "settopbox") //(typeName == "irstbbase")
+			{
+				var irCont = IRPortHelper.GetIrOutputPortController(dc);
+                var config = dc.Properties.ToObject<SetTopBoxPropertiesConfig>();
+				var stb = new IRSetTopBoxBase(key, name, irCont, config);
+
+				//stb.HasDvr = properties.Value<bool>("hasDvr");
+				var listName = properties.Value<string>("presetsList");
+				if (listName != null)
+					stb.LoadPresets(listName);
+				return stb;
+			}
+
+			else if (typeName == "laptop")
+			{
+				return new Laptop(key, name);
+			}
+
+			else if (typeName == "inroompc")
+			{
+				return new InRoomPc(key, name);
+			}
+
+			else if (typeName == "roku")
+			{
+				var irCont = IRPortHelper.GetIrOutputPortController(dc);
+				return new Roku2(key, name, irCont);
+
+				//var ir = IRPortHelper.GetIrPort(properties);
+				//if (ir != null)
+				//    return new Roku2(key, name, ir.Port, ir.FileName);
+			}
+
+			else if (typeName == "biamptesira")
+			{
+				var comm = CommFactory.CreateCommForDevice(dc);
+				var props = JsonConvert.DeserializeObject<BiampTesiraFortePropertiesConfig>(
+					properties.ToString());
+				return new BiampTesiraForteDsp(key, name, comm, props);
+			}
+
+			return null;
+		}
+	}
+}
--- a/Common/PC/InRoomPc.cs
+++ b/Common/PC/InRoomPc.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Routing;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	/// <summary>
+	/// This DVD class should cover most IR, one-way DVD and Bluray fuctions
+	/// </summary>
+	public class InRoomPc : Device, IHasFeedback, IRoutingOutputs, IAttachVideoStatus, IUiDisplayInfo
+	{
+		public uint DisplayUiType { get { return DisplayUiConstants.TypeLaptop; } }
+		public string IconName { get; set; }
+		public BoolFeedback HasPowerOnFeedback { get; private set; }
+
+		public RoutingOutputPort AnyVideoOut { get; private set; }
+
+		#region IRoutingOutputs Members
+
+		/// <summary>
+		/// Options: hdmi
+		/// </summary>
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		#endregion
+
+		public InRoomPc(string key, string name)
+			: base(key, name)
+		{
+			IconName = "PC";
+			HasPowerOnFeedback = new BoolFeedback(CommonBoolCue.HasPowerFeedback, 
+				() => this.GetVideoStatuses() != VideoStatusOutputs.NoStatus);
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+			OutputPorts.Add(AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.None, 0, this));
+		}
+
+		#region IHasFeedback Members
+
+		/// <summary>
+		/// Passes through the VideoStatuses list
+		/// </summary>
+		public List<Feedback> Feedbacks
+		{
+			get { return this.GetVideoStatuses().ToList(); }
+		}
+
+		#endregion
+	}
+}
--- a/Common/PC/Laptop.cs
+++ b/Common/PC/Laptop.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Routing;
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	/// <summary>
+	/// This DVD class should cover most IR, one-way DVD and Bluray fuctions
+	/// </summary>
+	public class Laptop : Device, IHasFeedback, IRoutingOutputs, IAttachVideoStatus, IUiDisplayInfo
+	{
+		public uint DisplayUiType { get { return DisplayUiConstants.TypeLaptop; } }
+		public string IconName { get; set; }
+		public BoolFeedback HasPowerOnFeedback { get; private set; }
+
+		public RoutingOutputPort AnyVideoOut { get; private set; }
+
+		#region IRoutingOutputs Members
+
+		/// <summary>
+		/// Options: hdmi
+		/// </summary>
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		#endregion
+
+		public Laptop(string key, string name)
+			: base(key, name)
+		{
+			IconName = "Laptop";
+			HasPowerOnFeedback = new BoolFeedback(CommonBoolCue.HasPowerFeedback, 
+				() => this.GetVideoStatuses() != VideoStatusOutputs.NoStatus);
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+			OutputPorts.Add(AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.None, 0, this));
+		}
+
+		#region IHasFeedback Members
+
+		/// <summary>
+		/// Passes through the VideoStatuses list
+		/// </summary>
+		public List<Feedback> Feedbacks
+		{
+			get { return this.GetVideoStatuses().ToList(); }
+		}
+
+		#endregion
+	}
+}
--- a/Common/Properties/AssemblyInfo.cs
+++ b/Common/Properties/AssemblyInfo.cs
@@ -0,0 +1,8 @@
+using System.Reflection;
+
+[assembly: AssemblyTitle("Essentials_Devices_Common")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Essentials_Devices_Common")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyVersion("1.0.0.*")]
+
--- a/Common/Properties/ControlSystem.cfg
+++ b/Common/Properties/ControlSystem.cfg
--- a/Common/SetTopBox/IRSetTopBoxBase.cs
+++ b/Common/SetTopBox/IRSetTopBoxBase.cs
@@ -0,0 +1,337 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Core.Presets;
+using PepperDash.Essentials.Core.Routing;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	public class IRSetTopBoxBase : Device, ISetTopBoxControls, IUiDisplayInfo, IRoutingOutputs
+	{
+		public IrOutputPortController IrPort { get; private set; }
+
+		public uint DisplayUiType { get { return DisplayUiConstants.TypeDirecTv; } }
+
+
+        public bool HasPresets { get; set; }
+        public bool HasDvr { get; set; }
+        public bool HasDpad { get; set; }
+        public bool HasNumeric { get; set; }
+
+        public DevicePresetsModel PresetsModel { get; private set; }
+
+		public IRSetTopBoxBase(string key, string name, IrOutputPortController portCont,
+            SetTopBoxPropertiesConfig props)
+			: base(key, name)
+		{
+			IrPort = portCont;
+			DeviceManager.AddDevice(portCont);
+
+            HasPresets = props.HasPresets;
+            HasDvr = props.HasDvr;
+            HasDpad = props.HasDpad;
+            HasNumeric = props.HasNumeric;
+
+			HasKeypadAccessoryButton1 = true;
+			KeypadAccessoryButton1Command = "Dash";
+			KeypadAccessoryButton1Label = "-";
+
+			HasKeypadAccessoryButton2 = true;
+			KeypadAccessoryButton2Command = "NumericEnter";
+			KeypadAccessoryButton2Label = "Enter";
+
+			AnyVideoOut = new RoutingOutputPort(RoutingPortNames.AnyVideoOut, eRoutingSignalType.AudioVideo,
+				eRoutingPortConnectionType.Hdmi, null, this);
+			AnyAudioOut = new RoutingOutputPort(RoutingPortNames.AnyAudioOut, eRoutingSignalType.Audio,
+				eRoutingPortConnectionType.DigitalAudio, null, this);
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort> { AnyVideoOut, AnyAudioOut };
+
+		}
+
+		public void LoadPresets(string filePath)
+		{
+			PresetsModel = new DevicePresetsModel(Key + "-presets", this, filePath);
+			DeviceManager.AddDevice(PresetsModel);
+		}
+
+
+		#region ISetTopBoxControls Members
+
+		public void DvrList(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_DVR, pressRelease);
+		}
+
+		public void Replay(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_REPLAY, pressRelease);
+		}
+
+		#endregion
+
+		#region IDPad Members
+
+		public void Up(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_UP_ARROW, pressRelease);
+		}
+
+		public void Down(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_DN_ARROW, pressRelease);
+		}
+
+		public void Left(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_LEFT_ARROW, pressRelease);
+		}
+
+		public void Right(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RIGHT_ARROW, pressRelease);
+		}
+
+		public void Select(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_ENTER, pressRelease);
+		}
+
+		public void Menu(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_MENU, pressRelease);
+		}
+
+		public void Exit(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_EXIT, pressRelease);
+		}
+
+		#endregion
+
+		#region INumericKeypad Members
+
+		public void Digit0(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_0, pressRelease);
+		}
+
+		public void Digit1(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_1, pressRelease);
+		}
+
+		public void Digit2(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_2, pressRelease);
+		}
+
+		public void Digit3(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_3, pressRelease);
+		}
+
+		public void Digit4(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_4, pressRelease);
+		}
+
+		public void Digit5(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_5, pressRelease);
+		}
+
+		public void Digit6(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_6, pressRelease);
+		}
+
+		public void Digit7(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_7, pressRelease);
+		}
+
+		public void Digit8(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_8, pressRelease);
+		}
+
+		public void Digit9(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_9, pressRelease);
+		}
+
+		/// <summary>
+		/// Defaults to true
+		/// </summary>
+		public bool HasKeypadAccessoryButton1 { get; set; }
+
+		/// <summary>
+		/// Defaults to "-"
+		/// </summary>
+		public string KeypadAccessoryButton1Label { get; set; }
+		
+
+		/// <summary>
+		/// Defaults to "Dash"
+		/// </summary>
+		public string KeypadAccessoryButton1Command { get; set; }
+
+		public void KeypadAccessoryButton1(bool pressRelease)
+		{
+			IrPort.PressRelease(KeypadAccessoryButton1Command, pressRelease);
+		}
+
+		/// <summary>
+		/// Defaults to true
+		/// </summary>
+		public bool HasKeypadAccessoryButton2 { get; set; }
+
+		/// <summary>
+		/// Defaults to "Enter"
+		/// </summary>
+		public string KeypadAccessoryButton2Label { get; set; }
+
+
+		/// <summary>
+		/// Defaults to "Enter"
+		/// </summary>
+		public string KeypadAccessoryButton2Command { get; set; }
+
+		public void KeypadAccessoryButton2(bool pressRelease)
+		{
+			IrPort.PressRelease(KeypadAccessoryButton2Command, pressRelease);
+		}
+
+		#endregion
+
+		#region ISetTopBoxNumericKeypad Members
+
+		/// <summary>
+		/// Corresponds to "dash" IR command
+		/// </summary>
+		public void Dash(bool pressRelease)
+		{
+			IrPort.PressRelease("dash", pressRelease);
+		}
+
+		/// <summary>
+		/// Corresponds to "numericEnter" IR command
+		/// </summary>
+		public void KeypadEnter(bool pressRelease)
+		{
+			IrPort.PressRelease("numericEnter", pressRelease);
+		}
+
+		#endregion
+
+		#region IChannelFunctions Members
+
+		public void ChannelUp(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_CH_PLUS, pressRelease);
+		}
+
+		public void ChannelDown(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_CH_MINUS, pressRelease);
+		}
+
+		public void LastChannel(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_LAST, pressRelease);
+		}
+
+		public void Guide(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_GUIDE, pressRelease);
+		}
+
+		public void Info(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_INFO, pressRelease);
+		}
+
+		#endregion
+
+		#region IColorFunctions Members
+
+		public void Red(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RED, pressRelease);
+		}
+
+		public void Green(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_GREEN, pressRelease);
+		}
+
+		public void Yellow(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_YELLOW, pressRelease);
+		}
+
+		public void Blue(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_BLUE, pressRelease);
+		}
+
+		#endregion
+
+		#region IRoutingOutputs Members
+
+		public RoutingOutputPort AnyVideoOut { get; private set; }
+		public RoutingOutputPort AnyAudioOut { get; private set; }
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		#endregion
+
+		#region ITransport Members
+
+		public void ChapMinus(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_REPLAY, pressRelease);
+		}
+
+		public void ChapPlus(bool pressRelease)
+		{
+		}
+
+		public void FFwd(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_FSCAN, pressRelease);
+		}
+
+		public void Pause(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RSCAN, pressRelease);
+		}
+
+		public void Play(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_PLAY, pressRelease);
+		}
+
+		public void Record(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RECORD, pressRelease);
+		}
+
+		public void Rewind(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RSCAN, pressRelease);
+		}
+
+		public void Stop(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_STOP, pressRelease);
+		}
+
+		#endregion
+	}
+}
--- a/Common/SetTopBox/SetTopBoxPropertiesConfig.cs
+++ b/Common/SetTopBox/SetTopBoxPropertiesConfig.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+    public class SetTopBoxPropertiesConfig
+    {
+        public bool HasPresets { get; set; }
+        public bool HasDvr { get; set; }
+        public bool HasDpad { get; set; }
+        public bool HasNumeric { get; set; }
+
+        public ControlPropertiesConfig Control { get; set; }
+    }
+}
--- a/Common/Streaming/AppleTV.cs
+++ b/Common/Streaming/AppleTV.cs
@@ -0,0 +1,145 @@
+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.Routing;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	public class AppleTV : Device, IDPad, ITransport, IUiDisplayInfo, IRoutingOutputs
+	{
+
+		public IrOutputPortController IrPort { get; private set; }
+		public const string StandardDriverName = "Apple AppleTV-v2.ir";
+		public uint DisplayUiType { get { return DisplayUiConstants.TypeAppleTv; } }
+
+		public AppleTV(string key, string name, IrOutputPortController portCont)
+			: base(key, name)
+		{
+			IrPort = portCont;
+			DeviceManager.AddDevice(portCont);
+
+			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.Hdmi, null, this);
+			AnyAudioOut = new RoutingOutputPort(RoutingPortNames.AnyAudioOut, eRoutingSignalType.Audio, 
+				eRoutingPortConnectionType.DigitalAudio, null, this);
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut, AnyAudioOut };
+		}
+
+
+		#region IDPad Members
+
+		public void Up(bool pressRelease)
+		{
+			IrPort.PressRelease("+", pressRelease);
+		}
+
+		public void Down(bool pressRelease)
+		{
+			IrPort.PressRelease("-", pressRelease);
+		}
+
+		public void Left(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_TRACK_MINUS, pressRelease);
+		}
+
+		public void Right(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_TRACK_PLUS, pressRelease);
+		}
+
+		public void Select(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_ENTER, pressRelease);
+		}
+
+		public void Menu(bool pressRelease)
+		{
+			IrPort.PressRelease("Menu", pressRelease);
+		}
+
+		public void Exit(bool pressRelease)
+		{
+
+		}
+
+		#endregion
+
+		#region ITransport Members
+
+		public void Play(bool pressRelease)
+		{
+			IrPort.PressRelease("PLAY/PAUSE", pressRelease);
+		}
+
+		public void Pause(bool pressRelease)
+		{
+			IrPort.PressRelease("PLAY/PAUSE", pressRelease);
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void Rewind(bool pressRelease)
+		{
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void FFwd(bool pressRelease)
+		{
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void ChapMinus(bool pressRelease)
+		{
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void ChapPlus(bool pressRelease)
+		{
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void Stop(bool pressRelease)
+		{
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void Record(bool pressRelease)
+		{
+		}
+
+		#endregion
+
+		#region IRoutingOutputs Members
+
+		public RoutingOutputPort HdmiOut { get; private set; }
+		public RoutingOutputPort AnyAudioOut { get; private set; }
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		#endregion
+	}
+}
--- a/Common/Streaming/Roku.cs
+++ b/Common/Streaming/Roku.cs
@@ -0,0 +1,148 @@
+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.Routing;
+
+namespace PepperDash.Essentials.Devices.Common
+{
+	public class Roku2 : Device, IDPad, ITransport, IUiDisplayInfo, IRoutingOutputs
+	{
+		[Api]
+		public IrOutputPortController IrPort { get; private set; }
+		public const string StandardDriverName = "Roku XD_S.ir";
+		[Api]
+		public uint DisplayUiType { get { return DisplayUiConstants.TypeRoku; } }
+
+		public Roku2(string key, string name, IrOutputPortController portCont)
+			: base(key, name)
+		{
+			IrPort = portCont;
+			DeviceManager.AddDevice(portCont);;
+
+			HdmiOut = new RoutingOutputPort(RoutingPortNames.HdmiOut, eRoutingSignalType.AudioVideo, 
+				eRoutingPortConnectionType.Hdmi, null, this);
+			OutputPorts = new RoutingPortCollection<RoutingOutputPort> { HdmiOut };
+		}
+
+		#region IDPad Members
+
+		[Api]
+		public void Up(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_UP_ARROW, pressRelease);
+		}
+
+		[Api]
+		public void Down(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_DN_ARROW, pressRelease);
+		}
+
+		[Api]
+		public void Left(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_LEFT_ARROW, pressRelease);
+		}
+
+		[Api]
+		public void Right(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RIGHT_ARROW, pressRelease);
+		}
+
+		[Api]
+		public void Select(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_ENTER, pressRelease);
+		}
+
+		[Api]
+		public void Menu(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_MENU, pressRelease);
+		}
+
+		[Api]
+		public void Exit(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_EXIT, pressRelease);
+		}
+
+		#endregion
+
+		#region ITransport Members
+
+		[Api]
+		public void Play(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_PLAY, pressRelease);
+		}
+
+		[Api]
+		public void Pause(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_PAUSE, pressRelease);
+		}
+
+		[Api]
+		public void Rewind(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_RSCAN, pressRelease);
+		}
+
+		[Api]
+		public void FFwd(bool pressRelease)
+		{
+			IrPort.PressRelease(IROutputStandardCommands.IROut_FSCAN, pressRelease);
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void ChapMinus(bool pressRelease)
+		{
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void ChapPlus(bool pressRelease)
+		{
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void Stop(bool pressRelease)
+		{
+		}
+
+		/// <summary>
+		/// Not implemented
+		/// </summary>
+		/// <param name="pressRelease"></param>
+		public void Record(bool pressRelease)
+		{
+		}
+
+		#endregion
+
+		#region IRoutingOutputs Members
+
+		public RoutingOutputPort HdmiOut { get; private set; }
+		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+		#endregion
+
+	}
+}