Subversion Repositories group.NITPanels

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Timers;

using Microsoft.FlightSimulator.SimConnect;

using LibUsbDotNet;

using LibUsbDotNet.Main;

using LibUsbDotNet.DeviceNotify;

namespace NITNavComm {

    public class NITAudioSelDevice : NITDevice {

        public VolumeControl volcontrol = new VolumeControl();

        public const byte USBCMD_READ_BUTTONS = 100;

        public const byte USBCMD_LEDS_SET = 101;

        public const byte USBCMD_GET_ANALOG = 102;

        public const byte USBCMD_SET_POWER_LED = 103;

        // The min analog value we'll ever read from the pot

        // If the analog val ever drops below this, a uint to int

        //  conversion will make the number >17k. If its not low enough

        //  the volume will never be able to be musted. Should probably 

        //  be calibrated or the protection resistor removed from the 

        //  analog pot ground line

        public const uint DEV_ANALOG_MIN = 4;

        private int simStatus { get; set; }

        public byte ledStatus { get; set; }

        public byte buttonStatus { get; set; }

        public byte analogValue { get; set; }

        public byte powerLedStatus { get; set; }

        public bool avionicsMaster { get; set; }

        private const int TIMER_COUNT = 8;

        Timer[] timers = new Timer[TIMER_COUNT];

        Timer inputTimer = new Timer();

        public NITAudioSelDevice(NITDevice nitDevice) :

            base(nitDevice.usbRegistry, "NITAudioSel", nitDevice.vid, nitDevice.pid) {

            this.init();

        }

        public NITAudioSelDevice(UsbRegistry usbRegistry, string type, int vid, int pid) :

            base(usbRegistry, "NITAudioSel", 0x4242, 0xe231) {

            this.init();

        }

        private void init() {

            base.Open();

            this.simStatus = 0;

            this.ledStatus = 0x00;

            this.buttonStatus = 0x00;

            this.analogValue = 0x00;

            this.powerLedStatus = 0;

            for (int i = 0; i < TIMER_COUNT; i++) {

                Timer timer = new Timer();

                timer.Enabled = false;

                timer.AutoReset = false;

                timer.Interval = NITPanels.CFG_BUTTON_DEBOUNCE_TIME;

                timer.Elapsed += OnDebounceTimer;

                timers[i] = timer;

            }

            inputTimer.Enabled = false;

            inputTimer.AutoReset = true;

            inputTimer.Interval = NITPanels.CFG_INPUT_TIMER_INTERVAL;

            inputTimer.Elapsed += inputTimer_Elapsed;

            // VolControl Stuff

            // Default the user setting to the first device it not already set

            if (Properties.Settings.Default.volcontroldevice == "" && volcontrol.deviceCount > 0) {

                Properties.Settings.Default.volcontroldevice = volcontrol.devices.ElementAt(0);

                Properties.Settings.Default.Save();

            }

            // Retrieve the user setting for the selected device, find its index

            if (volcontrol.deviceCount > 0) {

                string selectedDevice = Properties.Settings.Default.volcontroldevice;

                for (int i = 0; i < volcontrol.deviceCount; i++) {

                    if (selectedDevice == volcontrol.devices.ElementAt(i)) {

                        volcontrol.selectedDeviceIndex = (uint)i;

                        break;

                    }

                }

            }

        }

        void inputTimer_Elapsed(object sender, ElapsedEventArgs e) {

            this.SimButtons();

        }

        private static void OnDebounceTimer(Object source, ElapsedEventArgs e) {

            Timer timer = (Timer)source;

            timer.Enabled = false;

        }

        public override bool Close() {

            this.powerDown();

            return base.Close();

        }

        public void powerDown() {

            this.inputTimer.Enabled = false;

            this.ClearDisplay();

            this.simStatus = 2;

        }

        public void powerUp() {

            this.simStatus = 0;

            this.setLedPwr(true);

            this.fsx.requestAudioSelData();

            this.inputTimer.Enabled = true;

        }

        public override void FsxReady() {

            this.powerUp();

        }

