Subversion Repositories group.electronics

using MCP2221;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Text;

using System.Threading.Tasks;

using System.Timers;

namespace nitdcscore {

    public struct devdata {

        public uint prev_input;

        public uint cur_input;

        public int id;

        public string name;

        public string function;

    }

    public class mcp2221 {

        DcsBios bios = new DcsBios();

        MchpUsbI2c usbi2c = new MchpUsbI2c();

        public Boolean hasAHFS { get; set; }

        public Boolean hasAAP { get; set; }

        int idx { get; set; }

        int devcount { get; set; }

        public uint speed { get; set; }

        Timer refresh = new Timer();

        private readonly Object lockobject = new object();

        public devdata[] devices = new devdata[5];

        public mcp2221() {

            speed = 400000;

            idx = 0;

            bios.InitUDP();

            usbi2c.Settings.GetConnectionStatus();

            devcount = usbi2c.Management.GetDevCount();

            Console.WriteLine(devcount.ToString() + " devices found");

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

                int rslt = usbi2c.Management.SelectDev(i);

                usbi2c.Settings.GetConnectionStatus();

                string usbDescriptor = this.usbi2c.Settings.GetUsbStringDescriptor();

                if (usbDescriptor == "AHCP/FSCP Panel") {

                    this.hasAHFS = true;

                    devices[i].cur_input = 0;

                    devices[i].prev_input = 0;

                    devices[i].id = i;

                    devices[i].name = "AHCP/FSCP Panel";

                    devices[i].function = "refresh_ahfs";

                    init_ahfs(ref devices[i]);

                } else if (usbDescriptor == "AAP Panel") {

                    this.hasAAP = true;

                    devices[i].cur_input = 0;

                    devices[i].prev_input = 0;

                    devices[i].id = i;

                    devices[i].name = "AAP Panel";

                    devices[i].function = "refresh_aap";

                    init_aap(ref devices[i]);

                }

            }

            refresh.Interval = 500;

            refresh.AutoReset = true;

            refresh.Elapsed += refresh_Elapsed;

            refresh.Enabled = false;

        }

        private Boolean enabled;

        public Boolean Enabled {

            get {

                return enabled;

            }

            set {

                this.enabled = true;

                refresh.Enabled = true;

            }

        }

        void refresh_Elapsed(object sender, ElapsedEventArgs e) {

            if (!Enabled)

                return;

            devdata dev = devices[idx];

            usbi2c.Management.SelectDev(dev.id);

            Type type = this.GetType();

            MethodInfo callfunc = type.GetMethod(dev.function);

            ParameterInfo[] parameters = callfunc.GetParameters();

            object[] parms = { dev };

            callfunc.Invoke(this, parms);

            idx++;

            if (idx >= devcount)

                idx = 0;

        }

        public void init_aap(ref devdata dev) {

            // Enable the mcp23017

            WriteGpio(3, 1);

            // Set io dir, pullups and rev polarity

            byte[] data;

            data = new byte[] { 0x00, 0xff, 0xff, 0xff, 0xff }; // All inputs & polarity

            WriteI2cData(0x40, data, 5);

            data = new byte[] { 0x0c, 0xff, 0xff }; // All pullups = on

            WriteI2cData(0x40, data, 3);

            refresh_aap(ref dev);

            dev.prev_input = dev.cur_input;

        }

        public void refresh_aap(ref devdata dev) {

            Console.WriteLine("In aap " + usbi2c.Management.GetSelectedDevNum().ToString() + " : " + dev.name + " " + dev.cur_input.ToString("X"));

        }

