Device.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 SCHUNK GmbH & Co. KG
3  * Copyright (c) 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10 
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include "Device.h"
19 #include "RS232Device.h"
20 #ifdef USE_ESD
21 #include "ESDDevice.h"
22 #endif
23 #ifdef USE_PCAN
24 #include "PCanDevice.h"
25 #endif
26 #ifdef USE_SOCKET_CAN
27 #include "SocketCANDevice.h"
28 #endif
29 #if defined (_WIN32)
30  #include "CP5X11Device.h"
31 #endif
32 
33 // ========================================================================== ;
34 // ;
35 // ---- private auxiliary functions ----------------------------------------- ;
36 // ;
37 // ========================================================================== ;
38 
39 // ========================================================================== ;
40 // ;
41 // ---- protected auxiliary functions --------------------------------------- ;
42 // ;
43 // ========================================================================== ;
44 
45 void CDevice::charStateToLongState(unsigned char ucShort, unsigned long* puiState)
46 {
47  *puiState = 0;
48  if(ucShort & 1)
49  *puiState |= STATEID_MOD_ERROR;
50  if(ucShort & 2)
51  *puiState |= STATEID_MOD_SWR;
52  if(ucShort & 4)
53  *puiState |= STATEID_MOD_SW1;
54  if(ucShort & 8)
55  *puiState |= STATEID_MOD_SW2;
56  if(ucShort & 16)
57  *puiState |= STATEID_MOD_MOTION;
58  if(ucShort & 32)
59  *puiState |= STATEID_MOD_RAMP_END;
60  if(ucShort & 64)
61  *puiState |= STATEID_MOD_INPROGRESS;
62  if(ucShort & 128)
63  *puiState |= STATEID_MOD_FULLBUFFER;
64 }
65 
66 // ========================================================================== ;
67 // ;
68 // ---- constructors / destructor ------------------------------------------- ;
69 // ;
70 // ========================================================================== ;
71 
72 CDevice::CDevice() : m_bInitFlag(false),
73  m_iBaudRate(250),
74  m_iModuleCount(0),
75  m_iModuleCountMax(31),
76  m_clTimer(util_REAL_TIME),
77  m_iErrorState(0)
78 {
79  m_acName[0] = '\0';
80  m_acInitString[0] = '\0';
81  strncpy(m_acRevision,"$Revision: 1.45 $",20);
82 }
83 
84 CDevice::CDevice(const CDevice& rclDevice)
85 {
86  error(-1, "Sorry constructor is not implemented");
87 }
88 
89 CDevice::~CDevice()
90 {
91 }
92 
93 // ========================================================================== ;
94 // ;
95 // ---- operators ----------------------------------------------------------- ;
96 // ;
97 // ========================================================================== ;
98 
99 CDevice& CDevice::operator=(const CDevice& rclDevice)
100 {
101  error(-1, "Sorry operator= is not implemented");
102  return *this;
103 }
104 
105 // ========================================================================== ;
106 // ;
107 // ---- query functions ----------------------------------------------------- ;
108 // ;
109 // ========================================================================== ;
110 
111 bool CDevice::getInitFlag()
112 {
113  return m_bInitFlag;
114 }
115 
116 const char* CDevice::getRevision()
117 {
118  return m_acRevision;
119 }
120 
121 const char* CDevice::getName()
122 {
123  return m_acName;
124 }
125 
126 const char* CDevice::getInitString()
127 {
128  return m_acInitString;
129 }
130 
131 int CDevice::getBaudRate()
132 {
133  return m_iBaudRate;
134 }
135 
136 int CDevice::getModuleCount()
137 {
138  m_iErrorState = 0;
139  if(m_bInitFlag == false)
140  {
141  warning("device not initialized");
142  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
143  return m_iErrorState;
144  }
145  return m_iModuleCount;
146 }
147 
148 int CDevice::getModuleIdMap(std::vector<int>& raiModuleId)
149 {
150  m_iErrorState = 0;
151  if(m_bInitFlag == false)
152  {
153  warning("device not initialized");
154  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
155  return m_iErrorState;
156  }
157  raiModuleId.resize(m_iModuleCount);
158  for(int i=0; i < m_iModuleCount; i++)
159  raiModuleId[i] = m_aiModuleId[i];
160 
161  return m_iModuleCount;
162 }
163 
164 int CDevice::getModuleState(int iModuleId, unsigned long* puiState)
165 {
166  m_iErrorState = 0;
167  if(m_bInitFlag == false)
168  {
169  warning("device not initialized");
170  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
171  return m_iErrorState;
172  }
173  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
174  {
175  warning("wrong module id");
176  m_iErrorState = ERRID_DEV_WRONGMODULEID;
177  return m_iErrorState;
178  }
179  m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_ACT_STATE, puiState);
180 
181  return m_iErrorState;
182 }
183 
184 int CDevice::getModuleType(int iModuleId, unsigned char* pucValue)
185 {
186  m_iErrorState = 0;
187  if(m_bInitFlag == false)
188  {
189  warning("device not initialized");
190  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
191  return m_iErrorState;
192  }
193  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
194  {
195  warning("wrong module id");
196  m_iErrorState = ERRID_DEV_WRONGMODULEID;
197  return m_iErrorState;
198  }
199  unsigned long uiConfig = 0;
200  m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_DEF_CONFIG, &uiConfig);
201  if(m_iErrorState == 0)
202  {
203  if (uiConfig & CONFIGID_MOD_LINEAR)
204  *pucValue = TYPEID_MOD_LINEAR;
205  else
206  *pucValue = TYPEID_MOD_ROTARY;
207  }
208  return m_iErrorState;
209 }
210 
211 int CDevice::getModuleVersion(int iModuleId, unsigned short* puiValue)
212 {
213  m_iErrorState = 0;
214  if(m_bInitFlag == false)
215  {
216  warning("device not initialized");
217  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
218  return m_iErrorState;
219  }
220  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
221  {
222  warning("wrong module id");
223  m_iErrorState = ERRID_DEV_WRONGMODULEID;
224  return m_iErrorState;
225  }
226  m_iErrorState = readUnsignedShort(iModuleId, CMDID_GETPARAM, PARID_DEF_VERSION, puiValue);
227 
228  return m_iErrorState;
229 }
230 
231 int CDevice::getModuleSerialNo(int iModuleId, unsigned long* puiValue)
232 {
233  m_iErrorState = 0;
234  if(m_bInitFlag == false)
235  {
236  warning("device not initialized");
237  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
238  return m_iErrorState;
239  }
240  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
241  {
242  warning("wrong module id");
243  m_iErrorState = ERRID_DEV_WRONGMODULEID;
244  return m_iErrorState;
245  }
246  m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_DEF_SERIALNO, puiValue);
247  debug(0,"error state: 0x%04x",m_iErrorState);
248 
249  return m_iErrorState;
250 }
251 
252 int CDevice::getDefConfig(int iModuleId, unsigned long* puiValue)
253 {
254  m_iErrorState = 0;
255  if(m_bInitFlag == false)
256  {
257  warning("device not initialized");
258  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
259  return m_iErrorState;
260  }
261  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
262  {
263  warning("wrong module id");
264  m_iErrorState = ERRID_DEV_WRONGMODULEID;
265  return m_iErrorState;
266  }
267  m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_DEF_CONFIG, puiValue);
268 
269  return m_iErrorState;
270 }
271 
272 int CDevice::getDefSetup(int iModuleId, unsigned long* puiValue)
273 {
274  m_iErrorState = 0;
275  if(m_bInitFlag == false)
276  {
277  warning("device not initialized");
278  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
279  return m_iErrorState;
280  }
281  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
282  {
283  warning("wrong module id");
284  m_iErrorState = ERRID_DEV_WRONGMODULEID;
285  return m_iErrorState;
286  }
287  for(int i = 0; i < m_iModuleCount; i++)
288  {
289  if(m_aiModuleId[i] == iModuleId)
290  {
291  if(m_auiModuleVersion[i] < 0x3500)
292  {
293  warning("module version does not support function");
294  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
295  return m_iErrorState;
296  }
297  }
298  }
299  m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_DEF_SETUP, puiValue);
300 
301  return m_iErrorState;
302 }
303 
304 int CDevice::getDefBaudRate(int iModuleId, unsigned char* pucValue)
305 {
306  m_iErrorState = 0;
307  if(m_bInitFlag == false)
308  {
309  warning("device not initialized");
310  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
311  return m_iErrorState;
312  }
313  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
314  {
315  warning("wrong module id");
316  m_iErrorState = ERRID_DEV_WRONGMODULEID;
317  return m_iErrorState;
318  }
319  m_iErrorState = readUnsignedChar(iModuleId, CMDID_GETPARAM, PARID_DEF_CANBAUDRATE, pucValue);
320 
321  return m_iErrorState;
322 }
323 
324 int CDevice::getDefCANBaudRate(int iModuleId, unsigned char* pucValue)
325 {
326  m_iErrorState = 0;
327  if(m_bInitFlag == false)
328  {
329  warning("device not initialized");
330  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
331  return m_iErrorState;
332  }
333  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
334  {
335  warning("wrong module id");
336  m_iErrorState = ERRID_DEV_WRONGMODULEID;
337  return m_iErrorState;
338  }
339  m_iErrorState = readUnsignedChar(iModuleId, CMDID_GETPARAM, PARID_DEF_CANBAUDRATE, pucValue);
340 
341  return m_iErrorState;
342 }
343 
344 int CDevice::getDefRSBaudRate(int iModuleId, unsigned char* pucValue)
345 {
346  m_iErrorState = 0;
347  if(m_bInitFlag == false)
348  {
349  warning("device not initialized");
350  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
351  return m_iErrorState;
352  }
353  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
354  {
355  warning("wrong module id");
356  m_iErrorState = ERRID_DEV_WRONGMODULEID;
357  return m_iErrorState;
358  }
359  m_iErrorState = readUnsignedChar(iModuleId, CMDID_GETPARAM, PARID_DEF_RSBAUDRATE, pucValue);
360 
361  return m_iErrorState;
362 }
363 
364 int CDevice::getDefBurnCount(int iModuleId, unsigned char* pucValue)
365 {
366  m_iErrorState = 0;
367  if(m_bInitFlag == false)
368  {
369  warning("device not initialized");
370  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
371  return m_iErrorState;
372  }
373  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
374  {
375  warning("wrong module id");
376  m_iErrorState = ERRID_DEV_WRONGMODULEID;
377  return m_iErrorState;
378  }
379  m_iErrorState = readUnsignedChar(iModuleId, CMDID_GETPARAM, PARID_DEF_BURNCOUNT, pucValue);
380 
381  return m_iErrorState;
382 }
383 
384 int CDevice::getDefGearRatio(int iModuleId, float* pfValue)
385 {
386  m_iErrorState = 0;
387  if(m_bInitFlag == false)
388  {
389  warning("device not initialized");
390  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
391  return m_iErrorState;
392  }
393  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
394  {
395  warning("wrong module id");
396  m_iErrorState = ERRID_DEV_WRONGMODULEID;
397  return m_iErrorState;
398  }
399  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FGEARRATIO, pfValue);
400 
401  return m_iErrorState;
402 }
403 
404 int CDevice::getDefLinearRatio(int iModuleId, float* pfValue)
405 {
406  m_iErrorState = 0;
407  if(m_bInitFlag == false)
408  {
409  warning("device not initialized");
410  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
411  return m_iErrorState;
412  }
413  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
414  {
415  warning("wrong module id");
416  m_iErrorState = ERRID_DEV_WRONGMODULEID;
417  return m_iErrorState;
418  }
419  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FLINEARRATIO, pfValue);
420 
421  return m_iErrorState;
422 }
423 
424 int CDevice::getDefCurOffset(int iModuleId, float* pfValue)
425 {
426  m_iErrorState = 0;
427  if(m_bInitFlag == false)
428  {
429  warning("device not initialized");
430  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
431  return m_iErrorState;
432  }
433  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
434  {
435  warning("wrong module id");
436  m_iErrorState = ERRID_DEV_WRONGMODULEID;
437  return m_iErrorState;
438  }
439  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FCUROFFSET, pfValue);
440 
441  return m_iErrorState;
442 }
443 
444 int CDevice::getDefCurRatio(int iModuleId, float* pfValue)
445 {
446  m_iErrorState = 0;
447  if(m_bInitFlag == false)
448  {
449  warning("device not initialized");
450  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
451  return m_iErrorState;
452  }
453  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
454  {
455  warning("wrong module id");
456  m_iErrorState = ERRID_DEV_WRONGMODULEID;
457  return m_iErrorState;
458  }
459  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FCURRATIO, pfValue);
460 
461  return m_iErrorState;
462 }
463 
464 int CDevice::getDefBrakeTimeOut(int iModuleId, unsigned short* puiValue)
465 {
466  m_iErrorState = 0;
467  if(m_bInitFlag == false)
468  {
469  warning("device not initialized");
470  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
471  return m_iErrorState;
472  }
473  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
474  {
475  warning("wrong module id");
476  m_iErrorState = ERRID_DEV_WRONGMODULEID;
477  return m_iErrorState;
478  }
479  m_iErrorState = readUnsignedShort(iModuleId, CMDID_GETPARAM, PARID_DEF_BRAKETIMEOUT, puiValue);
480 
481  return m_iErrorState;
482 }
483 
484 int CDevice::getDefIncPerTurn(int iModuleId, unsigned long* puiValue)
485 {
486  m_iErrorState = 0;
487  if(m_bInitFlag == false)
488  {
489  warning("device not initialized");
490  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
491  return m_iErrorState;
492  }
493  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
494  {
495  warning("wrong module id");
496  m_iErrorState = ERRID_DEV_WRONGMODULEID;
497  return m_iErrorState;
498  }
499  m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_DEF_INCPERTURN, puiValue);
500 
501  return m_iErrorState;
502 }
503 
504 int CDevice::getDefDioData(int iModuleId, unsigned long* puiValue)
505 {
506  m_iErrorState = 0;
507  if(m_bInitFlag == false)
508  {
509  warning("device not initialized");
510  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
511  return m_iErrorState;
512  }
513  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
514  {
515  warning("wrong module id");
516  m_iErrorState = ERRID_DEV_WRONGMODULEID;
517  return m_iErrorState;
518  }
519 // m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_DEF_DIODATA, puiValue);
520 
521  *puiValue = 0;
522  return m_iErrorState;
523 }
524 
525 int CDevice::getDefA0(int iModuleId, short* piValue)
526 {
527  m_iErrorState = 0;
528  if(m_bInitFlag == false)
529  {
530  warning("device not initialized");
531  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
532  return m_iErrorState;
533  }
534  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
535  {
536  warning("wrong module id");
537  m_iErrorState = ERRID_DEV_WRONGMODULEID;
538  return m_iErrorState;
539  }
540  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_DEF_A0, piValue);
541 
542  return m_iErrorState;
543 }
544 
545 int CDevice::getDefC0(int iModuleId, short* piValue)
546 {
547  m_iErrorState = 0;
548  if(m_bInitFlag == false)
549  {
550  warning("device not initialized");
551  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
552  return m_iErrorState;
553  }
554  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
555  {
556  warning("wrong module id");
557  m_iErrorState = ERRID_DEV_WRONGMODULEID;
558  return m_iErrorState;
559  }
560  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_DEF_C0, piValue);
561 
562  return m_iErrorState;
563 }
564 
565 int CDevice::getDefDamp(int iModuleId, short* piValue)
566 {
567  m_iErrorState = 0;
568  if(m_bInitFlag == false)
569  {
570  warning("device not initialized");
571  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
572  return m_iErrorState;
573  }
574  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
575  {
576  warning("wrong module id");
577  m_iErrorState = ERRID_DEV_WRONGMODULEID;
578  return m_iErrorState;
579  }
580  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_DEF_DAMP, piValue);
581 
582  return m_iErrorState;
583 }
584 
585 int CDevice::getDefHomeOffset(int iModuleId, float* pfValue)
586 {
587  m_iErrorState = 0;
588  if(m_bInitFlag == false)
589  {
590  warning("device not initialized");
591  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
592  return m_iErrorState;
593  }
594  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
595  {
596  warning("wrong module id");
597  m_iErrorState = ERRID_DEV_WRONGMODULEID;
598  return m_iErrorState;
599  }
600  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FHOMEOFFSET, pfValue);
601 
602  return m_iErrorState;
603 }
604 
605 int CDevice::getDefHomeVel(int iModuleId, float* pfValue)
606 {
607  m_iErrorState = 0;
608  if(m_bInitFlag == false)
609  {
610  warning("device not initialized");
611  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
612  return m_iErrorState;
613  }
614  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
615  {
616  warning("wrong module id");
617  m_iErrorState = ERRID_DEV_WRONGMODULEID;
618  return m_iErrorState;
619  }
620  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FHOMEVEL, pfValue);
621 
622  return m_iErrorState;
623 }
624 
625 int CDevice::getDefMinPos(int iModuleId, float* pfValue)
626 {
627  m_iErrorState = 0;
628  if(m_bInitFlag == false)
629  {
630  warning("device not initialized");
631  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
632  return m_iErrorState;
633  }
634  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
635  {
636  warning("wrong module id");
637  m_iErrorState = ERRID_DEV_WRONGMODULEID;
638  return m_iErrorState;
639  }
640  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FMINPOS, pfValue);
641 
642  return m_iErrorState;
643 }
644 
645 int CDevice::getDefMaxPos(int iModuleId, float* pfValue)
646 {
647  m_iErrorState = 0;
648  if(m_bInitFlag == false)
649  {
650  warning("device not initialized");
651  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
652  return m_iErrorState;
653  }
654  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
655  {
656  warning("wrong module id");
657  m_iErrorState = ERRID_DEV_WRONGMODULEID;
658  return m_iErrorState;
659  }
660  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FMAXPOS, pfValue);
661 
662  return m_iErrorState;
663 }
664 
665 int CDevice::getDefMaxVel(int iModuleId, float* pfValue)
666 {
667  m_iErrorState = 0;
668  if(m_bInitFlag == false)
669  {
670  warning("device not initialized");
671  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
672  return m_iErrorState;
673  }
674  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
675  {
676  warning("wrong module id");
677  m_iErrorState = ERRID_DEV_WRONGMODULEID;
678  return m_iErrorState;
679  }
680  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FMAXVEL, pfValue);
681 
682  return m_iErrorState;
683 }
684 
685 int CDevice::getDefMaxAcc(int iModuleId, float* pfValue)
686 {
687  m_iErrorState = 0;
688  if(m_bInitFlag == false)
689  {
690  warning("device not initialized");
691  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
692  return m_iErrorState;
693  }
694  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
695  {
696  warning("wrong module id");
697  m_iErrorState = ERRID_DEV_WRONGMODULEID;
698  return m_iErrorState;
699  }
700  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FMAXACC, pfValue);
701 
702  return m_iErrorState;
703 }
704 
705 int CDevice::getDefMaxCur(int iModuleId, float* pfValue)
706 {
707  m_iErrorState = 0;
708  if(m_bInitFlag == false)
709  {
710  warning("device not initialized");
711  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
712  return m_iErrorState;
713  }
714  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
715  {
716  warning("wrong module id");
717  m_iErrorState = ERRID_DEV_WRONGMODULEID;
718  return m_iErrorState;
719  }
720  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FMAXCUR, pfValue);
721 
722  return m_iErrorState;
723 }
724 
725 int CDevice::getDefMaxDeltaPos(int iModuleId, float* pfValue)
726 {
727  m_iErrorState = 0;
728  if(m_bInitFlag == false)
729  {
730  warning("device not initialized");
731  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
732  return m_iErrorState;
733  }
734  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
735  {
736  warning("wrong module id");
737  m_iErrorState = ERRID_DEV_WRONGMODULEID;
738  return m_iErrorState;
739  }
740  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_DEF_FMAXDELTAPOS, pfValue);
741 
742  return m_iErrorState;
743 }
744 
745 int CDevice::getConfig(int iModuleId, unsigned long* puiValue)
746 {
747  m_iErrorState = 0;
748  if(m_bInitFlag == false)
749  {
750  warning("device not initialized");
751  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
752  return m_iErrorState;
753  }
754  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
755  {
756  warning("wrong module id");
757  m_iErrorState = ERRID_DEV_WRONGMODULEID;
758  return m_iErrorState;
759  }
760  m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_ACT_CONFIG, puiValue);
761 
762  return m_iErrorState;
763 }
764 
765 int CDevice::getHomeOffset(int iModuleId, float* pfValue)
766 {
767  m_iErrorState = 0;
768  if(m_bInitFlag == false)
769  {
770  warning("device not initialized");
771  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
772  return m_iErrorState;
773  }
774  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
775  {
776  warning("wrong module id");
777  m_iErrorState = ERRID_DEV_WRONGMODULEID;
778  return m_iErrorState;
779  }
780  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FHOMEOFFSET, pfValue);
781 
782  return m_iErrorState;
783 }
784 
785 int CDevice::getHomeOffsetInc(int iModuleId, long* piValue)
786 {
787  m_iErrorState = 0;
788  if(m_bInitFlag == false)
789  {
790  warning("device not initialized");
791  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
792  return m_iErrorState;
793  }
794  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
795  {
796  warning("wrong module id");
797  m_iErrorState = ERRID_DEV_WRONGMODULEID;
798  return m_iErrorState;
799  }
800  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IHOMEOFFSET, piValue);
801 
802  return m_iErrorState;
803 }
804 
805 int CDevice::getIncRatio(int iModuleId, float* pfValue)
806 {
807  m_iErrorState = 0;
808  if(m_bInitFlag == false)
809  {
810  warning("device not initialized");
811  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
812  return m_iErrorState;
813  }
814  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
815  {
816  warning("wrong module id");
817  m_iErrorState = ERRID_DEV_WRONGMODULEID;
818  return m_iErrorState;
819  }
820  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FINCRATIO, pfValue);
821 
822  return m_iErrorState;
823 }
824 
825 int CDevice::getDioData(int iModuleId, unsigned long* puiValue)
826 {
827  m_iErrorState = 0;
828  if(m_bInitFlag == false)
829  {
830  warning("device not initialized");
831  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
832  return m_iErrorState;
833  }
834  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
835  {
836  warning("wrong module id");
837  m_iErrorState = ERRID_DEV_WRONGMODULEID;
838  return m_iErrorState;
839  }
840  m_iErrorState = readUnsignedLong(iModuleId, CMDID_GETPARAM, PARID_ACT_DIODATA, puiValue);
841 
842  return m_iErrorState;
843 }
844 
845 int CDevice::getA0(int iModuleId, short* piValue)
846 {
847  m_iErrorState = 0;
848  if(m_bInitFlag == false)
849  {
850  warning("device not initialized");
851  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
852  return m_iErrorState;
853  }
854  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
855  {
856  warning("wrong module id");
857  m_iErrorState = ERRID_DEV_WRONGMODULEID;
858  return m_iErrorState;
859  }
860  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_A0, piValue);
861 
862  return m_iErrorState;
863 }
864 
865 int CDevice::getC0(int iModuleId, short* piValue)
866 {
867  m_iErrorState = 0;
868  if(m_bInitFlag == false)
869  {
870  warning("device not initialized");
871  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
872  return m_iErrorState;
873  }
874  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
875  {
876  warning("wrong module id");
877  m_iErrorState = ERRID_DEV_WRONGMODULEID;
878  return m_iErrorState;
879  }
880  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_C0, piValue);
881 
882  return m_iErrorState;
883 }
884 
885 int CDevice::getDamp(int iModuleId, short* piValue)
886 {
887  m_iErrorState = 0;
888  if(m_bInitFlag == false)
889  {
890  warning("device not initialized");
891  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
892  return m_iErrorState;
893  }
894  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
895  {
896  warning("wrong module id");
897  m_iErrorState = ERRID_DEV_WRONGMODULEID;
898  return m_iErrorState;
899  }
900  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_DAMP, piValue);
901 
902  return m_iErrorState;
903 }
904 
905 int CDevice::getPos(int iModuleId, float* pfPos)
906 {
907  m_iErrorState = 0;
908  if(m_bInitFlag == false)
909  {
910  warning("device not initialized");
911  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
912  return m_iErrorState;
913  }
914  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
915  {
916  warning("wrong module id");
917  m_iErrorState = ERRID_DEV_WRONGMODULEID;
918  return m_iErrorState;
919  }
920  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FPOS, pfPos);
921 
922  return m_iErrorState;
923 }
924 
925 int CDevice::getVel(int iModuleId, float* pfVel)
926 {
927  m_iErrorState = 0;
928  if(m_bInitFlag == false)
929  {
930  warning("device not initialized");
931  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
932  return m_iErrorState;
933  }
934  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
935  {
936  warning("wrong module id");
937  m_iErrorState = ERRID_DEV_WRONGMODULEID;
938  return m_iErrorState;
939  }
940  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FVEL, pfVel);
941 
942  return m_iErrorState;
943 }
944 
945 int CDevice::getCur(int iModuleId, float* pfCur)
946 {
947  m_iErrorState = 0;
948  if(m_bInitFlag == false)
949  {
950  warning("device not initialized");
951  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
952  return m_iErrorState;
953  }
954  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
955  {
956  warning("wrong module id");
957  m_iErrorState = ERRID_DEV_WRONGMODULEID;
958  return m_iErrorState;
959  }
960  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FCUR, pfCur);
961 
962  return m_iErrorState;
963 }
964 
965 int CDevice::getMinPos(int iModuleId, float* pfValue)
966 {
967  m_iErrorState = 0;
968  if(m_bInitFlag == false)
969  {
970  warning("device not initialized");
971  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
972  return m_iErrorState;
973  }
974  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
975  {
976  warning("wrong module id");
977  m_iErrorState = ERRID_DEV_WRONGMODULEID;
978  return m_iErrorState;
979  }
980  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FMINPOS, pfValue);
981 
982  return m_iErrorState;
983 }
984 
985 int CDevice::getMaxPos(int iModuleId, float* pfValue)
986 {
987  m_iErrorState = 0;
988  if(m_bInitFlag == false)
989  {
990  warning("device not initialized");
991  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
992  return m_iErrorState;
993  }
994  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
995  {
996  warning("wrong module id");
997  m_iErrorState = ERRID_DEV_WRONGMODULEID;
998  return m_iErrorState;
999  }
1000  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FMAXPOS, pfValue);
1001 
1002  return m_iErrorState;
1003 }
1004 
1005 
1006 int CDevice::getMaxVel(int iModuleId, float* pfValue)
1007 {
1008  m_iErrorState = 0;
1009  if(m_bInitFlag == false)
1010  {
1011  warning("device not initialized");
1012  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1013  return m_iErrorState;
1014  }
1015  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1016  {
1017  warning("wrong module id");
1018  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1019  return m_iErrorState;
1020  }
1021  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FMAXVEL, pfValue);
1022 
1023  return m_iErrorState;
1024 }
1025 
1026 int CDevice::getMaxAcc(int iModuleId, float* pfValue)
1027 {
1028  m_iErrorState = 0;
1029  if(m_bInitFlag == false)
1030  {
1031  warning("device not initialized");
1032  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1033  return m_iErrorState;
1034  }
1035  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1036  {
1037  warning("wrong module id");
1038  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1039  return m_iErrorState;
1040  }
1041  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FMAXACC, pfValue);
1042 
1043  return m_iErrorState;
1044 }
1045 
1046 int CDevice::getMaxCur(int iModuleId, float* pfValue)
1047 {
1048  m_iErrorState = 0;
1049  if(m_bInitFlag == false)
1050  {
1051  warning("device not initialized");
1052  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1053  return m_iErrorState;
1054  }
1055  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1056  {
1057  warning("wrong module id");
1058  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1059  return m_iErrorState;
1060  }
1061  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FMAXCUR, pfValue);
1062 
1063  return m_iErrorState;
1064 }
1065 
1066 int CDevice::getDeltaPos(int iModuleId, float* pfValue)
1067 {
1068  m_iErrorState = 0;
1069  if(m_bInitFlag == false)
1070  {
1071  warning("device not initialized");
1072  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1073  return m_iErrorState;
1074  }
1075  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1076  {
1077  warning("wrong module id");
1078  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1079  return m_iErrorState;
1080  }
1081  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FDELTAPOS, pfValue);
1082 
1083  return m_iErrorState;
1084 }
1085 
1086 int CDevice::getMaxDeltaPos(int iModuleId, float* pfValue)
1087 {
1088  m_iErrorState = 0;
1089  if(m_bInitFlag == false)
1090  {
1091  warning("device not initialized");
1092  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1093  return m_iErrorState;
1094  }
1095  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1096  {
1097  warning("wrong module id");
1098  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1099  return m_iErrorState;
1100  }
1101  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FMAXDELTAPOS, pfValue);
1102 
1103  return m_iErrorState;
1104 }
1105 
1106 int CDevice::getSavePos(int iModuleId, float* pfValue)
1107 {
1108  m_iErrorState = 0;
1109  if(m_bInitFlag == false)
1110  {
1111  warning("device not initialized");
1112  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1113  return m_iErrorState;
1114  }
1115  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1116  {
1117  warning("wrong module id");
1118  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1119  return m_iErrorState;
1120  }
1121  for(int i = 0; i < m_iModuleCount; i++)
1122  {
1123  if(m_aiModuleId[i] == iModuleId)
1124  {
1125  if(m_auiModuleVersion[i] < 0x2518 || (m_auiModuleVersion[i] >= 0x3500 && m_auiModuleVersion[i] < 0x3518))
1126  {
1127  warning("module version does not support function");
1128  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1129  return m_iErrorState;
1130  }
1131  }
1132  }
1133  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FSAVEPOS, pfValue);
1134 
1135  return m_iErrorState;
1136 }
1137 
1138 int CDevice::getIPolVel(int iModuleId, float* pfVel)
1139 {
1140  m_iErrorState = 0;
1141  if(m_bInitFlag == false)
1142  {
1143  warning("device not initialized");
1144  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1145  return m_iErrorState;
1146  }
1147  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1148  {
1149  warning("wrong module id");
1150  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1151  return m_iErrorState;
1152  }
1153  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FIPOLVEL, pfVel);
1154 
1155  return m_iErrorState;
1156 }
1157 
1158 int CDevice::getPosCountInc(int iModuleId, long* piValue)
1159 {
1160  m_iErrorState = 0;
1161  if(m_bInitFlag == false)
1162  {
1163  warning("device not initialized");
1164  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1165  return m_iErrorState;
1166  }
1167  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1168  {
1169  warning("wrong module id");
1170  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1171  return m_iErrorState;
1172  }
1173  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IPOSCOUNT, piValue);
1174 
1175  return m_iErrorState;
1176 }
1177 
1178 int CDevice::getPosInc(int iModuleId, long* piValue)
1179 {
1180  m_iErrorState = 0;
1181  if(m_bInitFlag == false)
1182  {
1183  warning("device not initialized");
1184  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1185  return m_iErrorState;
1186  }
1187  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1188  {
1189  warning("wrong module id");
1190  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1191  return m_iErrorState;
1192  }
1193  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IPOS, piValue);
1194 
1195  return m_iErrorState;
1196 }
1197 
1198 int CDevice::getVelInc(int iModuleId, long* piValue)
1199 {
1200  m_iErrorState = 0;
1201  if(m_bInitFlag == false)
1202  {
1203  warning("device not initialized");
1204  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1205  return m_iErrorState;
1206  }
1207  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1208  {
1209  warning("wrong module id");
1210  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1211  return m_iErrorState;
1212  }
1213  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IVEL, piValue);
1214 
1215  return m_iErrorState;
1216 }
1217 
1218 int CDevice::getCurInc(int iModuleId, short* piValue)
1219 {
1220  m_iErrorState = 0;
1221  if(m_bInitFlag == false)
1222  {
1223  warning("device not initialized");
1224  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1225  return m_iErrorState;
1226  }
1227  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1228  {
1229  warning("wrong module id");
1230  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1231  return m_iErrorState;
1232  }
1233  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_ICUR, piValue);
1234 
1235  return m_iErrorState;
1236 }
1237 
1238 int CDevice::getMinPosInc(int iModuleId, long* piValue)
1239 {
1240  m_iErrorState = 0;
1241  if(m_bInitFlag == false)
1242  {
1243  warning("device not initialized");
1244  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1245  return m_iErrorState;
1246  }
1247  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1248  {
1249  warning("wrong module id");
1250  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1251  return m_iErrorState;
1252  }
1253  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IMINPOS, piValue);
1254 
1255  return m_iErrorState;
1256 }
1257 
1258 int CDevice::getMaxPosInc(int iModuleId, long* piValue)
1259 {
1260  m_iErrorState = 0;
1261  if(m_bInitFlag == false)
1262  {
1263  warning("device not initialized");
1264  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1265  return m_iErrorState;
1266  }
1267  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1268  {
1269  warning("wrong module id");
1270  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1271  return m_iErrorState;
1272  }
1273  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IMAXPOS, piValue);
1274 
1275  return m_iErrorState;
1276 }
1277 
1278 int CDevice::getMaxVelInc(int iModuleId, long* piValue)
1279 {
1280  m_iErrorState = 0;
1281  if(m_bInitFlag == false)
1282  {
1283  warning("device not initialized");
1284  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1285  return m_iErrorState;
1286  }
1287  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1288  {
1289  warning("wrong module id");
1290  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1291  return m_iErrorState;
1292  }
1293  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IMAXVEL, piValue);
1294 
1295  return m_iErrorState;
1296 }
1297 
1298 int CDevice::getMaxAccInc(int iModuleId, long* piValue)
1299 {
1300  m_iErrorState = 0;
1301  if(m_bInitFlag == false)
1302  {
1303  warning("device not initialized");
1304  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1305  return m_iErrorState;
1306  }
1307  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1308  {
1309  warning("wrong module id");
1310  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1311  return m_iErrorState;
1312  }
1313  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IMAXACC, piValue);
1314 
1315  return m_iErrorState;
1316 }
1317 
1318 int CDevice::getDeltaPosInc(int iModuleId, long* piValue)
1319 {
1320  m_iErrorState = 0;
1321  if(m_bInitFlag == false)
1322  {
1323  warning("device not initialized");
1324  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1325  return m_iErrorState;
1326  }
1327  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1328  {
1329  warning("wrong module id");
1330  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1331  return m_iErrorState;
1332  }
1333  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IDELTAPOS, piValue);
1334 
1335  return m_iErrorState;
1336 }
1337 
1338 int CDevice::getMaxDeltaPosInc(int iModuleId, long* piValue)
1339 {
1340  m_iErrorState = 0;
1341  if(m_bInitFlag == false)
1342  {
1343  warning("device not initialized");
1344  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1345  return m_iErrorState;
1346  }
1347  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1348  {
1349  warning("wrong module id");
1350  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1351  return m_iErrorState;
1352  }
1353  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IMAXDELTAPOS, piValue);
1354 
1355  return m_iErrorState;
1356 }
1357 
1358 int CDevice::getStateDioPos(int iModuleId, unsigned long* puiState, unsigned char* pucDio, float* pfPos)
1359 {
1360  unsigned char ucState;
1361  m_iErrorState = 0;
1362  if(m_bInitFlag == false)
1363  {
1364  warning("device not initialized");
1365  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1366  return m_iErrorState;
1367  }
1368  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1369  {
1370  warning("wrong module id");
1371  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1372  return m_iErrorState;
1373  }
1374  for(int i = 0; i < m_iModuleCount; i++)
1375  {
1376  if(m_aiModuleId[i] == iModuleId)
1377  {
1378  if(m_auiModuleVersion[i] < 0x2518 || (m_auiModuleVersion[i] >= 0x3500 && m_auiModuleVersion[i] < 0x3518))
1379  {
1380  warning("module version does not support function");
1381  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1382  return m_iErrorState;
1383  }
1384  }
1385  }
1386  m_iErrorState = readFloatUnsignedChars(iModuleId, CMDID_GETPARAM, PARID_ACT_FPOSSTATEDIO, pfPos, &ucState, pucDio);
1387  if(m_iErrorState == 0)
1388  charStateToLongState(ucState, puiState);
1389  return m_iErrorState;
1390 }
1391 
1392 int CDevice::getHomeVel(int iModuleId, float* pfVel)
1393 {
1394  m_iErrorState = 0;
1395  if(m_bInitFlag == false)
1396  {
1397  warning("device not initialized");
1398  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1399  return m_iErrorState;
1400  }
1401  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1402  {
1403  warning("wrong module id");
1404  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1405  return m_iErrorState;
1406  }
1407  for(int i = 0; i < m_iModuleCount; i++)
1408  {
1409  if(m_aiModuleId[i] == iModuleId)
1410  {
1411  if(m_auiModuleVersion[i] < 0x2518 || (m_auiModuleVersion[i] >= 0x3500 && m_auiModuleVersion[i] < 0x3518))
1412  {
1413  warning("module version does not support function");
1414  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1415  return m_iErrorState;
1416  }
1417  }
1418  }
1419  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FHOMEVEL, pfVel);
1420 
1421  return m_iErrorState;
1422 }
1423 
1424 int CDevice::getHomeVelInc(int iModuleId, long* piValue)
1425 {
1426  m_iErrorState = 0;
1427  if(m_bInitFlag == false)
1428  {
1429  warning("device not initialized");
1430  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1431  return m_iErrorState;
1432  }
1433  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1434  {
1435  warning("wrong module id");
1436  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1437  return m_iErrorState;
1438  }
1439  for(int i = 0; i < m_iModuleCount; i++)
1440  {
1441  if(m_aiModuleId[i] == iModuleId)
1442  {
1443  if(m_auiModuleVersion[i] < 0x2518 || (m_auiModuleVersion[i] >= 0x3500 && m_auiModuleVersion[i] < 0x3518))
1444  {
1445  warning("module version does not support function");
1446  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1447  return m_iErrorState;
1448  }
1449  }
1450  }
1451  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_IHOMEVEL, piValue);
1452 
1453  return m_iErrorState;
1454 }
1455 
1456 int CDevice::getSyncTime(int iModuleId, short* piValue)
1457 {
1458  m_iErrorState = 0;
1459  if(m_bInitFlag == false)
1460  {
1461  warning("device not initialized");
1462  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1463  return m_iErrorState;
1464  }
1465  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1466  {
1467  warning("wrong module id");
1468  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1469  return m_iErrorState;
1470  }
1471  for(int i = 0; i < m_iModuleCount; i++)
1472  {
1473  if(m_aiModuleId[i] == iModuleId)
1474  {
1475  if(m_auiModuleVersion[i] < 0x3602)
1476  {
1477  warning("module version does not support function");
1478  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1479  return m_iErrorState;
1480  }
1481  }
1482  }
1483  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_SYNCTIME, piValue);
1484 
1485  return m_iErrorState;
1486 }
1487 
1488 int CDevice::getRawMotorCurrent(int iModuleId, short* piValue)
1489 {
1490  m_iErrorState = 0;
1491  if(m_bInitFlag == false)
1492  {
1493  warning("device not initialized");
1494  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1495  return m_iErrorState;
1496  }
1497  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1498  {
1499  warning("wrong module id");
1500  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1501  return m_iErrorState;
1502  }
1503  for(int i = 0; i < m_iModuleCount; i++)
1504  {
1505  if(m_aiModuleId[i] == iModuleId)
1506  {
1507  if(m_auiModuleVersion[i] < 0x3602)
1508  {
1509  warning("module version does not support function");
1510  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1511  return m_iErrorState;
1512  }
1513  }
1514  }
1515  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_RAWMOTCUR, piValue);
1516 
1517  return m_iErrorState;
1518 }
1519 
1520 int CDevice::getRawMotorSupply(int iModuleId, short* piValue)
1521 {
1522  m_iErrorState = 0;
1523  if(m_bInitFlag == false)
1524  {
1525  warning("device not initialized");
1526  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1527  return m_iErrorState;
1528  }
1529  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1530  {
1531  warning("wrong module id");
1532  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1533  return m_iErrorState;
1534  }
1535  for(int i = 0; i < m_iModuleCount; i++)
1536  {
1537  if(m_aiModuleId[i] == iModuleId)
1538  {
1539  if(m_auiModuleVersion[i] < 0x3602)
1540  {
1541  warning("module version does not support function");
1542  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1543  return m_iErrorState;
1544  }
1545  }
1546  }
1547  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_RAWMOTSUPPLY, piValue);
1548 
1549  return m_iErrorState;
1550 }
1551 
1552 int CDevice::getRawTemperature(int iModuleId, short* piValue)
1553 {
1554  m_iErrorState = 0;
1555  if(m_bInitFlag == false)
1556  {
1557  warning("device not initialized");
1558  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1559  return m_iErrorState;
1560  }
1561  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1562  {
1563  warning("wrong module id");
1564  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1565  return m_iErrorState;
1566  }
1567  for(int i = 0; i < m_iModuleCount; i++)
1568  {
1569  if(m_aiModuleId[i] == iModuleId)
1570  {
1571  if(m_auiModuleVersion[i] < 0x3602)
1572  {
1573  warning("module version does not support function");
1574  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1575  return m_iErrorState;
1576  }
1577  }
1578  }
1579  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_RAWTEMP, piValue);
1580 
1581  return m_iErrorState;
1582 }
1583 
1584 int CDevice::getRawLogicSupply(int iModuleId, short* piValue)
1585 {
1586  m_iErrorState = 0;
1587  if(m_bInitFlag == false)
1588  {
1589  warning("device not initialized");
1590  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1591  return m_iErrorState;
1592  }
1593  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1594  {
1595  warning("wrong module id");
1596  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1597  return m_iErrorState;
1598  }
1599  for(int i = 0; i < m_iModuleCount; i++)
1600  {
1601  if(m_aiModuleId[i] == iModuleId)
1602  {
1603  if(m_auiModuleVersion[i] < 0x3602)
1604  {
1605  warning("module version does not support function");
1606  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1607  return m_iErrorState;
1608  }
1609  }
1610  }
1611  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_RAWLOGICSUPPLY, piValue);
1612 
1613  return m_iErrorState;
1614 }
1615 
1616 int CDevice::getLoadLimit(int iModuleId, long* piValue)
1617 {
1618  m_iErrorState = 0;
1619  if(m_bInitFlag == false)
1620  {
1621  warning("device not initialized");
1622  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1623  return m_iErrorState;
1624  }
1625  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1626  {
1627  warning("wrong module id");
1628  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1629  return m_iErrorState;
1630  }
1631  for(int i = 0; i < m_iModuleCount; i++)
1632  {
1633  if(m_aiModuleId[i] == iModuleId)
1634  {
1635  if(m_auiModuleVersion[i] < 0x351A )
1636  {
1637  warning("module version does not support function");
1638  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1639  return m_iErrorState;
1640  }
1641  }
1642  }
1643  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_LOADLIMIT, piValue);
1644 
1645  return m_iErrorState;
1646 }
1647 
1648 int CDevice::getMaxLoadGradient(int iModuleId, long* piValue)
1649 {
1650  m_iErrorState = 0;
1651  if(m_bInitFlag == false)
1652  {
1653  warning("device not initialized");
1654  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1655  return m_iErrorState;
1656  }
1657  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1658  {
1659  warning("wrong module id");
1660  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1661  return m_iErrorState;
1662  }
1663  for(int i = 0; i < m_iModuleCount; i++)
1664  {
1665  if(m_aiModuleId[i] == iModuleId)
1666  {
1667  if(m_auiModuleVersion[i] < 0x351A )
1668  {
1669  warning("module version does not support function");
1670  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1671  return m_iErrorState;
1672  }
1673  }
1674  }
1675  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_MAXLOADGRADIENT, piValue);
1676 
1677  return m_iErrorState;
1678 }
1679 
1680 int CDevice::getLoadDeltaTime(int iModuleId, unsigned short* piValue)
1681 {
1682  m_iErrorState = 0;
1683  if(m_bInitFlag == false)
1684  {
1685  warning("device not initialized");
1686  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1687  return m_iErrorState;
1688  }
1689  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1690  {
1691  warning("wrong module id");
1692  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1693  return m_iErrorState;
1694  }
1695  for(int i = 0; i < m_iModuleCount; i++)
1696  {
1697  if(m_aiModuleId[i] == iModuleId)
1698  {
1699  if(m_auiModuleVersion[i] < 0x351A)
1700  {
1701  warning("module version does not support function");
1702  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1703  return m_iErrorState;
1704  }
1705  }
1706  }
1707  m_iErrorState = readShort(iModuleId, CMDID_GETPARAM, PARID_ACT_LOADDELTATIME, (short*)piValue);
1708 
1709  return m_iErrorState;
1710 }
1711 
1712 int CDevice::getMotorCurrent(int iModuleId, float* pfValue)
1713 {
1714  m_iErrorState = 0;
1715  if(m_bInitFlag == false)
1716  {
1717  warning("device not initialized");
1718  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1719  return m_iErrorState;
1720  }
1721  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1722  {
1723  warning("wrong module id");
1724  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1725  return m_iErrorState;
1726  }
1727  for(int i = 0; i < m_iModuleCount; i++)
1728  {
1729  if(m_aiModuleId[i] == iModuleId)
1730  {
1731  if(m_auiModuleVersion[i] < 0x4601)
1732  {
1733  warning("module version does not support function");
1734  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1735  return m_iErrorState;
1736  }
1737  }
1738  }
1739  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FMOTCUR, pfValue);
1740 
1741  return m_iErrorState;
1742 }
1743 
1744 int CDevice::getMotorSupply(int iModuleId, float* pfValue)
1745 {
1746  m_iErrorState = 0;
1747  if(m_bInitFlag == false)
1748  {
1749  warning("device not initialized");
1750  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1751  return m_iErrorState;
1752  }
1753  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1754  {
1755  warning("wrong module id");
1756  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1757  return m_iErrorState;
1758  }
1759  for(int i = 0; i < m_iModuleCount; i++)
1760  {
1761  if(m_aiModuleId[i] == iModuleId)
1762  {
1763  if(m_auiModuleVersion[i] < 0x4601)
1764  {
1765  warning("module version does not support function");
1766  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1767  return m_iErrorState;
1768  }
1769  }
1770  }
1771  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FMOTSUPPLY, pfValue);
1772 
1773  return m_iErrorState;
1774 }
1775 
1776 int CDevice::getTemperature(int iModuleId, float* pfValue)
1777 {
1778  m_iErrorState = 0;
1779  if(m_bInitFlag == false)
1780  {
1781  warning("device not initialized");
1782  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1783  return m_iErrorState;
1784  }
1785  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1786  {
1787  warning("wrong module id");
1788  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1789  return m_iErrorState;
1790  }
1791  for(int i = 0; i < m_iModuleCount; i++)
1792  {
1793  if(m_aiModuleId[i] == iModuleId)
1794  {
1795  if(m_auiModuleVersion[i] < 0x4601)
1796  {
1797  warning("module version does not support function");
1798  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1799  return m_iErrorState;
1800  }
1801  }
1802  }
1803  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FTEMP, pfValue);
1804 
1805  return m_iErrorState;
1806 }
1807 
1808 int CDevice::getLogicSupply(int iModuleId, float* pfValue)
1809 {
1810  m_iErrorState = 0;
1811  if(m_bInitFlag == false)
1812  {
1813  warning("device not initialized");
1814  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1815  return m_iErrorState;
1816  }
1817  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1818  {
1819  warning("wrong module id");
1820  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1821  return m_iErrorState;
1822  }
1823  for(int i = 0; i < m_iModuleCount; i++)
1824  {
1825  if(m_aiModuleId[i] == iModuleId)
1826  {
1827  if(m_auiModuleVersion[i] < 0x4601)
1828  {
1829  warning("module version does not support function");
1830  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1831  return m_iErrorState;
1832  }
1833  }
1834  }
1835  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_FLOGICSUPPLY, pfValue);
1836 
1837  return m_iErrorState;
1838 }
1839 
1840 int CDevice::getMinLogicVoltage(int iModuleId, float* pfValue)
1841 {
1842  m_iErrorState = 0;
1843  if(m_bInitFlag == false)
1844  {
1845  warning("device not initialized");
1846  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1847  return m_iErrorState;
1848  }
1849  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1850  {
1851  warning("wrong module id");
1852  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1853  return m_iErrorState;
1854  }
1855  for(int i = 0; i < m_iModuleCount; i++)
1856  {
1857  if(m_aiModuleId[i] == iModuleId)
1858  {
1859  if(m_auiModuleVersion[i] < 0x4601)
1860  {
1861  warning("module version does not support function");
1862  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1863  return m_iErrorState;
1864  }
1865  }
1866  }
1867  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_MINLOGIC, pfValue);
1868 
1869  return m_iErrorState;
1870 }
1871 
1872 int CDevice::getMaxLogicVoltage(int iModuleId, float* pfValue)
1873 {
1874  m_iErrorState = 0;
1875  if(m_bInitFlag == false)
1876  {
1877  warning("device not initialized");
1878  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1879  return m_iErrorState;
1880  }
1881  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1882  {
1883  warning("wrong module id");
1884  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1885  return m_iErrorState;
1886  }
1887  for(int i = 0; i < m_iModuleCount; i++)
1888  {
1889  if(m_aiModuleId[i] == iModuleId)
1890  {
1891  if(m_auiModuleVersion[i] < 0x4601)
1892  {
1893  warning("module version does not support function");
1894  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1895  return m_iErrorState;
1896  }
1897  }
1898  }
1899  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_MAXLOGIC, pfValue);
1900 
1901  return m_iErrorState;
1902 }
1903 
1904 int CDevice::getMinMotorVoltage(int iModuleId, float* pfValue)
1905 {
1906  m_iErrorState = 0;
1907  if(m_bInitFlag == false)
1908  {
1909  warning("device not initialized");
1910  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1911  return m_iErrorState;
1912  }
1913  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1914  {
1915  warning("wrong module id");
1916  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1917  return m_iErrorState;
1918  }
1919  for(int i = 0; i < m_iModuleCount; i++)
1920  {
1921  if(m_aiModuleId[i] == iModuleId)
1922  {
1923  if(m_auiModuleVersion[i] < 0x4601)
1924  {
1925  warning("module version does not support function");
1926  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1927  return m_iErrorState;
1928  }
1929  }
1930  }
1931  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_MINMOTOR, pfValue);
1932 
1933  return m_iErrorState;
1934 }
1935 
1936 int CDevice::getMaxMotorVoltage(int iModuleId, float* pfValue)
1937 {
1938  m_iErrorState = 0;
1939  if(m_bInitFlag == false)
1940  {
1941  warning("device not initialized");
1942  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1943  return m_iErrorState;
1944  }
1945  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1946  {
1947  warning("wrong module id");
1948  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1949  return m_iErrorState;
1950  }
1951  for(int i = 0; i < m_iModuleCount; i++)
1952  {
1953  if(m_aiModuleId[i] == iModuleId)
1954  {
1955  if(m_auiModuleVersion[i] < 0x4601)
1956  {
1957  warning("module version does not support function");
1958  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1959  return m_iErrorState;
1960  }
1961  }
1962  }
1963  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_MAXMOTOR, pfValue);
1964 
1965  return m_iErrorState;
1966 }
1967 
1968 int CDevice::getNominalMotorCurrent(int iModuleId, float* pfValue)
1969 {
1970  m_iErrorState = 0;
1971  if(m_bInitFlag == false)
1972  {
1973  warning("device not initialized");
1974  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
1975  return m_iErrorState;
1976  }
1977  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
1978  {
1979  warning("wrong module id");
1980  m_iErrorState = ERRID_DEV_WRONGMODULEID;
1981  return m_iErrorState;
1982  }
1983  for(int i = 0; i < m_iModuleCount; i++)
1984  {
1985  if(m_aiModuleId[i] == iModuleId)
1986  {
1987  if(m_auiModuleVersion[i] < 0x4601)
1988  {
1989  warning("module version does not support function");
1990  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
1991  return m_iErrorState;
1992  }
1993  }
1994  }
1995  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_NOMCUR, pfValue);
1996 
1997  return m_iErrorState;
1998 }
1999 
2000 int CDevice::getMaximumMotorCurrent(int iModuleId, float* pfValue)
2001 {
2002  m_iErrorState = 0;
2003  if(m_bInitFlag == false)
2004  {
2005  warning("device not initialized");
2006  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2007  return m_iErrorState;
2008  }
2009  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2010  {
2011  warning("wrong module id");
2012  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2013  return m_iErrorState;
2014  }
2015  for(int i = 0; i < m_iModuleCount; i++)
2016  {
2017  if(m_aiModuleId[i] == iModuleId)
2018  {
2019  if(m_auiModuleVersion[i] < 0x4601)
2020  {
2021  warning("module version does not support function");
2022  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2023  return m_iErrorState;
2024  }
2025  }
2026  }
2027  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_HMAXCUR, pfValue);
2028 
2029  return m_iErrorState;
2030 }
2031 
2032 int CDevice::getLogicUndershootTime(int iModuleId, long* piValue)
2033 {
2034  m_iErrorState = 0;
2035  if(m_bInitFlag == false)
2036  {
2037  warning("device not initialized");
2038  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2039  return m_iErrorState;
2040  }
2041  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2042  {
2043  warning("wrong module id");
2044  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2045  return m_iErrorState;
2046  }
2047  for(int i = 0; i < m_iModuleCount; i++)
2048  {
2049  if(m_aiModuleId[i] == iModuleId)
2050  {
2051  if(m_auiModuleVersion[i] < 0x4601 )
2052  {
2053  warning("module version does not support function");
2054  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2055  return m_iErrorState;
2056  }
2057  }
2058  }
2059  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_LOGICUNDERSHOOT, piValue);
2060 
2061  return m_iErrorState;
2062 }
2063 
2064 int CDevice::getLogicOvershootTime(int iModuleId, long* piValue)
2065 {
2066  m_iErrorState = 0;
2067  if(m_bInitFlag == false)
2068  {
2069  warning("device not initialized");
2070  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2071  return m_iErrorState;
2072  }
2073  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2074  {
2075  warning("wrong module id");
2076  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2077  return m_iErrorState;
2078  }
2079  for(int i = 0; i < m_iModuleCount; i++)
2080  {
2081  if(m_aiModuleId[i] == iModuleId)
2082  {
2083  if(m_auiModuleVersion[i] < 0x4601 )
2084  {
2085  warning("module version does not support function");
2086  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2087  return m_iErrorState;
2088  }
2089  }
2090  }
2091  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_LOGICOVERSHOOT, piValue);
2092 
2093  return m_iErrorState;
2094 }
2095 
2096 int CDevice::getMotorUndershootTime(int iModuleId, long* piValue)
2097 {
2098  m_iErrorState = 0;
2099  if(m_bInitFlag == false)
2100  {
2101  warning("device not initialized");
2102  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2103  return m_iErrorState;
2104  }
2105  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2106  {
2107  warning("wrong module id");
2108  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2109  return m_iErrorState;
2110  }
2111  for(int i = 0; i < m_iModuleCount; i++)
2112  {
2113  if(m_aiModuleId[i] == iModuleId)
2114  {
2115  if(m_auiModuleVersion[i] < 0x4601 )
2116  {
2117  warning("module version does not support function");
2118  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2119  return m_iErrorState;
2120  }
2121  }
2122  }
2123  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_MOTORUNDERSHOOT, piValue);
2124 
2125  return m_iErrorState;
2126 }
2127 
2128 int CDevice::getMotorOvershootTime(int iModuleId, long* piValue)
2129 {
2130  m_iErrorState = 0;
2131  if(m_bInitFlag == false)
2132  {
2133  warning("device not initialized");
2134  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2135  return m_iErrorState;
2136  }
2137  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2138  {
2139  warning("wrong module id");
2140  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2141  return m_iErrorState;
2142  }
2143  for(int i = 0; i < m_iModuleCount; i++)
2144  {
2145  if(m_aiModuleId[i] == iModuleId)
2146  {
2147  if(m_auiModuleVersion[i] < 0x4601 )
2148  {
2149  warning("module version does not support function");
2150  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2151  return m_iErrorState;
2152  }
2153  }
2154  }
2155  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_MOTOROVERSHOOT, piValue);
2156 
2157  return m_iErrorState;
2158 }
2159 
2160 int CDevice::getNomCurOvershootTime(int iModuleId, long* piValue)
2161 {
2162  m_iErrorState = 0;
2163  if(m_bInitFlag == false)
2164  {
2165  warning("device not initialized");
2166  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2167  return m_iErrorState;
2168  }
2169  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2170  {
2171  warning("wrong module id");
2172  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2173  return m_iErrorState;
2174  }
2175  for(int i = 0; i < m_iModuleCount; i++)
2176  {
2177  if(m_aiModuleId[i] == iModuleId)
2178  {
2179  if(m_auiModuleVersion[i] < 0x4601 )
2180  {
2181  warning("module version does not support function");
2182  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2183  return m_iErrorState;
2184  }
2185  }
2186  }
2187  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_NOMCUROVERSHOOT, piValue);
2188 
2189  return m_iErrorState;
2190 }
2191 
2192 int CDevice::getHMaxCurOvershootTime(int iModuleId, long* piValue)
2193 {
2194  m_iErrorState = 0;
2195  if(m_bInitFlag == false)
2196  {
2197  warning("device not initialized");
2198  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2199  return m_iErrorState;
2200  }
2201  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2202  {
2203  warning("wrong module id");
2204  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2205  return m_iErrorState;
2206  }
2207  for(int i = 0; i < m_iModuleCount; i++)
2208  {
2209  if(m_aiModuleId[i] == iModuleId)
2210  {
2211  if(m_auiModuleVersion[i] < 0x4601 )
2212  {
2213  warning("module version does not support function");
2214  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2215  return m_iErrorState;
2216  }
2217  }
2218  }
2219  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_HMAXCUROVERSHOOT, piValue);
2220 
2221  return m_iErrorState;
2222 }
2223 
2224 int CDevice::getKpPWMLimit(int iModuleId, long* piValue)
2225 {
2226  m_iErrorState = 0;
2227  if(m_bInitFlag == false)
2228  {
2229  warning("device not initialized");
2230  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2231  return m_iErrorState;
2232  }
2233  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2234  {
2235  warning("wrong module id");
2236  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2237  return m_iErrorState;
2238  }
2239  for(int i = 0; i < m_iModuleCount; i++)
2240  {
2241  if(m_aiModuleId[i] == iModuleId)
2242  {
2243  if(m_auiModuleVersion[i] < 0x4601 )
2244  {
2245  warning("module version does not support function");
2246  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2247  return m_iErrorState;
2248  }
2249  }
2250  }
2251  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_KP_PWMLIM, piValue);
2252 
2253  return m_iErrorState;
2254 }
2255 
2256 int CDevice::getCurrentLimit(int iModuleId, float* pfValue)
2257 {
2258  m_iErrorState = 0;
2259  if(m_bInitFlag == false)
2260  {
2261  warning("device not initialized");
2262  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2263  return m_iErrorState;
2264  }
2265  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2266  {
2267  warning("wrong module id");
2268  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2269  return m_iErrorState;
2270  }
2271  for(int i = 0; i < m_iModuleCount; i++)
2272  {
2273  if(m_aiModuleId[i] == iModuleId)
2274  {
2275  if(m_auiModuleVersion[i] < 0x4601)
2276  {
2277  warning("module version does not support function");
2278  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2279  return m_iErrorState;
2280  }
2281  }
2282  }
2283  m_iErrorState = readFloat(iModuleId, CMDID_GETPARAM, PARID_ACT_CURRENTLIMIT, pfValue);
2284 
2285  return m_iErrorState;
2286 }
2287 
2288 int CDevice::getMaxPWMOutput(int iModuleId, long* piValue)
2289 {
2290  m_iErrorState = 0;
2291  if(m_bInitFlag == false)
2292  {
2293  warning("device not initialized");
2294  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2295  return m_iErrorState;
2296  }
2297  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2298  {
2299  warning("wrong module id");
2300  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2301  return m_iErrorState;
2302  }
2303  for(int i = 0; i < m_iModuleCount; i++)
2304  {
2305  if(m_aiModuleId[i] == iModuleId)
2306  {
2307  if(m_auiModuleVersion[i] < 0x4601 )
2308  {
2309  warning("module version does not support function");
2310  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2311  return m_iErrorState;
2312  }
2313  }
2314  }
2315  m_iErrorState = readLong(iModuleId, CMDID_GETPARAM, PARID_ACT_MAXPWMOUTPUT, piValue);
2316 
2317  return m_iErrorState;
2318 }
2319 
2320 // ========================================================================== ;
2321 // ;
2322 // ---- modify functions ---------------------------------------------------- ;
2323 // ;
2324 // ========================================================================== ;
2325 
2326 void CDevice::setName(const char* acName)
2327 {
2328  strncpy(m_acName, acName, 128);
2329 }
2330 
2331 void CDevice::setInitString(const char* acInitString)
2332 {
2333  strncpy(m_acInitString, acInitString, 128);
2334 }
2335 
2336 int CDevice::setConfig(int iModuleId, unsigned long uiValue)
2337 {
2338  m_iErrorState = 0;
2339  if(m_bInitFlag == false)
2340  {
2341  warning("device not initialized");
2342  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2343  return m_iErrorState;
2344  }
2345  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2346  {
2347  warning("wrong module id");
2348  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2349  return m_iErrorState;
2350  }
2351  m_iErrorState = writeUnsignedLong(iModuleId, CMDID_SETPARAM, PARID_ACT_CONFIG, uiValue);
2352 
2353  return m_iErrorState;
2354 }
2355 
2356 int CDevice::setHomeOffset(int iModuleId, float fValue)
2357 {
2358  m_iErrorState = 0;
2359  if(m_bInitFlag == false)
2360  {
2361  warning("device not initialized");
2362  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2363  return m_iErrorState;
2364  }
2365  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2366  {
2367  warning("wrong module id");
2368  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2369  return m_iErrorState;
2370  }
2371  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FHOMEOFFSET, fValue);
2372 
2373  return m_iErrorState;
2374 }
2375 
2376 int CDevice::setHomeOffsetInc(int iModuleId, long iValue)
2377 {
2378  m_iErrorState = 0;
2379  if(m_bInitFlag == false)
2380  {
2381  warning("device not initialized");
2382  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2383  return m_iErrorState;
2384  }
2385  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2386  {
2387  warning("wrong module id");
2388  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2389  return m_iErrorState;
2390  }
2391  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IHOMEOFFSET, iValue);
2392 
2393  return m_iErrorState;
2394 }
2395 
2396 int CDevice::setDioData(int iModuleId, unsigned long uiValue)
2397 {
2398  m_iErrorState = 0;
2399  if(m_bInitFlag == false)
2400  {
2401  warning("device not initialized");
2402  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2403  return m_iErrorState;
2404  }
2405  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2406  {
2407  warning("wrong module id");
2408  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2409  return m_iErrorState;
2410  }
2411  m_iErrorState = writeUnsignedLong(iModuleId, CMDID_SETPARAM, PARID_ACT_DIODATA, uiValue);
2412 
2413  return m_iErrorState;
2414 }
2415 
2416 int CDevice::setA0(int iModuleId, short iValue)
2417 {
2418  m_iErrorState = 0;
2419  if(m_bInitFlag == false)
2420  {
2421  warning("device not initialized");
2422  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2423  return m_iErrorState;
2424  }
2425  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2426  {
2427  warning("wrong module id");
2428  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2429  return m_iErrorState;
2430  }
2431  m_iErrorState = writeShort(iModuleId, CMDID_SETPARAM, PARID_ACT_A0, iValue);
2432 
2433  return m_iErrorState;
2434 }
2435 
2436 int CDevice::setC0(int iModuleId, short iValue)
2437 {
2438  m_iErrorState = 0;
2439  if(m_bInitFlag == false)
2440  {
2441  warning("device not initialized");
2442  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2443  return m_iErrorState;
2444  }
2445  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2446  {
2447  warning("wrong module id");
2448  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2449  return m_iErrorState;
2450  }
2451  m_iErrorState = writeShort(iModuleId, CMDID_SETPARAM, PARID_ACT_C0, iValue);
2452 
2453  return m_iErrorState;
2454 }
2455 
2456 int CDevice::setDamp(int iModuleId, short iValue)
2457 {
2458  m_iErrorState = 0;
2459  if(m_bInitFlag == false)
2460  {
2461  warning("device not initialized");
2462  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2463  return m_iErrorState;
2464  }
2465  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2466  {
2467  warning("wrong module id");
2468  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2469  return m_iErrorState;
2470  }
2471  m_iErrorState = writeShort(iModuleId, CMDID_SETPARAM, PARID_ACT_DAMP, iValue);
2472 
2473  return m_iErrorState;
2474 }
2475 
2476 int CDevice::setMinPos(int iModuleId, float fValue)
2477 {
2478  m_iErrorState = 0;
2479  if(m_bInitFlag == false)
2480  {
2481  warning("device not initialized");
2482  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2483  return m_iErrorState;
2484  }
2485  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2486  {
2487  warning("wrong module id");
2488  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2489  return m_iErrorState;
2490  }
2491  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FMINPOS, fValue);
2492 
2493  return m_iErrorState;
2494 }
2495 
2496 int CDevice::setMaxPos(int iModuleId, float fValue)
2497 {
2498  m_iErrorState = 0;
2499  if(m_bInitFlag == false)
2500  {
2501  warning("device not initialized");
2502  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2503  return m_iErrorState;
2504  }
2505  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2506  {
2507  warning("wrong module id");
2508  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2509  return m_iErrorState;
2510  }
2511  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FMAXPOS, fValue);
2512 
2513  return m_iErrorState;
2514 }
2515 
2516 int CDevice::setMaxVel(int iModuleId, float fValue)
2517 {
2518  m_iErrorState = 0;
2519  if(m_bInitFlag == false)
2520  {
2521  warning("device not initialized");
2522  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2523  return m_iErrorState;
2524  }
2525  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2526  {
2527  warning("wrong module id");
2528  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2529  return m_iErrorState;
2530  }
2531  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FMAXVEL, fValue);
2532 
2533  return m_iErrorState;
2534 }
2535 
2536 int CDevice::setMaxAcc(int iModuleId, float fValue)
2537 {
2538  m_iErrorState = 0;
2539  if(m_bInitFlag == false)
2540  {
2541  warning("device not initialized");
2542  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2543  return m_iErrorState;
2544  }
2545  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2546  {
2547  warning("wrong module id");
2548  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2549  return m_iErrorState;
2550  }
2551  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FMAXACC, fValue);
2552 
2553  return m_iErrorState;
2554 }
2555 
2556 int CDevice::setMaxCur(int iModuleId, float fValue)
2557 {
2558  m_iErrorState = 0;
2559  if(m_bInitFlag == false)
2560  {
2561  warning("device not initialized");
2562  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2563  return m_iErrorState;
2564  }
2565  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2566  {
2567  warning("wrong module id");
2568  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2569  return m_iErrorState;
2570  }
2571  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FMAXCUR, fValue);
2572 
2573  return m_iErrorState;
2574 }
2575 
2576 int CDevice::setMaxDeltaPos(int iModuleId, float fValue)
2577 {
2578  m_iErrorState = 0;
2579  if(m_bInitFlag == false)
2580  {
2581  warning("device not initialized");
2582  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2583  return m_iErrorState;
2584  }
2585  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2586  {
2587  warning("wrong module id");
2588  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2589  return m_iErrorState;
2590  }
2591  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FMAXDELTAPOS, fValue);
2592 
2593  return m_iErrorState;
2594 }
2595 
2596 int CDevice::setMinPosInc(int iModuleId, long iValue)
2597 {
2598  m_iErrorState = 0;
2599  if(m_bInitFlag == false)
2600  {
2601  warning("device not initialized");
2602  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2603  return m_iErrorState;
2604  }
2605  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2606  {
2607  warning("wrong module id");
2608  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2609  return m_iErrorState;
2610  }
2611  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IMINPOS, iValue);
2612 
2613  return m_iErrorState;
2614 }
2615 
2616 int CDevice::setMaxPosInc(int iModuleId, long iValue)
2617 {
2618  m_iErrorState = 0;
2619  if(m_bInitFlag == false)
2620  {
2621  warning("device not initialized");
2622  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2623  return m_iErrorState;
2624  }
2625  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2626  {
2627  warning("wrong module id");
2628  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2629  return m_iErrorState;
2630  }
2631  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IMAXPOS, iValue);
2632 
2633  return m_iErrorState;
2634 }
2635 
2636 int CDevice::setMaxVelInc(int iModuleId, long iValue)
2637 {
2638  m_iErrorState = 0;
2639  if(m_bInitFlag == false)
2640  {
2641  warning("device not initialized");
2642  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2643  return m_iErrorState;
2644  }
2645  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2646  {
2647  warning("wrong module id");
2648  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2649  return m_iErrorState;
2650  }
2651  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IMAXVEL, iValue);
2652 
2653  return m_iErrorState;
2654 }
2655 
2656 int CDevice::setMaxAccInc(int iModuleId, long iValue)
2657 {
2658  m_iErrorState = 0;
2659  if(m_bInitFlag == false)
2660  {
2661  warning("device not initialized");
2662  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2663  return m_iErrorState;
2664  }
2665  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2666  {
2667  warning("wrong module id");
2668  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2669  return m_iErrorState;
2670  }
2671  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IMAXACC, iValue);
2672 
2673  return m_iErrorState;
2674 }
2675 
2676 int CDevice::setMaxDeltaPosInc(int iModuleId, long iValue)
2677 {
2678  m_iErrorState = 0;
2679  if(m_bInitFlag == false)
2680  {
2681  warning("device not initialized");
2682  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2683  return m_iErrorState;
2684  }
2685  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2686  {
2687  warning("wrong module id");
2688  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2689  return m_iErrorState;
2690  }
2691  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IMAXDELTAPOS, iValue);
2692 
2693  return m_iErrorState;
2694 }
2695 
2696 int CDevice::setHomeVel(int iModuleId, float fValue)
2697 {
2698  m_iErrorState = 0;
2699  if(m_bInitFlag == false)
2700  {
2701  warning("device not initialized");
2702  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2703  return m_iErrorState;
2704  }
2705  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2706  {
2707  warning("wrong module id");
2708  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2709  return m_iErrorState;
2710  }
2711  for(int i = 0; i < m_iModuleCount; i++)
2712  {
2713  if(m_aiModuleId[i] == iModuleId)
2714  {
2715  if(m_auiModuleVersion[i] < 0x2518 || (m_auiModuleVersion[i] >= 0x3500 && m_auiModuleVersion[i] < 0x3518))
2716  {
2717  warning("module version does not support function");
2718  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2719  return m_iErrorState;
2720  }
2721  }
2722  }
2723  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FHOMEVEL, fValue);
2724 
2725  return m_iErrorState;
2726 }
2727 
2728 int CDevice::setHomeVelInc(int iModuleId, long iValue)
2729 {
2730  m_iErrorState = 0;
2731  if(m_bInitFlag == false)
2732  {
2733  warning("device not initialized");
2734  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2735  return m_iErrorState;
2736  }
2737  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2738  {
2739  warning("wrong module id");
2740  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2741  return m_iErrorState;
2742  }
2743  for(int i = 0; i < m_iModuleCount; i++)
2744  {
2745  if(m_aiModuleId[i] == iModuleId)
2746  {
2747  if(m_auiModuleVersion[i] < 0x2518 || (m_auiModuleVersion[i] >= 0x3500 && m_auiModuleVersion[i] < 0x3518))
2748  {
2749  warning("module version does not support function");
2750  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2751  return m_iErrorState;
2752  }
2753  }
2754  }
2755  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IHOMEVEL, iValue);
2756 
2757  return m_iErrorState;
2758 }
2759 
2760 int CDevice::setRampVel(int iModuleId, float fValue)
2761 {
2762  m_iErrorState = 0;
2763  if(m_bInitFlag == false)
2764  {
2765  warning("device not initialized");
2766  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2767  return m_iErrorState;
2768  }
2769  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2770  {
2771  warning("wrong module id");
2772  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2773  return m_iErrorState;
2774  }
2775  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FRAMPVEL, fValue);
2776 
2777  return m_iErrorState;
2778 }
2779 
2780 int CDevice::setRampVelInc(int iModuleId, long iValue)
2781 {
2782  m_iErrorState = 0;
2783  if(m_bInitFlag == false)
2784  {
2785  warning("device not initialized");
2786  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2787  return m_iErrorState;
2788  }
2789  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2790  {
2791  warning("wrong module id");
2792  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2793  return m_iErrorState;
2794  }
2795  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IRAMPVEL, iValue);
2796 
2797  return m_iErrorState;
2798 }
2799 
2800 int CDevice::setRampAcc(int iModuleId, float fValue)
2801 {
2802  m_iErrorState = 0;
2803  if(m_bInitFlag == false)
2804  {
2805  warning("device not initialized");
2806  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2807  return m_iErrorState;
2808  }
2809  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2810  {
2811  warning("wrong module id");
2812  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2813  return m_iErrorState;
2814  }
2815  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FRAMPACC, fValue);
2816 
2817  return m_iErrorState;
2818 }
2819 
2820 int CDevice::setRampAccInc(int iModuleId, long iValue)
2821 {
2822  m_iErrorState = 0;
2823  if(m_bInitFlag == false)
2824  {
2825  warning("device not initialized");
2826  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2827  return m_iErrorState;
2828  }
2829  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2830  {
2831  warning("wrong module id");
2832  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2833  return m_iErrorState;
2834  }
2835  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IRAMPACC, iValue);
2836 
2837  return m_iErrorState;
2838 }
2839 
2840 int CDevice::setSyncTime(int iModuleId, short iValue)
2841 {
2842  m_iErrorState = 0;
2843  if(m_bInitFlag == false)
2844  {
2845  warning("device not initialized");
2846  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2847  return m_iErrorState;
2848  }
2849  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2850  {
2851  warning("wrong module id");
2852  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2853  return m_iErrorState;
2854  }
2855  for(int i = 0; i < m_iModuleCount; i++)
2856  {
2857  if(m_aiModuleId[i] == iModuleId)
2858  {
2859  if(m_auiModuleVersion[i] < 0x3602)
2860  {
2861  warning("module version does not support function");
2862  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2863  return m_iErrorState;
2864  }
2865  }
2866  }
2867  m_iErrorState = writeShort(iModuleId, CMDID_SETPARAM, PARID_ACT_SYNCTIME, iValue);
2868 
2869  return m_iErrorState;
2870 }
2871 
2872 int CDevice::setLoadLimit(int iModuleId, long iValue)
2873 {
2874  m_iErrorState = 0;
2875  if(m_bInitFlag == false)
2876  {
2877  warning("device not initialized");
2878  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2879  return m_iErrorState;
2880  }
2881  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2882  {
2883  warning("wrong module id");
2884  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2885  return m_iErrorState;
2886  }
2887  for(int i = 0; i < m_iModuleCount; i++)
2888  {
2889  if(m_aiModuleId[i] == iModuleId)
2890  {
2891  if(m_auiModuleVersion[i] < 0x351A)
2892  {
2893  warning("module version does not support function");
2894  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2895  return m_iErrorState;
2896  }
2897  }
2898  }
2899  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_LOADLIMIT, iValue);
2900 
2901  return m_iErrorState;
2902 }
2903 
2904 int CDevice::setMaxLoadGradient(int iModuleId, long iValue)
2905 {
2906  m_iErrorState = 0;
2907  if(m_bInitFlag == false)
2908  {
2909  warning("device not initialized");
2910  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2911  return m_iErrorState;
2912  }
2913  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2914  {
2915  warning("wrong module id");
2916  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2917  return m_iErrorState;
2918  }
2919  for(int i = 0; i < m_iModuleCount; i++)
2920  {
2921  if(m_aiModuleId[i] == iModuleId)
2922  {
2923  if(m_auiModuleVersion[i] < 0x351A)
2924  {
2925  warning("module version does not support function");
2926  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2927  return m_iErrorState;
2928  }
2929  }
2930  }
2931  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_MAXLOADGRADIENT, iValue);
2932 
2933  return m_iErrorState;
2934 }
2935 
2936 int CDevice::setLoadDeltaTime(int iModuleId, unsigned short iValue)
2937 {
2938  m_iErrorState = 0;
2939  if(m_bInitFlag == false)
2940  {
2941  warning("device not initialized");
2942  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2943  return m_iErrorState;
2944  }
2945  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2946  {
2947  warning("wrong module id");
2948  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2949  return m_iErrorState;
2950  }
2951  for(int i = 0; i < m_iModuleCount; i++)
2952  {
2953  if(m_aiModuleId[i] == iModuleId)
2954  {
2955  if(m_auiModuleVersion[i] < 0x351A)
2956  {
2957  warning("module version does not support function");
2958  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2959  return m_iErrorState;
2960  }
2961  }
2962  }
2963  m_iErrorState = writeShort(iModuleId, CMDID_SETPARAM, PARID_ACT_LOADDELTATIME, iValue);
2964 
2965  return m_iErrorState;
2966 }
2967 
2968 int CDevice::setDefGearRatio(int iModuleId, float fValue)
2969 {
2970  m_iErrorState = 0;
2971  if(m_bInitFlag == false)
2972  {
2973  warning("device not initialized");
2974  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
2975  return m_iErrorState;
2976  }
2977  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
2978  {
2979  warning("wrong module id");
2980  m_iErrorState = ERRID_DEV_WRONGMODULEID;
2981  return m_iErrorState;
2982  }
2983  for(int i = 0; i < m_iModuleCount; i++)
2984  {
2985  if(m_aiModuleId[i] == iModuleId)
2986  {
2987  if(m_auiModuleVersion[i] < 0x4601)
2988  {
2989  warning("module version does not support function");
2990  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
2991  return m_iErrorState;
2992  }
2993  }
2994  }
2995  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_DEF_FGEARRATIO, fValue);
2996 
2997  return m_iErrorState;
2998 }
2999 
3000 int CDevice::setDefLinRatio(int iModuleId, float fValue)
3001 {
3002  m_iErrorState = 0;
3003  if(m_bInitFlag == false)
3004  {
3005  warning("device not initialized");
3006  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3007  return m_iErrorState;
3008  }
3009  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3010  {
3011  warning("wrong module id");
3012  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3013  return m_iErrorState;
3014  }
3015  for(int i = 0; i < m_iModuleCount; i++)
3016  {
3017  if(m_aiModuleId[i] == iModuleId)
3018  {
3019  if(m_auiModuleVersion[i] < 0x4601)
3020  {
3021  warning("module version does not support function");
3022  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3023  return m_iErrorState;
3024  }
3025  }
3026  }
3027  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_DEF_FLINEARRATIO, fValue);
3028 
3029  return m_iErrorState;
3030 }
3031 
3032 int CDevice::setDefCurRatio(int iModuleId, float fValue)
3033 {
3034  m_iErrorState = 0;
3035  if(m_bInitFlag == false)
3036  {
3037  warning("device not initialized");
3038  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3039  return m_iErrorState;
3040  }
3041  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3042  {
3043  warning("wrong module id");
3044  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3045  return m_iErrorState;
3046  }
3047  for(int i = 0; i < m_iModuleCount; i++)
3048  {
3049  if(m_aiModuleId[i] == iModuleId)
3050  {
3051  if(m_auiModuleVersion[i] < 0x4601)
3052  {
3053  warning("module version does not support function");
3054  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3055  return m_iErrorState;
3056  }
3057  }
3058  }
3059  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_DEF_FCURRATIO, fValue);
3060 
3061  return m_iErrorState;
3062 }
3063 
3064 int CDevice::setDefHomeAcc(int iModuleId, float fValue)
3065 {
3066  m_iErrorState = 0;
3067  if(m_bInitFlag == false)
3068  {
3069  warning("device not initialized");
3070  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3071  return m_iErrorState;
3072  }
3073  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3074  {
3075  warning("wrong module id");
3076  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3077  return m_iErrorState;
3078  }
3079  for(int i = 0; i < m_iModuleCount; i++)
3080  {
3081  if(m_aiModuleId[i] == iModuleId)
3082  {
3083  if(m_auiModuleVersion[i] < 0x4601)
3084  {
3085  warning("module version does not support function");
3086  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3087  return m_iErrorState;
3088  }
3089  }
3090  }
3091  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_DEF_FHOMEACC, fValue);
3092 
3093  return m_iErrorState;
3094 }
3095 
3096 int CDevice::setModuleSerialNo(int iModuleId, unsigned long uiValue)
3097 {
3098  m_iErrorState = 0;
3099  if(m_bInitFlag == false)
3100  {
3101  warning("device not initialized");
3102  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3103  return m_iErrorState;
3104  }
3105  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3106  {
3107  warning("wrong module id");
3108  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3109  return m_iErrorState;
3110  }
3111  for(int i = 0; i < m_iModuleCount; i++)
3112  {
3113  if(m_aiModuleId[i] == iModuleId)
3114  {
3115  if(m_auiModuleVersion[i] < 0x4601)
3116  {
3117  warning("module version does not support function");
3118  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3119  return m_iErrorState;
3120  }
3121  }
3122  }
3123  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_DEF_SERIALNO, uiValue);
3124 
3125  return m_iErrorState;
3126 }
3127 
3128 int CDevice::setDefIncPerTurn(int iModuleId, unsigned long uiValue)
3129 {
3130  m_iErrorState = 0;
3131  if(m_bInitFlag == false)
3132  {
3133  warning("device not initialized");
3134  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3135  return m_iErrorState;
3136  }
3137  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3138  {
3139  warning("wrong module id");
3140  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3141  return m_iErrorState;
3142  }
3143  for(int i = 0; i < m_iModuleCount; i++)
3144  {
3145  if(m_aiModuleId[i] == iModuleId)
3146  {
3147  if(m_auiModuleVersion[i] < 0x4601)
3148  {
3149  warning("module version does not support function");
3150  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3151  return m_iErrorState;
3152  }
3153  }
3154  }
3155  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_DEF_INCPERTURN, uiValue);
3156 
3157  return m_iErrorState;
3158 }
3159 
3160 int CDevice::setDefBrakeTimeOut(int iModuleId, unsigned short uiValue)
3161 {
3162  m_iErrorState = 0;
3163  if(m_bInitFlag == false)
3164  {
3165  warning("device not initialized");
3166  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3167  return m_iErrorState;
3168  }
3169  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3170  {
3171  warning("wrong module id");
3172  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3173  return m_iErrorState;
3174  }
3175  for(int i = 0; i < m_iModuleCount; i++)
3176  {
3177  if(m_aiModuleId[i] == iModuleId)
3178  {
3179  if(m_auiModuleVersion[i] < 0x4601)
3180  {
3181  warning("module version does not support function");
3182  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3183  return m_iErrorState;
3184  }
3185  }
3186  }
3187  m_iErrorState = writeShort(iModuleId, CMDID_SETPARAM, PARID_DEF_BRAKETIMEOUT, uiValue);
3188 
3189  return m_iErrorState;
3190 }
3191 
3192 int CDevice::setDefAddress(int iModuleId, unsigned char uiValue)
3193 {
3194  m_iErrorState = 0;
3195  if(m_bInitFlag == false)
3196  {
3197  warning("device not initialized");
3198  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3199  return m_iErrorState;
3200  }
3201  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3202  {
3203  warning("wrong module id");
3204  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3205  return m_iErrorState;
3206  }
3207  for(int i = 0; i < m_iModuleCount; i++)
3208  {
3209  if(m_aiModuleId[i] == iModuleId)
3210  {
3211  if(m_auiModuleVersion[i] < 0x4601)
3212  {
3213  warning("module version does not support function");
3214  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3215  return m_iErrorState;
3216  }
3217  }
3218  }
3219  m_iErrorState = writeChar(iModuleId, CMDID_SETPARAM, PARID_DEF_ADDRESS, uiValue);
3220 
3221  return m_iErrorState;
3222 }
3223 
3224 int CDevice::setDefCANBaudRate(int iModuleId, unsigned char uiValue)
3225 {
3226  m_iErrorState = 0;
3227  if(m_bInitFlag == false)
3228  {
3229  warning("device not initialized");
3230  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3231  return m_iErrorState;
3232  }
3233  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3234  {
3235  warning("wrong module id");
3236  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3237  return m_iErrorState;
3238  }
3239  for(int i = 0; i < m_iModuleCount; i++)
3240  {
3241  if(m_aiModuleId[i] == iModuleId)
3242  {
3243  if(m_auiModuleVersion[i] < 0x4601)
3244  {
3245  warning("module version does not support function");
3246  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3247  return m_iErrorState;
3248  }
3249  }
3250  }
3251  m_iErrorState = writeChar(iModuleId, CMDID_SETPARAM, PARID_DEF_CANBAUDRATE, uiValue);
3252 
3253  return m_iErrorState;
3254 }
3255 
3256 int CDevice::setDefRSBaudRate(int iModuleId, unsigned char uiValue)
3257 {
3258  m_iErrorState = 0;
3259  if(m_bInitFlag == false)
3260  {
3261  warning("device not initialized");
3262  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3263  return m_iErrorState;
3264  }
3265  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3266  {
3267  warning("wrong module id");
3268  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3269  return m_iErrorState;
3270  }
3271  for(int i = 0; i < m_iModuleCount; i++)
3272  {
3273  if(m_aiModuleId[i] == iModuleId)
3274  {
3275  if(m_auiModuleVersion[i] < 0x4601)
3276  {
3277  warning("module version does not support function");
3278  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3279  return m_iErrorState;
3280  }
3281  }
3282  }
3283  m_iErrorState = writeChar(iModuleId, CMDID_SETPARAM, PARID_DEF_RSBAUDRATE, uiValue);
3284 
3285  return m_iErrorState;
3286 }
3287 
3288 int CDevice::setDefSetup(int iModuleId, unsigned long uiValue)
3289 {
3290  m_iErrorState = 0;
3291  if(m_bInitFlag == false)
3292  {
3293  warning("device not initialized");
3294  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3295  return m_iErrorState;
3296  }
3297  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3298  {
3299  warning("wrong module id");
3300  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3301  return m_iErrorState;
3302  }
3303  for(int i = 0; i < m_iModuleCount; i++)
3304  {
3305  if(m_aiModuleId[i] == iModuleId)
3306  {
3307  if(m_auiModuleVersion[i] < 0x4601)
3308  {
3309  warning("module version does not support function");
3310  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3311  return m_iErrorState;
3312  }
3313  }
3314  }
3315  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_DEF_SETUP, uiValue);
3316 
3317  return m_iErrorState;
3318 }
3319 
3320 int CDevice::setMinLogicVoltage(int iModuleId, float fValue)
3321 {
3322  m_iErrorState = 0;
3323  if(m_bInitFlag == false)
3324  {
3325  warning("device not initialized");
3326  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3327  return m_iErrorState;
3328  }
3329  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3330  {
3331  warning("wrong module id");
3332  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3333  return m_iErrorState;
3334  }
3335  for(int i = 0; i < m_iModuleCount; i++)
3336  {
3337  if(m_aiModuleId[i] == iModuleId)
3338  {
3339  if(m_auiModuleVersion[i] < 0x4601)
3340  {
3341  warning("module version does not support function");
3342  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3343  return m_iErrorState;
3344  }
3345  }
3346  }
3347  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_MINLOGIC, fValue);
3348 
3349  return m_iErrorState;
3350 }
3351 
3352 int CDevice::setMaxLogicVoltage(int iModuleId, float fValue)
3353 {
3354  m_iErrorState = 0;
3355  if(m_bInitFlag == false)
3356  {
3357  warning("device not initialized");
3358  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3359  return m_iErrorState;
3360  }
3361  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3362  {
3363  warning("wrong module id");
3364  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3365  return m_iErrorState;
3366  }
3367  for(int i = 0; i < m_iModuleCount; i++)
3368  {
3369  if(m_aiModuleId[i] == iModuleId)
3370  {
3371  if(m_auiModuleVersion[i] < 0x4601)
3372  {
3373  warning("module version does not support function");
3374  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3375  return m_iErrorState;
3376  }
3377  }
3378  }
3379  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_MAXLOGIC, fValue);
3380 
3381  return m_iErrorState;
3382 }
3383 
3384 int CDevice::setMinMotorVoltage(int iModuleId, float fValue)
3385 {
3386  m_iErrorState = 0;
3387  if(m_bInitFlag == false)
3388  {
3389  warning("device not initialized");
3390  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3391  return m_iErrorState;
3392  }
3393  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3394  {
3395  warning("wrong module id");
3396  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3397  return m_iErrorState;
3398  }
3399  for(int i = 0; i < m_iModuleCount; i++)
3400  {
3401  if(m_aiModuleId[i] == iModuleId)
3402  {
3403  if(m_auiModuleVersion[i] < 0x4601)
3404  {
3405  warning("module version does not support function");
3406  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3407  return m_iErrorState;
3408  }
3409  }
3410  }
3411  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_MINMOTOR, fValue);
3412 
3413  return m_iErrorState;
3414 }
3415 
3416 int CDevice::setMaxMotorVoltage(int iModuleId, float fValue)
3417 {
3418  m_iErrorState = 0;
3419  if(m_bInitFlag == false)
3420  {
3421  warning("device not initialized");
3422  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3423  return m_iErrorState;
3424  }
3425  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3426  {
3427  warning("wrong module id");
3428  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3429  return m_iErrorState;
3430  }
3431  for(int i = 0; i < m_iModuleCount; i++)
3432  {
3433  if(m_aiModuleId[i] == iModuleId)
3434  {
3435  if(m_auiModuleVersion[i] < 0x4601)
3436  {
3437  warning("module version does not support function");
3438  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3439  return m_iErrorState;
3440  }
3441  }
3442  }
3443  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_MAXMOTOR, fValue);
3444 
3445  return m_iErrorState;
3446 }
3447 
3448 int CDevice::setNominalMotorCurrent(int iModuleId, float fValue)
3449 {
3450  m_iErrorState = 0;
3451  if(m_bInitFlag == false)
3452  {
3453  warning("device not initialized");
3454  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3455  return m_iErrorState;
3456  }
3457  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3458  {
3459  warning("wrong module id");
3460  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3461  return m_iErrorState;
3462  }
3463  for(int i = 0; i < m_iModuleCount; i++)
3464  {
3465  if(m_aiModuleId[i] == iModuleId)
3466  {
3467  if(m_auiModuleVersion[i] < 0x4601)
3468  {
3469  warning("module version does not support function");
3470  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3471  return m_iErrorState;
3472  }
3473  }
3474  }
3475  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_NOMCUR, fValue);
3476 
3477  return m_iErrorState;
3478 }
3479 
3480 int CDevice::setMaximumMotorCurrent(int iModuleId, float fValue)
3481 {
3482  m_iErrorState = 0;
3483  if(m_bInitFlag == false)
3484  {
3485  warning("device not initialized");
3486  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3487  return m_iErrorState;
3488  }
3489  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3490  {
3491  warning("wrong module id");
3492  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3493  return m_iErrorState;
3494  }
3495  for(int i = 0; i < m_iModuleCount; i++)
3496  {
3497  if(m_aiModuleId[i] == iModuleId)
3498  {
3499  if(m_auiModuleVersion[i] < 0x4601)
3500  {
3501  warning("module version does not support function");
3502  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3503  return m_iErrorState;
3504  }
3505  }
3506  }
3507  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_HMAXCUR, fValue);
3508 
3509  return m_iErrorState;
3510 }
3511 
3512 int CDevice::setLogicUndershootTime(int iModuleId, long iValue)
3513 {
3514  m_iErrorState = 0;
3515  if(m_bInitFlag == false)
3516  {
3517  warning("device not initialized");
3518  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3519  return m_iErrorState;
3520  }
3521  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3522  {
3523  warning("wrong module id");
3524  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3525  return m_iErrorState;
3526  }
3527  for(int i = 0; i < m_iModuleCount; i++)
3528  {
3529  if(m_aiModuleId[i] == iModuleId)
3530  {
3531  if(m_auiModuleVersion[i] < 0x4601)
3532  {
3533  warning("module version does not support function");
3534  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3535  return m_iErrorState;
3536  }
3537  }
3538  }
3539  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_LOGICUNDERSHOOT, iValue);
3540 
3541  return m_iErrorState;
3542 }
3543 
3544 int CDevice::setLogicOvershootTime(int iModuleId, long iValue)
3545 {
3546  m_iErrorState = 0;
3547  if(m_bInitFlag == false)
3548  {
3549  warning("device not initialized");
3550  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3551  return m_iErrorState;
3552  }
3553  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3554  {
3555  warning("wrong module id");
3556  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3557  return m_iErrorState;
3558  }
3559  for(int i = 0; i < m_iModuleCount; i++)
3560  {
3561  if(m_aiModuleId[i] == iModuleId)
3562  {
3563  if(m_auiModuleVersion[i] < 0x4601)
3564  {
3565  warning("module version does not support function");
3566  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3567  return m_iErrorState;
3568  }
3569  }
3570  }
3571  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_LOGICOVERSHOOT, iValue);
3572 
3573  return m_iErrorState;
3574 }
3575 
3576 int CDevice::setMotorUndershootTime(int iModuleId, long iValue)
3577 {
3578  m_iErrorState = 0;
3579  if(m_bInitFlag == false)
3580  {
3581  warning("device not initialized");
3582  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3583  return m_iErrorState;
3584  }
3585  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3586  {
3587  warning("wrong module id");
3588  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3589  return m_iErrorState;
3590  }
3591  for(int i = 0; i < m_iModuleCount; i++)
3592  {
3593  if(m_aiModuleId[i] == iModuleId)
3594  {
3595  if(m_auiModuleVersion[i] < 0x4601)
3596  {
3597  warning("module version does not support function");
3598  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3599  return m_iErrorState;
3600  }
3601  }
3602  }
3603  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_MOTORUNDERSHOOT, iValue);
3604 
3605  return m_iErrorState;
3606 }
3607 
3608 int CDevice::setMotorOvershootTime(int iModuleId, long iValue)
3609 {
3610  m_iErrorState = 0;
3611  if(m_bInitFlag == false)
3612  {
3613  warning("device not initialized");
3614  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3615  return m_iErrorState;
3616  }
3617  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3618  {
3619  warning("wrong module id");
3620  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3621  return m_iErrorState;
3622  }
3623  for(int i = 0; i < m_iModuleCount; i++)
3624  {
3625  if(m_aiModuleId[i] == iModuleId)
3626  {
3627  if(m_auiModuleVersion[i] < 0x4601)
3628  {
3629  warning("module version does not support function");
3630  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3631  return m_iErrorState;
3632  }
3633  }
3634  }
3635  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_MOTOROVERSHOOT, iValue);
3636 
3637  return m_iErrorState;
3638 }
3639 
3640 int CDevice::setNomCurOvershootTime(int iModuleId, long iValue)
3641 {
3642  m_iErrorState = 0;
3643  if(m_bInitFlag == false)
3644  {
3645  warning("device not initialized");
3646  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3647  return m_iErrorState;
3648  }
3649  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3650  {
3651  warning("wrong module id");
3652  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3653  return m_iErrorState;
3654  }
3655  for(int i = 0; i < m_iModuleCount; i++)
3656  {
3657  if(m_aiModuleId[i] == iModuleId)
3658  {
3659  if(m_auiModuleVersion[i] < 0x4601)
3660  {
3661  warning("module version does not support function");
3662  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3663  return m_iErrorState;
3664  }
3665  }
3666  }
3667  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_NOMCUROVERSHOOT, iValue);
3668 
3669  return m_iErrorState;
3670 }
3671 
3672 int CDevice::setHMaxCurOvershootTime(int iModuleId, long iValue)
3673 {
3674  m_iErrorState = 0;
3675  if(m_bInitFlag == false)
3676  {
3677  warning("device not initialized");
3678  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3679  return m_iErrorState;
3680  }
3681  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3682  {
3683  warning("wrong module id");
3684  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3685  return m_iErrorState;
3686  }
3687  for(int i = 0; i < m_iModuleCount; i++)
3688  {
3689  if(m_aiModuleId[i] == iModuleId)
3690  {
3691  if(m_auiModuleVersion[i] < 0x4601)
3692  {
3693  warning("module version does not support function");
3694  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3695  return m_iErrorState;
3696  }
3697  }
3698  }
3699  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_HMAXCUROVERSHOOT, iValue);
3700 
3701  return m_iErrorState;
3702 }
3703 
3704 int CDevice::setKpPWMLimit(int iModuleId, long iValue)
3705 {
3706  m_iErrorState = 0;
3707  if(m_bInitFlag == false)
3708  {
3709  warning("device not initialized");
3710  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3711  return m_iErrorState;
3712  }
3713  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3714  {
3715  warning("wrong module id");
3716  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3717  return m_iErrorState;
3718  }
3719  for(int i = 0; i < m_iModuleCount; i++)
3720  {
3721  if(m_aiModuleId[i] == iModuleId)
3722  {
3723  if(m_auiModuleVersion[i] < 0x4601)
3724  {
3725  warning("module version does not support function");
3726  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3727  return m_iErrorState;
3728  }
3729  }
3730  }
3731  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_KP_PWMLIM, iValue);
3732 
3733  return m_iErrorState;
3734 }
3735 
3736 int CDevice::setCurrentLimit(int iModuleId, float fValue)
3737 {
3738  m_iErrorState = 0;
3739  if(m_bInitFlag == false)
3740  {
3741  warning("device not initialized");
3742  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3743  return m_iErrorState;
3744  }
3745  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3746  {
3747  warning("wrong module id");
3748  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3749  return m_iErrorState;
3750  }
3751  for(int i = 0; i < m_iModuleCount; i++)
3752  {
3753  if(m_aiModuleId[i] == iModuleId)
3754  {
3755  if(m_auiModuleVersion[i] < 0x4601)
3756  {
3757  warning("module version does not support function");
3758  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
3759  return m_iErrorState;
3760  }
3761  }
3762  }
3763  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_CURRENTLIMIT, fValue);
3764 
3765  return m_iErrorState;
3766 }
3767 // ========================================================================== ;
3768 // ;
3769 // ---- I/O functions ------------------------------------------------------- ;
3770 // ;
3771 // ========================================================================== ;
3772 
3773 // ========================================================================== ;
3774 // ;
3775 // ---- exec functions ------------------------------------------------------ ;
3776 // ;
3777 // ========================================================================== ;
3778 
3779 int CDevice::updateModuleIdMap()
3780 {
3781  unsigned short uiVersion;
3782  std::vector<float> afData;
3783  if(m_bInitFlag == false)
3784  {
3785  warning("device not initialized");
3786  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3787  return m_iErrorState;
3788  }
3789  m_aiModuleId.clear();
3790  m_auiModuleVersion.clear();
3791 
3792  m_iModuleCount = m_iModuleCountMax; // timout = m_uiTimeOut + 10 * m_iModuleCount for RS232
3793  for(int i = 1; i <= m_iModuleCountMax; i++)
3794  {
3795  debug(0,"searching for module %i", i);
3796  m_iErrorState = getModuleVersion(i, &uiVersion);
3797  if(m_iErrorState == 0)
3798  {
3799  m_aiModuleId.push_back(i);
3800  m_auiModuleVersion.push_back(uiVersion);
3801  debug(0,"found module with ID %i and Version %x", i, uiVersion);
3802  }
3803  else
3804  m_iErrorState = 0;
3805  }
3806  m_iModuleCount = m_aiModuleId.size();
3807  m_iErrorState = 0;
3808  return m_iModuleCount;
3809 }
3810 
3811 int CDevice::homeModule(int iModuleId)
3812 {
3813  m_iErrorState = 0;
3814  if(m_bInitFlag == false)
3815  {
3816  warning("device not initialized");
3817  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3818  return m_iErrorState;
3819  }
3820  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3821  {
3822  warning("wrong module id");
3823  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3824  return m_iErrorState;
3825  }
3826  m_iErrorState = writeCommand(iModuleId, CMDID_HOME);
3827 
3828  return m_iErrorState;
3829 }
3830 
3831 int CDevice::haltModule(int iModuleId)
3832 {
3833  m_iErrorState = 0;
3834  if(m_bInitFlag == false)
3835  {
3836  warning("device not initialized");
3837  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3838  return m_iErrorState;
3839  }
3840  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3841  {
3842  warning("wrong module id");
3843  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3844  return m_iErrorState;
3845  }
3846  m_iErrorState = writeCommand(iModuleId, CMDID_HALT);
3847 
3848  return m_iErrorState;
3849 }
3850 
3851 int CDevice::resetModule(int iModuleId)
3852 {
3853  m_iErrorState = 0;
3854  if(m_bInitFlag == false)
3855  {
3856  warning("device not initialized");
3857  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3858  return m_iErrorState;
3859  }
3860  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3861  {
3862  warning("wrong module id");
3863  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3864  return m_iErrorState;
3865  }
3866  m_iErrorState = writeCommand(iModuleId, CMDID_RESET);
3867 
3868  return m_iErrorState;
3869 }
3870 
3871 int CDevice::recalcPIDParams(int iModuleId)
3872 {
3873  m_iErrorState = 0;
3874  if(m_bInitFlag == false)
3875  {
3876  warning("device not initialized");
3877  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3878  return m_iErrorState;
3879  }
3880  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3881  {
3882  warning("wrong module id");
3883  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3884  return m_iErrorState;
3885  }
3886  m_iErrorState = writeCommand(iModuleId, CMDID_RECALCPID);
3887 
3888  return m_iErrorState;
3889 }
3890 
3891 int CDevice::saveParameters(int iModuleId)
3892 {
3893  m_iErrorState = 0;
3894  if(m_bInitFlag == false)
3895  {
3896  warning("device not initialized");
3897  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3898  return m_iErrorState;
3899  }
3900  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3901  {
3902  warning("wrong module id");
3903  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3904  return m_iErrorState;
3905  }
3906  m_iErrorState = writeCommand(iModuleId, CMDID_SAVEPARAMS);
3907 
3908  return m_iErrorState;
3909 }
3910 
3911 int CDevice::movePos(int iModuleId, float fPos)
3912 {
3913  m_iErrorState = 0;
3914  if(m_bInitFlag == false)
3915  {
3916  warning("device not initialized");
3917  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3918  return m_iErrorState;
3919  }
3920  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3921  {
3922  warning("wrong module id");
3923  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3924  return m_iErrorState;
3925  }
3926  m_iErrorState = writeFloat(iModuleId, CMDID_SETMOVE, PARID_MOVE_FRAMP, fPos);
3927 
3928  return m_iErrorState;
3929 }
3930 
3931 int CDevice::moveRamp(int iModuleId, float fPos, float fVel, float fAcc)
3932 {
3933  m_iErrorState = 0;
3934  if(m_bInitFlag == false)
3935  {
3936  warning("device not initialized");
3937  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3938  return m_iErrorState;
3939  }
3940  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3941  {
3942  warning("wrong module id");
3943  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3944  return m_iErrorState;
3945  }
3946  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FRAMPVEL, fVel);
3947  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FRAMPACC, fAcc);
3948  m_iErrorState = writeFloat(iModuleId, CMDID_SETMOVE, PARID_MOVE_FRAMP, fPos);
3949 
3950  return m_iErrorState;
3951 }
3952 
3953 int CDevice::moveVel(int iModuleId, float fVel)
3954 {
3955  m_iErrorState = 0;
3956  if(m_bInitFlag == false)
3957  {
3958  warning("device not initialized");
3959  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3960  return m_iErrorState;
3961  }
3962  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3963  {
3964  warning("wrong module id");
3965  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3966  return m_iErrorState;
3967  }
3968  m_iErrorState = writeFloat(iModuleId, CMDID_SETMOVE, PARID_MOVE_FVEL, fVel);
3969 
3970  return m_iErrorState;
3971 }
3972 
3973 int CDevice::moveCur(int iModuleId, float fCur)
3974 {
3975  m_iErrorState = 0;
3976  if(m_bInitFlag == false)
3977  {
3978  warning("device not initialized");
3979  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
3980  return m_iErrorState;
3981  }
3982  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
3983  {
3984  warning("wrong module id");
3985  m_iErrorState = ERRID_DEV_WRONGMODULEID;
3986  return m_iErrorState;
3987  }
3988  m_iErrorState = writeFloat(iModuleId, CMDID_SETMOVE, PARID_MOVE_FCUR, fCur);
3989 
3990  return m_iErrorState;
3991 }
3992 
3993 int CDevice::moveStep(int iModuleId, float fPos, unsigned short uiTime)
3994 {
3995  m_iErrorState = 0;
3996  if(m_bInitFlag == false)
3997  {
3998  warning("device not initialized");
3999  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4000  return m_iErrorState;
4001  }
4002  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4003  {
4004  warning("wrong module id");
4005  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4006  return m_iErrorState;
4007  }
4008  m_iErrorState = writeFloatShort(iModuleId, CMDID_SETMOVE, PARID_MOVE_FSTEP, fPos, uiTime);
4009 
4010  return m_iErrorState;
4011 }
4012 
4013 int CDevice::movePosInc(int iModuleId, long iPos)
4014 {
4015  m_iErrorState = 0;
4016  if(m_bInitFlag == false)
4017  {
4018  warning("device not initialized");
4019  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4020  return m_iErrorState;
4021  }
4022  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4023  {
4024  warning("wrong module id");
4025  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4026  return m_iErrorState;
4027  }
4028  m_iErrorState = writeLong(iModuleId, CMDID_SETMOVE, PARID_MOVE_IRAMP, iPos);
4029 
4030  return m_iErrorState;
4031 }
4032 
4033 int CDevice::moveRampInc(int iModuleId, long iPos, long iVel, long iAcc)
4034 {
4035  m_iErrorState = 0;
4036  if(m_bInitFlag == false)
4037  {
4038  warning("device not initialized");
4039  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4040  return m_iErrorState;
4041  }
4042  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4043  {
4044  warning("wrong module id");
4045  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4046  return m_iErrorState;
4047  }
4048  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IRAMPVEL, iVel);
4049  m_iErrorState = writeLong(iModuleId, CMDID_SETPARAM, PARID_ACT_IRAMPACC, iAcc);
4050  m_iErrorState = writeLong(iModuleId, CMDID_SETMOVE, PARID_MOVE_IRAMP, iPos);
4051 
4052  return m_iErrorState;
4053 }
4054 
4055 int CDevice::moveVelInc(int iModuleId, long iVel)
4056 {
4057  m_iErrorState = 0;
4058  if(m_bInitFlag == false)
4059  {
4060  warning("device not initialized");
4061  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4062  return m_iErrorState;
4063  }
4064  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4065  {
4066  warning("wrong module id");
4067  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4068  return m_iErrorState;
4069  }
4070  m_iErrorState = writeLong(iModuleId, CMDID_SETMOVE, PARID_MOVE_IVEL, iVel);
4071 
4072  return m_iErrorState;
4073 }
4074 
4075 int CDevice::moveCurInc(int iModuleId, long iCur)
4076 {
4077  m_iErrorState = 0;
4078  if(m_bInitFlag == false)
4079  {
4080  warning("device not initialized");
4081  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4082  return m_iErrorState;
4083  }
4084  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4085  {
4086  warning("wrong module id");
4087  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4088  return m_iErrorState;
4089  }
4090  m_iErrorState = writeLong(iModuleId, CMDID_SETMOVE, PARID_MOVE_ICUR, iCur);
4091 
4092  return m_iErrorState;
4093 }
4094 
4095 int CDevice::moveStepInc(int iModuleId, long iPos, unsigned short uiTime)
4096 {
4097  m_iErrorState = 0;
4098  if(m_bInitFlag == false)
4099  {
4100  warning("device not initialized");
4101  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4102  return m_iErrorState;
4103  }
4104  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4105  {
4106  warning("wrong module id");
4107  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4108  return m_iErrorState;
4109  }
4110  m_iErrorState = writeLongShort(iModuleId, CMDID_SETMOVE, PARID_MOVE_ISTEP, iPos, uiTime);
4111 
4112  return m_iErrorState;
4113 }
4114 
4115 int CDevice::movePosExtended(int iModuleId, float fPos,
4116  unsigned long* puiState, unsigned char* pucDio, float* pfPos)
4117 {
4118  m_iErrorState = 0;
4119  if(m_bInitFlag == false)
4120  {
4121  warning("device not initialized");
4122  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4123  return m_iErrorState;
4124  }
4125  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4126  {
4127  warning("wrong module id");
4128  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4129  return m_iErrorState;
4130  }
4131  unsigned char ucState = 0;
4132  m_iErrorState = writeFloatReadFloatUnsignedChars(iModuleId, CMDID_SETMOVE, PARID_MOVE_FRAMP_EXT, fPos, pfPos, &ucState, pucDio);
4133  if(m_iErrorState == 0)
4134  charStateToLongState(ucState, puiState);
4135 
4136  return m_iErrorState;
4137 }
4138 
4139 int CDevice::moveRampExtended(int iModuleId, float fPos, float fVel, float fAcc,
4140  unsigned long* puiState, unsigned char* pucDio, float* pfPos)
4141 {
4142  m_iErrorState = 0;
4143  if(m_bInitFlag == false)
4144  {
4145  warning("device not initialized");
4146  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4147  return m_iErrorState;
4148  }
4149  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4150  {
4151  warning("wrong module id");
4152  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4153  return m_iErrorState;
4154  }
4155  unsigned char ucState = 0;
4156  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FRAMPVEL, fVel);
4157  m_iErrorState = writeFloat(iModuleId, CMDID_SETPARAM, PARID_ACT_FRAMPACC, fAcc);
4158  m_iErrorState = writeFloatReadFloatUnsignedChars(iModuleId, CMDID_SETMOVE, PARID_MOVE_FRAMP_EXT, fPos, pfPos, &ucState, pucDio);
4159  if(m_iErrorState == 0)
4160  charStateToLongState(ucState, puiState);
4161 
4162  return m_iErrorState;
4163 }
4164 
4165 int CDevice::moveVelExtended(int iModuleId, float fVel,
4166  unsigned long* puiState, unsigned char* pucDio, float* pfPos)
4167 {
4168  m_iErrorState = 0;
4169  if(m_bInitFlag == false)
4170  {
4171  warning("device not initialized");
4172  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4173  return m_iErrorState;
4174  }
4175  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4176  {
4177  warning("wrong module id");
4178  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4179  return m_iErrorState;
4180  }
4181  unsigned char ucState = 0;
4182  m_iErrorState = writeFloatReadFloatUnsignedChars(iModuleId, CMDID_SETMOVE, PARID_MOVE_FVEL_EXT, fVel, pfPos, &ucState, pucDio);
4183  if(m_iErrorState == 0)
4184  charStateToLongState(ucState, puiState);
4185 
4186  return m_iErrorState;
4187 }
4188 
4189 int CDevice::moveCurExtended(int iModuleId, float fCur,
4190  unsigned long* puiState, unsigned char* pucDio, float* pfPos)
4191 {
4192  m_iErrorState = 0;
4193  if(m_bInitFlag == false)
4194  {
4195  warning("device not initialized");
4196  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4197  return m_iErrorState;
4198  }
4199  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4200  {
4201  warning("wrong module id");
4202  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4203  return m_iErrorState;
4204  }
4205  unsigned char ucState = 0;
4206  m_iErrorState = writeFloatReadFloatUnsignedChars(iModuleId, CMDID_SETMOVE, PARID_MOVE_FCUR_EXT, fCur, pfPos, &ucState, pucDio);
4207  if(m_iErrorState == 0)
4208  charStateToLongState(ucState, puiState);
4209 
4210  return m_iErrorState;
4211 }
4212 
4213 int CDevice::moveStepExtended(int iModuleId, float fPos, unsigned short uiTime,
4214  unsigned long* puiState, unsigned char* pucDio, float* pfPos)
4215 {
4216  m_iErrorState = 0;
4217  if(m_bInitFlag == false)
4218  {
4219  warning("device not initialized");
4220  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4221  return m_iErrorState;
4222  }
4223  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4224  {
4225  warning("wrong module id");
4226  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4227  return m_iErrorState;
4228  }
4229  unsigned char ucState = 0;
4230  m_iErrorState = writeFloatShortReadFloatUnsignedChars(iModuleId, CMDID_SETMOVE, PARID_MOVE_FSTEP_EXT, fPos, uiTime, pfPos, &ucState, pucDio);
4231  if(m_iErrorState == 0)
4232  charStateToLongState(ucState, puiState);
4233  return m_iErrorState;
4234 }
4235 
4236 // ========================================================================== ;
4237 // ;
4238 // ---- wait functions ------------------------------------------------------ ;
4239 // ;
4240 // ========================================================================== ;
4241 
4242 int CDevice::waitForHomeEnd(int iModuleId, unsigned long uiTimeOut)
4243 {
4244  int iRetVal;
4245  unsigned long uiTime, uiState;
4246  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4247  {
4248  warning("wrong module id");
4249  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4250  return m_iErrorState;
4251  }
4252  m_clTimer.start();
4253  while(1)
4254  {
4255  Sleep(1);
4256  iRetVal = getModuleState(iModuleId, &uiState);
4257  if (iRetVal < 0)
4258  {
4259  debug(1,"com error in waitForHomeEnd()");
4260  break;
4261  }
4262  if (uiState & STATEID_MOD_ERROR)
4263  {
4264  debug(1, "module error in waitForHomeEnd()");
4265  iRetVal=ERRID_DEV_MODULEERROR;
4266  break;
4267  }
4268  if ((uiState & STATEID_MOD_HOME) && (uiState & STATEID_MOD_RAMP_END))
4269  {
4270  debug(2, "reached home position in waitForHomeEnd()");
4271  iRetVal=0;
4272  break;
4273  }
4274  m_clTimer.stop();
4275  uiTime = (unsigned long)(1000 * m_clTimer.executionTime());
4276  if (uiTime > uiTimeOut)
4277  {
4278  debug(1, "timeout in waitForHomeEnd()");
4279  iRetVal=ERRID_DEV_WAITTIMEOUT;
4280  break;
4281  }
4282  }
4283  return iRetVal;
4284 }
4285 
4286 int CDevice::waitForMotionEnd(int iModuleId, unsigned long uiTimeOut)
4287 {
4288  int iRetVal;
4289  unsigned long uiTime, uiState;
4290  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4291  {
4292  warning("wrong module id");
4293  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4294  return m_iErrorState;
4295  }
4296  m_clTimer.start();
4297  while(1)
4298  {
4299  Sleep(1);
4300  iRetVal = getModuleState(iModuleId, &uiState);
4301  if (iRetVal < 0)
4302  {
4303  debug(1,"com error in waitForMotionEnd()");
4304  break;
4305  }
4306  if (uiState & STATEID_MOD_ERROR)
4307  {
4308  debug(1, "module error in waitForMotionEnd()");
4309  iRetVal=ERRID_DEV_MODULEERROR;
4310  break;
4311  }
4312  if (!(uiState & STATEID_MOD_MOTION))
4313  {
4314  debug(2, "finished motion in waitForMotionEnd()");
4315  iRetVal=0;
4316  break;
4317  }
4318  m_clTimer.stop();
4319  uiTime = (unsigned long)(1000 * m_clTimer.executionTime());
4320  if (uiTime > uiTimeOut)
4321  {
4322  debug(1, "timeout in waitForMotionEnd()");
4323  iRetVal=ERRID_DEV_WAITTIMEOUT;
4324  break;
4325  }
4326  }
4327  return iRetVal;
4328 }
4329 
4330 int CDevice::waitForRampEnd(int iModuleId, unsigned long uiTimeOut)
4331 {
4332  int iRetVal;
4333  unsigned long uiTime, uiState;
4334  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4335  {
4336  warning("wrong module id");
4337  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4338  return m_iErrorState;
4339  }
4340  m_clTimer.start();
4341  while(1)
4342  {
4343  Sleep(1);
4344  iRetVal = getModuleState(iModuleId, &uiState);
4345  if (iRetVal < 0)
4346  {
4347  debug(1,"com error in waitForRampEnd()");
4348  break;
4349  }
4350  if (uiState & STATEID_MOD_ERROR)
4351  {
4352  debug(1, "module error in waitForRampEnd()");
4353  iRetVal=ERRID_DEV_MODULEERROR;
4354  break;
4355  }
4356  if (uiState & STATEID_MOD_RAMP_END)
4357  {
4358  debug(2, "reached ramp end position in waitForRampEnd()");
4359  iRetVal=0;
4360  break;
4361  }
4362  m_clTimer.stop();
4363  uiTime = (unsigned long)(1000 * m_clTimer.executionTime());
4364  if (uiTime > uiTimeOut)
4365  {
4366  debug(1, "timeout in waitForRampEnd()");
4367  iRetVal=ERRID_DEV_WAITTIMEOUT;
4368  break;
4369  }
4370  }
4371  return iRetVal;
4372 }
4373 
4374 int CDevice::waitForRampDec(int iModuleId, unsigned long uiTimeOut)
4375 {
4376  int iRetVal;
4377  unsigned long uiTime, uiState;
4378  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4379  {
4380  warning("wrong module id");
4381  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4382  return m_iErrorState;
4383  }
4384  m_clTimer.start();
4385  while(1)
4386  {
4387  Sleep(1);
4388  iRetVal = getModuleState(iModuleId, &uiState);
4389  if (iRetVal < 0)
4390  {
4391  debug(1,"com error in waitForRampDec()");
4392  break;
4393  }
4394  if (uiState & STATEID_MOD_ERROR)
4395  {
4396  debug(1, "module error in waitForRampDec()");
4397  iRetVal=ERRID_DEV_MODULEERROR;
4398  break;
4399  }
4400  if (uiState & STATEID_MOD_RAMP_DEC)
4401  {
4402  debug(2, "reached ramp end position in waitForRampDec()");
4403  iRetVal=0;
4404  break;
4405  }
4406  m_clTimer.stop();
4407  uiTime = (unsigned long)(1000 * m_clTimer.executionTime());
4408  if (uiTime > uiTimeOut)
4409  {
4410  debug(1, "timeout in waitForRampDec()");
4411  iRetVal=ERRID_DEV_WAITTIMEOUT;
4412  break;
4413  }
4414  }
4415  return iRetVal;
4416 }
4417 
4418 int CDevice::waitForRampSteady(int iModuleId, unsigned long uiTimeOut)
4419 {
4420  int iRetVal;
4421  unsigned long uiTime, uiState;
4422  if(iModuleId < 0 || iModuleId > m_iModuleCountMax)
4423  {
4424  warning("wrong module id");
4425  m_iErrorState = ERRID_DEV_WRONGMODULEID;
4426  return m_iErrorState;
4427  }
4428  m_clTimer.start();
4429  while(1)
4430  {
4431  Sleep(1);
4432  iRetVal = getModuleState(iModuleId, &uiState);
4433  if (iRetVal < 0)
4434  {
4435  debug(1,"com error in waitForRampSteady()");
4436  break;
4437  }
4438  if (uiState & STATEID_MOD_ERROR)
4439  {
4440  debug(1, "module error in waitForRampSteady()");
4441  iRetVal=ERRID_DEV_MODULEERROR;
4442  break;
4443  }
4444  if (uiState & STATEID_MOD_RAMP_STEADY)
4445  {
4446  debug(2, "reached ramp end position in waitForRampSteady()");
4447  iRetVal=0;
4448  break;
4449  }
4450  m_clTimer.stop();
4451  uiTime = (unsigned long)(1000 * m_clTimer.executionTime());
4452  if (uiTime > uiTimeOut)
4453  {
4454  debug(1, "timeout in waitForRampSteady()");
4455  iRetVal=ERRID_DEV_WAITTIMEOUT;
4456  break;
4457  }
4458  }
4459  return iRetVal;
4460 }
4461 
4462 int CDevice::waitForHomeEndAll(unsigned long uiTimeOut)
4463 {
4464  int i, iRetVal = ERRID_DEV_NOMODULES;
4465  bool bExitFlag = false;
4466  unsigned long uiTime, uiState;
4467  m_clTimer.start();
4468  do
4469  {
4470  Sleep(1);
4471  bExitFlag = true;
4472  for(i = 0; i < m_iModuleCount;i++)
4473  {
4474  iRetVal = getModuleState(m_aiModuleId[i], &uiState);
4475  if (iRetVal < 0)
4476  {
4477  debug(1,"com error in waitForHomeEndAll()");
4478  return iRetVal;
4479  }
4480  if (uiState & STATEID_MOD_ERROR)
4481  {
4482  debug(1, "module error in waitForHomeEndAll()");
4483  iRetVal=ERRID_DEV_MODULEERROR;
4484  return iRetVal;
4485  }
4486  if (!(uiState & STATEID_MOD_HOME) || !(uiState & STATEID_MOD_RAMP_END))
4487  {
4488  debug(2, "module %i not home end in waitForHomeEndAll()", m_aiModuleId[i]);
4489  bExitFlag = false;
4490  break;
4491  }
4492  }
4493  m_clTimer.stop();
4494  uiTime = (unsigned long)(1000 * m_clTimer.executionTime());
4495  if (uiTime > uiTimeOut)
4496  {
4497  debug(1, "timeout in waitForHomeEndAll()");
4498  iRetVal=ERRID_DEV_WAITTIMEOUT;
4499  return iRetVal;
4500  }
4501  }while(!bExitFlag);
4502  return iRetVal;
4503 }
4504 
4505 int CDevice::waitForMotionEndAll(unsigned long uiTimeOut)
4506 {
4507  int i, iRetVal = ERRID_DEV_NOMODULES;
4508  bool bExitFlag = false;
4509  unsigned long uiTime, uiState;
4510  m_clTimer.start();
4511  do
4512  {
4513  Sleep(1);
4514  bExitFlag = true;
4515  for(i = 0; i < m_iModuleCount;i++)
4516  {
4517  iRetVal = getModuleState(m_aiModuleId[i], &uiState);
4518  if (iRetVal < 0)
4519  {
4520  debug(1,"com error in waitForMotionEndAll()");
4521  return iRetVal;
4522  }
4523  if (uiState & STATEID_MOD_ERROR)
4524  {
4525  debug(1, "module error in waitForMotionEndAll()");
4526  iRetVal=ERRID_DEV_MODULEERROR;
4527  return iRetVal;
4528  }
4529  if (uiState & STATEID_MOD_MOTION)
4530  {
4531  debug(2, "module %i not motion end in waitForMotionEndAll()", m_aiModuleId[i]);
4532  bExitFlag = false;
4533  break;
4534  }
4535  }
4536  m_clTimer.stop();
4537  uiTime = (unsigned long)(1000 * m_clTimer.executionTime());
4538  if (uiTime > uiTimeOut)
4539  {
4540  debug(1, "timeout in waitForMotionEndAll()");
4541  iRetVal=ERRID_DEV_WAITTIMEOUT;
4542  return iRetVal;
4543  }
4544  }while(!bExitFlag);
4545  return iRetVal;
4546 }
4547 
4548 int CDevice::waitForRampEndAll(unsigned long uiTimeOut)
4549 {
4550  int i, iRetVal = ERRID_DEV_NOMODULES;
4551  bool bExitFlag = false;
4552  unsigned long uiTime, uiState;
4553  m_clTimer.start();
4554  do
4555  {
4556  Sleep(1);
4557  bExitFlag = true;
4558  for(i = 0; i < m_iModuleCount;i++)
4559  {
4560  iRetVal = getModuleState(m_aiModuleId[i], &uiState);
4561  if (iRetVal < 0)
4562  {
4563  debug(1,"com error in waitForRampEndAll()");
4564  return iRetVal;
4565  }
4566  if (uiState & STATEID_MOD_ERROR)
4567  {
4568  debug(1, "module error in waitForRampEndAll()");
4569  iRetVal=ERRID_DEV_MODULEERROR;
4570  return iRetVal;
4571  }
4572  if (!(uiState & STATEID_MOD_RAMP_END))
4573  {
4574  debug(2, "module %i not ramp end in waitForRampEndAll()", m_aiModuleId[i]);
4575  bExitFlag = false;
4576  break;
4577  }
4578  }
4579  m_clTimer.stop();
4580  uiTime = (unsigned long)(1000 * m_clTimer.executionTime());
4581  if (uiTime > uiTimeOut)
4582  {
4583  debug(1, "timeout in waitForRampEndAll()");
4584  iRetVal=ERRID_DEV_WAITTIMEOUT;
4585  return iRetVal;
4586  }
4587  }while(!bExitFlag);
4588  return iRetVal;
4589 }
4590 
4591 int CDevice::waitForStartMotionAll()
4592 {
4593  m_iErrorState = 0;
4594  if(m_bInitFlag == false)
4595  {
4596  warning("device not initialized");
4597  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4598  return m_iErrorState;
4599  }
4600  m_iErrorState = ERRID_DEV_FUNCTIONNOTAVAILABLE;
4601  return m_iErrorState;
4602 }
4603 
4604 
4605 // ========================================================================== ;
4606 // ;
4607 // ---- broadcast functions -------------------------------------------------- ;
4608 // ;
4609 // ========================================================================== ;
4610 
4611 int CDevice::homeAll(void)
4612 {
4613  m_iErrorState = 0;
4614  if(m_bInitFlag == false)
4615  {
4616  warning("device not initialized");
4617  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4618  return m_iErrorState;
4619  }
4620  m_iErrorState = writeAll( CMDID_HOME, 0 );
4621  return m_iErrorState;
4622 }
4623 
4624 int CDevice::resetAll(void)
4625 {
4626  m_iErrorState = 0;
4627  if(m_bInitFlag == false)
4628  {
4629  warning("device not initialized");
4630  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4631  return m_iErrorState;
4632  }
4633  m_iErrorState = writeAll( CMDID_RESET, 0 );
4634  return m_iErrorState;
4635 }
4636 
4637 int CDevice::haltAll(void)
4638 {
4639  m_iErrorState = 0;
4640  if(m_bInitFlag == false)
4641  {
4642  warning("device not initialized");
4643  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4644  return m_iErrorState;
4645  }
4646  m_iErrorState = writeAll( CMDID_HALT, 0 );
4647  return m_iErrorState;
4648 }
4649 
4650 int CDevice::serveWatchdogAll(void)
4651 {
4652  m_iErrorState = 0;
4653  if(m_bInitFlag == false)
4654  {
4655  warning("device not initialized");
4656  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4657  return m_iErrorState;
4658  }
4659  m_iErrorState = writeAll( CMDID_WATCHDOG, 0 );
4660  return m_iErrorState;
4661 }
4662 
4663 int CDevice::setBaudRateAll(unsigned char ucBaudRateId)
4664 {
4665  m_iErrorState = 0;
4666  if(m_bInitFlag == false)
4667  {
4668  warning("device not initialized");
4669  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4670  return m_iErrorState;
4671  }
4672  m_iErrorState = writeAll( CMDID_BAUDRATE, ucBaudRateId );
4673  reinit(ucBaudRateId);
4674  return m_iErrorState;
4675 }
4676 
4677 int CDevice::startMotionAll(void)
4678 {
4679  m_iErrorState = 0;
4680  if(m_bInitFlag == false)
4681  {
4682  warning("device not initialized");
4683  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4684  return m_iErrorState;
4685  }
4686  m_iErrorState = writeAll( CMDID_STARTMOVE, 0 );
4687  return m_iErrorState;
4688 }
4689 
4690 int CDevice::savePosAll(void)
4691 {
4692  m_iErrorState = 0;
4693  if(m_bInitFlag == false)
4694  {
4695  warning("device not initialized");
4696  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4697  return m_iErrorState;
4698  }
4699  m_iErrorState = writeAll( CMDID_SAVEPOS, 0 );
4700  return m_iErrorState;
4701 }
4702 
4703 // ========================================================================== ;
4704 // ;
4705 // ---- Special functions for internal use ---------------------------------- ;
4706 // ;
4707 // ========================================================================== ;
4708 int CDevice::xmit8Bytes(int iModuleId, void* pBytes )
4709 {
4710  m_iErrorState = 0;
4711  if(m_bInitFlag == false)
4712  {
4713  warning("device not initialized");
4714  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4715  return m_iErrorState;
4716  }
4717  m_iErrorState = write8Bytes(iModuleId, false, pBytes );
4718  return m_iErrorState;
4719 }
4720 
4721 int CDevice::xack8Bytes(int iModuleId, void* pBytes )
4722 {
4723  m_iErrorState = 0;
4724  if(m_bInitFlag == false)
4725  {
4726  warning("device not initialized");
4727  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4728  return m_iErrorState;
4729  }
4730  m_iErrorState = write8Bytes( iModuleId, true, pBytes );
4731  return m_iErrorState;
4732 }
4733 
4734 int CDevice::doInternal(int iModuleId, void* pBytes )
4735 { unsigned char toSend[8];
4736  m_iErrorState = 0;
4737  if(m_bInitFlag == false)
4738  {
4739  warning("device not initialized");
4740  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4741  return m_iErrorState;
4742  }
4743  toSend[0] = 0x04;
4744  memcpy( &toSend[1], pBytes, 7 );
4745  m_iErrorState = write8Bytes( iModuleId, true, toSend );
4746  memcpy( pBytes, &toSend[1], 7 );
4747  return m_iErrorState;
4748 }
4749 
4750 int CDevice::getStateInternal(int iModuleId, unsigned long* pStat )
4751 { m_iErrorState = 0;
4752  if(m_bInitFlag == false)
4753  {
4754  warning("device not initialized");
4755  m_iErrorState = ERRID_DEV_NOTINITIALIZED;
4756  return m_iErrorState;
4757  }
4758  m_iErrorState = getUnsignedLong( iModuleId, pStat );
4759  return m_iErrorState;
4760 }
4761 
4762 // ========================================================================== ;
4763 // ;
4764 // ---- Init functions ------------------------------------------------------ ;
4765 // ;
4766 // ========================================================================== ;
4767 
4768 CDevice* newDevice(const char* acInitString)
4769 {
4770  char* pcToken;
4771  char acString[128];
4772  strncpy(acString,acInitString,128);
4773  pcToken = strtok( acString, ":" );
4774  if( !pcToken )
4775  {
4776  printf("CDevice* newDevice(const char* acInitString): wrong format, no ':' found!\n");
4777  return NULL;
4778  }
4779  if( strcmp( pcToken, "RS232" ) == 0 )
4780  {
4781  return new CRS232Device();
4782  }
4783 #ifdef USE_ESD
4784  if( strcmp( pcToken, "ESD" ) == 0 )
4785  {
4786  return new CESDDevice();
4787  }
4788 #endif
4789 #ifdef USE_PCAN
4790  if( strcmp( pcToken, "PCAN" ) == 0 )
4791  {
4792  return new CPCanDevice();
4793  }
4794 #endif
4795 #ifdef USE_SOCKET_CAN
4796  if( strcmp( pcToken, "SOCKETCAN" ) == 0 )
4797  {
4798  return new SocketCANDevice();
4799  }
4800 #endif
4801 #if defined(_WIN32)
4802  if( strcmp( pcToken, "CP5X11" ) == 0 )
4803  {
4804  return new CCP5X11Device();
4805  }
4806 #endif
4807  printf("CDevice* newDevice(const char* acInitString): wrong format, no device found!\n");
4808  return NULL;
4809 }
PARID_ACT_FMOTSUPPLY
#define PARID_ACT_FMOTSUPPLY
Definition: ProtocolCommands.h:192
PARID_ACT_FMINPOS
#define PARID_ACT_FMINPOS
Definition: ProtocolCommands.h:153
CDevice::getMinMotorVoltage
int getMinMotorVoltage(int iModuleId, float *pfValue)
Definition: Device.cpp:1904
PARID_MOVE_ISTEP
#define PARID_MOVE_ISTEP
Definition: ProtocolCommands.h:105
CDevice::getMaxLogicVoltage
int getMaxLogicVoltage(int iModuleId, float *pfValue)
Definition: Device.cpp:1872
CDevice::homeModule
int homeModule(int iModuleId)
Definition: Device.cpp:3811
CDevice::serveWatchdogAll
int serveWatchdogAll(void)
Definition: Device.cpp:4650
PARID_DEF_FLINEARRATIO
#define PARID_DEF_FLINEARRATIO
Definition: ProtocolCommands.h:119
PARID_DEF_A0
#define PARID_DEF_A0
Definition: ProtocolCommands.h:163
CDevice::getDefDamp
int getDefDamp(int iModuleId, short *piValue)
Definition: Device.cpp:565
PARID_DEF_ADDRESS
#define PARID_DEF_ADDRESS
Definition: ProtocolCommands.h:136
CDevice::getHomeVel
int getHomeVel(int iModuleId, float *pfValue)
Definition: Device.cpp:1392
CDevice::writeFloatReadFloatUnsignedChars
virtual int writeFloatReadFloatUnsignedChars(int iModuleId, int iCommandId, int iParameterId, float fData, float *pfData, unsigned char *pucData1, unsigned char *pucData2)=0
PARID_MOVE_FRAMP_EXT
#define PARID_MOVE_FRAMP_EXT
Definition: ProtocolCommands.h:108
CDevice::setMaxDeltaPos
int setMaxDeltaPos(int iModuleId, float fValue)
Definition: Device.cpp:2576
PARID_ACT_FMOTCUR
#define PARID_ACT_FMOTCUR
Definition: ProtocolCommands.h:191
PARID_DEF_BRAKETIMEOUT
#define PARID_DEF_BRAKETIMEOUT
Definition: ProtocolCommands.h:135
CDevice::getDioData
int getDioData(int iModuleId, unsigned long *puiValue)
Definition: Device.cpp:825
CDevice::getMinPos
int getMinPos(int iModuleId, float *pfValue)
Definition: Device.cpp:965
CDevice::setDefBrakeTimeOut
int setDefBrakeTimeOut(int iModuleId, unsigned short uiValue)
Definition: Device.cpp:3160
PARID_DEF_FMINPOS
#define PARID_DEF_FMINPOS
Definition: ProtocolCommands.h:120
CDevice::CDevice
CDevice(void)
default constructor
Definition: Device.cpp:72
CDevice::m_acName
char m_acName[128]
Definition: Device.h:41
PARID_DEF_FMAXDELTAPOS
#define PARID_DEF_FMAXDELTAPOS
Definition: ProtocolCommands.h:122
PARID_ACT_MAXMOTOR
#define PARID_ACT_MAXMOTOR
Definition: ProtocolCommands.h:199
CDevice::getDefBrakeTimeOut
int getDefBrakeTimeOut(int iModuleId, unsigned short *puiValue)
Definition: Device.cpp:464
CDevice::waitForMotionEndAll
int waitForMotionEndAll(unsigned long uiTimeOut=60000)
Definition: Device.cpp:4505
CDevice::getDamp
int getDamp(int iModuleId, short *piValue)
Definition: Device.cpp:885
CDevice::getRevision
const char * getRevision()
gets the revision string of the class
Definition: Device.cpp:116
CDevice::getDefBurnCount
int getDefBurnCount(int iModuleId, unsigned char *pucValue)
Definition: Device.cpp:364
CDevice::setDefIncPerTurn
int setDefIncPerTurn(int iModuleId, unsigned long uiValue)
Definition: Device.cpp:3128
TYPEID_MOD_LINEAR
#define TYPEID_MOD_LINEAR
Definition: m5apiw32.h:156
CDevice::xack8Bytes
int xack8Bytes(int iModuleId, void *pBytes)
Definition: Device.cpp:4721
CDevice::getSavePos
int getSavePos(int iModuleId, float *pfValue)
Definition: Device.cpp:1106
CDevice::getDefMaxCur
int getDefMaxCur(int iModuleId, float *pfValue)
Definition: Device.cpp:705
PARID_ACT_MINLOGIC
#define PARID_ACT_MINLOGIC
Definition: ProtocolCommands.h:196
CDevice::updateModuleIdMap
int updateModuleIdMap()
Definition: Device.cpp:3779
CDevice::getLogicSupply
int getLogicSupply(int iModuleId, float *pfValue)
Definition: Device.cpp:1808
PARID_DEF_FCUROFFSET
#define PARID_DEF_FCUROFFSET
Definition: ProtocolCommands.h:123
CDevice::getIPolVel
int getIPolVel(int iModuleId, float *pValue)
Definition: Device.cpp:1138
CDevice::setRampAcc
int setRampAcc(int iModuleId, float fValue)
Definition: Device.cpp:2800
CDevice::setMaxMotorVoltage
int setMaxMotorVoltage(int iModuleId, float fValue)
Definition: Device.cpp:3416
CDevice::setMinPos
int setMinPos(int iModuleId, float fValue)
Definition: Device.cpp:2476
PARID_ACT_DAMP
#define PARID_ACT_DAMP
Definition: ProtocolCommands.h:165
ERRID_DEV_WRONGMODULEID
#define ERRID_DEV_WRONGMODULEID
Definition: m5apiw32.h:232
PARID_ACT_RAWTEMP
#define PARID_ACT_RAWTEMP
Definition: ProtocolCommands.h:189
CDevice::setModuleSerialNo
int setModuleSerialNo(int iModuleId, unsigned long uiValue)
Definition: Device.cpp:3096
CDevice::setDefCANBaudRate
int setDefCANBaudRate(int iModuleId, unsigned char uiValue)
Definition: Device.cpp:3224
CDevice::writeLong
virtual int writeLong(int iModuleId, int iCommandId, int iParameterId, long iData)=0
PARID_DEF_FMAXACC
#define PARID_DEF_FMAXACC
Definition: ProtocolCommands.h:126
PARID_ACT_RAWLOGICSUPPLY
#define PARID_ACT_RAWLOGICSUPPLY
Definition: ProtocolCommands.h:190
CDevice::getHMaxCurOvershootTime
int getHMaxCurOvershootTime(int iModuleId, long *piValue)
Definition: Device.cpp:2192
CDevice::getTemperature
int getTemperature(int iModuleId, float *pfValue)
Definition: Device.cpp:1776
CDevice::xmit8Bytes
int xmit8Bytes(int iModuleId, void *pBytes)
Definition: Device.cpp:4708
CDevice::setConfig
int setConfig(int iModuleId, unsigned long puiValue)
Definition: Device.cpp:2336
CDevice::waitForHomeEnd
int waitForHomeEnd(int iModuleId, unsigned long uiTimeOut=60000)
Definition: Device.cpp:4242
CDevice::getInitFlag
bool getInitFlag()
gets the init flag
Definition: Device.cpp:111
STATEID_MOD_RAMP_STEADY
#define STATEID_MOD_RAMP_STEADY
Definition: m5apiw32.h:70
CDevice::setHMaxCurOvershootTime
int setHMaxCurOvershootTime(int iModuleId, long iValue)
Definition: Device.cpp:3672
CDevice::setA0
int setA0(int iModuleId, short iValue)
Definition: Device.cpp:2416
CDevice::haltModule
int haltModule(int iModuleId)
Definition: Device.cpp:3831
PARID_ACT_MAXPWMOUTPUT
#define PARID_ACT_MAXPWMOUTPUT
Definition: ProtocolCommands.h:211
PARID_ACT_IMAXVEL
#define PARID_ACT_IMAXVEL
Definition: ProtocolCommands.h:174
PARID_ACT_RAWMOTCUR
#define PARID_ACT_RAWMOTCUR
Definition: ProtocolCommands.h:187
CDevice::setMinLogicVoltage
int setMinLogicVoltage(int iModuleId, float fValue)
Definition: Device.cpp:3320
CDevice::getMaxVelInc
int getMaxVelInc(int iModuleId, long *piValue)
Definition: Device.cpp:1278
CDevice::reinit
virtual int reinit(unsigned char ucBaudRateId)=0
CDevice::setDefGearRatio
int setDefGearRatio(int iModuleId, float fValue)
Definition: Device.cpp:2968
PARID_DEF_FMAXPOS
#define PARID_DEF_FMAXPOS
Definition: ProtocolCommands.h:121
PARID_ACT_STATE
#define PARID_ACT_STATE
Definition: ProtocolCommands.h:141
CDevice::m_acRevision
char m_acRevision[20]
Definition: Device.h:43
PARID_MOVE_FVEL_EXT
#define PARID_MOVE_FVEL_EXT
Definition: ProtocolCommands.h:110
CDevice::getCur
int getCur(int iModuleId, float *pfCur)
Definition: Device.cpp:945
CDevice::setNominalMotorCurrent
int setNominalMotorCurrent(int iModuleId, float fValue)
Definition: Device.cpp:3448
CDevice::m_iModuleCountMax
int m_iModuleCountMax
Definition: Device.h:46
CDevice::waitForMotionEnd
int waitForMotionEnd(int iModuleId, unsigned long uiTimeOut=60000)
Definition: Device.cpp:4286
PARID_ACT_IHOMEOFFSET
#define PARID_ACT_IHOMEOFFSET
Definition: ProtocolCommands.h:144
CMDID_WATCHDOG
#define CMDID_WATCHDOG
Definition: ProtocolCommands.h:64
CMDID_RESET
#define CMDID_RESET
Definition: ProtocolCommands.h:59
CDevice::getRawMotorCurrent
int getRawMotorCurrent(int iModuleId, short *piValue)
Definition: Device.cpp:1488
CDevice::readFloat
virtual int readFloat(int iModuleId, int iCommandId, int iParameterId, float *pfData)=0
PARID_MOVE_FSTEP
#define PARID_MOVE_FSTEP
Definition: ProtocolCommands.h:101
CDevice::getDefDioData
int getDefDioData(int iModuleId, unsigned long *puiValue)
Definition: Device.cpp:504
CStopWatch::stop
void stop()
Definition: StopWatch.cpp:236
CDevice::setDamp
int setDamp(int iModuleId, short iValue)
Definition: Device.cpp:2456
CDevice::getDeltaPos
int getDeltaPos(int iModuleId, float *pfValue)
Definition: Device.cpp:1066
PARID_ACT_LOADDELTATIME
#define PARID_ACT_LOADDELTATIME
Definition: ProtocolCommands.h:185
PARID_ACT_FPOSSTATEDIO
#define PARID_ACT_FPOSSTATEDIO
Definition: ProtocolCommands.h:178
CDevice::getMaxPos
int getMaxPos(int iModuleId, float *pfValue)
Definition: Device.cpp:985
CMessage::error
void error(const int iErrorCode, const char *pcErrorMessage,...) const
Definition: Message.cpp:204
CDevice::waitForRampEnd
int waitForRampEnd(int iModuleId, unsigned long uiTimeOut=60000)
Definition: Device.cpp:4330
PARID_ACT_FRAMPACC
#define PARID_ACT_FRAMPACC
Definition: ProtocolCommands.h:160
CDevice::getDeltaPosInc
int getDeltaPosInc(int iModuleId, long *piValue)
Definition: Device.cpp:1318
CDevice::m_aiModuleId
std::vector< int > m_aiModuleId
Definition: Device.h:47
CDevice::getLoadDeltaTime
int getLoadDeltaTime(int iModuleId, unsigned short *piValue)
Definition: Device.cpp:1680
PARID_ACT_DIODATA
#define PARID_ACT_DIODATA
Definition: ProtocolCommands.h:140
STATEID_MOD_MOTION
#define STATEID_MOD_MOTION
Definition: m5apiw32.h:68
PARID_ACT_FRAMPVEL
#define PARID_ACT_FRAMPVEL
Definition: ProtocolCommands.h:159
PARID_ACT_IMAXDELTAPOS
#define PARID_ACT_IMAXDELTAPOS
Definition: ProtocolCommands.h:171
PARID_MOVE_FRAMP
#define PARID_MOVE_FRAMP
Definition: ProtocolCommands.h:100
PARID_ACT_FHOMEVEL
#define PARID_ACT_FHOMEVEL
Definition: ProtocolCommands.h:180
CDevice::getMotorOvershootTime
int getMotorOvershootTime(int iModuleId, long *piValue)
Definition: Device.cpp:2128
CDevice::getMinPosInc
int getMinPosInc(int iModuleId, long *piValue)
Definition: Device.cpp:1238
CDevice::getLogicUndershootTime
int getLogicUndershootTime(int iModuleId, long *piValue)
Definition: Device.cpp:2032
PARID_DEF_CANBAUDRATE
#define PARID_DEF_CANBAUDRATE
Definition: ProtocolCommands.h:137
CDevice::setMinMotorVoltage
int setMinMotorVoltage(int iModuleId, float fValue)
Definition: Device.cpp:3384
CDevice::setDefSetup
int setDefSetup(int iModuleId, unsigned long uiValue)
Definition: Device.cpp:3288
PARID_ACT_LOGICOVERSHOOT
#define PARID_ACT_LOGICOVERSHOOT
Definition: ProtocolCommands.h:203
PARID_ACT_A0
#define PARID_ACT_A0
Definition: ProtocolCommands.h:166
CDevice::getMotorSupply
int getMotorSupply(int iModuleId, float *pfValue)
Definition: Device.cpp:1744
CDevice::setMotorOvershootTime
int setMotorOvershootTime(int iModuleId, long iValue)
Definition: Device.cpp:3608
CDevice::writeFloat
virtual int writeFloat(int iModuleId, int iCommandId, int iParameterId, float fData)=0
CDevice::readFloatUnsignedChars
virtual int readFloatUnsignedChars(int iModuleId, int iCommandId, int iParameterId, float *pfData, unsigned char *pucData1, unsigned char *pucData2)=0
PARID_ACT_IMAXPOS
#define PARID_ACT_IMAXPOS
Definition: ProtocolCommands.h:173
PARID_DEF_C0
#define PARID_DEF_C0
Definition: ProtocolCommands.h:161
PARID_MOVE_IRAMP
#define PARID_MOVE_IRAMP
Definition: ProtocolCommands.h:104
CDevice::getIncRatio
int getIncRatio(int iModuleId, float *pValue)
Definition: Device.cpp:805
CDevice::readLong
virtual int readLong(int iModuleId, int iCommandId, int iParameterId, long *piData)=0
PARID_DEF_FMAXVEL
#define PARID_DEF_FMAXVEL
Definition: ProtocolCommands.h:125
CDevice::moveVelInc
int moveVelInc(int iModuleId, long iVel)
Definition: Device.cpp:4055
CMDID_GETPARAM
#define CMDID_GETPARAM
Definition: ProtocolCommands.h:69
CDevice::setC0
int setC0(int iModuleId, short iValue)
Definition: Device.cpp:2436
CDevice::getDefMinPos
int getDefMinPos(int iModuleId, float *pfValue)
Definition: Device.cpp:625
PARID_MOVE_FSTEP_EXT
#define PARID_MOVE_FSTEP_EXT
Definition: ProtocolCommands.h:109
ERRID_DEV_MODULEERROR
#define ERRID_DEV_MODULEERROR
Definition: m5apiw32.h:233
CDevice::moveVelExtended
int moveVelExtended(int iModuleId, float fCur, unsigned long *puiState, unsigned char *pucDio, float *pfPos)
Definition: Device.cpp:4165
ERRID_DEV_NOTINITIALIZED
#define ERRID_DEV_NOTINITIALIZED
Definition: m5apiw32.h:211
CDevice::getDefHomeOffset
int getDefHomeOffset(int iModuleId, float *pfValue)
Definition: Device.cpp:585
CDevice::getMaxPWMOutput
int getMaxPWMOutput(int iModuleId, long *piValue)
Definition: Device.cpp:2288
CDevice::getDefSetup
int getDefSetup(int iModuleId, unsigned long *puiValue)
Definition: Device.cpp:272
CDevice::setHomeVel
int setHomeVel(int iModuleId, float fValue)
Definition: Device.cpp:2696
CDevice::getDefIncPerTurn
int getDefIncPerTurn(int iModuleId, unsigned long *puiValue)
Definition: Device.cpp:484
CDevice::setMaxDeltaPosInc
int setMaxDeltaPosInc(int iModuleId, long iValue)
Definition: Device.cpp:2676
CDevice::waitForRampEndAll
int waitForRampEndAll(unsigned long uiTimeOut=60000)
Definition: Device.cpp:4548
PARID_ACT_MAXLOADGRADIENT
#define PARID_ACT_MAXLOADGRADIENT
Definition: ProtocolCommands.h:184
CStopWatch::executionTime
double executionTime()
Definition: StopWatch.cpp:166
PARID_ACT_FMAXCUR
#define PARID_ACT_FMAXCUR
Definition: ProtocolCommands.h:157
CDevice::operator=
CDevice & operator=(const CDevice &rclDevice)
Definition: Device.cpp:99
CDevice::getMotorCurrent
int getMotorCurrent(int iModuleId, float *pfValue)
Definition: Device.cpp:1712
CONFIGID_MOD_LINEAR
#define CONFIGID_MOD_LINEAR
Definition: m5apiw32.h:109
CDevice::getDefLinearRatio
int getDefLinearRatio(int iModuleId, float *pfValue)
Definition: Device.cpp:404
CDevice::getDefC0
int getDefC0(int iModuleId, short *piValue)
Definition: Device.cpp:545
CDevice::moveVel
int moveVel(int iModuleId, float fVel)
Definition: Device.cpp:3953
CDevice::getDefGearRatio
int getDefGearRatio(int iModuleId, float *pfValue)
Definition: Device.cpp:384
CDevice::getVel
int getVel(int iModuleId, float *pfVel)
Definition: Device.cpp:925
PARID_DEF_DAMP
#define PARID_DEF_DAMP
Definition: ProtocolCommands.h:162
PARID_DEF_FGEARRATIO
#define PARID_DEF_FGEARRATIO
Definition: ProtocolCommands.h:118
CDevice::setInitString
void setInitString(const char *acInitString)
Definition: Device.cpp:2331
CDevice::setDefHomeAcc
int setDefHomeAcc(int iModuleId, float fValue)
Definition: Device.cpp:3064
CDevice::getMaxVel
int getMaxVel(int iModuleId, float *pfValue)
Definition: Device.cpp:1006
CDevice::getStateDioPos
int getStateDioPos(int iModuleId, unsigned long *puiState, unsigned char *pucDio, float *pfPos)
Definition: Device.cpp:1358
PARID_ACT_FMAXDELTAPOS
#define PARID_ACT_FMAXDELTAPOS
Definition: ProtocolCommands.h:150
PARID_ACT_SYNCTIME
#define PARID_ACT_SYNCTIME
Definition: ProtocolCommands.h:182
CDevice::setMaxPosInc
int setMaxPosInc(int iModuleId, long iValue)
Definition: Device.cpp:2616
CDevice::getC0
int getC0(int iModuleId, short *piValue)
Definition: Device.cpp:865
CDevice::getRawTemperature
int getRawTemperature(int iModuleId, short *piValue)
Definition: Device.cpp:1552
CDevice::setLogicOvershootTime
int setLogicOvershootTime(int iModuleId, long iValue)
Definition: Device.cpp:3544
CDevice::saveParameters
int saveParameters(int iModuleId)
Definition: Device.cpp:3891
CDevice::writeAll
virtual int writeAll(int iCommandId, int iParameterId)=0
CDevice::setDefAddress
int setDefAddress(int iModuleId, unsigned char uiValue)
Definition: Device.cpp:3192
CDevice::haltAll
int haltAll(void)
Definition: Device.cpp:4637
CDevice::getMaxMotorVoltage
int getMaxMotorVoltage(int iModuleId, float *pfValue)
Definition: Device.cpp:1936
CDevice::charStateToLongState
void charStateToLongState(unsigned char uiShort, unsigned long *puiState)
Definition: Device.cpp:45
CDevice::m_auiModuleVersion
std::vector< unsigned short > m_auiModuleVersion
Definition: Device.h:48
CDevice::setBaudRateAll
int setBaudRateAll(unsigned char ucBaudRateId)
Definition: Device.cpp:4663
PARID_ACT_IDELTAPOS
#define PARID_ACT_IDELTAPOS
Definition: ProtocolCommands.h:177
CDevice::setDioData
int setDioData(int iModuleId, unsigned long uiValue)
Definition: Device.cpp:2396
CDevice::getSyncTime
int getSyncTime(int iModuleId, short *piValue)
Definition: Device.cpp:1456
CDevice::getModuleSerialNo
int getModuleSerialNo(int iModuleId, unsigned long *puiValue)
Definition: Device.cpp:231
CDevice::getDefMaxDeltaPos
int getDefMaxDeltaPos(int iModuleId, float *pfValue)
Definition: Device.cpp:725
CDevice::getVelInc
int getVelInc(int iModuleId, long *piValue)
Definition: Device.cpp:1198
CDevice::movePosExtended
int movePosExtended(int iModuleId, float fPos, unsigned long *puiState, unsigned char *pucDio, float *pfPos)
Definition: Device.cpp:4115
PARID_DEF_SETUP
#define PARID_DEF_SETUP
Definition: ProtocolCommands.h:168
CDevice::getHomeOffsetInc
int getHomeOffsetInc(int iModuleId, long *piValue)
Definition: Device.cpp:785
PARID_ACT_FHOMEOFFSET
#define PARID_ACT_FHOMEOFFSET
Definition: ProtocolCommands.h:169
CDevice::getNomCurOvershootTime
int getNomCurOvershootTime(int iModuleId, long *piValue)
Definition: Device.cpp:2160
PARID_ACT_KP_PWMLIM
#define PARID_ACT_KP_PWMLIM
Definition: ProtocolCommands.h:209
CStopWatch::start
void start()
Definition: StopWatch.cpp:211
PARID_ACT_FIPOLVEL
#define PARID_ACT_FIPOLVEL
Definition: ProtocolCommands.h:152
PARID_DEF_FMAXCUR
#define PARID_DEF_FMAXCUR
Definition: ProtocolCommands.h:127
CDevice::getMotorUndershootTime
int getMotorUndershootTime(int iModuleId, long *piValue)
Definition: Device.cpp:2096
CDevice::moveCurExtended
int moveCurExtended(int iModuleId, float fCur, unsigned long *puiState, unsigned char *pucDio, float *pfPos)
Definition: Device.cpp:4189
CDevice::setCurrentLimit
int setCurrentLimit(int iModuleId, float fValue)
Definition: Device.cpp:3736
PARID_ACT_NOMCUROVERSHOOT
#define PARID_ACT_NOMCUROVERSHOOT
Definition: ProtocolCommands.h:206
CMessage::warning
void warning(const char *pcWarningMessage,...) const
Definition: Message.cpp:257
PARID_ACT_FMAXACC
#define PARID_ACT_FMAXACC
Definition: ProtocolCommands.h:156
CDevice::getDefMaxVel
int getDefMaxVel(int iModuleId, float *pfValue)
Definition: Device.cpp:665
PARID_ACT_FLOGICSUPPLY
#define PARID_ACT_FLOGICSUPPLY
Definition: ProtocolCommands.h:194
CDevice::~CDevice
virtual ~CDevice()
destructor
Definition: Device.cpp:89
CDevice::getDefA0
int getDefA0(int iModuleId, short *piValue)
Definition: Device.cpp:525
CDevice::setSyncTime
int setSyncTime(int iModuleId, short iValue)
Definition: Device.cpp:2840
CDevice::setRampVelInc
int setRampVelInc(int iModuleId, long iValue)
Definition: Device.cpp:2780
CDevice::getLoadLimit
int getLoadLimit(int iModuleId, long *piValue)
Definition: Device.cpp:1616
CDevice::getKpPWMLimit
int getKpPWMLimit(int iModuleId, long *piValue)
Definition: Device.cpp:2224
PARID_ACT_IPOS
#define PARID_ACT_IPOS
Definition: ProtocolCommands.h:170
CDevice::setNomCurOvershootTime
int setNomCurOvershootTime(int iModuleId, long iValue)
Definition: Device.cpp:3640
CDevice::getRawLogicSupply
int getRawLogicSupply(int iModuleId, short *piValue)
Definition: Device.cpp:1584
PARID_ACT_LOADLIMIT
#define PARID_ACT_LOADLIMIT
Definition: ProtocolCommands.h:183
PARID_MOVE_ICUR
#define PARID_MOVE_ICUR
Definition: ProtocolCommands.h:107
PARID_DEF_FHOMEVEL
#define PARID_DEF_FHOMEVEL
Definition: ProtocolCommands.h:128
CDevice::getDefCurOffset
int getDefCurOffset(int iModuleId, float *pfValue)
Definition: Device.cpp:424
CDevice::moveCurInc
int moveCurInc(int iModuleId, long iCur)
Definition: Device.cpp:4075
PARID_DEF_FCURRATIO
#define PARID_DEF_FCURRATIO
Definition: ProtocolCommands.h:124
CDevice::getMaxAccInc
int getMaxAccInc(int iModuleId, long *piValue)
Definition: Device.cpp:1298
CDevice::setLoadDeltaTime
int setLoadDeltaTime(int iModuleId, unsigned short iValue)
Definition: Device.cpp:2936
CDevice::writeCommand
virtual int writeCommand(int iModuleId, int iCommandId)=0
CDevice::setMaxAccInc
int setMaxAccInc(int iModuleId, long iValue)
Definition: Device.cpp:2656
PARID_ACT_MOTORUNDERSHOOT
#define PARID_ACT_MOTORUNDERSHOOT
Definition: ProtocolCommands.h:204
PARID_ACT_FTEMP
#define PARID_ACT_FTEMP
Definition: ProtocolCommands.h:193
PARID_ACT_FVEL
#define PARID_ACT_FVEL
Definition: ProtocolCommands.h:151
CDevice::m_bInitFlag
bool m_bInitFlag
Definition: Device.h:40
CDevice::getDefBaudRate
int getDefBaudRate(int iModuleId, unsigned char *pucValue)
Definition: Device.cpp:304
CDevice::setMaxVelInc
int setMaxVelInc(int iModuleId, long iValue)
Definition: Device.cpp:2636
CDevice::moveRampInc
int moveRampInc(int iModuleId, long iPos, long iVel, long iAcc)
Definition: Device.cpp:4033
CDevice::getDefHomeVel
int getDefHomeVel(int iModuleId, float *pfValue)
Definition: Device.cpp:605
CDevice::recalcPIDParams
int recalcPIDParams(int iModuleId)
Definition: Device.cpp:3871
PARID_ACT_MINMOTOR
#define PARID_ACT_MINMOTOR
Definition: ProtocolCommands.h:198
CDevice::setDefLinRatio
int setDefLinRatio(int iModuleId, float fValue)
Definition: Device.cpp:3000
CDevice::getPos
int getPos(int iModuleId, float *pfPos)
Definition: Device.cpp:905
CDevice::getMaxPosInc
int getMaxPosInc(int iModuleId, long *piValue)
Definition: Device.cpp:1258
CDevice::setRampAccInc
int setRampAccInc(int iModuleId, long iValue)
Definition: Device.cpp:2820
PARID_ACT_MOTOROVERSHOOT
#define PARID_ACT_MOTOROVERSHOOT
Definition: ProtocolCommands.h:205
CMDID_SETMOVE
#define CMDID_SETMOVE
Definition: ProtocolCommands.h:70
CDevice::setKpPWMLimit
int setKpPWMLimit(int iModuleId, long iValue)
Definition: Device.cpp:3704
CDevice::getMaximumMotorCurrent
int getMaximumMotorCurrent(int iModuleId, float *pfValue)
Definition: Device.cpp:2000
CDevice::homeAll
int homeAll(void)
Definition: Device.cpp:4611
ERRID_DEV_WAITTIMEOUT
#define ERRID_DEV_WAITTIMEOUT
Definition: m5apiw32.h:234
CDevice::getModuleVersion
int getModuleVersion(int iModuleId, unsigned short *puiValue)
Definition: Device.cpp:211
CMDID_SETPARAM
#define CMDID_SETPARAM
Definition: ProtocolCommands.h:66
CDevice::writeFloatShort
virtual int writeFloatShort(int iModuleId, int iCommandId, int iParameterId, float fData, short iTime)=0
CDevice::getMaxDeltaPosInc
int getMaxDeltaPosInc(int iModuleId, long *piValue)
Definition: Device.cpp:1338
STATEID_MOD_SWR
#define STATEID_MOD_SWR
Definition: m5apiw32.h:63
CMessage::debug
void debug(const int iDebugLevel, const char *pcDebugMessage,...) const
Definition: Message.cpp:332
CDevice::m_clTimer
CStopWatch m_clTimer
Definition: Device.h:49
PARID_MOVE_FCUR_EXT
#define PARID_MOVE_FCUR_EXT
Definition: ProtocolCommands.h:111
CDevice::getMaxAcc
int getMaxAcc(int iModuleId, float *pfValue)
Definition: Device.cpp:1026
CDevice::moveStepExtended
int moveStepExtended(int iModuleId, float fPos, unsigned short uiTime, unsigned long *puiState, unsigned char *pucDio, float *pfPos)
Definition: Device.cpp:4213
PARID_ACT_IMAXACC
#define PARID_ACT_IMAXACC
Definition: ProtocolCommands.h:175
CDevice
Definition: Device.h:28
CMDID_STARTMOVE
#define CMDID_STARTMOVE
Definition: ProtocolCommands.h:73
TYPEID_MOD_ROTARY
#define TYPEID_MOD_ROTARY
Definition: m5apiw32.h:155
CDevice::writeFloatShortReadFloatUnsignedChars
virtual int writeFloatShortReadFloatUnsignedChars(int iModuleId, int iCommandId, int iParameterId, float fData, short iData, float *pfData, unsigned char *pucData1, unsigned char *pucData2)=0
CDevice::getPosCountInc
int getPosCountInc(int iModuleId, long *piValue)
Definition: Device.cpp:1158
PARID_ACT_FINCRATIO
#define PARID_ACT_FINCRATIO
Definition: ProtocolCommands.h:147
PARID_ACT_IRAMPVEL
#define PARID_ACT_IRAMPVEL
Definition: ProtocolCommands.h:142
STATEID_MOD_SW1
#define STATEID_MOD_SW1
Definition: m5apiw32.h:64
CDevice::getStateInternal
int getStateInternal(int iModuleId, unsigned long *pBytes)
Definition: Device.cpp:4750
CDevice::resetAll
int resetAll(void)
Definition: Device.cpp:4624
CDevice::setHomeVelInc
int setHomeVelInc(int iModuleId, long iValue)
Definition: Device.cpp:2728
CDevice::waitForRampSteady
int waitForRampSteady(int iModuleId, unsigned long uiTimeOut=60000)
Definition: Device.cpp:4418
CDevice::waitForHomeEndAll
int waitForHomeEndAll(unsigned long uiTimeOut=60000)
Definition: Device.cpp:4462
STATEID_MOD_SW2
#define STATEID_MOD_SW2
Definition: m5apiw32.h:65
CDevice::getInitString
const char * getInitString()
gets the init string of the device
Definition: Device.cpp:126
CDevice::getCurrentLimit
int getCurrentLimit(int iModuleId, float *pfValue)
Definition: Device.cpp:2256
PARID_ACT_CONFIG
#define PARID_ACT_CONFIG
Definition: ProtocolCommands.h:146
CDevice::m_iModuleCount
int m_iModuleCount
Definition: Device.h:45
CDevice::setHomeOffset
int setHomeOffset(int iModuleId, float fValue)
Definition: Device.cpp:2356
STATEID_MOD_RAMP_END
#define STATEID_MOD_RAMP_END
Definition: m5apiw32.h:72
PARID_MOVE_IVEL
#define PARID_MOVE_IVEL
Definition: ProtocolCommands.h:106
PARID_DEF_CONFIG
#define PARID_DEF_CONFIG
Definition: ProtocolCommands.h:132
PARID_ACT_IRAMPACC
#define PARID_ACT_IRAMPACC
Definition: ProtocolCommands.h:143
PARID_DEF_SERIALNO
#define PARID_DEF_SERIALNO
Definition: ProtocolCommands.h:131
STATEID_MOD_RAMP_DEC
#define STATEID_MOD_RAMP_DEC
Definition: m5apiw32.h:71
CDevice::movePosInc
int movePosInc(int iModuleId, long iPos)
Definition: Device.cpp:4013
PARID_ACT_MAXLOGIC
#define PARID_ACT_MAXLOGIC
Definition: ProtocolCommands.h:197
CDevice::getDefCurRatio
int getDefCurRatio(int iModuleId, float *pfValue)
Definition: Device.cpp:444
CDevice::moveCur
int moveCur(int iModuleId, float fCur)
Definition: Device.cpp:3973
PARID_ACT_CURRENTLIMIT
#define PARID_ACT_CURRENTLIMIT
Definition: ProtocolCommands.h:210
CDevice::setMaxAcc
int setMaxAcc(int iModuleId, float fValue)
Definition: Device.cpp:2536
PARID_ACT_IPOSCOUNT
#define PARID_ACT_IPOSCOUNT
Definition: ProtocolCommands.h:139
PARID_ACT_NOMCUR
#define PARID_ACT_NOMCUR
Definition: ProtocolCommands.h:200
PARID_ACT_FSAVEPOS
#define PARID_ACT_FSAVEPOS
Definition: ProtocolCommands.h:179
CDevice::waitForStartMotionAll
virtual int waitForStartMotionAll()
Definition: Device.cpp:4591
PARID_MOVE_FCUR
#define PARID_MOVE_FCUR
Definition: ProtocolCommands.h:103
CDevice::getLogicOvershootTime
int getLogicOvershootTime(int iModuleId, long *piValue)
Definition: Device.cpp:2064
PARID_MOVE_FVEL
#define PARID_MOVE_FVEL
Definition: ProtocolCommands.h:102
CDevice::getBaudRate
int getBaudRate(void)
gets the baud rate of the device
Definition: Device.cpp:131
CDevice::getPosInc
int getPosInc(int iModuleId, long *piValue)
Definition: Device.cpp:1178
CMDID_SAVEPARAMS
#define CMDID_SAVEPARAMS
Definition: ProtocolCommands.h:74
CDevice::write8Bytes
virtual int write8Bytes(int iModuleId, bool ack, void *pBytes)=0
PARID_ACT_HMAXCUR
#define PARID_ACT_HMAXCUR
Definition: ProtocolCommands.h:201
CDevice::getDefRSBaudRate
int getDefRSBaudRate(int iModuleId, unsigned char *pucValue)
Definition: Device.cpp:344
CMDID_HOME
#define CMDID_HOME
Definition: ProtocolCommands.h:60
STATEID_MOD_INPROGRESS
#define STATEID_MOD_INPROGRESS
Definition: m5apiw32.h:73
CDevice::getDefCANBaudRate
int getDefCANBaudRate(int iModuleId, unsigned char *pucValue)
Definition: Device.cpp:324
PARID_ACT_FMAXVEL
#define PARID_ACT_FMAXVEL
Definition: ProtocolCommands.h:155
PARID_ACT_FPOS
#define PARID_ACT_FPOS
Definition: ProtocolCommands.h:148
PARID_DEF_INCPERTURN
#define PARID_DEF_INCPERTURN
Definition: ProtocolCommands.h:133
CDevice::waitForRampDec
int waitForRampDec(int iModuleId, unsigned long uiTimeOut=60000)
Definition: Device.cpp:4374
CDevice::readShort
virtual int readShort(int iModuleId, int iCommandId, int iParameterId, short *piData)=0
CDevice::readUnsignedShort
virtual int readUnsignedShort(int iModuleId, int iCommandId, int iParameterId, unsigned short *puiData)=0
ERRID_DEV_FUNCTIONNOTAVAILABLE
#define ERRID_DEV_FUNCTIONNOTAVAILABLE
Definition: m5apiw32.h:206
CDevice::writeLongShort
virtual int writeLongShort(int iModuleId, int iCommandId, int iParameterId, long iData, short iTime)=0
CDevice::setRampVel
int setRampVel(int iModuleId, float fValue)
Definition: Device.cpp:2760
CMDID_SAVEPOS
#define CMDID_SAVEPOS
Definition: ProtocolCommands.h:72
CDevice::setHomeOffsetInc
int setHomeOffsetInc(int iModuleId, long iValue)
Definition: Device.cpp:2376
CDevice::writeChar
virtual int writeChar(int iModuleId, int iCommandId, int iParameterId, char cData)=0
CDevice::getRawMotorSupply
int getRawMotorSupply(int iModuleId, short *piValue)
Definition: Device.cpp:1520
PARID_ACT_IMINPOS
#define PARID_ACT_IMINPOS
Definition: ProtocolCommands.h:172
CDevice::getMaxDeltaPos
int getMaxDeltaPos(int iModuleId, float *pfValue)
Definition: Device.cpp:1086
PARID_DEF_BURNCOUNT
#define PARID_DEF_BURNCOUNT
Definition: ProtocolCommands.h:167
CDevice::setMotorUndershootTime
int setMotorUndershootTime(int iModuleId, long iValue)
Definition: Device.cpp:3576
CDevice::moveStep
int moveStep(int iModuleId, float fPos, unsigned short uiTime)
Definition: Device.cpp:3993
PARID_ACT_FCUR
#define PARID_ACT_FCUR
Definition: ProtocolCommands.h:158
CDevice::getMinLogicVoltage
int getMinLogicVoltage(int iModuleId, float *pfValue)
Definition: Device.cpp:1840
CDevice::writeShort
virtual int writeShort(int iModuleId, int iCommandId, int iParameterId, short iData)=0
CDevice::getModuleIdMap
int getModuleIdMap(std::vector< int > &raiModuleId)
gets the module ID map of the open device
Definition: Device.cpp:148
STATEID_MOD_HOME
#define STATEID_MOD_HOME
Definition: m5apiw32.h:58
CDevice::moveRampExtended
int moveRampExtended(int iModuleId, float fPos, float fVel, float fAcc, unsigned long *puiState, unsigned char *pucDio, float *pfPos)
Definition: Device.cpp:4139
CDevice::getModuleType
int getModuleType(int iModuleId, unsigned char *pucValue)
Definition: Device.cpp:184
newDevice
CDevice * newDevice(const char *acInitString)
Definition: Device.cpp:4768
CDevice::getCurInc
int getCurInc(int iModuleId, short *piValue)
Definition: Device.cpp:1218
STATEID_MOD_ERROR
#define STATEID_MOD_ERROR
Definition: m5apiw32.h:57
CDevice::startMotionAll
int startMotionAll(void)
Definition: Device.cpp:4677
CDevice::m_iErrorState
int m_iErrorState
Definition: Device.h:50
CDevice::setMaxVel
int setMaxVel(int iModuleId, float fValue)
Definition: Device.cpp:2516
CDevice::readUnsignedLong
virtual int readUnsignedLong(int iModuleId, int iCommandId, int iParameterId, unsigned long *puiData)=0
PARID_ACT_IHOMEVEL
#define PARID_ACT_IHOMEVEL
Definition: ProtocolCommands.h:181
CDevice::getMaxCur
int getMaxCur(int iModuleId, float *pfValue)
Definition: Device.cpp:1046
CDevice::getA0
int getA0(int iModuleId, short *piValue)
Definition: Device.cpp:845
CDevice::setMaxCur
int setMaxCur(int iModuleId, float fValue)
Definition: Device.cpp:2556
CDevice::getConfig
int getConfig(int iModuleId, unsigned long *puiValue)
Definition: Device.cpp:745
CDevice::writeUnsignedLong
virtual int writeUnsignedLong(int iModuleId, int iCommandId, int iParameterId, unsigned long uiData)=0
CDevice::setMaxLogicVoltage
int setMaxLogicVoltage(int iModuleId, float fValue)
Definition: Device.cpp:3352
CDevice::getModuleState
int getModuleState(int iModuleId, unsigned long *puiState)
Definition: Device.cpp:164
PARID_ACT_FDELTAPOS
#define PARID_ACT_FDELTAPOS
Definition: ProtocolCommands.h:149
STATEID_MOD_FULLBUFFER
#define STATEID_MOD_FULLBUFFER
Definition: m5apiw32.h:74
CDevice::moveStepInc
int moveStepInc(int iModuleId, long iPos, unsigned short uiTime)
Definition: Device.cpp:4095
CDevice::setLogicUndershootTime
int setLogicUndershootTime(int iModuleId, long iValue)
Definition: Device.cpp:3512
CDevice::getMaxLoadGradient
int getMaxLoadGradient(int iModuleId, long *piValue)
Definition: Device.cpp:1648
CDevice::setMinPosInc
int setMinPosInc(int iModuleId, long iValue)
Definition: Device.cpp:2596
CDevice::doInternal
int doInternal(int iModuleId, void *pBytes)
Definition: Device.cpp:4734
CDevice::readUnsignedChar
virtual int readUnsignedChar(int iModuleId, int iCommandId, int iParameterId, unsigned char *pucData)=0
PARID_ACT_LOGICUNDERSHOOT
#define PARID_ACT_LOGICUNDERSHOOT
Definition: ProtocolCommands.h:202
CDevice::setMaxPos
int setMaxPos(int iModuleId, float fValue)
Definition: Device.cpp:2496
CDevice::getUnsignedLong
virtual int getUnsignedLong(int iModuleId, unsigned long *puiData)=0
CDevice::setName
void setName(const char *acNameString)
sets the baud rate of the device
Definition: Device.cpp:2326
CDevice::moveRamp
int moveRamp(int iModuleId, float fPos, float fVel, float fAcc)
Definition: Device.cpp:3931
CDevice::setDefRSBaudRate
int setDefRSBaudRate(int iModuleId, unsigned char uiValue)
Definition: Device.cpp:3256
CDevice::m_acInitString
char m_acInitString[128]
Definition: Device.h:42
CDevice::getDefMaxAcc
int getDefMaxAcc(int iModuleId, float *pfValue)
Definition: Device.cpp:685
CDevice::setDefCurRatio
int setDefCurRatio(int iModuleId, float fValue)
Definition: Device.cpp:3032
CDevice::getHomeOffset
int getHomeOffset(int iModuleId, float *pValue)
Definition: Device.cpp:765
PARID_ACT_HMAXCUROVERSHOOT
#define PARID_ACT_HMAXCUROVERSHOOT
Definition: ProtocolCommands.h:207
CDevice::setLoadLimit
int setLoadLimit(int iModuleId, long iValue)
Definition: Device.cpp:2872
CDevice::getModuleCount
int getModuleCount(void)
gets the number of modules of the device
Definition: Device.cpp:136
CDevice::getDefMaxPos
int getDefMaxPos(int iModuleId, float *pfValue)
Definition: Device.cpp:645
PARID_DEF_FHOMEOFFSET
#define PARID_DEF_FHOMEOFFSET
Definition: ProtocolCommands.h:117
CDevice::resetModule
int resetModule(int iModuleId)
Definition: Device.cpp:3851
CDevice::setMaximumMotorCurrent
int setMaximumMotorCurrent(int iModuleId, float fValue)
Definition: Device.cpp:3480
CMDID_BAUDRATE
#define CMDID_BAUDRATE
Definition: ProtocolCommands.h:68
CDevice::savePosAll
int savePosAll(void)
Definition: Device.cpp:4690
PARID_ACT_IVEL
#define PARID_ACT_IVEL
Definition: ProtocolCommands.h:176
ERRID_DEV_NOMODULES
#define ERRID_DEV_NOMODULES
Definition: m5apiw32.h:220
CDevice::getNominalMotorCurrent
int getNominalMotorCurrent(int iModuleId, float *pfValue)
Definition: Device.cpp:1968
CDevice::m_iBaudRate
int m_iBaudRate
Definition: Device.h:44
CMDID_HALT
#define CMDID_HALT
Definition: ProtocolCommands.h:61
PARID_ACT_FMAXPOS
#define PARID_ACT_FMAXPOS
Definition: ProtocolCommands.h:154
PARID_DEF_FHOMEACC
#define PARID_DEF_FHOMEACC
Definition: ProtocolCommands.h:129
PARID_ACT_C0
#define PARID_ACT_C0
Definition: ProtocolCommands.h:164
PARID_DEF_VERSION
#define PARID_DEF_VERSION
Definition: ProtocolCommands.h:134
PARID_ACT_ICUR
#define PARID_ACT_ICUR
Definition: ProtocolCommands.h:145
CDevice::movePos
int movePos(int iModuleId, float fPos)
Definition: Device.cpp:3911
PARID_ACT_RAWMOTSUPPLY
#define PARID_ACT_RAWMOTSUPPLY
Definition: ProtocolCommands.h:188
CDevice::getHomeVelInc
int getHomeVelInc(int iModuleId, long *piValue)
Definition: Device.cpp:1424
CMDID_RECALCPID
#define CMDID_RECALCPID
Definition: ProtocolCommands.h:67
CDevice::setMaxLoadGradient
int setMaxLoadGradient(int iModuleId, long iValue)
Definition: Device.cpp:2904
CDevice::getDefConfig
int getDefConfig(int iModuleId, unsigned long *puiValue)
Definition: Device.cpp:252
CDevice::getName
const char * getName()
gets the name string of the open device
Definition: Device.cpp:121
PARID_DEF_RSBAUDRATE
#define PARID_DEF_RSBAUDRATE
Definition: ProtocolCommands.h:138

schunk_libm5api
Author(s): Florian Weisshardt
autogenerated on Mon Nov 25 2019 03:48:19