//using Broc.AOI.Entity;
//using System;
//using System.Collections.Generic;
//using System.Runtime.InteropServices;
//using System.Threading;

//namespace Bro.Device.GTSCard
//{
//    public class GtsMotionCard
//    {
//        private const int dangliang = 1;
//        private object lockobj = new object();//线程锁
//        /// <summary>
//        /// 初始化卡
//        /// </summary>
//        /// <returns></returns>
//        public bool InitCard()
//        {
//            short rtn;
//            rtn = GTSCardAPI.GT_Open(0, 0, 1);                  //打开运动控制器。参数必须为（0,1），不能修改。
//            //rtn += mc.GT_Reset(0);
//            rtn += GTSCardAPI.GT_LoadConfig(0, AppDomain.CurrentDomain.BaseDirectory + @"Gts800.cfg");
//            rtn += GTSCardAPI.GT_ClrSts(0, 1, 8);
//            return rtn == 0;

//        }
//        /// <summary>
//        /// 扩展模块初始化
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <returns></returns>
//        public bool ExtIOModuleInit(short cardNum)
//        {
//            short rtn = 0;
//            rtn += GTSCardAPI.GT_OpenExtMdl(cardNum, "gts.dll");
//            rtn += GTSCardAPI.GT_LoadExtConfig(cardNum, "ExtModule.cfg");
//            rtn += GTSCardAPI.GT_ResetExtMdl(cardNum);
//            return rtn == 0;
//        }
//        /// <summary>
//        /// 回零
//        /// </summary>
//        /// <param name="cardNum">卡号</param>
//        /// <param name="axisNum">轴号</param>
//        /// <param name="homests">轴回原点状态</param>
//        public bool GoHome(short cardNum, short axisNum, short home_mode, short home_dir, int homeoffset)
//        {
//            GTSCardAPI.GT_ZeroPos(cardNum, axisNum, 1);
//            GTSCardAPI.THomePrm thomeprm;
//            GTSCardAPI.THomeStatus homests;
//            short rtn = GTSCardAPI.GT_GetHomePrm(cardNum, axisNum, out thomeprm);
//            thomeprm.mode = home_mode;//回零方式
//            thomeprm.moveDir = home_dir;//回零方向
//            thomeprm.edge = 0;
//            thomeprm.velHigh = 50;
//            thomeprm.velLow = 50;
//            thomeprm.acc = 50;
//            thomeprm.dec = 50;
//            thomeprm.searchHomeDistance = 9999999;//搜搜距离
//            thomeprm.homeOffset = 0;  //偏移距离
//            thomeprm.escapeStep = 1000;
//            rtn = GTSCardAPI.GT_GoHome(cardNum, axisNum, ref thomeprm);  //启动回零
//            //do
//            //{
//            //    mc.GT_GetHomeStatus(cardNum, axisNum, out homests);//获取回原点状态
//            //} while (homests.run == 1); // 等待搜索原点停止
//            //mc.GT_ZeroPos(cardNum, axisNum, 1);
//            //return true;

//            while (true)
//            {
//                Thread.Sleep(5);
//                GTSCardAPI.GT_GetHomeStatus(cardNum, axisNum, out homests);
//                if (homests.run == 0)
//                {
//                    if (homests.error == 0)
//                    {
//                        Thread.Sleep(200);
//                        GTSCardAPI.GT_ZeroPos(cardNum, axisNum, 1);
//                    }
//                    return true;
//                }
//            }
//        }

