领胜LDS 键盘AOI检测项目
wells.liu
2020-06-26 cfb34dcd56659252216cd88efbe41868e4ac5227
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
using Bro.Common.Base;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Bro.Device.GTSCard
{
    public class GTSCardDriver : DeviceBase, IMotion
    {
        public List<AxisInfo> GetCurrentAxisInfo(params string[] axisName)
        {
            throw new NotImplementedException();
        }
 
        protected override void Init()
        {
            throw new NotImplementedException();
        }
 
        protected override void Pause()
        {
            throw new NotImplementedException();
        }
 
        protected override void Resume()
        {
            throw new NotImplementedException();
        }
 
        protected override void Start()
        {
            throw new NotImplementedException();
        }
 
        protected override void Stop()
        {
            throw new NotImplementedException();
        }
 
        /// <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 = GTSCardParameter.P2PAcc;
            trapprm.dec = GTSCardParameter.P2PDec;
            trapprm.smoothTime = 1;
            GTSCardAPI.GT_SetTrapPrm(cardNum, axisNum, ref trapprm);
            GTSCardAPI.GT_SetPos(cardNum, axisNum, prfPosition * GTSCardParameter.Dangliang);
            GTSCardAPI.GT_SetVel(cardNum, axisNum, prfVelocity * GTSCardParameter.Dangliang);
            GTSCardAPI.GT_Update(cardNum, 1 << (axisNum - 1));
        }
 
        /// <summary>
        /// Jog运动
        /// </summary>
        /// <param name="cardNum"></param>
        /// <param name="axisNum"></param>
        /// <param name="velocity">规划速度,单位米每秒</param>
        public void Jog(short cardNum, short axisNum, double velocity)
        {
            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, velocity);//设置目标速度
            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="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 = (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>
        /// 停止 某个轴
        /// </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="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>
        /// 停止 全部轴
        /// </summary>
        /// <param name="cardNum"></param>
        /// <param name="value">停止方式,false表示平滑停止,true表示紧急停止</param>
        public void StopAll(short cardNum, bool value)
        {
            for (short i = 1; i <= GTSCardParameter.AxisCount; i++)
            {
                Stop(cardNum, i, value);
            }
        }
 
        /// <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>
        /// 读取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;
        }
 
        static object lockObj = new object();
 
        /// <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 / GTSCardParameter.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
            }
        }
    }
}