        public void init_ahfs(ref devdata dev) {

            // Get the initial ADC value

            //this._prev_adc = this.adc = _mcp.ReadADC(1);

            // Enable the mcp23017

            WriteGpio(3, 1);

            // Set io dir, pullups and rev polarity

            byte[] data;

            // Soldered a couple of inputs wrong, the f0 is to reverse them (fuel boost switches)

            data = new byte[] { 0x00, 0xff, 0xff, 0xf0, 0xff }; // All inputs & polarity

            WriteI2cData(0x40, data, 5);

            data = new byte[] { 0x0c, 0xff, 0xff }; // All pullups = on

            WriteI2cData(0x40, data, 3);

            data = new byte[] { 0x00, 0xff, 0xff, 0xff, 0xff }; // All inputs & polarity

            WriteI2cData(0x42, data, 5);

            data = new byte[] { 0x0c, 0xff, 0xff }; // All pullups = on

            WriteI2cData(0x42, data, 3);

            refresh_ahfs(ref dev);

            dev.prev_input = dev.cur_input;

        }

        public void refresh_ahfs(ref devdata dev) {

            byte[] data;

            lock (lockobject) {

                data = new byte[] { 0x12 }; // Select GPIOA register

                WriteI2cData(0x40, data, 1);

                data = new byte[] { 0x00, 0x00 }; // Read two bytes

                int rslt = ReadI2CData(0x41, ref data, 2);

                dev.cur_input = (uint)data[0] << 24;

                dev.cur_input |= (uint)data[1] << 16;

                data = new byte[] { 0x12 }; // Select GPIOA register

                WriteI2cData(0x42, data, 1);

                data = new byte[] { 0x00, 0x00 }; // Read two bytes

                rslt = ReadI2CData(0x43, ref data, 2);

                dev.cur_input |= (uint)data[0] << 8;

                dev.cur_input |= (uint)data[1];

            }

            Console.WriteLine("In ahfs " + usbi2c.Management.GetSelectedDevNum().ToString() + " : " + dev.name + " " + dev.cur_input.ToString("X"));

        }

        public byte ReadGpio(byte pinNum) {

            return Convert.ToByte(usbi2c.Functions.ReadGpioPinValue(pinNum));

        }

        public ushort ReadADC(byte pinNum) {

            ushort[] adcData = { 0, 0, 0, 0, 0, 0 };

            int rslt = usbi2c.Functions.GetAdcData(adcData);

            return adcData[pinNum];

        }

        public void WriteGpio(byte pinNum, byte value) {

            this.usbi2c.Functions.WriteGpioPinValue(pinNum, value);

        }

        public int WriteI2cData(byte address, byte[] data, uint count) {

            int rslt = this.usbi2c.Functions.WriteI2cData(address, data, count, this.speed);

            return rslt;

        }

        public int ReadI2CData(byte address, ref byte[] data, uint count) {

            int rslt = this.usbi2c.Functions.ReadI2cData(address, data, count, this.speed);

            return rslt;

        }

        public uint Switch2Pos(int pin, String cmd, devdata data, Boolean invert = false) {

            uint chg = (uint)(data.prev_input >> pin) & 0x01;

            uint norm = (uint)(data.cur_input >> pin) & 0x01;

            uint value = 0;

            if ((uint)(norm) == 1) {

                value = (uint)(invert ? 0 : 1);

            }

            if (norm != chg) {

                bios.SendData(cmd + " " + value.ToString() + "\n");

                Console.WriteLine(cmd + ":" + value.ToString());

            }

            return value;

        }

        public uint Switch3Pos(int pin0, int pin1, String cmd, devdata data, Boolean invert = false) {

            uint value = 1;

            uint chg0 = (uint)(data.prev_input >> pin0) & 0x01;

            uint chg1 = (uint)(data.prev_input >> pin1) & 0x01;

            uint nrm0 = (uint)(data.cur_input >> pin0) & 0x01;

            uint nrm1 = (uint)(data.cur_input >> pin1) & 0x01;

            if ((uint)nrm0 == 1)

                value = (uint)(invert ? 2 : 0);

            else if ((uint)nrm1 == 1)

                value = (uint)(invert ? 0 : 2);

            if ((nrm0 != chg0) || (nrm1 != chg1)) {

                bios.SendData(cmd + " " + value.ToString() + "\n");

                Console.WriteLine(cmd + ":" + value.ToString());

            }

            return value;

        }

        public ushort map_ushort(ushort x, ushort in_min, ushort in_max, ushort out_min, ushort out_max) {

            return (ushort)((x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min);

        }

    }

}