//        /// <summary>
//        /// 点位到点位 运动
//        /// </summary>
//        /// <param name="cardNum">卡号</param>
//        /// <param name="axisNum">轴号</param>
//        /// <param name="prfPosition">规划位置,单位毫米</param>
//        /// <param name="prfVelocity">规划速度,单位米每秒</param>
//        public void P2P(short cardNum, short axisNum, int prfPosition, int prfVelocity)
//        {
//            GTSCardAPI.TTrapPrm trapprm;
//            GTSCardAPI.GT_PrfTrap(cardNum, axisNum);
//            GTSCardAPI.GT_GetTrapPrm(cardNum, axisNum, out trapprm);
//            trapprm.acc = Parameter.p2pAcc;
//            trapprm.dec = Parameter.p2pDec;
//            trapprm.smoothTime = 1;
//            GTSCardAPI.GT_SetTrapPrm(cardNum, axisNum, ref trapprm);
//            GTSCardAPI.GT_SetPos(cardNum, axisNum, prfPosition * dangliang);
//            GTSCardAPI.GT_SetVel(cardNum, axisNum, prfVelocity * dangliang);
//            GTSCardAPI.GT_Update(cardNum, 1 << (axisNum - 1));
//        }

//        /// <summary>
//        /// 停止
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="axisNum"></param>
//        /// <param name="option">0表示平滑停止，1表示紧急停止</param>
//        public void Stop(short cardNum, short axisNum, short option)
//        {
//            GTSCardAPI.GT_Stop(cardNum, 1 << (axisNum - 1), option);
//        }

//        /// <summary>
//        /// 停止
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="value">停止方式，false表示平滑停止，true表示紧急停止</param>
//        public void Stop(short cardNum, bool value)
//        {
//            for (short i = 1; i <= Axisn.Count; i++)
//            {
//                Stop(cardNum, i, value);
//            }
//        }

//        /// <summary>
//        /// Jog运动
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="axisNum"></param>
//        /// <param name="prfvel_ms">规划速度，单位米每秒</param>
//        public void Jog(short cardNum, short axisNum, double prfvel_ms)
//        {
//            GTSCardAPI.TJogPrm jogprm = new GTSCardAPI.TJogPrm();
//            short rtn = GTSCardAPI.GT_PrfJog(cardNum, axisNum);
//            jogprm.acc = 1;
//            jogprm.dec = 1;
//            GTSCardAPI.GT_SetJogPrm(cardNum, axisNum, ref jogprm);//设置jog运动参数
//            GTSCardAPI.GT_SetVel(cardNum, axisNum, prfvel_ms);//设置目标速度
//            GTSCardAPI.GT_Update(cardNum, 1 << (axisNum - 1));//更新轴运动
//        }
//        /// <summary>
//        /// 读取输入
//        /// </summary>
//        /// <param name="cardNum">卡号</param>
//        /// <param name="index">输入口</param>
//        /// <returns>有输入返回true，无输入返回false</returns>
//        public bool GetDi(short cardNum, short index)
//        {
//            int value;
//            GTSCardAPI.GT_GetDi(cardNum, GTSCardAPI.MC_GPI, out value);
//            if ((value & 1 << index) == 0) return true;//有输入返回true
//            else return false;          //无输入返回false
//        }
//        /// <summary>
//        /// 读取正限位
//        /// </summary>
//        /// <param name="cardNum">卡号</param>
//        /// <param name="axisNum">轴号</param>
//        /// <returns>0表示触发限位，1表示没有触发</returns>
//        public bool GetPosLimit(short cardNum, short axisNum)
//        {
//            int value;
//            GTSCardAPI.GT_GetDi(cardNum, GTSCardAPI.MC_LIMIT_POSITIVE, out value);
//            if ((value & 1 << axisNum) == 0) return true;////0表示触发限位,返回true，
//            else return false;    // //1表示没有触发,返回false
//        }
//        /// <summary>
//        /// 读取负限位
//        /// </summary>
//        /// <param name="cardNum">卡号</param>
//        /// <param name="axisNum">轴号</param>
//        /// <returns>0表示触发限位,返回true，1表示没有触发,返回false</returns>
//        public bool GetNegLimit(short cardNum, short axisNum)
//        {
//            int value;
//            GTSCardAPI.GT_GetDi(cardNum, GTSCardAPI.MC_LIMIT_NEGATIVE, out value);
//            if ((value & 1 << axisNum) == 0) return true;//0表示触发限位,返回true，
//            else return false;                         //1表示没有触发,返回false
//        }
//        /// <summary>
//        /// 输出
//        /// </summary>
//        /// <param name="cardNumo">卡号</param>
//        /// <param name="index">输出口,返回1-16</param>
//        /// <param name="value">0表示输出，1表示关闭</param>
//        public void WriteOut(short cardNumo, short index, bool value)
//        {
//            short outNum = 0;
//            outNum = (short)(index % 100 + 1);
//            switch (value)
//            {
//                case true:
//                    {
//                        GTSCardAPI.GT_SetDoBit(cardNumo, GTSCardAPI.MC_GPO, outNum, 0);//按位输出，0表示输出，1表示关闭
//                    }
//                    break;
//                case false:
//                    {
//                        GTSCardAPI.GT_SetDoBit(cardNumo, GTSCardAPI.MC_GPO, outNum, 1);//按位输出，0表示输出，1表示关闭
//                    }
//                    break;
//            }
//        }
//        /// <summary>
//        /// 读取IO输出状态
//        /// </summary>
//        /// <param name="cardNumo"></param>
//        /// <param name="index"></param>
//        /// <returns></returns>
//        public bool GetDoSts(short cardNumo, short index)
//        {
//            short outNum = 0;
//            int outSts;
//            outNum = (short)(index % 100);
//            GTSCardAPI.GT_GetDo(cardNumo, GTSCardAPI.MC_GPO, out outSts);
//            if ((outSts & (1 << outNum)) == 0) return true;
//            else return false;
//        }
//        /// <summary>
//        /// 读取当前值
//        /// </summary>
//        /// <param name="cardNum">卡号</param>
//        /// <param name="axisNum">轴号</param>
//        /// <returns>返回当前值，单位毫米</returns>
//        public double GetPosMM(short cardNum, short axisNum)
//        {
//            lock (lockobj)
//            {
//                double prfpos = 0; uint pclock = 0;
//                GTSCardAPI.GT_GetPrfPos(cardNum, axisNum, out prfpos, 1, out pclock);
//                return prfpos / dangliang;
//            }
//        }

