Subversion Repositories group.electronics

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using LibUsbDotNet;

using LibUsbDotNet.Main;

using LibUsbDotNet.DeviceNotify;

namespace NITNavComm {

    public class NITNavCommDevice : NITDevice  {

        enum UsbCommands : byte {

            CMD_LATCH_DISPLAY = 20,

            CMD_SET_DISPLAY = 21,

        };

        private byte[,] display { get; set; }

        private byte[] buttons {get; set; }

        private sbyte[,] rotary;

        public NITNavCommDevice(NITDevice nitDevice) :

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

            init();

        }

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

            base(usbRegistry, "NITNavComm", 0x20a0, 0x4236) {

            init();

        }

        private void init()

        {

            this.display = new byte[2, 10];

            for (byte j = 0; j < 2; j++)

                for (byte i = 0; i < 10; i++)

                    this.display[j, i] = 0x0a;

            this.buttons = new byte[2];

            this.buttons[0] = 0x00;

            this.buttons[1] = 0x00;

            this.rotary = new sbyte[2, 2];

            this.rotary[0, 0] = 0x00;

            this.rotary[0, 1] = 0x00;

            this.rotary[1, 0] = 0x00;

            this.rotary[1, 1] = 0x00;

        }

        new public bool Close() {

            byte[] blank = { 0x0a, 0x0a, 0x0a, 0x0a, 0x0a };

            for (byte i = 0; i < 4; i++)

                setFreq(i, ref blank);

            this.UpdateDisplay();

            return base.Close();

        }

        public byte[] getFreq(byte freq) {

            byte[] ret = new byte[5];

            switch (freq) {

                case 0:

                    for (byte i = 0; i < 5; i++)

                        ret[i] = display[0, i];

                    break;

                case 1:

                    for (byte i = 0; i < 5; i++)

                        ret[i] = display[0, i + 5];

                    break;

                case 2:

                    for (byte i = 0; i < 5; i++)

                        ret[i] = display[1, i];

                    break;

                case 3:

                    for (byte i = 0; i < 5; i++)

                        ret[i] = display[1, i + 5];

                    break;

            }

            return ret;

        }

        public void setFreq(byte freq, ref byte[] data) {

            switch (freq) {

                case 0:

                    for (byte i = 0; i < 5; i++)

                        display[0, i] = data[i];

                    break;

                case 1:

                    for (byte i = 0; i < 5; i++)

                        display[0, i+5] = data[i];

                    break;

                case 2:

                    for (byte i = 0; i < 5; i++)

                        display[1, i] = data[i];

                    break;

                case 3:

                    for (byte i = 0; i < 5; i++)

                        display[1, i + 5] = data[i];

                    break;

            }

        }

        public void setNavComFreqs(MainForm.NavCom_Data data) {

            byte[] freq0 = this.charArrayToBytes(data.Freq0.ToString().ToCharArray());

            byte[] freq1 = this.charArrayToBytes(data.Freq1.ToString().ToCharArray());

            byte[] freq2 = this.charArrayToBytes(data.Freq2.ToString().ToCharArray());

            byte[] freq3 = this.charArrayToBytes(data.Freq3.ToString().ToCharArray());

            this.setFreq(0, ref freq0);

            this.setFreq(1, ref freq1);

            this.setFreq(2, ref freq2);

            this.setFreq(3, ref freq3);

            this.UpdateDisplay();

        }

        private byte[] charArrayToBytes(char[] digits) {

            byte[] bytes = new byte[5];

            for (byte i = 0; i < 5; i++) {

                bytes[i] = (byte)(digits[i] - '0');

            }

            return bytes;

        }

        public void setDisplay(byte dis, ref byte[] data) {

            for (byte i = 0; i < data.Length; i++) {

                display[dis, i] = data[i];

            }

        }

        private void sendDigit(byte dis, byte dig, byte val, byte dp) {

            ushort wxValue = (ushort)(dis <<8);

            wxValue |= dig;

            ushort wxIndex = (ushort)(dp << 8);

            wxIndex |= val;

            base.SendCommand(21, (short)wxValue, (short)wxIndex);

        }

        private void sendLatch(byte dis) {

            if (!this.isOpen())

                return;

            base.SendCommand(20, (short)dis, 0);

        }

        public void updateInput() {

            byte[] data = new byte[8];

            int transferred;

            base.SendCommand(30, 0, 0, data, out transferred);

            this.buttons[0] = data[0];

            this.rotary[0, 0] += (sbyte)data[1];

            this.buttons[1] = data[2];

            this.rotary[1, 0] += (sbyte)data[3];

        }

        public bool isSwapSet(byte dis) {

            if ((this.buttons[dis] & 0x01)>0)

                return true;

            return false;

        }

        public bool isFlipSet(byte dis) {

            if ((this.buttons[dis] & 0x02) > 0)

                return true;

            return false;

        }

        public sbyte getRotary(byte dis, byte rotary) {

            return this.rotary[dis, rotary];

        }

        public void resetRotary(byte display, byte rotary) {

            this.rotary[display, rotary] = 0x00;

        }

        public void UpdateDisplay() {

            this.sendData(0);

            this.sendData(1);

            this.latchDisplay(0);

            this.latchDisplay(1);

        }

        public void UpdateDisplay(byte dis) {

            this.sendData(dis);

            this.latchDisplay(dis);

        }

        private void sendData(byte dis) {

            for (byte i = 0; i < 10; i++) {

                this.sendDigit(dis, i, display[dis, i], 0);

            }            

        }

        private void latchDisplay(byte dis) {

            this.sendLatch(dis);

        }

        public void swapFreq(byte display) {

            if (display == 0) {

                byte[] left = this.getFreq(0);

                byte[] right = this.getFreq(1);

                this.setFreq(0, ref right);

                this.setFreq(1, ref left);

            } else if (display == 1) {

                byte[] left = this.getFreq(2);

                byte[] right = this.getFreq(3);

                this.setFreq(2, ref right);

                this.setFreq(3, ref left);

            }

        }

    }

}