/// <summary>
    /// A list of Channels
    /// </summary>
    public enum Channel
    {
        Discovery=776,
        FOX=708,
        NFL=777,
        ABC=710,
        NBC=713,
        CBS=706,
        AandE=771,
        HBO=750,
        ESPN=772,
        ESPN2=778,
        NESN=733,
        TNT=764,
    }

/// <summary>
        /// Takes a channel name and sends the commands to change to that channel
        /// </summary>
        /// <param name="strChannel">Channel Name</param>
        [AjaxPro.AjaxMethod]
        public static void ChannelCommmand(string strChannel)
        {
            Controller uirt = new Controller();
            // make str into enum type
            Channel channel = (Channel)Enum.Parse(typeof(Channel), strChannel);

            // get the channel # via cast
            int channelNumber = (int)channel;

            // pop it into a char array
            char[] digits = channelNumber.ToString().ToCharArray();

            // loop through each char of the channel
            foreach (char digit in digits)
            {
                // get the index of the number in the static array
                int codeIndex = Convert.ToInt32(digit.ToString());

                // transmit the propper code using the index
                uirt.Transmit(ControlCodes.SA8300HD.Number[codeIndex]);
            }

            // transmit an accept code for immediate results
            uirt.Transmit(ControlCodes.SA8300HD.Button_Select);
        }

            SerialPort sp5000 = new SerialPort("COM1", 19200, Parity.None, 8, StopBits.One);

            // Open the sp5000 for communications
            sp5000.Open();

            sp5000.Write(ControlCodes.InfocusSP5000.RS232.OverscanOff);

            sp5000.Close();

using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;

namespace X10
{
    public class FireCracker
    {
        // Serial Port used to send commands
        private SerialPort sp;

        /// <summary>
        /// Init FireCracker
        /// </summary>
        /// <param name="ComPort">The COM Port to use to send Commands</param>
        public FireCracker(int ComPort)
        {
            // set up the Com Port
            sp = new SerialPort("COM" + ComPort.ToString(), 9600, Parity.None, 8, StopBits.One);
        }

        #region Methods

        /// <summary>
        /// Send a command to the X10 device with the supplied house code, device code, and command.
        /// </summary>
        /// <param name="houseCode">The house code of the device you wish to control.</param>
        /// <param name="deviceCode">The numeric id of the device you wish to control.</param>
        /// <param name="cmd">The command you wish to give this device. TurnOn, TurnOff, Brighten, Dim.</param>
        /// <returns>True when the SendCommand operation is complete</returns>
        public bool SendCommand(char houseCode, int deviceCode, X10DeviceCommand cmd)
        {

            // Send to the mCommPort serial port a binary stream consisting of the house code
            // device code, and any additional binary data that helps execute the desired command.;
            string binaryCmd = HeaderCode + GetBinaryHouseCode(houseCode) + GetBinaryGroupCode(deviceCode);

            switch (cmd)
            {
                case X10DeviceCommand.TurnOn:
                    binaryCmd += GetBinaryCommandCode(deviceCode, BinaryCommandCodes.TurnOnIndex);
                    break;
                case X10DeviceCommand.TurnOff:
                    binaryCmd += GetBinaryCommandCode(deviceCode, BinaryCommandCodes.TurnOffIndex);
                    break;
                case X10DeviceCommand.MakeBrighter:
                    binaryCmd += MakeBrighterCommandCode;
                    break;
                case X10DeviceCommand.MakeDimmer:
                    binaryCmd += MakeDimmerCommandCode;
                    break;
            }

            binaryCmd += FooterCode;

            // Open the port up
            sp.Open();
            sp.DtrEnable = false;
            sp.RtsEnable = false;
            System.Threading.Thread.Sleep(DELAY);
            sp.DtrEnable = true;
            sp.RtsEnable = true;
            System.Threading.Thread.Sleep(DELAY);
            for (int bit = 0; bit < binaryCmd.Length; bit++)
            {
                if (Convert.ToInt32(binaryCmd.Substring(bit, 1)) == 0)
                {
                    sp.DtrEnable = true;
                    sp.RtsEnable = false;
                }
                else
                {
                    sp.DtrEnable = false;
                    sp.RtsEnable = true;
                }
                System.Threading.Thread.Sleep(DELAY);
                sp.RtsEnable = true;
                sp.DtrEnable = true;
                System.Threading.Thread.Sleep(DELAY);
            }

            // Close Port
            sp.Close();
            return true;
        }

        /// <summary>
        /// Determine the binary group code from the device code
        /// </summary>
        private string GetBinaryGroupCode(int deviceCode)
        {
            return (deviceCode > 8 ? SecondGroupCode : FirstGroupCode);
        }


        /// <summary>
        /// Convert a house code (A-P) to its binary representation
        /// </summary>
        private string GetBinaryHouseCode(char houseCode)
        {
            houseCode = Convert.ToChar(houseCode.ToString().ToLower());
            return mBinaryHouseCode[houseCode - Convert.ToInt32('a')];
        }


        /// <summary>
        /// Convert a device code + command code index to its binary representation
        /// </summary>
        private string GetBinaryCommandCode(int deviceCode, BinaryCommandCodes codeIndex)
        {
            return mBinaryCommandCode[deviceCode - 1, Convert.ToInt32(codeIndex)];
        }

        #endregion

        #region BinaryCodes

        private const int DELAY = 30; // The delay between sending bits, in milliseconds
        private const string HeaderCode = "1101010110101010"; // Header (never changes);
        private const string FooterCode = "10101101"; // Footer (never changes);
        private const string MakeBrighterCommandCode = "10001000"; // Brightens last device, if applicable;
        private const string MakeDimmerCommandCode = "10011000"; // Dims last device, if applicable;
        private const string FirstGroupCode = "0000"; // Applies to devices 1-8;
        private const string SecondGroupCode = "0100"; // Applies to devices 9-16;

        // y value in mBinaryCommandCode(x,y) array.
        private enum BinaryCommandCodes
        {
            TurnOnIndex = 0,
            TurnOffIndex = 1
        }

        // House codes A-P in binary.
        private string[] mBinaryHouseCode =        { "0110", "0111", "0100", "0101", "1000", "1001", "1010", "1011", "1110", "1111", "1100", "1101", "0000", "0001", "0010", "0011" };

        // Pattern: { { Dev Code 1, On } { Deve Code 1, Off }, { Dev Code 2, On } { Dev Code 2, Off }, ... }
        // Bit layout: "0ac0b000" where bits
        // a = 1-4/9-12 vs. 5-9/13-16
        // b = 1-2/5-6/9-10/13-14 vs. 3-4/7-8/11-12/15-16
        // c = on vs. off
        private string[,] mBinaryCommandCode =     { { "00000000", "00100000" }, { "00010000", "00110000" }, { "00001000", "00101000" }, { "00011000", "00111000" }, { "01000000", "01100000" }, { "01010000", "01110000" }, { "01001000", "01101000" }, { "01011000", "01111000" }, { "00000000", "00100000" }, { "00010000", "00110000" }, { "00001000", "00101000" }, { "00011000", "00111000" }, { "01000000", "01100000" }, { "01010000", "01110000" }, { "01001000", "01101000" }, { "01011000", "01111000" } };

        #endregion

    }

    /// <summary>
    /// Commands that may be sent to SendCommand().
    /// </summary>
    public enum X10DeviceCommand
    {
        TurnOn = 0,
        TurnOff = 1,
        MakeBrighter = 2,
        MakeDimmer = 3
    }
}