Subversion Repositories group.electronics

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;

using Microsoft.FlightSimulator.SimConnect;

using LibUsbDotNet;
using LibUsbDotNet.Main;
using LibUsbDotNet.DeviceNotify;


namespace NITNavComm {

    public class Device {
        public int vid { get; set; }
        public int pid { get; set; }
        public string type { get; set; }

        public Device(string type, int vid, int pid) {
            this.type = type;
            this.vid = vid;
            this.pid = pid;
        }

    }

    public abstract class NITDevice : Device {
        public int id { get; set; }
        public string hw { get; set; }
        public string sw { get; set; }
        public string status { get; set; }
        public string serial { get; set; }
        public int assigned { get; set; }

        public FSXObject fsx { get; set; }

        protected UsbDevice usbDevice;
        public UsbRegistry usbRegistry { get; set; }

        public NITDevice(UsbRegistry usbRegistry, string type, int vid, int pid) : base(type, vid, pid) {
            this.id = -1;
            this.hw = "";
            this.sw = "";
            this.serial = "";
            this.status = "";
            this.usbRegistry = usbRegistry;
            
        }

        public bool Open() {
            if (this.usbRegistry == null || !this.usbRegistry.IsAlive)
                return false;

            if (this.usbDevice == null)
                this.usbRegistry.Open(out this.usbDevice);
            else
                this.usbDevice.Open();
                
            return true;
        }

        public virtual bool Close() {
            if (this.usbDevice == null)
                return false;

            if (this.usbDevice.IsOpen)
                this.usbDevice.Close();

            return true;
        }

        public bool isOpen() {
            if (this.usbDevice == null || ! usbDevice.IsOpen)
                return false;
            

            return true;
        }

        public bool SendCommand(byte command, short value, short index) {
            int transferred;
            byte[] buffer = new byte[8];
            return SendCommand(command, value, index, buffer, out transferred);
        }

        public bool SendCommand(byte command, short value, short index, object buffer, out int transferred) {
            if (!this.isOpen())
                throw new Exception("USB Device " + this.type + "(" + this.serial + ") not open/connected");

            UsbSetupPacket packet = new UsbSetupPacket((byte)UsbRequestType.TypeVendor 
                | (byte)UsbEndpointDirection.EndpointIn, command, value, index, 0);

            return this.usbDevice.ControlTransfer(ref packet, buffer, 8, out transferred);
        }

        public bool GetDeviceVersion() {
            byte[] data = new byte[8];
            int transferred;
            bool success = this.SendCommand(01, 0, 0, data, out transferred);
            this.hw = data[0].ToString();
            this.sw = data[1].ToString();
            return success;
        }

        // Virtual Functions
        abstract public void MapEvents(FSXObject fsx);
        abstract public void FsxEvent(FSXObject fsx, SIMCONNECT_RECV_SIMOBJECT_DATA data);
        abstract public void FsxReady(FSXObject fsx);
        abstract public void SimButtons(FSXObject fsx);

    }

    class NITPanels {

        public static int CFG_BUTTON_DEBOUNCE_TIME = 500;

        public List<NITDevice> devices { get; set; }

        public NITPanels() {
            devices = new List<NITDevice>();
        }

        public int UsbScan() {

            List<Device> regDevices = new List<Device>();
            regDevices.Add(new Device("NITNavComm", 0x20a0, 0x4236));
            regDevices.Add(new Device("NITAudioSel", 0x4242, 0xe231));
            regDevices.Add(new Device("NITAdf", 0x20a0, 0x4238));

            int idCount = 0;
            devices = new List<NITDevice>();

            UsbRegDeviceList allDevices = UsbDevice.AllLibUsbDevices;
            foreach (UsbRegistry usbReg in allDevices) {
                foreach (Device device in regDevices) {
                    if (usbReg.Vid == device.vid 
                        && usbReg.Pid == device.pid) {
                            NITDevice found = null;
                            switch (device.type) {
                                case ("NITNavComm"): {
                                    found = new NITNavCommDevice(usbReg, device.type, device.vid, device.pid);
                                    break;
                                }
                                case ("NITAudioSel"): {
                                    found = new NITAudioSelDevice(usbReg, device.type, device.vid, device.pid);
                                    break;
                                }
                            }

                            found.id = idCount;
                            found.status = "Found";
                            
                            found.usbRegistry = usbReg;
                            UsbDevice dev; 
                            if (usbReg.Open(out dev)) {
                                found.status = "Available";
                                dev.Close();
                            }

                            if (found.Open()) {
                                found.status = "Connected";
                                found.GetDeviceVersion();
                            }  else
                                found.status = "Failed";
                            
                            idCount++;
                            devices.Add(found);
                    }
                }
            }

            return idCount;

        }

        public static bool readBit(byte data, int bitNum) {
            return (data & (1 << bitNum)) != 0;
        }

        public static byte setBit(byte data, int bitNum) {
            return (byte)(data | (1 << bitNum));
        }

        public static byte clearBit(byte data, int bitNum) {
            return (byte)(data & ~(1 << bitNum));
        }

    }
}