//        /// <summary>
//        /// 读取轴状态，判断电机是否停止
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="axisNum"></param>
//        /// <returns></returns>
//        public bool IsStop(short cardNum, short axisNum)
//        {
//            lock (lockobj)
//            {
//                int sts = 0;
//                uint pclock = 0;
//                GTSCardAPI.GT_GetSts(cardNum, axisNum, out sts, 1, out pclock);
//                if ((sts & 0x400) == 0) return true;//停止返回true
//                else return false;              //运行中返回false
//            }
//        }

//        /// <summary>
//        /// 二维位置比较输出
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="output_data"></param>
//        public void Compare2DOutput(short cardNum, short chn, int[] output_data)
//        {
//            GTSCardAPI.GT_2DCompareClear(cardNum, chn);
//            GTSCardAPI.GT_2DCompareMode(cardNum, chn, GTSCardAPI.COMPARE2D_MODE_2D);
//            GTSCardAPI.GT_SetComparePort(cardNum, GTSCardAPI.COMPARE_PORT_GPO, 0, 1);
//            GTSCardAPI.T2DComparePrm Prm;
//            Prm.encx = 1;
//            Prm.ency = 2;
//            Prm.maxerr = 300;
//            Prm.outputType = 0;
//            Prm.source = 0;
//            Prm.startLevel = 0;
//            Prm.threshold = 10;
//            Prm.time = 10000;
//            GTSCardAPI.GT_2DCompareSetPrm(cardNum, chn, ref Prm);
//            GTSCardAPI.T2DCompareData[] pBuf = new GTSCardAPI.T2DCompareData[5];
//            for (int i = 0; i < output_data.Length / 2; i += 2)
//            {
//                pBuf[i].px = 1000;
//                pBuf[i + 1].py = 1000;
//            }
//            GTSCardAPI.GT_2DCompareData(cardNum, chn, (short)(output_data.Length / 2), ref pBuf[0], 0);
//            GTSCardAPI.GT_2DCompareStart(cardNum, chn);
//        }

