using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Runtime.InteropServices;

using System.Runtime.InteropServices.WindowsRuntime;

using System.Text;

using System.Threading.Tasks;

​

namespace FanucFocas

{

    class Focas : IDisposable

    {

        string Ip;

        ushort FlibHndl;

        const ushort FocasPort = 8193;

        readonly TimeSpan ConnectionTimeout = TimeSpan.FromSeconds(6);

​

        public bool Ready { get { return FlibHndl != 0; } }

​

        public Focas(string Ip)

        {

            this.Ip = Ip;

        }

​

        internal void ConnectAsync()

        {

            short ret = Focas1.cnc_allclibhndl3(Ip, FocasPort, (int)ConnectionTimeout.TotalSeconds, out FlibHndl);

            if (ret != Focas1.EW_OK)

                throw new ApplicationException($"Errore su connessione FOCAS {Ip}:{FocasPort}\n{ret} - {convert.ResultToString(ret)}");

        }

​

        internal void Disconnect()

        {

            if (FlibHndl != 0)

                Focas1.cnc_freelibhndl(FlibHndl);

            FlibHndl = 0;

        }

​

        internal Focas1.ODBST GetStatInfo()

        {

            var buf = new Focas1.ODBST();

            short ret = Focas1.cnc_statinfo(FlibHndl, buf);

            if (ret != Focas1.EW_OK)

                throw new ApplicationException($"Errore su cnc_statinfo: {ret} - {convert.ResultToString(ret)}");

            return buf;

        }

​

        internal Focas1.ODBDY2_1 GetDynamicData()

        {

            var buf = new Focas1.ODBDY2_1();

            short ret = Focas1.cnc_rddynamic2(FlibHndl, Focas1.ALL_AXES, (short)Marshal.SizeOf(buf), buf);

            if (ret != Focas1.EW_OK)

                throw new ApplicationException($"Errore su cnc_rddynamic2: {ret} - {convert.ResultToString(ret)}");

            return buf;

        }

​

        internal Focas1.LOADELM[] GetServo()

        {

            var sv = new Focas1.LOADELM();

            byte[] bytes = new byte[Marshal.SizeOf(sv) * Focas1.MAX_AXIS];

            IntPtr ptrWork = IntPtr.Zero;

            try

            {

                ptrWork = Marshal.AllocCoTaskMem(Marshal.SizeOf(sv));

                short num = Focas1.MAX_AXIS;

                short ret = Focas1.cnc_rdsvmeter(FlibHndl, ref num, bytes);

                if (ret != Focas1.EW_OK)

                    throw new ApplicationException($"Errore su cnc_rdsvmeter: {ret} - {convert.ResultToString(ret)}");

                var buf = new Focas1.LOADELM[num];

                for (int i = 0; i < num; i++)

                {

                    sv = new Focas1.LOADELM();

                    Marshal.Copy(bytes, i * Marshal.SizeOf(sv), ptrWork, Marshal.SizeOf(sv));

                    Marshal.PtrToStructure(ptrWork, sv);

                    buf[i] = sv;

                }

                return buf;

            }

            finally

            {

                Marshal.FreeCoTaskMem(ptrWork);

            }

        }

​

        internal Focas1.ODBSPLOAD_data[] GetSpindle()

        {

            var sp = new Focas1.ODBSPLOAD_data();

            short num = 4; /* 4 = maximum spinlde number */

            byte[] bytes = new byte[Marshal.SizeOf(sp) * num];

            IntPtr ptrWork = IntPtr.Zero;

            try

            {

                ptrWork = Marshal.AllocCoTaskMem(Marshal.SizeOf(sp));

                const short Type = -1; // 0 : spindle load meter data; 1 : spindle motor speed data; -1 : all type

                short ret = Focas1.cnc_rdspmeter(FlibHndl, Type, ref num, bytes);

                if (ret != Focas1.EW_OK)

                {

                    // sul robocut della stilmec questa funzione da errore (non ha lo spindle?)

                    //throw new ApplicationException($"Errore su cnc_rdspmeter: {ret} - {convert.ResultToString(ret)}");

                    return new Focas1.ODBSPLOAD_data[0];

                }

                var buf = new Focas1.ODBSPLOAD_data[num];

                for (int i = 0; i < num; i++)

                {

                    sp = new Focas1.ODBSPLOAD_data();

                    Marshal.Copy(bytes, i * Marshal.SizeOf(sp), ptrWork, Marshal.SizeOf(sp));

                    Marshal.PtrToStructure(ptrWork, sp);

                    buf[i] = sp;

                }

                return buf;

            }

            finally

            {

                Marshal.FreeCoTaskMem(ptrWork);

            }

        }

​

        private short GetAxno()