        public override void reAssign() {

            if (this.simStatus != 0  && this.fsx != null)

                return;

            this.fsx.requestAudioSelData();

        }

        public override void FsxEvent(SIMCONNECT_RECV_SIMOBJECT_DATA data) {

            if (data.dwRequestID == (uint)FSXObject.DATA_REQUESTS.AVIONICS) {

                FSXObject.Avionics_Data avionics = (FSXObject.Avionics_Data)data.dwData[0];

                this.avionicsMaster = avionics.avionics_master;

                if (!this.avionicsMaster) {

                    this.powerDown();

                    return;

                }

                if (this.avionicsMaster && this.simStatus != 0) {

                    this.powerUp();

                    return;

                }

            }

            if (this.simStatus != 0)

                return;

            if (data.dwRequestID != (uint)FSXObject.DATA_REQUESTS.AUDIOSEL_REQ)

                return;

            FSXObject.AudioSel_Data audioseldata = (FSXObject.AudioSel_Data)data.dwData[0];

            this.setLed(0, audioseldata.com1);

            this.setLed(1, audioseldata.com2);

            this.setLed(2, audioseldata.comb);

            this.setLed(3, audioseldata.vor1);

            this.setLed(4, audioseldata.vor2);

            this.setLed(5, audioseldata.mkr);

            this.setLed(6, audioseldata.dme);

            this.setLed(7, audioseldata.adf);

            this.UpdateDisplay();

        }

        public override void SimButtons() {

            if (this.simStatus != 0)

                return;

            this.updateInput();

            for (int i = 0; i <= 7; i++) {

                if (timers[i].Enabled)                              // Wait for the debounce before processing again

                    continue;

                if (NITPanels.readBit(this.buttonStatus, i)) {      // Check an audio button is pressed

                    this.fsx.AudioSelButton(i);                          //  and if so, send of the audio select event

                    timers[i].Enabled = true;                       //  and start up a timer to debounce the button

                }

            }

            // VolControl Stuff

            float setVolume = NITPanels.map_f(this.analogValue, DEV_ANALOG_MIN, 255, 0.00F, 1.00F);

            float devVolume = this.volcontrol.getDeviceVolume();

            if (setVolume != devVolume)

                this.volcontrol.setDeviceVolume(setVolume);

        }

        public void updateInput() {

            byte[] data = new byte[8];

            int transferred;

            base.SendCommand(NITAudioSelDevice.USBCMD_READ_BUTTONS, 0, 0, data, out transferred);

            this.buttonStatus = data[1];

            base.SendCommand(NITAudioSelDevice.USBCMD_GET_ANALOG, 0, 0, data, out transferred);

            this.analogValue = data[0];

        }

        public void UpdateDisplay() {

            base.SendCommand(NITAudioSelDevice.USBCMD_LEDS_SET, this.ledStatus, 0);

            base.SendCommand(NITAudioSelDevice.USBCMD_SET_POWER_LED, this.powerLedStatus, 0);

        }

        public void ClearDisplay() {

            this.ledStatus = 0x00;

            this.setLedPwr(false);

            this.UpdateDisplay();

        }

        public void setLed(int ledNum, double status) {

            if (status == 1)

                this.ledStatus = NITPanels.setBit(this.ledStatus, ledNum);

            else

                this.ledStatus = NITPanels.clearBit(this.ledStatus, ledNum);

        }

        public void setLed(int ledNum, bool status) {

            if (status)

                this.ledStatus = NITPanels.setBit(this.ledStatus, ledNum);

            else

                this.ledStatus = NITPanels.clearBit(this.ledStatus, ledNum);

        }

        public bool isLedSet(int ledNum) {

            return NITPanels.readBit(this.ledStatus, ledNum);

        }

        public bool isLedPwrSet() {

            if (this.powerLedStatus>0)

                return true;

            return false;

        }

        public void setLedPwr(bool status) {

            if (status)

                this.powerLedStatus = 1;

            else

                this.powerLedStatus = 0;

        }

        public bool isButtonSet(int buttonNum) {

            return NITPanels.readBit(this.buttonStatus, buttonNum);

        }

    }

}