//        /// <summary>
//        /// 按位读取扩展IO输入口
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="mdl"></param>
//        /// <param name="index"></param>
//        /// <returns></returns>
//        public bool GetDiBit(short cardNum, short mdl, short index)
//        {
//            ushort pvalue = 0;
//            GTSCardAPI.GT_GetExtIoBit(cardNum, mdl, index, out pvalue);
//            return pvalue == 0;
//        }

//        /// <summary>
//        /// IO输出
//        /// </summary>
//        /// <param name="cardNum">卡号</param>
//        /// <param name="mdl">模块号</param>
//        /// <param name="index">IO输出</param>
//        /// <param name="value">true表示输出，false表示无输出</param>
//        public void MC_WriteDigitalOutput(short cardNum, short mdl, short index, bool value)
//        {
//            if (value)
//            {
//                GTSCardAPI.GT_SetExtIoBit(cardNum, mdl, index, 0);
//            }
//            else
//            {
//                GTSCardAPI.GT_SetExtIoBit(cardNum, mdl, index, 1);
//            }
//        }

//        /// <summary>
//        /// 建立插补坐标系
//        /// </summary>
//        /// <param name="crdnum">坐标系号</param>
//        public void BuildCrd(short cardNum, short crdn, short axis_x, short axis_y, double maxVel, double maxAcc, short evenTime)
//        {
//            GTSCardAPI.TCrdPrm crdPrm;
//            crdPrm.dimension = 2;
//            crdPrm.synVelMax = maxVel;
//            crdPrm.synAccMax = maxAcc;
//            crdPrm.evenTime = evenTime;
//            crdPrm.profile1 = 1;
//            crdPrm.profile2 = 2;
//            crdPrm.profile3 = 0;
//            crdPrm.profile4 = 0;
//            crdPrm.profile5 = 0;
//            crdPrm.profile6 = 0;
//            crdPrm.profile7 = 0;
//            crdPrm.profile8 = 0;
//            crdPrm.setOriginFlag = 1;
//            crdPrm.originPos1 = 0;
//            crdPrm.originPos2 = 0;
//            crdPrm.originPos3 = 0;
//            crdPrm.originPos4 = 0;
//            crdPrm.originPos5 = 0;
//            crdPrm.originPos6 = 0;
//            crdPrm.originPos7 = 0;
//            crdPrm.originPos8 = 0;
//            GTSCardAPI.GT_SetCrdPrm(cardNum, crdn, ref crdPrm);
//            GTSCardAPI.GT_CrdClear(cardNum, crdn, 0);
//            GTSCardAPI.GT_ClrSts(cardNum, 1, 4);
//        }
//        /// <summary>
//        /// 直线插补
//        /// </summary>
//        /// <param name="chabunum"></param>
//        public void LnXY(short cardNum, short crdn, short fifon, int[] data, double vel, double prfacc, double endVel)
//        {
//            short run;
//            int segment;
//            for (int i = 0; i < data.Length; i += 2)
//            {
//                run = GTSCardAPI.GT_LnXY(cardNum, crdn, data[i], data[i + 1], vel, prfacc, endVel, fifon);
//            }
//            run = GTSCardAPI.GT_CrdStart(cardNum, crdn, 0);
//            //while (true)
//            //{
//            //    mc.GT_CrdStatus(cardNum, crdn, out run, out segment, fifon);
//            //    if (run == 0)
//            //    {
//            //        break;
//            //    }
//            //}
//        }
//        /// <summary>
//        /// 以圆心做圆弧插补
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="crdn"></param>
//        /// <param name="fifon"></param>
//        /// <param name="data"></param>
//        /// <param name="xCenter"></param>
//        /// <param name="yCenter"></param>
//        /// <param name="dir"></param>
//        /// <param name="vel"></param>
//        /// <param name="prfacc"></param>
//        /// <param name="endVel"></param>
//        public void ArcXYC(short cardNum, short crdn, short fifon, int[] data, double xCenter, double yCenter, short dir, double vel, double prfacc, double endVel)
//        {
//            short run;
//            int segment;
//            for (int i = 0; i < data.Length; i += 2)
//            {
//                GTSCardAPI.GT_ArcXYC(cardNum, crdn, data[i], data[i + 1], xCenter, yCenter, dir, vel, prfacc, endVel, fifon);
//            }
//            GTSCardAPI.GT_CrdStart(cardNum, crdn, 0);
//            while (true)
//            {
//                GTSCardAPI.GT_CrdStatus(cardNum, crdn, out run, out segment, fifon);
//                if (run == 0)
//                {
//                    break;
//                }
//            }
//        }
//        /// <summary>
//        /// 以半径做圆弧插补
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="crdn"></param>
//        /// <param name="fifon"></param>
//        /// <param name="data"></param>
//        /// <param name="rad"></param>
//        /// <param name="dir"></param>
//        /// <param name="vel"></param>
//        /// <param name="prfacc"></param>
//        /// <param name="endVel"></param>
//        public void ArcXYR(short cardNum, short crdn, short fifon, int[] data, double rad, short dir, double vel, double prfacc, double endVel)
//        {
//            short run;
//            int segment;
//            for (int i = 0; i < data.Length; i += 2)
//            {
//                GTSCardAPI.GT_ArcXYR(cardNum, crdn, data[i], data[i + 1], rad, dir, vel, prfacc, endVel, fifon);
//            }
//            GTSCardAPI.GT_CrdStart(cardNum, crdn, 0);
//            while (true)
//            {
//                GTSCardAPI.GT_CrdStatus(cardNum, crdn, out run, out segment, fifon);
//                if (run == 0)
//                {
//                    break;
//                }
//            }
//        }
//        /// <summary>
//        /// 停止运动
//        /// </summary>
//        /// <param name="cardNum"></param>
//        /// <param name="axisNum">轴号</param>
//        /// <param name="value">停止方式，false表示平滑停止，true表示紧急停止</param>
//        public void Stop(short cardNum, short axisNum, bool value)
//        {
//            switch (value)
//            {
//                case false:
//                    {
//                        GTSCardAPI.GT_Stop(cardNum, 1 << (axisNum - 1), 0);
//                    }
//                    break;
//                case true:
//                    {
//                        GTSCardAPI.GT_Stop(cardNum, 1 << (axisNum - 1), 1 << (axisNum - 1));

//                    }
//                    break;
//            }

//        }

//        /// <summary>
//        /// 是否报警
//        /// bit 0-光栅，bit 1-门开关，bit 2-急停
//        /// 1100 0000 0101
//        /// </summary>
//        /// <returns></returns>
//        public bool IsAlarm()
//        {
//            GTSCardAPI.GT_GetDi(Parameter.cardNum, GTSCardAPI.MC_GPI, out var input);
//            var bRet = 
//                ((input & (1 << Parameter.EXI6)) >> Parameter.EXI6) == 1 ||
//                //((input & (1 << GlueInCommands.EXI1)) >> GlueInCommands.EXI1) == 0 || todo
//                ((input & (1 << Parameter.EXI4)) >> Parameter.EXI4) == 1;
//            //var bRet = isAlarm ||
//            //    ((input & (1 << Parameter.EXI6)) >> Parameter.EXI6) == 1 ||
//            //    //((input & (1 << GlueInCommands.EXI1)) >> GlueInCommands.EXI1) == 0 || todo
//            //    ((input & (1 << Parameter.EXI4)) >> Parameter.EXI4) == 1;

//            return bRet;
//        }
//    }
//}