        {

            var info = new Focas1.ODBSYS();

            short ret = Focas1.cnc_sysinfo(FlibHndl, info);

            if (ret != Focas1.EW_OK)

                throw new ApplicationException($"Errore su cnc_sysinfo: {ret} - {convert.ResultToString(ret)}");

            return short.Parse(new string(info.axes));

        }

​

        internal Focas1.IODBPSD[] GetParameters(short start, short end, short axis = 0)

        {

            short axno = GetAxno();

            var param = new Focas1.IODBPSD();

            short length = (short)(Marshal.SizeOf(param) * (end - start + 1)); // In case of axis type parameters  

            var bytes = new byte[length];

            IntPtr ptrWork = IntPtr.Zero;

            try

            {

                ptrWork = Marshal.AllocCoTaskMem(Marshal.SizeOf(param));

                short ret = Focas1.cnc_rdparar(FlibHndl, ref start, axis, ref end, ref length, bytes);

                if (ret != Focas1.EW_OK)

                    throw new ApplicationException($"Errore su cnc_rdparar: {ret} - {convert.ResultToString(ret)}");

                var buf = new List<Focas1.IODBPSD>();

                short inc = 0;

                int pos = 0;

                for (short idx1 = start; idx1 <= end; idx1++)

                {

                    param = new Focas1.IODBPSD();

                    Marshal.Copy(bytes, pos, ptrWork, Marshal.SizeOf(param));

                    Marshal.PtrToStructure(ptrWork, param);

                    if ((start != 0) && (param.datano == 0)) break;

                    switch (param.type & 0xff)

                    {

                        case 0xff:

                            for (short idx2 = 0; idx2 < axno; idx2++)

                            {

                                switch (param.type >> 8)

                                {

                                    case 0:

                                    case 1: inc = 1; break;

                                    case 2: inc = 2; break;

                                    case 3: inc = 4; break;

                                }

                            }

                            pos += (short)(4 + Focas1.MAX_AXIS * inc);

                            break;

                        case 0:

                            switch (param.type >> 8)

                            {

                                case 0:

                                case 1: inc = 1 + 3; break;

                                case 2: inc = 2 + 2; break;

                                case 3: inc = 4; break;

                            }

                            pos += (short)(4 + inc);

                            break;

                        default: throw new NotImplementedException();

                    }

                    buf.Add(param);

                }

                return buf.ToArray();

            }

            finally

            {

                Marshal.FreeCoTaskMem(ptrWork);

            }

        }

​

        internal Focas1.ODBALMMSG2_data[] GetAlarms()

        {

            short type = -1; //all type

            short num = 10;

            var buf = new Focas1.ODBALMMSG2();

            short ret = Focas1.cnc_rdalmmsg2(FlibHndl, type, ref num, buf);

            if (ret != Focas1.EW_OK)

                throw new ApplicationException($"Errore su cnc_sysinfo: {ret} - {convert.ResultToString(ret)}");

            if (num > 10)

                num = 10;

            var list = new List<Focas1.ODBALMMSG2_data>();

            for (int i = 1; i <= num; i++)

                list.Add(GetAlarmMessage(buf, i));

            return list.ToArray();

        }

​

        private Focas1.ODBALMMSG2_data GetAlarmMessage(Focas1.ODBALMMSG2 buf, int i)

        {

            switch (i)

            {

                case 1: return buf.msg1;

                case 2: return buf.msg2;

                case 3: return buf.msg3;

                case 4: return buf.msg4;

                case 5: return buf.msg5;

                case 6: return buf.msg6;

                case 7: return buf.msg7;

                case 8: return buf.msg8;

                case 9: return buf.msg9;

                case 10: return buf.msg10;

                default: throw new NotImplementedException();

            }

        }

​

        #region Dispose

        private bool disposedValue;

​

        protected virtual void Dispose(bool disposing)

        {

            if (!disposedValue)

            {

                if (disposing)

                {

                    // TODO: eliminare lo stato gestito (oggetti gestiti)

                    Disconnect();

                }

​

                // TODO: liberare risorse non gestite (oggetti non gestiti) ed eseguire l'override del finalizzatore

                // TODO: impostare campi di grandi dimensioni su Null

                disposedValue = true;

            }

        }

​

        // // TODO: eseguire l'override del finalizzatore solo se 'Dispose(bool disposing)' contiene codice per liberare risorse non gestite

        // ~Focas()

        // {

        //     // Non modificare questo codice. Inserire il codice di pulizia nel metodo 'Dispose(bool disposing)'

        //     Dispose(disposing: false);

        // }

​

        public void Dispose()

        {

            // Non modificare questo codice. Inserire il codice di pulizia nel metodo 'Dispose(bool disposing)'

            Dispose(disposing: true);

            GC.SuppressFinalize(this);

        }

        #endregion

    }

}

​