INOS
cinosbaseaxis.h
Go to the documentation of this file.
1//******************************************************************************
27//******************************************************************************
28
29#ifndef INC_CINOSBASEAXIS_H
30#define INC_CINOSBASEAXIS_H
31//
32//------------------------------------------------------------------------------
33// defines
34//------------------------------------------------------------------------------
35//
36#define DF_INOS_BASE_AXIS_DBT "INOS-BASE-AXIS" // db table name
37//
38#define DF_INOS_MAX_AXIS 256 // max. number of allowed axis
39//
40// --- axis states -------------------------------------------------------------
41//
42#define DF_INOS_AXIS_STATE_DISABLED -1 // static state 'disabled'
43#define DF_INOS_AXIS_STATE_UNDEFINED 0 // static state 'undefined'
44#define DF_INOS_AXIS_STATE_OFF 0 // static state 'off', same as 'undefined'
45#define DF_INOS_AXIS_STATE_ACTIVE 1 // static state 'active'
46#define DF_INOS_AXIS_STATE_READY 2 // static state 'ready'
47#define DF_INOS_AXIS_STATE_PEACE 2 // static state 'ready'
48#define DF_INOS_AXIS_STATE_PULL 3 // static state 'pull'
49#define DF_INOS_AXIS_STATE_BREAK 4 // static state 'break'
50#define DF_INOS_AXIS_STATE_COUPLED 5 // static state 'coupled'
51#define DF_INOS_AXIS_STATE_FORCE 6 // static state 'force'
52#define DF_INOS_AXIS_STATE_ACTIVATING 8 // dynamic state 'activating'
53#define DF_INOS_AXIS_STATE_INACTIVATING 9 // dynamic state 'inactivating'
54#define DF_INOS_AXIS_STATE_SYNCING 10 // dynamic state 'syncing'
55#define DF_INOS_AXIS_STATE_MOVING 11 // dynamic state 'moving'
56#define DF_INOS_AXIS_STATE_ENDLESS 12 // dynamic state 'endless'
57#define DF_INOS_AXIS_STATE_TOGGLE 13 // dynamic state 'toggle'
58#define DF_INOS_AXIS_STATE_STOPPING 14 // dynamic state 'stopping'
59#define DF_INOS_AXIS_STATE_BREAKING 15 // dynamic state 'breaking'
60#define DF_INOS_AXIS_STATE_EMSTOPPING 16 // dynamic state 'emergency stopping'
61#define DF_INOS_AXIS_STATE_MOVINGEX 17 // dynamic state 'moving ex'
62#define DF_INOS_AXIS_STATE_CURSOR 18 // dynamic state 'cursor'
63#define DF_INOS_AXIS_STATE_TRACK 19 // dynamic state 'track'
64#define DF_INOS_AXIS_STATE_MOVINGAPP 20 // dynamic state 'movingapp'
65#define DF_INOS_AXIS_STATE_MOVINGDEP 21 // dynamic state 'movingapp'
66#define DF_INOS_AXIS_STATE_RELAXING 22 // dynamic state 'relaxing'
67#define DF_INOS_AXIS_STATE_UMOVE 23 // dynamic state 'micromove' => see also DF_INOS_CONTROL_SUBSTATE_ACTIVE_UMOVE
68#define DF_INOS_AXIS_STATE_SEARCHING 24 // dynamic state 'searching touch down'
69#define DF_INOS_AXIS_STATE_DEPARTING 25 // dynamic state 'departing from touch down'
70#define DF_INOS_AXIS_STATES 27 // number of states
71//
72// --- axis substates ----------------------------------------------------------
73//
74#define DF_INOS_AXIS_SUBSTATE_TRACK_FOLLOW 0 // track mode 'follow'
75#define DF_INOS_AXIS_SUBSTATE_TRACK_KEEP 1 // track mode 'keep'
76//
77// --- axis commands -----------------------------------------------------------
78//
79#define DF_INOS_AXIS_CMD_ACTIVATE 0x00000001 // command 'Activate'
80#define DF_INOS_AXIS_CMD_INACTIVATE 0x00000002 // command 'InActivate'
81#define DF_INOS_AXIS_CMD_SYNC 0x00000004 // command 'Sync'
82#define DF_INOS_AXIS_CMD_MOVE 0x00000008 // command 'Move'
83#define DF_INOS_AXIS_CMD_ENDLESS 0x00000010 // command 'Endless'
84#define DF_INOS_AXIS_CMD_STOP 0x00000020 // command 'Stop'
85#define DF_INOS_AXIS_CMD_BREAK 0x00000040 // command 'Break'
86#define DF_INOS_AXIS_CMD_CONTINUE 0x00000080 // command 'Continue'
87#define DF_INOS_AXIS_CMD_EMSTOP 0x00000100 // command 'EmergencyStop'
88#define DF_INOS_AXIS_CMD_UPDATE 0x00000200 // command 'Update'
89#define DF_INOS_AXIS_CMD_TOGGLE 0x00000400 // command 'Toggle'
90#define DF_INOS_AXIS_CMD_MOVEEX 0x00002000 // command 'MoveEx'
91#define DF_INOS_AXIS_CMD_HANDLE_CACHE 0x00004000 // commands 'Enable,Disable,FlushCache'
92#define DF_INOS_AXIS_CMD_CURSOR 0x00008000 // command 'Cursor'
93#define DF_INOS_AXIS_CMD_TRACK 0x00010000 // command 'Track'
94#define DF_INOS_AXIS_CMD_MOVESEG 0x00020000 // command 'Seg...'
95#define DF_INOS_AXIS_CMD_COUPLING 0x00040000 // command 'couple'
96#define DF_INOS_AXIS_CMD_PULL 0x00080000 // command 'pull'
97#define DF_INOS_AXIS_CMD_MOVEAPP 0x00100000 // command 'MoveApp'
98#define DF_INOS_AXIS_CMD_MOVEDEP 0x00200000 // command 'MoveDep'
99#define DF_INOS_AXIS_CMD_ENABLE 0x00400000 // command 'Enable'
100#define DF_INOS_AXIS_CMD_DISABLE 0x00800000 // command 'Disable'
101#define DF_INOS_AXIS_CMD_COMMUTATE 0x01000000 // command 'Commutate'
102#define DF_INOS_AXIS_CMD_MOVETIME 0x02000000 // command 'MoveTime'
103#define DF_INOS_AXIS_CMD_RELAX 0x04000000 // command 'Relax'
104//
105// --- axis errors -------------------------------------------------------------
106//
107#define ER_INOS_AXIS_REJECTED 0x00000001 // command rejected
108#define ER_INOS_AXIS_FAILED 0x00000002 // command failed
109#define ER_INOS_AXIS_POS_WINDOW 0x00000004 // positioning window failed
110#define ER_INOS_AXIS_CPD_ERROR 0x00000008 // coupled axis on error
111#define ER_INOS_AXIS_CPD_DELTA 0x00000010 // coupling max delta reached
112#define ER_INOS_AXIS_CPD_CORR 0x00000020 // coupling max correction reached
113#define ER_INOS_AXIS_COM_FAILED 0x00000040 // communication to foreign controller failed
114#define ER_INOS_AXIS_RAMP_LIMIT 0x00000080 // ramp limits exceeded
115#define ER_INOS_AXIS_REJECTED_SOS 0x00000100// command SOS (safe operating stop) rejected
116#define ER_INOS_AXIS_PULL_UNDERRUN 0x00000200// pull underrun detected
117#define ER_INOS_AXIS_SLS_VIOLATION 0x00000400// emergency stop due to upcoming SLS violation
118#define ER_INOS_AXIS_SOS_VIOLATION 0x00000800// emergency stop due to upcoming SOS violation
119#define ER_INOS_AXIS_CORE_MISMATCH 0x00001000// core mismatch
120#define ER_INOS_AXIS_FORCE_CONTROL 0x00002000 // force control error pending
121#define ER_INOS_AXIS_CONTROL 0x00004000 // control error pending
122#define ER_INOS_AXIS_RAMP 0x00008000 // ramp error pending
123#define ER_INOS_AXIS_HOOK 0x00010000 // registering hook failed
124//
125// --- axis warnings -----------------------------------------------------------
126//
127#define WR_INOS_AXIS_RAMP 0x00008000 // ramp warning pending
128#define WR_INOS_AXIS_CONTROL 0x00004000 // control warning pending
129#define WR_INOS_AXIS_IGNORED 0x00000001 // command ignored
130#define WR_INOS_AXIS_CPD_CORR_IGNORED 0x00000002 // coupling correction ignored
131#define WR_INOS_AXIS_COUPLED 0x00000008 // coupled axis has warning
132#define WR_INOS_AXIS_EME_STOPPED 0x00000010 // the axis has been emergency stopped
133//
134// --- axis flags --------------------------------------------------------------
135//
136#define DF_INOS_AXIS_FLAG_ZERO 0x00000001 // zero position after move
137#define DF_INOS_AXIS_FLAG_NORM 0x00000002 // norm position after move
138#define DF_INOS_AXIS_FLAG_INCR 0x00000004 // incremental moves
139#define DF_INOS_AXIS_FLAG_SYNC 0x00000008 // live sync position
140#define DF_INOS_AXIS_FLAG_EDONE 0x00000010 // early done
141#define DF_INOS_AXIS_FLAG_AACC 0x00000020 // auto accept errors on activate
142#define DF_INOS_AXIS_FLAG_CURL 0x00000040 // current limitation
143#define DF_INOS_AXIS_FLAG_LSNCD 0x00000080 // limits only checked if synched
144#define DF_INOS_AXIS_FLAG_DISMP 0x00000100 // mapping permanently disabled
145#define DF_INOS_AXIS_FLAG_RNDNR 0x00000200 // axis has random number
146#define DF_INOS_AXIS_FLAG_PWCL 0x00000400 // limits are checked in post write
147#define DF_INOS_AXIS_FLAG_DSAP 0x00000800 // disable SetAct/SetRealPosition in case of synched
148#define DF_INOS_AXIS_FLAG_SAFETY 0x00001000 // powered by Indel safety
149#define DF_INOS_AXIS_FLAG_ESPULL 0x00002000 // emergency stop pull in case of an axis error
150#define DF_INOS_AXIS_FLAG_IGNORE_CORE 0x00004000 // ignore core mismatch failure (should only be used in desperate situations)
151#define DF_INOS_AXIS_FLAG_INPUT_SHAPING_ACTIVE 0x20000000 // temporary input shaping active
152#define DF_INOS_AXIS_FLAG_WINDOW 0x40000000 // temporary position window active
153#define DF_INOS_AXIS_FLAG_SNCD 0x80000000 // axis is synced
154//
155// --- axis sync modes ---------------------------------------------------------
156//
157#define DF_INOS_AXIS_SYNC_NOADJ 0x00 // live sync with no move adjust
158#define DF_INOS_AXIS_SYNC_ADJUST 0x01 // live sync with move adjust
159#define DF_INOS_AXIS_SYNC_STOP 0x02 // live sync with stop at sync
160//
161// --- axis norm modes ---------------------------------------------------------
162//
167#define DF_INOS_AXIS_NORM_AFTER 0x00
170#define DF_INOS_AXIS_NORM_LIVE 0x01
173#define DF_INOS_AXIS_NORM_POSITIVE 0x40
178#define DF_INOS_AXIS_NORM_ROUND 0x80
179//
180// --- axis moving direction in norm mode --------------------------------------
181//
184#define DF_INOS_AXIS_NORM_MOVE_DIR_NO 0x00
189#define DF_INOS_AXIS_NORM_MOVE_DIR_POS 0x01
194#define DF_INOS_AXIS_NORM_MOVE_DIR_NEG 0x02
199#define DF_INOS_AXIS_NORM_MOVE_DIR_SHORT 0x03
205#define DF_INOS_AXIS_NORM_MOVE_DIR_SHORT_EX 0x04
206//
207// --- axis safety types -------------------------------------------------------
208//
212#define DF_INOS_AXIS_SAFETY_EMGSTOP 0x00
217#define DF_INOS_AXIS_SAFETY_AUTO 0x01
220#define DF_INOS_AXIS_SAFETY_NONE 0x02
221//
222// --- axis emergency types ----------------------------------------------------
223//
228#define DF_INOS_AXIS_EMGT_STOP 0x00
234#define DF_INOS_AXIS_EMGT_STOP_INACTIVATE 0x01
237#define DF_INOS_AXIS_EMGT_INACTIVATE 0x02
241#define DF_INOS_AXIS_EMGT_NONE 0x03
247#define DF_INOS_AXIS_EMGT_STOP_POSITION 0x04
253#define DF_INOS_AXIS_EMGT_STOP_POSITION_INACTIVATE 0x05
254//
255// --- emergency stop special values -------------------------------------------
256//
257#define DF_PRECONFIGURED_EME_STOP_TYPE 0xffff // preconfigured (by dt2 or via inco variable) emergency stop type
261#define DF_PRECONFIGURED_EME_STOP_POS_OR_STOP 0xfffe
262#define DF_PRECONFIGURED_EME_STOP_DELAY 0xffff // preconfigured (by dt2 or via inco variable) emergency stop delay
263//
264// --- positioning type --------------------------------------------------------
265//
268#define DF_INOS_AXIS_PST_STANDARD 0x00000000
273#define DF_INOS_AXIS_PST_WINDOW 0x00000001
279#define DF_INOS_AXIS_PST_WINDOW_OPT 0x00000002
280//
281// --- axis options ------------------------------------------------------------
282//
287#define DF_INOS_BASE_AXIS_OPT_EARLY_DONE 0x00000001
294#define DF_INOS_BASE_AXIS_OPT_AUTO_ACCEPT 0x00000002
298#define DF_INOS_BASE_AXIS_OPT_LIMITS_IF_SNCD 0x00000004
303#define DF_INOS_BASE_AXIS_OPT_MAPPING_DISABLED 0x00000008
308#define DF_INOS_BASE_AXIS_OPT_NORM_ENABLED 0x00000010
313#define DF_INOS_BASE_AXIS_OPT_CHECK_LIMITS 0x00000020
318#define DF_INOS_BASE_AXIS_OPT_LIFETIME 0x00000040
323#define DF_INOS_BASE_AXIS_OPT_SETPOS_DISABLED 0x00000080
328#define DF_INOS_BASE_AXIS_OPT_EMGSTOP_PULL 0x00000100
331#define DF_INOS_BASE_AXIS_OPT_FORCE_CONTROL 0x00000200
335#define DF_INOS_BASE_AXIS_OPT_IGNORE_CORE 0x00000400
336
337#if defined(INOS_MOTORCONFIG_LOAD_SUPPORT)
344#define DF_INOS_BASE_AXIS_OPT_CPF_UNIQUE 0x00000800
345#endif
346
347// --- axis limit errors -------------------------------------------------------------
348//
349#define DF_INOS_BASE_AXIS_LIMIT_S 0x00000001 // position limit of cmdS exceeded
350#define DF_INOS_BASE_AXIS_LIMIT_V_OF_S 0x00000002 // velocity limit of cmdS exceeded
351#define DF_INOS_BASE_AXIS_LIMIT_A_OF_S 0x00000004 // accelleration ity limit of cmdS exceeded
352#define DF_INOS_BASE_AXIS_LIMIT_B_OF_S 0x00000008 // de-accelleration ity limit of cmdS exceeded
353#define DF_INOS_BASE_AXIS_LIMIT_S_V_CONS 0x00000010 // consistency error between S and V
354#define DF_INOS_BASE_AXIS_LIMIT_V 0x00000020 // velocity limit of cmdV exceeded
355#define DF_INOS_BASE_AXIS_LIMIT_A_OF_V 0x00000040 // accelleration ity limit of cmdV exceeded
356#define DF_INOS_BASE_AXIS_LIMIT_B_OF_V 0x00000080 // de-accelleration ity limit of cmdV exceeded
357#define DF_INOS_BASE_AXIS_LIMIT_A 0x00000100 // accelleration ity limit of cmdA exceeded
358#define DF_INOS_BASE_AXIS_LIMIT_B 0x00000200 // de-accelleration ity limit of cmdA exceeded
359#define DF_INOS_BASE_AXIS_LIMIT_BRAKE 0x00000400 // axis cannot stop within bordes
360#define DF_INOS_BASE_AXIS_LIMIT_J_OF_S 0x00000800 // jerk limit of cmdS exceeded
361#define DF_INOS_BASE_AXIS_LIMIT_J_OF_V 0x00001000 // jerk limit of cmdV exceeded
362#define DF_INOS_BASE_AXIS_LIMIT_J_OF_A 0x00002000 // jerk limit of cmdA exceeded
363#define DF_INOS_BASE_AXIS_LIMIT_J 0x00004000 // jerk limit of cmdJ exceeded
364
365//
366//------------------------------------------------------------------------------
367// includes
368//------------------------------------------------------------------------------
369//
370// system
371#include <cinosbus.h>
372#include <cinosbaseramp.h>
373#if defined(INOS_AXIS_EXTENSION_SUPPORT)
374#include <cinosbaseaxisextension.h>
375#endif
376//
377// C++
378//
379// project
380//
381//------------------------------------------------------------------------------
382//--- structures ---------------------------------------------------------------
383//------------------------------------------------------------------------------
384
389struct SINOSBaseAxis
390{
393 inosName64 m_cName;
394
399 inosName32 m_cRampType;
400
406 uint16 m_uNumber;
407
411 uint8 m_uCoreId;
412
415 uint8 m_uReserved;
416
428 uint32 m_uOptions;
429
435 uint8 m_uSafetyType;
436
447 uint8 m_uEmergencyType;
448
452 uint16 m_uEmergencyDelay;
453
458 uint32 m_uTestDelay;
459
462 real64 m_rTestPos1;
463
466 real64 m_rTestPos1Max;
467
470 real64 m_rTestPos2;
471
474 real64 m_rTestPos2Max;
475
479 real64 m_rEmergencyPosition;
480
483 real64 m_rTrackFactor;
484
487 uint32 m_uTrackFilterLength;
488
496 uint32 m_uPosType;
497
501 uint32 m_uPosTime;
502
506 uint32 m_uPosTimeout;
507
511 real64 m_rPosTolerance;
512
516 uint32 m_uCacheSize;
517
521 uint16 m_cShort;
522
530 uint8 m_uNormMode;
531
540 uint8 m_uNormMoveDir;
541
544 real64 m_rNormPos;
545
551 inosName32 m_cDefaultParam;
552
555 inosName32 m_cEmergencyParam;
556
559 inosName64 m_cDescription;
560
561 // constructor
562 SINOSBaseAxis();
563};
564
565//------------------------------------------------------------------------------
566// forward declarations
567//------------------------------------------------------------------------------
568//
569class CINOSMoveCache;
570class CINOSBaseAxis;
571class CINOSLimitChecker;
572//
573//------------------------------------------------------------------------------
574// class definition
575//------------------------------------------------------------------------------
576
578class CINOSBaseAxisParamSet
579{
580 //--- user interface ---------------------------------------------------
581
582 // public member functions
583 public :
584 virtual uint32 SetParam(const char* apName, real64 arValue);
585 //; universal set parameter with aName to aValue and return error code
586 //; \return 0 on success, an INCO error code otherwise, such as
587 //; defVarNotFound, defVarReadOnly, etc.
588 virtual uint32 GetParam(const char* apName, real64& arResult);
589 //; universal get parameter with aName to aResult and return error code
590 virtual CINCOObject* GetRegister(CINOSBaseAxis* apAxis);
591 //; On the first invocation, this function creates the INCO tree
592 //; for this object. Subsequent invocations just return the
593 //; previously created tree.
594 //; return pointer to my inco object
595 virtual CINCOObject* GetRegister() const;
596 //; \return Pointer to my INCO object (or NULL if non have been
597 //; created so far). This function doesn't create any INCO items,
598 //; it just returns what's currently there.
599 SINOSRampParam* GetRampParam()
600 { return &m_pRamp->m_Param;};
601
602 #if defined(INOS_AXIS_EXTENSION_SUPPORT)
604 void AddExtension(SINOSParamSetExtension* apExtension);
606 void RemoveExtension(const char* apName);
607 #endif
608
609 //--- internals --------------------------------------------------------
610
611 // my axis is my friend
612 friend class CINOSBaseAxis;
613 friend class CINOSPhysicalAxis;
614 friend class CINOSShape;
615
616 // public but just for internal use
617 public:
621 CINOSBaseAxisParamSet& operator=(const CINOSBaseAxisParamSet& aOther);
622 int operator < (CINOSBaseAxisParamSet& aSet) const
623 { return (strcmp(m_cName, aSet.m_cName)<0);}
624 int operator == (CINOSBaseAxisParamSet& aSet) const
625 { return (strcmp(m_cName, aSet.m_cName)==0);}
626 int operator < (const char* apName) const
627 { return (strcmp(m_cName, apName)<0);}
628 int operator == (const char* apName) const
629 { return (strcmp(m_cName, apName)==0);}
630 friend int operator == (CINOSBaseAxisParamSet& aSet1, CINOSBaseAxisParamSet& aSet2)
631 { return (strcmp(aSet1.m_cName, aSet2.m_cName)==0);}
632
633 // public but just for internal use
634 public:
635 explicit CINOSBaseAxisParamSet(const char* apName);
636 //; constructor
637 CINOSBaseAxisParamSet(const CINOSBaseAxisParamSet& aOther);
638 //; copy constructor, creates deep copies of the values. Note
639 //; that m_pRegister will not be copied nor created. The caller
640 //; would need to call GetRegister() to create the INCO
641 //; representation
642 virtual ~CINOSBaseAxisParamSet();
643 //; destructor
644
645 // protected members
646 protected:
647 inosName64 m_cName;
648 //; set name
649 CINCOObject* m_pRegister;
650 //; pointer to inco registration of set
651 CINOSBaseRampParamSet* m_pRamp;
652 //; pointer to ramp param set
653 uint32 m_uPosType;
654 //; positioning type [0-standard, 1-window]
655 uint32 m_uPosTime;
656 //; positioning time [ms]
657 uint32 m_uPosTimeout;
658 //; positioning timeout [ms]
659 real64 m_rPosTolerance;
660 //; positioning tolerance [unit]
661
662 // allow dynamic object handling (new/delete)
663 DECLARE_DYNAMIC(CINOSBaseAxisParamSet);
664};
666
667//------------------------------------------------------------------------------
668// class definition
669//------------------------------------------------------------------------------
670//
671typedef real64 (*tpGetter)(void* apVal);
672
673struct SINOSBaseAxisHook;
674class CINOSMapping;
675class CINOSBaseAxis
676{
677 //--- user interface ---------------------------------------------------
678
679 // public member functions
680 public :
681
686 explicit CINOSBaseAxis(SINOSBaseAxis* apDesc);
687
694 CINOSBaseAxis(SINOSBaseAxis* apDesc, CINOSBaseRamp* apRamp);
695
698 virtual ~CINOSBaseAxis();
699
704 static CINOSBaseAxis* GetAxis(const char* apAxisName);
705
710 static CINOSBaseAxis* GetAxis(uint32 auNumber)
711 {
712 if (auNumber < DF_INOS_MAX_AXIS)
713 return m_pAxis[auNumber];
714 else
715 return nullptr;
716 }
717
722 static uint8 GetNumber(const char* apAxisName);
723 //; return number of axis apAxis
724
732 virtual uint32 WaitTicks(uint32 auTicks = 1);
733
737 virtual uint32 Connect()
738 { return 0; };
739
745 virtual uint32 Enable(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
746
752 virtual uint32 Disable(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
753
755 void InitializeLimitChecker();
756
757
767 virtual uint32 Activate(bool abCheckPos = true, bool abSimulatePos = false,
768 bool abSimulateOut = false, bool abSimulateAct = false,
769 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
770
775 virtual uint32 InActivate(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
776
782 virtual uint32 Relax(uint32 auTimeMs, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
783
790 virtual uint32 Sync(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
791
800 virtual uint32 Sync(real64 arPosition, SINOSRampParam* apParam,
801 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
802
810 virtual uint32 Sync(real64 arPosition, const char* apParam,
811 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
812
820 virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
821 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
822
832 virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
833 SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
834
843 virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
844 const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
845
853 virtual uint32 Sync(real64 arSyncPos, const char* apParam, CINCOObject* apObject,
854 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
855
862 virtual uint32 Move(real64 arPosition,
863 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
864
872 virtual uint32 Move(real64 arPosition, SINOSRampParam* apParam,
873 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
874
881 virtual uint32 Move(real64 arPosition, const char* apParam,
882 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
883
894 virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5 = true,
895 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
896
909 virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5,
910 SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
911
923 virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5,
924 const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
925
940 virtual uint32 Move(real64 arPosition, real64 arSafe1, real64 arSafe2,
941 SINOSRampParam* apParam1, SINOSRampParam* apParam2, real64 arPartner, SINOSRampParam* apPartner,
942 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
943
957 virtual uint32 Move(real64 arPosition, real64 arSave1, real64 arSave2,
958 const char* apParam1, const char* apParam2, real64 arPartner, const char* apPartner,
959 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
960
971 virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity,
972 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
973
988 virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity,
989 SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
990
1005 virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity,
1006 const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
1007
1021 virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity,
1022 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
1023
1038 virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity,
1039 SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
1040
1055 virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity,
1056 const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
1057
1064 virtual uint32 Toggle(real64 arPosition1, real64 arPosition2);
1065
1076 virtual uint32 ToggleSection(real64 arPos1Min, real64 arPos1Max,
1077 real64 arPos2Min, real64 arPos2Max, uint32 auDelayMin, uint32 auDelayMax);
1078
1087 virtual uint32 Track(const char* apVarName, real64 arFactor,
1088 uint32 auFilterLength, uint32 auDirection = 0);
1089
1099 virtual uint32 Track(const char* apVarName, real64 arFactor,
1100 uint32 auFilterLength, uint32 auDirection, const char* apParam);
1101
1111 virtual uint32 Track(const char* apVarName, real64 arCmdValue,
1112 real64 arFactor, uint32 auFilterLength);
1113
1118 virtual uint32 SetTrackFactor(real64 arFactor);
1119
1125 virtual uint32 Endless(bool abPositive = true);
1126
1134 virtual uint32 Endless(bool abPositive, SINOSRampParam* apParam,
1135 CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1136
1143 virtual uint32 Endless(bool abPositive, const char* apParam,
1144 CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1145
1152 virtual uint32 Cursor(bool abPositive = true);
1153
1160 virtual uint32 Cursor(real64 arPosition);
1161
1169 virtual uint32 Cursor(bool abPositive, uint32 auWaitTime);
1170
1177 virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime);
1178
1187 virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
1188 real64 arStep);
1189
1198 virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime,
1199 real64 arStep);
1200
1210 virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
1211 real64 arStep, SINOSRampParam* apParam);
1212
1222 virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime,
1223 real64 arStep, SINOSRampParam* apParam);
1224
1234 virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
1235 real64 arStep, const char* apParam);
1236
1246 virtual uint32 Cursor(real64 arbPosition, uint32 auWaitTime,
1247 real64 arStep, const char* apParam);
1248
1254 virtual uint32 Update(CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1255
1262 virtual uint32 Update(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1263
1270 virtual uint32 Update(const char* apParam, CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1271
1276 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition);
1277
1282 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, SINOSRampParam* apParam);
1283
1288 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, const char* apParam);
1293 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta);
1298 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta,
1299 SINOSRampParam* apParam);
1304 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta, const char* apParam);
1309 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
1310 real64 arDelta);
1315 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
1316 real64 arDelta, SINOSRampParam* apParam);
1321 virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
1322 real64 arDelta, const char* apParam);
1323
1328 virtual real64 GetMoveTime(real64 arPosition);
1329
1334 virtual real64 GetAccelerationTime(real64 arPosition);
1335
1340 virtual real64 GetConstTime(real64 arPosition);
1341
1346 virtual real64 GetDecelerationTime(real64 arPosition);
1347
1353 virtual real64 GetMoveTime(real64 arPosition, SINOSRampParam* apParam);
1354
1360 virtual real64 GetAccelerationTime(real64 arPosition, SINOSRampParam* apParam);
1361
1367 virtual real64 GetConstTime(real64 arPosition, SINOSRampParam* apParam);
1368
1374 virtual real64 GetDecelerationTime(real64 arPosition, SINOSRampParam* apParam);
1375
1381 virtual real64 GetMoveTime(real64 arPosition, const char* apParam);
1382
1388 virtual real64 GetAccelerationTime(real64 arPosition, const char* apParam);
1389
1395 virtual real64 GetConstTime(real64 arPosition, const char* apParam);
1396
1402 virtual real64 GetDecelerationTime(real64 arPosition, const char* apParam);
1403
1409 virtual real64 GetMoveTime(real64 arPosition, real64 arDelta);
1410
1416 virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta);
1417
1423 virtual real64 GetConstTime(real64 arPosition, real64 arDelta);
1424
1430 virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta);
1431
1438 virtual real64 GetMoveTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1439
1446 virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1447
1454 virtual real64 GetConstTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1455
1462 virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1463
1470 virtual real64 GetMoveTime(real64 arPosition, real64 arDelta, const char* apParam);
1471
1478 virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta, const char* apParam);
1479
1486 virtual real64 GetConstTime(real64 arPosition, real64 arDelta, const char* apParam);
1487
1494 virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta, const char* apParam);
1495
1503 virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
1504 real64 arDelta);
1505
1513 virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
1514 real64 arDelta);
1515
1523 virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
1524 real64 arDelta);
1525
1533 virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
1534 real64 arDelta);
1535
1544 virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
1545 real64 arDelta, SINOSRampParam* apParam);
1546
1555 virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
1556 real64 arDelta, SINOSRampParam* apParam);
1557
1566 virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
1567 real64 arDelta, SINOSRampParam* apParam);
1568
1577 virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
1578 real64 arDelta, SINOSRampParam* apParam);
1579
1588 virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
1589 real64 arDelta, const char* apParam);
1590
1599 virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
1600 real64 arDelta, const char* apParam);
1601
1610 virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
1611 real64 arDelta, const char* apParam);
1612
1621 virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
1622 real64 arDelta, const char* apParam);
1623
1631 virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1632 real64 arVelocity);
1633
1642 virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1643 real64 arVelocity, SINOSRampParam* apParam);
1644
1653 virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1654 real64 arVelocity, const char* apParam);
1655
1664 virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1665 real64 arVelocity, real64 arDelta);
1666
1676 virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1677 real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
1678
1688 virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1689 real64 arVelocity, real64 arDelta, const char* apParam);
1690
1700 virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
1701 real64 arPositionVel, real64 arVelocity, real64 arDelta);
1702
1713 virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
1714 real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
1715
1726 virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
1727 real64 arPositionVel, real64 arVelocity, real64 arDelta, const char* apParam);
1728
1736 virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1737 real64 arVelocity);
1738
1747 virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1748 real64 arVelocity, SINOSRampParam* apParam);
1749
1758 virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1759 real64 arVelocity, const char* apParam);
1760
1769 virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1770 real64 arVelocity, real64 arDelta);
1771
1781 virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1782 real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
1783
1793 virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1794 real64 arVelocity, real64 arDelta, const char* apParam);
1795
1805 virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
1806 real64 arPositionVel, real64 arVelocity, real64 arDelta);
1807
1818 virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
1819 real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
1820
1831 virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
1832 real64 arPositionVel, real64 arVelocity, real64 arDelta, const char* apParam);
1833
1838 virtual int32 GetMoveTicks(real64 arPosition);
1839
1844 virtual int32 GetAccelerationTicks(real64 arPosition);
1845
1850 virtual int32 GetConstTicks(real64 arPosition);
1851
1856 virtual int32 GetDecelerationTicks(real64 arPosition);
1857
1863 virtual int32 GetMoveTicks(real64 arPosition, SINOSRampParam* apParam);
1864
1870 virtual int32 GetAccelerationTicks(real64 arPosition, SINOSRampParam* apParam);
1871
1877 virtual int32 GetConstTicks(real64 arPosition, SINOSRampParam* apParam);
1878
1884 virtual int32 GetDecelerationTicks(real64 arPosition, SINOSRampParam* apParam);
1885
1891 virtual int32 GetMoveTicks(real64 arPosition, const char* apParam);
1892
1898 virtual int32 GetAccelerationTicks(real64 arPosition, const char* apParam);
1899
1905 virtual int32 GetConstTicks(real64 arPosition, const char* apParam);
1906
1912 virtual int32 GetDecelerationTicks(real64 arPosition, const char* apParam);
1913
1919 virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta);
1920
1926 virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta);
1927
1933 virtual int32 GetConstTicks(real64 arPosition, real64 arDelta);
1934
1940 virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta);
1941
1948 virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1949
1956 virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1957
1964 virtual int32 GetConstTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1965
1972 virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1973
1980 virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta, const char* apParam);
1981
1988 virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta, const char* apParam);
1989
1996 virtual int32 GetConstTicks(real64 arPosition, real64 arDelta, const char* apParam);
1997
2004 virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta, const char* apParam);
2005
2013 virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
2014 real64 arDelta);
2015
2023 virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
2024 real64 arDelta);
2025
2033 virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
2034 real64 arDelta);
2035
2043 virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
2044 real64 arDelta);
2045
2054 virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
2055 real64 arDelta, SINOSRampParam* apParam);
2056
2065 virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
2066 real64 arDelta, SINOSRampParam* apParam);
2067
2076 virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
2077 real64 arDelta, SINOSRampParam* apParam);
2078
2087 virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
2088 real64 arDelta, SINOSRampParam* apParam);
2089
2098 virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
2099 real64 arDelta, const char* apParam);
2100
2109 virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
2110 real64 arDelta, const char* apParam);
2111
2120 virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
2121 real64 arDelta, const char* apParam);
2122
2131 virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
2132 real64 arDelta, const char* apParam);
2133
2137 virtual int32 GetExitTicks();
2138
2143 virtual real64 GetMoveDist(real64 arTime);
2144
2150 virtual real64 GetMoveDist(real64 arPosition, real64 arTime);
2151
2157 virtual real64 GetMoveDist(real64 arTime, SINOSRampParam* apParam);
2158
2165 virtual real64 GetMoveDist(real64 arPosition, real64 arTime,
2166 SINOSRampParam* apParam);
2167
2173 virtual real64 GetMoveDist(real64 arTime, const char* apParam);
2174
2181 virtual real64 GetMoveDist(real64 arPosition, real64 arTime,
2182 const char* apParam);
2183
2189 virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks);
2190
2197 virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks,
2198 SINOSRampParam* apParam);
2199
2206 virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks,
2207 const char* apParam);
2208
2216 virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2217 real64 arTime);
2218
2227 virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2228 real64 arTime, SINOSRampParam* apParam);
2229
2238 virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2239 real64 arTime, const char* apParam);
2240
2248 virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2249 uint32 auTicks);
2250
2259 virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2260 uint32 auTicks, SINOSRampParam* apParam);
2261
2270 virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2271 uint32 auTicks, const char* apParam);
2272
2276 virtual uint64 GetStartTicks(real64 arDelta);
2277
2281 virtual uint64 GetTargetTicks();
2282
2286 virtual uint64 GetTargetTicks(real64 arDelta);
2287
2293 virtual uint32 SegBegin(real64 arSlowMotion = REAL64(1.0), real64 arStartVelocity = REAL64(0.0));
2294
2301 virtual uint32 SegBegin(real64 arSlowMotion, real64 arStartPosition, real64 arStartVelocity);
2302
2308 virtual uint32 SegMove(real64 arPosition);
2309
2316 virtual uint32 SegMove(real64 arPosition, SINOSRampParam* apParam);
2317
2324 virtual uint32 SegMove(real64 arPosition, const char* apParam);
2325
2332 virtual uint32 SegMove(real64 arPosition, real64 arVelocity);
2333
2341 virtual uint32 SegMove(real64 arPosition, real64 arVelocity,
2342 SINOSRampParam* apParam);
2343
2351 virtual uint32 SegMove(real64 arPosition, real64 arVelocity,
2352 const char* apParam);
2353
2358 virtual uint32 SegConst(real64 arPosition);
2359
2364 virtual uint32 SegPos(real64 arTime);
2365
2371 virtual uint32 SegPosSetTime(real64 arTime);
2372
2378 virtual uint32 SegVelocity(real64 arVelocity, SINOSRampParam* apParam);
2379
2385 virtual uint32 SegVelocity(real64 arVelocity, const char* apParam);
2386
2390 virtual real64 SegTime();
2391
2396 virtual uint32 SegRun(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2397
2401 virtual uint32 WaitInPosition();
2402
2406 virtual uint32 GetBusTicksPerAxisTick();
2407
2408 // pulling
2409
2420 virtual uint32 Pull(real64 arS, real64 arV, real64 arA, real64 arJ);
2421
2430 virtual uint32 Pull(SINOSRampData& aData);
2431
2441 virtual uint32 Pull(SINOSRampDataEx* apData);
2442
2446 void EnableRamp()
2447 {
2448 // enable trajectory generator
2449 m_pRamp->Enable();
2450 };
2451
2456 void DisableRamp()
2457 {
2458 // disable trajectory generator
2459 m_pRamp->Disable();
2460 };
2461
2462 // stop/break/continue functions
2463
2468 virtual uint32 Stop(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2469
2475 virtual uint32 Stop(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2476
2482 virtual uint32 Stop(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2483
2489 virtual uint32 Stop(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2490
2497 virtual uint32 Stop(real64 arPosition, SINOSRampParam* apParam,
2498 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2499
2506 virtual uint32 Stop(real64 arPosition, const char* apParam,
2507 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2508
2515 virtual uint32 StopLive();
2516
2525 virtual uint32 StopLive(real64 arSlowMotion, SINOSRampParam* apParam);
2526
2536 virtual uint32 StopLiveDelta(real64 arDelta, real64 arSlowMotion, SINOSRampParam* apParam = nullptr);
2537
2544 virtual uint32 Break(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2545
2553 virtual uint32 Break(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2554
2562 virtual uint32 Break(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2563
2571 virtual uint32 Break(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2572
2581 virtual uint32 Break(real64 arPosition, SINOSRampParam* apParam,
2582 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2583
2592 virtual uint32 Break(real64 arPosition, const char* apParam,
2593 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2594
2600 virtual uint32 Continue(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2601
2608 virtual uint32 Continue(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2609
2616 virtual uint32 Continue(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2617
2622 virtual uint32 EmergencyStop(CINOSSync* apSync);
2623
2630 virtual uint32 EmergencyStop(uint16 auType = DF_PRECONFIGURED_EME_STOP_TYPE, uint16 auDelay = DF_PRECONFIGURED_EME_STOP_DELAY,
2631 CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2632
2639 virtual uint32 EmergencyStopLive();
2640
2649 virtual uint32 EmergencyStopLive(uint16 auType, uint16 auDelay = DF_PRECONFIGURED_EME_STOP_DELAY);
2650
2651 // get/set property functions
2652
2664 virtual const char* GetName();
2665 //; return axis name
2666 virtual const char* GetType();
2667 //; return axis type
2668 virtual const char* GetUnit();
2669 //; return axis unit
2670 virtual uint32 GetCharacteristics();
2671 //; return axis characteristics
2672 virtual uint8 GetNumber()
2673 //; return axis number
2674 { return (uint8) m_pDesc->m_uNumber;};
2675 virtual uint32 GetOptions()
2676 //; return axis options
2677 { return m_pDesc->m_uOptions;};
2678 virtual char GetShort()
2679 //; return axis short character
2680 { return m_cShort[0];};
2681 virtual void SetShort(char acShort)
2682 //; set axis short character
2683 { m_cShort[0] = acShort;};
2684 virtual void SetPartner(const char* apPartner);
2685 //; set partner axis (used for special move commands)
2686 virtual void SetPartner(CINOSBaseAxis* apPartner);
2687 //; set partner axis (used for special move commands)
2688 virtual void SetCmdPosition(real64 arPosition);
2689 //; set commanded axis position (see comment above)
2690 virtual void SetPathPosition(real64 arPosition){};
2691 //; set commanded path axis position
2692 virtual void GetCmdPosition(real64& arPosition);
2693 //; get commanded axis position (see comment above)
2694 virtual void SetCmdVelocity(real64 arVelocity);
2695 //; set commanded velocity (see comment above)
2696 virtual void GetCmdVelocity(real64& arVelocity, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
2697 //; get commanded velocity (see comment above)
2698 virtual void SetCmdAcceleration(real64 arAcceleration);
2699 //; set commanded acceleration (see comment above)
2700 virtual void GetCmdAcceleration(real64& arAcceleration, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
2701 //; get commanded acceleration (see comment above)
2702 virtual void SetCmdDeceleration(real64 arDeceleration);
2703 //; set commanded deceleration (see comment above)
2704 virtual void GetCmdDeceleration(real64& arDeceleration, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
2705 //; get commanded deceleration (see comment above)
2706 virtual void SetCmdCruiseleration(real64 arCruiseleration);
2707 //; set commanded cruiseleration (see comment above)
2708 virtual void GetCmdCruiseleration(real64& arCruiseleration);
2709 //; get commanded cruiseleration (see comment above)
2710 virtual void SetCmdJerk(real64 arJerk, uint32 auNumber = DF_INOS_RAMP_JERK_ALL);
2711 //; set commanded jerk (see comment above)
2712 virtual void GetCmdJerk(real64& arJerk, uint32 auNumber = 0);
2713 //; get commanded jerk (see comment above)
2714 virtual void SetCmdCruiseJerk(real64 arCruiseJerk);
2715 //; set commanded cruise jerk (see comment above)
2716 virtual void GetCmdCruiseJerk(real64& arCruiseJerk);
2717 //; get commanded cruise jerk (see comment above)
2718 virtual void GetCmdRealJerk(real64& arJerk, uint32 auNumber = 0);
2719 //; get commanded real jerk (see comment above)
2720 virtual void SetCmdSlowMotion(real64 arSlowMotion, bool abUpdate = false);
2721 //; set commanded slowmotion factor
2722 virtual void GetCmdSlowMotion(real64& arSlowMotion, const char* apParam = 0);
2723 //; get commanded slowmotion factor
2724 virtual void GetActSlowMotion(real64& arSlowMotion, const char* apParam = 0);
2725 //; get actual slowmotion factor (slowmotion>slowmotionmax ? slowmotionmax : slowmotion)
2726 virtual void SetCmdRelaxTime(real64 arRelaxTime);
2727 //; set commanded relax time
2728 virtual void GetCmdRelaxTime(real64& arRelaxTime);
2729 //; get commanded relax time
2730 virtual void SetEmgDeceleration(real64 arDeceleration);
2731 //; set commanded emergency deceleration
2732 virtual void GetEmgDeceleration(real64& arDeceleration);
2733 //; get commanded emergency deceleration
2734 //; get commanded relax time
2735 virtual void SetEmgPosition(real64 arPosition);
2736 //; set emergency position
2737 virtual void GetEmgPosition(real64& arPosition);
2738 //; get emergency position
2739
2740
2753 virtual uint32 SetActPosition(real64 arPosition);
2754
2766 virtual void GetActPosition(real64& arPosition, bool abRamp = true);
2767
2775 double NormPosition(real64 arPosition) const
2776 {
2777 if (m_uFlag & DF_INOS_AXIS_FLAG_NORM){
2778 // norming active
2779 return iNormPosition(arPosition, m_rNormPos, m_uNormMode & DF_INOS_AXIS_NORM_ROUND);
2780 }
2781 else {
2782 // no norming
2783 return arPosition;
2784 }
2785 }
2786
2787 virtual void GetActPosition(real64& arPosition, uint64 auTicks);
2788 //; get actual commanded position at bus ticks auTicks
2789 virtual uint32 NrmActPosition(real64 arRange = REAL64(0.0), bool abRound = false);
2790 //; norm actual position
2791 virtual void GetActVelocity(real64& arVelocity, bool abMapped = true);
2792 //; get actual commaned velocity (see comment above)
2793 virtual void GetActAcceleration(real64& arAcceleration, bool abRamp = true);
2794 //; get actual commanded acceleratio (see comment above)n
2795 virtual void GetActJerk(real64& arJerk, bool abRamp = true);
2796 //; get actual commanded jerk (see comment above)
2797 virtual uint32 AdjActTime(real64 arDelta);
2798 //; adjust actual move time
2799
2815 virtual uint32 SetRealPosition(real64 arPosition);
2816
2828 virtual void GetRealPosition(real64& arPosition, bool abMapped = true);
2829
2830 virtual void GetRealVelocity(real64& arVelocity);
2831 //; get real velocity (see comment above)
2832 virtual void GetRealAcceleration(real64& arAcceleration);
2833 //; get real acceleration (see comment above)
2834 virtual void GetRealJerk(real64& arJerk);
2835 //; get real jerk (see comment above)
2836 virtual void GetActPosError(real64& arPosError)
2837 { arPosError = REAL64(0.0);};
2838 //; get actual position error (see comment above)
2839 virtual void GetActVelocityError(real64& arVelocityError, bool abFiltered = false)
2840 { arVelocityError = REAL64(0.0);};
2841 //; get actual position error
2842 virtual void GetUnitsPerInc(double& adUnits);
2843 //; get number of units per one inc
2844 virtual void GetIncsPerUnit(double& adIncs);
2845 //; get number of incs per unit
2846 virtual void SetMinPosition(real64 arPosition);
2847 //; set min. allowed position
2848 virtual void GetMinPosition(real64& apPosition) const;
2849 //; get min. allowed position
2850 virtual void SetMaxPosition(real64 arPosition);
2851 //; set max. allowed position
2852 virtual void GetMaxPosition(real64& arPosition) const;
2853 //; get max. allowed position
2854 virtual bool CheckPosition(real64& arPosition, bool abIgnoreMapping = false, SINOSRampParam* apParam = nullptr);
2855 //; return true if arPosition within the range or no range requested
2856 virtual void SetMinVelocity(real64 arVelocity);
2857 //; set min. allowed velocity
2858 virtual void SetMaxVelocity(real64 arVelocity);
2859 //; set max. allowed velocity
2860 virtual void SetMaxSetupVelocity(real64 arVelocity);
2861 //; set max. allowed velocity in setup mode
2862 virtual void SetMaxInitVelocity(real64 arVelocity);
2863 //; set max. allowed velocity during initialization
2864 virtual void GetMinVelocity(real64& arVelocity);
2865 //; get min. allowed velocity
2866 virtual void GetMaxVelocity(real64& arVelocity, uint32 auFlags = eMaxVelocityNone);
2867 //; get max. allowed velocity
2868 virtual void GetTrqVelocity(real64& arVelocity);
2869 //; get torque velocity
2870 virtual void GetMaxSetupVelocity(real64& arVelocity);
2871 //; get max. allowed velocity in setup mode
2872 virtual void GetMaxInitVelocity(real64& arVelocity);
2873 //; get max. allowed velocity during initialization
2874 virtual void SetMinAcceleration(real64 arAcceleration);
2875 //; set min. allowed acceleration
2876 virtual void SetMaxAcceleration(real64 arAcceleration);
2877 //; set max. allowed acceleration
2878 virtual void SetMaxAccelerationPull(real64 arAcceleration);
2879 //; set max. allowed acceleration during pull
2880 virtual void GetMinAcceleration(real64& arAcceleration);
2881 //; get min. allowed acceleration
2882 virtual void GetMaxAcceleration(real64& arAcceleration);
2883 //; get max. allowed acceleration
2884 virtual void GetMaxAccelerationPull(real64& arAcceleration);
2885 //; get max. allowed acceleration during pull
2886 virtual void GetTrqAcceleration(real64& arAcceleration);
2887 //; get torque acceleration
2888 virtual void SetMinDeceleration(real64 arDeceleration);
2889 //; set min. allowed deceleration
2890 virtual void SetMaxDeceleration(real64 arDeceleration);
2891 //; set max. allowed deceleration
2892 virtual void GetMinDeceleration(real64& arDeceleration);
2893 //; get min. allowed deceleration
2894 virtual void GetMaxDeceleration(real64& arDeceleration);
2895 //; get max. allowed deceleration
2896 virtual void GetTrqDeceleration(real64& arDeceleration);
2897 //; get tourque deceleration
2898 virtual void SetMinCruiseleration(real64 arCruiseleration);
2899 //; set min. allowed cruiseleration
2900 virtual void SetMaxCruiseleration(real64 arCruiseleration);
2901 //; set max. allowed cruiseleration
2902 virtual void GetMinCruiseleration(real64& arCruiseleration);
2903 //; get min. allowed cruiseleration
2904 virtual void GetMaxCruiseleration(real64& arCruiseleration);
2905 //; get max. allowed cruiseleration
2906 virtual void SetMinJerk(real64 arJerk);
2907 //; set min. allowed jerk
2908 virtual void SetMaxJerk(real64 arJerk);
2909 //; set max. allowed jerk
2910 virtual void GetMinJerk(real64& arJerk);
2911 //; get min. allowed jerk
2912 virtual void GetMaxJerk(real64& arJerk);
2913 //; get max. allowed jerk
2914 virtual void GetEpsilon(real64& arEpsilon);
2915 //; get axis epsilon
2916 virtual void GetCycleTime(real64& arCycleTime, bool abOversampled=false);
2917 //; get axis cycle time [sec]
2918 virtual void GetCycleTimeUs(uint32& auCycleTime);
2919 //; get axis cycle time [us]
2920 virtual void GetCycleTimeNs(uint32& auCycleTime);
2921 //; get axis cycle time [ns]
2922 virtual uint8 GetOversampling();
2923 //; get oversampling factor
2924 virtual uint16 GetCycleNumber();
2925 //; get axis cycle number
2926 virtual uint16 GetCycleId();
2927 //; get axis cycle id
2928 virtual void UpdateCycleId(uint16 auCycleId);
2929 //; inform about updated cycle id (core id and cycle number could have changed)
2930 virtual uint8 GetBusId();
2931 //; get axis bus id
2932 virtual uint32 SetParam(const char* apName, real64 arValue);
2933 //; universal set parameter with aName to aValue and return error code
2934 virtual uint32 SetParam(const char* apName, uint64 auValue)
2935 //; universal set parameter with aName to aValue and return error code
2936 { return defVarNotFound;};
2937 virtual uint32 GetParam(const char* apName, real64& arResult);
2938 //; universal get parameter with aName to aResult and return error code
2939 virtual uint32 GetParam(const char* apName, uint64& auResult)
2940 //; universal get parameter with aName to aResult and return error code
2941 { return defVarNotFound;};
2942 virtual volatile real64* GetParamAdr(const char* apName);
2943 //; universal get address of parameter with aName or NULL if not found
2944 void SetFlag(uint32 auFlag)
2945 { INOS_OR(m_uFlag, auFlag);};
2946 //; set axis flags
2947 void ClrFlag(uint32 auFlag)
2948 { INOS_AND(m_uFlag, ~auFlag);};
2949 //; clear axis flags
2950 uint32 GetFlag()
2951 { return m_uFlag & m_uFlagEnb;};
2952 //; get axis flags
2953 void Absolute()
2954 { ClrFlag(DF_INOS_AXIS_FLAG_INCR);};
2955 //; switch to absolute mode
2956 void Incremental()
2957 { SetFlag(DF_INOS_AXIS_FLAG_INCR);};
2958 //; switch to incremental mode
2959 virtual uint32 SetState(uint32 auState);
2960 //; set axis state (used to set from ready to active to be able to force sync)
2961 virtual int32 GetState();
2962 //; get axis state
2963 virtual int32 GetState(uint32& auRampState);
2964 //; get axis and ramp state
2965 const char* GetStateText() const;
2966 //; \return A human readable text describing the current axis state.
2967 virtual bool IsBusy() const;
2968 //; Whether the axis is busy or not. Busy means: The axis is "used"
2969 //; by someone. E.g. the axis is also busy if it's in the "Coupled"
2970 //; state, which means that this axis is the "slave" and therefore
2971 //; it gets its positions/commands from its master axis. The axis
2972 //; is also busy if it is in "break" state (which means it is not
2973 //; currently moving, but it'll continue an already started move
2974 //; later). And it is also 'busy' if it's in "relax" state. In
2975 //; fact, the axis is always busy, unless it is in undefined,
2976 //; disabled, active, peace or read state.
2977 //; return true if the axis is currently busy. false otherwise.
2978 virtual uint32 GetError(bool abResolveExternal = false);
2979 //; get axis error
2980 virtual uint64 GetErrorEx(bool abResolveExternal = false);
2981 //; get extended axis errors
2982 virtual uint32 GetError(uint32& auRampError, bool abResolveExternal = false);
2983 //; get axis and ramp error
2984 virtual uint64 GetErrorEx(uint64& auRampError, bool abResolveExternal = false);
2985 //; get extended axis and ramp error
2986 virtual uint32 GetErrorHook() { return m_uErrorHook; };
2987 //; get axis and ramp error
2988 virtual bool IsErrorFatal()
2989 //; return true if error is fatal
2990 { return false;};
2991 virtual uint32 GetWarning(bool abResolveExternal = false);
2992 //; get axis warning
2993 virtual uint64 GetWarningEx(bool abResolveExternal = false);
2994 //; get extended axis warning
2995 virtual uint32 GetWarning(uint32& auRampWarning, bool abResolveExternal = false);
2996 //; get axis and ramp warning
2997 virtual uint64 GetWarningEx(uint64& auRampWarning, bool abResolveExternal = false);
2998 //; get extended axis and ramp warning
2999 virtual uint32 GetLimitViolation() { return m_uLimitViolation;};
3000 //; get axis limit violation
3001 virtual void SetErrorMask(uint32 auMask) { m_uErrorMask = auMask;};
3002 //; set error mask and return old mask
3003 virtual void SetWarningMask(uint32 auMask) { m_uWarningMask = auMask;};
3004 //; set warning mask and return old mask
3005 virtual void SetLimitViolation(uint32 auLimitViolation)
3006 { INOSOr(&m_uLimitViolation, auLimitViolation);};
3007 //; set axis limit violation
3008 virtual uint32 GetErrorMask() { return m_uErrorMask;};
3009 //; get actual error mask
3010 virtual uint32 GetWarningMask() { return m_uWarningMask;};
3011 //; get actual warning mask
3012 virtual uint32 AcceptError();
3013 //; accept all errors
3014 virtual uint32 AcceptError(uint32 auError);
3015 //; accept error
3016 virtual uint32 AcceptError(uint32 auError, uint32 auRampError);
3017 //; accept error
3018 virtual uint32 AcceptWarning();
3019 //; accept all warnings
3020 virtual uint32 AcceptWarning(uint32 auWarning);
3021 //; accept warning
3022 virtual uint32 AcceptWarning(uint32 auWarning, uint32 auRampWarning);
3023 //; accept warning
3024 virtual uint32 AcceptLimitViolation() { m_uLimitViolation = 0; return 0;};
3025 //; get axis limit violation
3026
3027 // param set functions
3028 virtual void eCreateParamSet(const char* apSetName);
3029 //; Same as CreateParamSet but for INCO registration (as it doesn't return
3030 //; a pointer)
3031 virtual CINOSBaseAxisParamSet* CreateParamSet(const char* apSetName);
3032 //; create new param set with name apSetName and return pointer to it
3033 virtual void DestroyParamSet(const char* apSetName);
3034 //; destroy param set with name apSetName
3035 virtual bool SelectParamSet(const char* apSetName);
3036 //; select param set with name apSetName
3037
3038 enum {
3039 eFlgParamSetNone = 0x00000000,
3040 eFlgParamSetSearchGlobal = 0x00000001,
3041 eFlgParamSetIgnoreOverwrite = 0x00000002
3042 };
3043
3044 virtual CINOSBaseAxisParamSet* GetParamSet(const char* apSetName, uint32 auFlags = eFlgParamSetSearchGlobal);
3045 //; get pointer to param set with name apSetName
3046 virtual SINOSRampParam* GetRampParam(const char* apSetName, uint32 auFlags = eFlgParamSetSearchGlobal);
3047 //; get pointer to ramp param of set apSetName
3048 virtual bool GetRampParam(const char* apSetName, char* apResult, uint32 auSize,
3049 SINOSRampParam& aResult, uint32 auFlags = eFlgParamSetSearchGlobal);
3050 //; copy ramp param data to aResult and return true if successful, copy also to original speed set
3051 //; name to apResult. This method is also able to handle the xxx[V/A/B=yyy] case
3052 virtual void PreDestroyRampParam(SINOSRampParam* apParam);
3053 //; use this method to inform axis, that we're about to destroy a previously
3054 //; used speed set
3055
3056 static void eCreateGlobalParamSet(const char* apSetName);
3057 //; Same as CreateParamSet but for INCO registration (as it doesn't return
3058 //; a pointer)
3059 static CINOSBaseAxisParamSet* CreateGlobalParamSet(const char* apSetName);
3060 //; create new param set with name apSetName and return pointer to it
3061 static void DestroyGlobalParamSet(const char* apSetName);
3062 //; destroy param set with name apSetName
3063 static CINOSBaseAxisParamSet* GetGlobalParamSet(const char* apSetName);
3064 //; get pointer to param set with name apSetName
3065 static SINOSRampParam* GetGlobalRampParam(const char* apSetName);
3066 //; get pointer to ramp param of set apSetName
3067
3068 // pos type functions
3069 virtual void SetPosType(uint32 auPosType)
3070 //; set pos type
3071 { m_uPosType = auPosType; };
3072 virtual void SetPosTime(uint32 auPosTime)
3073 //; set pos time
3074 { m_uPosTime = auPosTime; };
3075 virtual void SetPosTimeout(uint32 auPosTimeout)
3076 //; set pos timeout
3077 { m_uPosTimeout = auPosTimeout; };
3078 virtual void SetPosTolerance(real64 arPosTolerance)
3079 //; set pos tolerance
3080 { m_rPosTolerance = arPosTolerance; };
3081
3082 // param set extensions
3083
3084 #if defined(INOS_AXIS_EXTENSION_SUPPORT)
3086 SINOSParamSetExtension* GetParamSetExtension(uint32 auExtensionId)
3087 {
3088 // handle over
3089 return m_pRamp->GetParamSetExtension(auExtensionId);
3090 }
3092 real64 GetMoveTimeAdjust(SINOSRampParam* apParam);
3093 #endif
3094
3095 // caching functions
3096
3097 void EnableCache(uint32 auSize = 32);
3098 //; create moving cache with size auSize if nessecary and enable it
3099 CINOSRampCache* EnableCache(CINOSRampCache* apCache);
3100 //; set actual moving cache to apCache and return old one or 0
3101 CINOSRampCache* DisableCache();
3102 //; disable moving cache and return old one
3103 void ReEnableCache();
3104 //; Reenables a previously disabled ramp cache. This function is
3105 //; useful if the cache feature has temporarily been disabled
3106 //; before (DisableCache). Note: This function has no effect if
3107 //; the ramp does not yet owns a cache object. Also: It's safe
3108 //; to call this function while the cache is already enabled.
3109 void FlushCache();
3110 //; flush ramp cache
3111 void SetCacheEpsilon(real64 arEpsilon);
3112 //; set new cache 'epsilon' (standard is = 0.0)
3113 #ifdef INOS_MOVE_CACHE_SUPPORT
3114 void FlushMoveCache();
3115 //; flush moving cache
3116 #endif
3117
3118 // safety
3119
3120 #ifdef INOS_SAFETY_SUPPORT
3122 virtual void EnableSafetySupervision();
3124 virtual bool DisableSafetySupervision();
3126 virtual void ToggleSafetySupervision();
3127 #endif
3128
3129 // miscellaneous functions
3130
3131 virtual CINCOObject* GetRegister();
3132 //; do inco registration and return pointer to it
3133 virtual void SetRamp(CINOSBaseRamp* apRamp);
3134 //; set new ramp geni
3135 CINOSBaseRamp* GetRamp()
3136 { return m_pRamp;};
3137 //; return pointer to ramp geni
3138 virtual CINOSMapping* GetMapping()
3139 { return m_pMapping;};
3140 //; return pointer to actual axis mapping
3141 uint32 GetMappingIndex()
3142 { return m_uMappingIndex;};
3143 //; get actual mapping index
3144
3145 // miscellaneous functions
3146
3147 virtual uint32 RegisterHook(uintid& auHookId, void* apHandler, void* apObject,
3148 int32 aiOrder, bool abEnabled=true);
3149 //; register bus hook that runs in the same bus context, core,
3150 //; category, cyclenumber and cycletime as the axis
3151 virtual uint32 UnRegisterHook(uintid auHookId);
3152 //; unregister bus hook
3153 virtual uint32 EnableHook(uintid auHookId);
3154 //; enable hook
3155 virtual uint32 DisableHook(uintid auHookId);
3156 //; disable hook
3157 virtual uint32 RegisterPostHook(uintid& auHookId, void* apHandler, void* apObject,
3158 int32 aiOrder, bool abEnabled=true);
3159 //; register post bus hook that runs in the same bus context, core,
3160 //; category, cyclenumber and cycletime as the axis
3161 virtual uint32 UnRegisterPostHook(uintid auHookId);
3162 //; unregister bus hook
3163 virtual uintid RegisterErrorHook(void* apHandler, void* apObject = 0);
3164 //; register error hook and return hook id
3165 virtual void UnRegisterErrorHook(uintid auHookId);
3166 //; unregister error hook
3167 virtual uintid RegisterWarningHook(void* apHandler, void* apObject = 0);
3168 //; register Warning hook and return hook id
3169 virtual void UnRegisterWarningHook(uintid auHookId);
3170 //; unregister Warning hook
3171 #ifdef INOS_SAFETY_SUPPORT
3172 virtual uintid RegisterSOSHook(void* apHandler, void* apObject = 0);
3173 //; register SOS hook and return hook id
3174 virtual void UnRegisterSOSHook(uintid auHookId);
3175 //; unregister SOS hook
3176 #endif
3177
3178 #if defined(INOS_AXIS_EXTENSION_SUPPORT)
3180 virtual void RegisterExtension(IINOSBaseAxisExtension* apExtension);
3182 virtual void UnRegisterExtension(IINOSBaseAxisExtension* apExtension);
3183 #endif
3184
3185 // auto sync
3186
3187 virtual void EnableSync(real64 arPosition = REAL64(0.0),
3188 uint8 auMode = DF_INOS_AXIS_SYNC_NOADJ){};
3189 //; enable auto syncing (at sync set pos = arPosition)
3190 virtual void DisableSync(){};
3191 //; disable auto syncing
3192 virtual void GetSyncCount(uint32& auSyncCount)
3193 { auSyncCount = 0;};
3194 //; return actual sync counter
3195 virtual void SetSyncCount(uint32 auSyncCount){};
3196 //; set sync counter
3197
3198 // auto norm
3199
3220 virtual void EnableNorm(uint8 auMode = DF_INOS_AXIS_NORM_AFTER,
3221 uint8 auMoveDir = DF_INOS_AXIS_NORM_MOVE_DIR_NO,
3222 real64 arNormPos = REAL64(0.0));
3224 virtual void DisableNorm();
3225
3227 virtual uint8 GetNormMoveDir()
3228 { return m_uNormMoveDir; };
3229
3231 virtual void SetNormMoveDir(uint8 auNormMoveDir)
3232 { m_uNormMoveDir = auNormMoveDir; };
3233
3235 virtual uint8 GetNormMode()
3236 { return m_uNormMode; };
3237
3239 virtual void SetNormMode(uint8 auNormMode)
3240 { m_uNormMode = auNormMode; };
3241
3242 // current limitation
3243
3244 virtual void EnableCurLimit(){};
3245 //; enable current limitation
3246 virtual void DisableCurLimit(){};
3247 //; disable current limitation
3248 virtual bool GetCurLimit()
3249 //; return state of current limitation
3250 { return (m_uFlag & DF_INOS_AXIS_FLAG_CURL) != 0;};
3251
3252 enum EActualType {
3253 eActInput,
3254 eActActual,
3255 eActOutput
3256 };
3258 SINOSRampData* GetActual(EActualType aeType = eActOutput, bool abCopy = true)
3259 {
3260 // check reqeusted type
3261 if (aeType == eActInput) {
3262 // return pointer to ramp values
3263 return m_pActRamp;
3264 } // end if
3265 else if (aeType == eActActual) {
3266 // return pointer to actual values
3267 return m_pActual;
3268 } // end if
3269 else {
3270 // copy requested ?
3271 if (abCopy && (m_pActual == m_pActRamp)) {
3272 // yes
3273 *m_pActControl = *m_pActRamp;
3274 }
3275 // actuals are now control avalues
3276 m_pActual = m_pActControl;
3277 // return pointer to output values
3278 return m_pActControl;
3279 } // end else
3280 };
3288 SINOSRampData* GetActPhy()
3289 { return GetActual(eActOutput, false);};
3290
3291 // safety move
3292
3293 virtual void SetMoveSafeMin(real64 arMin, real64 arFact1=REAL64(0.0),
3294 real64 arFact2=REAL64(0.0));
3295 //; set move safe minimum : arMin=requested minimum,
3296 //; safe1=safe1+arFact(MoveSafeMin-calcedMin), safe2=dito
3297 virtual void ResetMoveSafeMin();
3298 //; reset move safe minimum
3299
3300 // setup mode
3301
3302 void EnableSetupMode();
3303 //; enable setup mode
3304 void DisableSetupMode();
3305 //; disable setup mode
3306 virtual bool CheckSetupMode();
3307 //; return true if setup mode active and fullfilled
3308
3309 #ifdef INOS_USE_CUSTOMER_IMAGE_DATA
3310 void* GetCustomerSpecificData() const { return m_pCustomerSpecificData; }
3311 //; \return The pinter to the customer specific data (or NULL if
3312 //; no such data are set).
3313 void SetCustomerSpecificData(void* apData) { m_pCustomerSpecificData = apData; }
3314 //; Sets apData to be the "customer specific data" of this axis.
3315 //; The function doesn't care about any previously set customer
3316 //; specific data: The caller is 100% responsible for freeing amy
3317 //; resource related to these data!
3318 //; This class will never access the data in any way apart from
3319 //; initialization to NULL during object contstruction!
3320 #endif
3321
3323 virtual uint32 GetToggleCnt()
3324 { return m_uToggleCnt; };
3326 virtual void SetToggleCnt(uint32 auSetVal)
3327 { m_uToggleCnt=auSetVal; };
3328
3329 #ifdef INOS_MOVEPATH_SUPPORT
3330 void SetMovePathActuals(struct SINOSMovePathActual* apActuals);
3331 #endif
3332
3333 // torque limitation
3334
3341
3342 // multicore
3343
3345 uint8 GetCoreId()
3346 { return m_uCoreId; };
3347
3348 #ifdef INOS_SAFETY_SUPPORT
3350 uint32 GetSafetyUid()
3351 { return m_uSafetyUid; };
3353 uint32 GetSafetyType()
3354 { return m_uSafetyType; };
3356 ESafetyFunction GetSafetyFunction() const {
3357 return m_eSafetyFunction;
3358 }
3359 #endif
3360
3361 //--- internals --------------------------------------------------------
3362
3363 // after this function you can register new ramps
3364 friend void _INI_0000_CINOSBaseAxis();
3365 friend void _INI_0400_CINOSBaseAxis();
3366 friend class CINOSRegisterBaseAxis;
3367 friend class CINOSMapping;
3368 friend class CINOSPhysicalAxis;
3369 friend void _INI_0400_INFO_DCM();
3370 friend class CINOSBaseAxisTest;
3371 friend class CINOSMovePathResourcePosAxis;
3372 friend class CINOSMcRobotCmdMove;
3373 friend class CINOSMcRobotCmdInit;
3374 friend class CINOSMcRobotCmdCalib;
3375 friend class CINOSMcTargetAxis;
3376
3377 // protected member functions
3378 protected:
3379 void Create();
3380 //; create base axis
3381 real64 iNormPosition(real64 arPosition, real64 arRange = REAL64(0.0), bool abRound = false) const;
3382 //; norm arPosition to 0..360
3383 void Signal(CINOSSync*& apSync);
3384 //; signal sync object if requested
3385 virtual void SignalSync(CINOSSync& apSync);
3386 //; signal given sync object
3387 virtual void SetError(uint32 auErrors);
3388 //; set axis error (and call error hook if nessecary)
3389 virtual void SetWarning(uint32 auWarnings);
3390 //; set axis warning (and call warning hook if nessecary)
3391#ifdef INOS_SAFETY_SUPPORT
3392 virtual void CallSOSHooks();
3393 //; call SOS hooks
3394#endif // INOS_SAFETY_SUPPORT
3395 bool Enter(uint32 auCommand, CINOSSync* apSync = 0);
3396 //; check if command allowed in current state and return false if not
3397 void Exit ();
3398 //; leave critical section
3399 void Exit (CINOSSync*& apCmdSync, CINOSSync* apSync);
3400 //; leave critical section and wait if nessecary
3401 bool IsCritical()
3402 { return m_CmdLock.GetOwner() != 0;};
3403 //; return true if somebody stays in critical section
3404 virtual void iInActivate();
3405 //; inactivate axis
3406 virtual void iStop(SINOSRampParam* apParam);
3407 //; internal stop
3408 virtual void iEmergencyStop(bool abLive = false);
3409 //; internal emergency stop
3410 virtual uint32 iCursor(bool abPositive, uint32 auWaitTime,
3411 real64 arStep, SINOSRampParam* apParam);
3412 //; internal cursor
3413 virtual uint32 iCursor(real64 arPosition, uint32 auWaitTime,
3414 real64 arStep, SINOSRampParam* apParam);
3415 //; internal cursor
3416 real64 iGetAbsPosition(real64 arRelPosition);
3417 //; get absolute position of arRelPosition
3418 real64 iGetNrmAbsPosition(real64 arRelPosition, SINOSRampParam* apParam = nullptr, bool abConsiderStop = false);
3419 //; get normed absolute position of arRelPosition
3420 virtual void iSetCycleTime(real64 arCycleTime);
3421 //; set axis cycle time [sec]
3422 virtual void iRegisterAxis();
3423 //; register axis
3424 ICACHE virtual void iPreMap();
3425 //; pre mapping handler
3426 ICACHE virtual void iPostMap();
3427
3428 ICACHE inline void iCheckRampLimits() {
3429 if (m_pRamp->GetError() & ER_INOS_RAMP_VMAX_REACHED) {
3430 SetError(ER_INOS_AXIS_RAMP_LIMIT);
3431 }
3432 }
3433
3434 //; post mapping handler
3435 ICACHE virtual void iPostWrite();
3436 //; post bus write handler
3437 void SetMapping(CINOSMapping* apMapping, uint32 auIndex)
3438 { m_pMapping = apMapping; m_uMappingIndex = auIndex;
3439 m_pRamp->SetMapping(apMapping, auIndex);};
3440 //; set actual axis mapping
3441 void ResetMapping()
3442 { m_pMapping = 0; m_uMappingIndex = 0;
3443 m_pRamp->ResetMapping();};
3444 //; reset actual axis mapping
3445 virtual bool iInPosition(bool abEarlyDone);
3446 //; returns true if requested position reached
3447 virtual bool iInPosition();
3448 //; returns true if requested position reached (originally, only
3449 //; this overload existed. Then, the abEarlyDone was introduced.
3450 //; Unfortunately, as this function was already 'virtual' we could
3451 //; not just add abEalyDone with a default value, as it would
3452 //; cause derived class, implemented by customers, to not function
3453 //; properly anymore.
3454 virtual void iAdjPreviousPositions(real64 arDifference);
3455 //; adjust previous axis positions (used in limit checker)
3456 virtual void iSetActRampPosition(real64 arPosition);
3457 //; set actual ramp geni position
3458 virtual bool IsCheckPositionRequired();
3459 //; return true if check position required
3460 void SetDefaultParamIfRequired();
3461 //; Sets the "default param" values (V,A,J) to the ramp if those
3462 //; ramp values are current undefined (means: are 0.0). Function does
3463 //; nothing otherwise, or if no "default param" has been specified
3464 //; in the axis config (e.g. in dt2)
3465 void iSetupPositionType(SINOSRampParam* apParam = 0);
3466 //; init position type handling
3467 virtual void iResetTrajectory();
3468 //; reset trajectory planner
3469
3470 void iCoreMismatchError();
3471 //; set core mismatch axis error
3472
3473 INOS_INLINE void AtomicEnter(uint32& auToken)
3474 {
3475 CINOSBus* pBus=CINOSBus::FindBus(GetBusId());
3476 if (pBus) {
3477 pBus->AtomicGatherEnter(auToken);
3478 } else {
3479 // no bus -> no token
3480 auToken = 0;
3481 }
3482 }
3483
3484 INOS_INLINE bool AtomicExit(uint32 auToken)
3485 {
3486 CINOSBus* pBus=CINOSBus::FindBus(GetBusId());
3487 if (pBus) {
3488 return pBus->AtomicGatherExit(auToken);
3489 } else {
3490 // no bus -> always OK
3491 return true;
3492 }
3493 }
3494
3495 // private member functions (external versions, because until now we are not
3496 // able to register functions with default parameters)
3497 private:
3498 uint32 eEnable();
3499 //; enable axis
3500 uint32 eDisable();
3501 //; disable axis
3502 uint32 eActivate(bool abCheckPos, bool abSimulatePos, bool abSimulateOut,
3503 bool abSimulateAct);
3504 //; activate physical axis
3505 uint32 eInActivate();
3506 //; inactivate physical axis
3507 uint32 eRelax(uint32 auTimeMs);
3508 //; relax coupled axis
3509 uint32 eMove(real64 arPosition);
3510 //; move to position with acc/deceleration and velocity
3511 uint32 eMove(real64 arPosition, char* apParam);
3512 //; move to position with apParam parameters
3513 uint32 eMoveTime(real64 arPosition, real64 arTime);
3514 //; move to position with acc/deceleration and velocity
3515 uint32 eMoveTime(real64 arPosition, real64 arTime, char* apParam);
3516 //; move to position with apParam parameters
3517 uint32 eMoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity);
3518 //; move to position with acc/deceleration and velocity
3519 uint32 eMoveApp(real64 arPosition, real64 aPositionVel, real64 arVelocity, char* apParam);
3520 //; move to position with apParam parameters
3521 uint32 eMoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity);
3522 //; move to position with acc/deceleration and velocity
3523 uint32 eMoveDep(real64 arPosition, real64 aPositionVel, real64 arVelocity, char* apParam);
3524 //; move to position with apParam parameters
3525 uint32 eSync(real64 arPosition);
3526 //; sync axis
3527 uint32 eSync(real64 arPosition, char* apParam);
3528 //; sync axis
3529 uint32 eSync(real64 arPosition, real64 arSyncPosition);
3530 //; sync axis
3531 uint32 eSync(real64 arPosition, real64 arSyncPosition, char* apParam);
3532 //; sync axis
3533 uint32 eCursor();
3534 //; cursor
3535 uint32 eUpdate();
3536 //; update
3537 uint32 eUpdate(const char* apParam);
3538 //; update
3539 uint32 eEndless(bool abPositive);
3540 //; move to position with acc/deceleration and velocity
3541 uint32 eEndless(bool abPositive, const char* aparam);
3542 //; move to position with acc/deceleration and velocity
3543 uint32 eStop();
3544 //; stop
3545 uint32 eStop(const char* apParam);
3546 //; stop
3547 uint32 eStop(real64 arPosition);
3548 //; stop
3549 uint32 eStop(real64 arPosition, const char* apParam);
3550 //; stop
3551 uint32 eBreak();
3552 //; break
3553 uint32 eBreak(const char* apParam);
3554 //; break
3555 uint32 eBreak(real64 arPosition);
3556 //; break
3557 uint32 eBreak(real64 arPosition, const char* apParam);
3558 //; break
3559 uint32 eEmergencyStop();
3560 //; emergency stop
3561 uint32 eEmergencyStop(uint32 auType, uint32 auDelay);
3562 //; emergency stop
3563 uint32 eContinue();
3564 //; stop
3565 uint32 eContinue(const char* apParam);
3566 //; stop
3567 void eSetSlowMotion(real64 arSlowMotion);
3568 //; stop
3569 void ePos1();
3570 //; move to pos 1
3571 void ePos2();
3572 //; move to pos 2
3573 void eToggle();
3574 //; toggle between pos 1 and pos 2
3575 void eZero();
3576 //; set act pos = 0
3577 uint32 eAcceptError();
3578 //; accept all pending errors
3579 uint32 eAcceptWarning();
3580 //; accept all pending warnings
3581 void iToggling();
3582 //; toggle handler (called cyclic)
3583 void iCursoring();
3584 //; toggle handler (called cyclic)
3585 bool iTrack(const char* apVarName, real64 arFactor, uint32 auFilterLength);
3586 //; track the variable apVarName
3587 uint32 _Track(const char* apVarName, real64 arFactor, uint32 auFilter,
3588 uint32 auDirection, SINOSRampParam* apParam);
3589 void iTrackFollow();
3590 //; tracking handler (called cyclic)
3591 void iTrackKeep();
3592 //; tracking handler (called cyclic)
3593
3594 // protected members
3595 protected:
3596 int32 m_uState;
3597 //; actual state
3598 uint32 m_uSubState;
3599 //; actual sub state
3600 uint32 m_uNxtState;
3601 //; next state
3602 uint32 m_uPrvState;
3603 //; previous state
3604 uint32 m_uBrkState;
3605 //; state before break
3606 uint32 m_uRmpState;
3607 //; state of ramp geni before GetSVAJ
3608 uint32 m_uError;
3609 //; actual errors
3610 uint32 m_uErrorMask;
3611 //; actual error mask
3612 uint32 m_uErrorHook;
3613 //; actual hook error
3614 uint32 m_uWarning;
3615 //; actual warnings
3616 uint32 m_uWarningMask;
3617 //; actual warnings mask
3618 uint32 m_uLimitViolation;
3619 //; actual limit violation mask
3620 uint32 m_uFlag;
3621 //; axis flags (zero, norm, ...)
3622 uint32 m_uFlagEnb;
3623 //; axis flags enable
3624
3625 const char* m_pName;
3626 //; axis name
3627 const char* m_pType;
3628 //; axis type
3629 char m_cShort[2];
3630 //; short character
3631 CINOSBaseAxis* m_pPartner;
3632 //; pointer to partner axis
3633 CINCOObject* m_pRegister;
3634 //; pointer to inco registration
3635 CINCOObject* m_pCommand;
3636 //; pointer to inco registration of commands
3637 CINCOObject* m_pTest;
3638 //; pointer to inco registration of axis test
3639 CINCOObject* m_pError;
3640 //; pointer to inco registration of axis errors
3641 CINCOObject* m_pWarning;
3642 //; pointer to inco registration of axis warnings
3643 CINCOObject* m_pLimitViolation;
3644 //; pointer to inco registration of limit violations
3645 CINCOObject* m_pFlag;
3646 //; pointer to inco registration of axis flags
3647 CINCOObject* m_pState;
3648 //; pointer to inco registration of axis state
3649 CINOSBaseRamp* m_pRamp;
3650 //; pointer to ramp generator
3651 CINOSLimitChecker* m_pLimitChecker;
3652 //; pointer to limit checker
3653 CINOSMapping* m_pMapping;
3654 //; pointer to actual mapping
3655 uint32 m_uMappingIndex;
3656 //; index this axis has in the actual mapping
3657 SINOSBaseAxis* m_pDesc;
3658 //; pointer to object descriptor
3659 CINOSMutex m_CmdLock;
3660 //; mutex to guarantee mutual exclusion in command handling
3661 CINOSSync* m_pActivate;
3662 //; pointer to synch object to be signaled on end of activate
3663 CINOSSync* m_pInActivate;
3664 //; pointer to synch object to be signaled on end of inactivate
3665 CINOSSync* m_pMove;
3666 //; pointer to synch object to be signaled on end of move
3667 CINOSSync* m_pEndless;
3668 //; pointer to synch object to be signaled on end of endless
3669 CINOSSync* m_pStop;
3670 //; pointer to synch object to be signaled on end of stop
3671 CINOSSync* m_pEmStop;
3672 //; pointer to synch object to be signaled on end of emstop
3673 CINOSSync* m_pBreak;
3674 //; pointer to synch object to be signaled on end of break
3675 CINOSSync* m_pVelocity;
3676 //; pointer to synch object to be signaled on velocity reached
3677 CINOSSync* m_pContinue;
3678 //; pointer to synch object to be signaled on end of continue
3679 CINOSSync* m_pWaitInPosition;
3680 //; pointer to synch object to be signaled on end of waitinposition
3681 CINOSSync* m_pWaitInPositionDyn;
3682 //; pointer to dynamically created synch object to be signaled on end of waitinposition
3683 CINOSSync* m_pWaitTicks;
3684 //; pointer to synch object to be signaled on end of waitticks
3685 uint32 m_uWaitTicks;
3686 //; to to be waited for
3687 uintid m_uPreMapHookId;
3688 //; id of pre map hook
3689 uintid m_uPostMapHookId;
3690 //; id of post map hook
3691 uintid m_uPostWriteHookId;
3692 //; id of post bus write hook
3693 uintid m_uPreHookId;
3694 //; id of pre axis command hooks (e.g. track)
3695 #ifdef INOS_SAFETY_SUPPORT
3696 bool m_bPreHookSafetyEnabled;
3698 #endif
3699 uintid m_uPostHookId;
3700 //; id of post hook command hooks (e.g. toggle)
3701 SINOSBaseAxisHook* m_pErrorHooks;
3702 //; pointer to list of error hooks
3703 SINOSBaseAxisHook* m_pWarningHooks;
3704 //; pointer to list of error hooks
3705 TINOSNameBalancedBinaryTree<CINOSBaseAxisParamSet>* m_pParamSets;
3706 //; pool of all param sets
3707 static CINOSMutex m_GlobalParamSetsMutex;
3708 //; global param set mutex
3709 static TINOSNameBalancedBinaryTree<CINOSBaseAxisParamSet>* m_pGlobalParamSets;
3710 //; pool of all param sets
3711 #ifdef INOS_MOVE_CACHE_SUPPORT
3712 CINOSMoveCache* m_pMoveCache;
3713 //; pointer to move cache
3714 #endif
3715
3716 // actual commanded values
3717
3719 SINOSRampDataEx* m_pActual;
3721 SINOSRampDataEx* m_pActRamp;
3723 SINOSRampDataEx* m_pActControl;
3725 SINOSRampDataEx* m_pRealVrt;
3726
3727 // previous three commanded values
3728 SINOSRampData m_sPreviousVrt[3];
3729
3730 // test values
3731
3732 real64 m_rPos1;
3733 //; toggle position 1
3734 real64 m_rPos1Max;
3735 //; max. toggle position 1
3736 real64 m_rPos2;
3737 //; toggle position 2
3738 real64 m_rPos2Max;
3739 //; max. toggle position 2
3740 uint32 m_uDelay;
3741 //; delay in ms between toggles
3742 uint32 m_uDelayMax;
3743 //; max. delay in ms between toggles
3744 uint32 m_uDelayAct;
3745 //; act. delay in ms between toggles
3746 int32 m_iTicks;
3747 //; system ticks to handle delay
3748 uint32 m_uToggleCnt;
3749 //; toggle counter
3750
3751 // miscelanselous
3752 real64 m_rFeedPerTurn;
3753 //; feed per turn (used in method NormPosition)
3754 real64 m_rFeedPerTurn_1;
3755 //; 1 / feed per turn (used in method NormPosition)
3756 real64 m_rInertia;
3757 //; inertia (used in torque limitation)
3758
3759 inosName32 m_cSelectedParamName;
3760 //; last selected param name
3761
3762 // emergency values
3763
3764 uint32 m_uEmergencyType;
3765 //; type of emergency stop (0-Stop, 1-Stop/InActivate, 2-InActivate, 3-none
3766 //; 4-Position, 5-Position/InActivate)
3767 uint32 m_uEmergencyDelay;
3768 //; Delay [ms] after Stop till InActivate (Type = 1)
3769 real64 m_rEmergencyPosition;
3770 //; emergency position
3771 uint16 m_uIntEmergencyType;
3772 //; type of emergency stop (0-Stop, 1-Stop/InActivate, 2-InActivate)
3773 uint16 m_uIntEmergencyDelay;
3774 //; Delay [ms] after Stop till InActivate (Type = 1)
3775 SINOSRampParam* m_pEmergency;
3776 //; pointer to emergency speed set (if available)
3777
3778 // cursoring
3779 uint32 m_uCurWaitTime;
3780 //; wait afet initial move
3781 real64 m_rCurPosition;
3782 //; cursoring direction
3783 SINOSRampParam* m_pCurParam;
3784 //; cursoring params
3785
3786 // syncing
3787 uint8 m_uSyncMode;
3788 //; requested sync mode
3789 // sync methods available
3790 bool m_bSyncAvailable = true;
3791
3792 // norming
3793 uint8 m_uNormMode;
3794 //; requested norm mode
3795 uint8 m_uNormMoveDir;
3796 //; requested norm move direction
3797 real64 m_rNormPos;
3798 //; requested norm position
3799
3800 // multicore
3801
3803 uint8 m_uCoreId = DF_INOS_CORE_DEFAULT;
3804
3805 // tracking
3806 uint16 m_uTrackValType;
3807 //; tracking value type
3808 uint16 m_uTrackDir;
3809 //; tracking direction (0-pos and neg, 1-pos, 2-neg)
3810 void* m_pTrackVal;
3811 //; pointer to track value
3812 real64 m_rTrackCyc;
3813 //; track cycletime [sec]
3814 real64 m_rTrackFct;
3815 //; tracking factor
3816 real64 m_rTrackPos;
3817 //; tracking position
3818 real64 m_rTrackVel;
3819 //; tracking velocity
3820 real64 m_rTrackCmd;
3821 //; tracking commanded value
3822 real64 m_rTrackSum;
3823 //; tracking sum
3824 uint16 m_uTrackLen;
3825 //; tracking buffer length
3826 uint16 m_uTrackInd;
3827 //; tracking buffer index
3828 int32 m_iTrackLst;
3829 //; last track value
3830 int32 m_iTrackOld;
3831 //; old track value
3832 real64* m_pTrackBuf;
3833 //; pointer to tracking buffer
3834 tpGetter m_pTrackGet;
3835 //; pointer to tracking value getter method
3836 real64 m_rTrackVmax;
3837 real64 m_rTrackAmax;
3838 real64 m_rTrackBmax;
3839
3840 // positioning
3841
3842 uint32 m_uPosType;
3843 //; positioning type
3844 uint32 m_uPosTime;
3845 //; positioning time [ms]
3846 uint32 m_uPosTimeout;
3847 //; positioning timeout [ms]
3848 int32 m_iPosTicks;
3849 //; positioning ticks
3850 int32 m_iPosTimeout;
3851 //; positioning timeout ticks
3852 real64 m_rPosTolerance;
3853 //; positioning tolerance
3854
3855 // save moves
3856
3857 // exit time
3858 real64 m_rExitTime;
3859 // partner also running
3860 bool m_bPartnerMoving;
3861
3862 // bus timing
3863
3865 uint32 m_uBusTicksPerAxisTick;
3866
3868 uint16 m_uCycleId;
3869
3870 #ifdef INOS_USE_CUSTOMER_IMAGE_DATA
3876 void* m_pCustomerSpecificData;
3877 #endif
3878
3879 // safety
3880
3881 #ifdef INOS_SAFETY_SUPPORT
3883 tUid m_uSafetyUid;
3885 uint8 m_uSafetyLevel;
3887 uint8 m_uSafetyType;
3889 ESafetyFunction m_eSafetyFunction;
3891 real64 m_rSafetyLimit;
3893 uint32 m_uSafetyDelay;
3895 int32 m_iSafetySupervisionStart;
3897 real64 m_rSafetySupervisionLimit;
3899 SINOSBaseAxisHook* m_pSOSHooks;
3900
3901 // also called from CINOSMcTargetSafety at reload of ch.indel.safety.config.img
3902 friend class CINOSMcTargetSafety;
3904 void iSetupSafety();
3906 virtual bool iSetupSafetyRegistration();
3907 #endif
3908
3909 // axis extensions
3910
3911 #if defined(INOS_AXIS_EXTENSION_SUPPORT)
3913 TINOSDoubleLinkedList<IINOSBaseAxisExtension>* m_pExtensions = 0;
3914 #endif
3915
3916 // command parameters
3917 protected:
3918 uint32 m_ueActivateCheckPos;
3919 //; param : CheckPos
3920 uint32 m_ueActivateSimulatePos;
3921 //; param : SimulatePos
3922 uint32 m_ueActivateSimulateOut;
3923 //; param : SimulateOut
3924 uint32 m_ueActivateSimulateAct;
3925 //; param : SimulateAct
3926 real64 m_rePosition;
3927 //; param : Position
3928 real64 m_rePositionVel{};
3929 //; param : PositionVel
3930 real64 m_reVelocity{};
3931 //; param : Velocity
3932 real64 m_reSyncPosition;
3933 //; param : SyncPosition
3934 inosName32 m_ceParam;
3935 //; param : Param
3936 char m_ceVariable[64];
3937 //; param : Variable
3938 real64 m_reFactor;
3939 //; param : Factor
3940 real64 m_reValue;
3941 //; param : Value
3942 uint32 m_ueFilter;
3943 //; param : Filter
3944 uint32 m_ueTrackDir;
3945 //; param : Track direction
3946 uint32 m_ueDirection;
3947 //; param : Direction
3948 uint32 m_ueWait;
3949 //; param : Wait
3950 real64 m_reStep;
3951 //; param : Step
3952 real64 m_reReturn;
3953 //; param : return
3954 real64 m_reDelta;
3955 //; param : delta
3956 real64 m_reStart;
3957 //; param : start
3958 real64 m_reEnd;
3959 //; param : end
3960 uint32 m_ueReturn;
3961 //; param : return
3962 uint32 m_ueTicks;
3963 //; param : ticks
3964 real64 m_reTime;
3965 //; param : time
3966 real64 m_reSlowMotion;
3967 //; param SLowMotion
3968
3969 #ifdef INOS_MOVEPATH_SUPPORT
3970 class CINCOMovePathActuals* m_pMovePathActuals;
3971 #endif
3972
3973 // static private members
3974 private:
3975 static uint32 m_uCount;
3976 //; number of axis in pool
3977 static uint8 m_uCountCoreId;
3978 //; current core id
3979 static CINOSBaseAxis* m_pFirst;
3980 //; pointer to first axis
3981 CINOSBaseAxis* m_pNext;
3982 //; pointer to next axis in the chain of all axis
3983 static CINOSBaseAxis* m_pAxis[DF_INOS_MAX_AXIS];
3984 //; array of axis pointers
3985 static char m_cStateCombo[494];
3986 //; axis state INCO item text. Use 494 (=defMaxDataLength). I fear
3987 //; to include inco_com.h here, that's why a plain number is used)
3988
3989 // allow dynamic object handling (new/delete)
3990 DECLARE_DYNAMIC(CINOSBaseAxis);
3991};
3992
3993//------------------------------------------------------------------------------
3994// class registration
3995//------------------------------------------------------------------------------
3996
3998typedef CINOSBaseAxis *(*TCreateAxis)(const char* apAxisName);
3999class CINOSRegisterBaseAxis
4000{
4001 // after this function you can register new ramps
4002 friend void _INI_0000_CINOSRegisterBaseAxis();
4003
4004 //--- internals --------------------------------------------------------
4005 // private members
4006private:
4007 // pointer to the first registered axis
4008 static CINOSRegisterBaseAxis* m_pFirst;
4009 // pointer to the next axis
4010 CINOSRegisterBaseAxis* m_pNext;
4011 // create funtion for axis
4012 TCreateAxis m_pCreate;
4013 // axis type name
4014 const char* m_pAxisType;
4015 // database table name
4016 const char* m_pDatabaseTable;
4017
4018 //--- user interface ---------------------------------------------------
4019
4020public:
4021 // register a new axis type
4022 CINOSRegisterBaseAxis(TCreateAxis apFunction, const char* apAxisType,
4023 const char* apDatabaseTable);
4024
4025 // create and return and new axis instance
4026 static CINOSBaseAxis* GetAxis(const char* apAxisName, const char* apAxisType);
4027 // create all registered axis
4028 static void CreateAll();
4029};
4031
4032//
4033//------------------------------------------------------------------------------
4034//--- helper macros ------------------------------------------------------------
4035//------------------------------------------------------------------------------
4036//
4037#if defined(INOS_MULTICORE)
4038#define INOS_AXIS_CORE_MISMATCH_IS_ERROR(ret) \
4039if ((m_uCoreId != DF_INOS_CORE_DEFAULT) && (::GetCoreId() != m_uCoreId)) { \
4040 if (!(GetFlag() & DF_INOS_AXIS_FLAG_IGNORE_CORE)) { \
4041 iCoreMismatchError(); \
4042 return ret; \
4043 } \
4044}
4045#else
4046#define INOS_AXIS_CORE_MISMATCH_IS_ERROR(ret)
4047#endif
4048
4049
4050//
4051//------------------------------------------------------------------------------
4052// safety macros
4053//------------------------------------------------------------------------------
4054//
4055#ifdef INOS_SAFETY_SUPPORT
4056#define SAFETY_CHECK_SOS() \
4057 if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) { \
4058 if (m_eSafetyFunction == eSafetyFunctionSOS) { \
4059 real64 rSlowMotion; GetActSlowMotion(rSlowMotion); \
4060 if (rSlowMotion != REAL64(0.0)) { \
4061 m_uError |= ER_INOS_AXIS_REJECTED_SOS; \
4062 INOS_ERROR("AXIS[%s]: Command rejected, axis in SOS (safe operating stop)", GetName());\
4063 return m_uError; \
4064 } \
4065 } \
4066 }
4067//
4068#define SAFETY_CHECK_SOS_SYNC(apSync) \
4069 if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) { \
4070 if (m_eSafetyFunction == eSafetyFunctionSOS) { \
4071 real64 rSlowMotion; GetActSlowMotion(rSlowMotion); \
4072 if (rSlowMotion != REAL64(0.0)) { \
4073 m_uError |= ER_INOS_AXIS_REJECTED_SOS; \
4074 INOS_ERROR("AXIS[%s]: Command rejected, axis in SOS (safe operating stop)", GetName());\
4075 Signal(apSync); \
4076 return m_uError; \
4077 } \
4078 } \
4079 }
4080//
4081#define SAFETY_IGNORE_IF_SOS() \
4082 if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) { \
4083 if (m_eSafetyFunction == eSafetyFunctionSOS) { \
4084 return m_uError; \
4085 } \
4086 }
4087#else
4088#define SAFETY_CHECK_SOS()
4089#define SAFETY_CHECK_SOS_SYNC(apSync)
4090#define SAFETY_IGNORE_IF_SOS()
4091#endif
4092//
4093//------------------------------------------------------------------------------
4094// end of file
4095//------------------------------------------------------------------------------
4096
4097#endif // INC_CINOSBASEAXIS_H
DF_INOS_AXIS_NORM_MOVE_DIR_NO
#define DF_INOS_AXIS_NORM_MOVE_DIR_NO
Definition cinosbaseaxis.h:184
DF_INOS_AXIS_NORM_AFTER
#define DF_INOS_AXIS_NORM_AFTER
Definition cinosbaseaxis.h:167
DF_INOS_AXIS_NORM_ROUND
#define DF_INOS_AXIS_NORM_ROUND
Definition cinosbaseaxis.h:178
cinosbaseramp.h
Short comment.
cinosbus.h
Short comment.
DECLARE_DYNAMIC
#define DECLARE_DYNAMIC(aClass)
Definition cinospartitionmemory.h:328
CINOSBaseAxis
Provides axis functionality.
Definition cinosbaseaxis.h:676
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::Update
virtual uint32 Update(CINOSSync *apSync=DF_INOS_ASYNCHRONOUS)
Update a running Move to actual commanded values (acc,dec,vel,jerk) Signal apSync if constant velocit...
CINOSBaseAxis::MoveTime
virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5, const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition within the given time arTime and the speedset apParam. The speed set values are tr...
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition, real64 arTime, const char *apParam)
Calc distance [unit] a move from arStartPosition to arEndPosition progresses in arTime [sec].
CINOSBaseAxis::Sync
virtual uint32 Sync(real64 arPosition, real64 arSyncPos, const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Search reference mark till arPosition and set actual position to arSyncPos at mark.
CINOSBaseAxis::GetStartTicks
virtual uint64 GetStartTicks(real64 arDelta)
Get absolut bus ticks the actual move reaches the start position + arDelta.
CINOSBaseAxis::Endless
virtual uint32 Endless(bool abPositive, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_ASYNCHRONOUS)
Start and endless move in the requested direction with speed set apParam.
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arPosition, SINOSRampParam *apParam)
Calc bus ticks a Move(adPosition) needs until arPosition.
CINOSBaseAxis::Pull
virtual uint32 Pull(SINOSRampDataEx *apData)
Add a path point to the actual pull list and start pull mode if not et done. If one is running an axi...
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta, const char *apParam)
Calc bus ticks a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta, const char *apParam)
Calc time [sec] an according MoveApp needs until arEndPosition-arDelta.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition, uint32 auTicks, const char *apParam)
Calc distance [unit] a move from arStartPosition to arEndPosition progresses in auTicks [bus ticks].
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arTime, const char *apParam)
Calc distance [unit] a Move progresses in arTime [sec].
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arPosition, real64 arDelta, const char *apParam)
Calc time [sec] a Move(adPosition) needs until arPosition-arDelta.
CINOSBaseAxis::SegVelocity
virtual uint32 SegVelocity(real64 arVelocity, const char *apParam)
Directly change velocity to the new value.
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta, const char *apParam)
Calc time [sec] an according MoveDep needs until arEndPosition-arDelta.
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the const part.
CINOSBaseAxis::SegPosSetTime
virtual uint32 SegPosSetTime(real64 arTime)
Sets the time of the last added segpos segment [sec]. Can be used to adjust a previous added pos segm...
CINOSBaseAxis::SegRun
virtual uint32 SegRun(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Run actual segments.
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta, const char *apParam)
Calc bus ticks a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel, real64 arVelocity)
Calc time [sec] an according MoveDep needs.
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] a Move needs from arStartPosition until arEndPosition-arDelta.
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, SINOSRampParam *apParam)
Calculate time characteristics of a move.
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calc bus ticks a Move needs from arStartPosition until arEndPosition-arDelta.
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta)
Calc bus ticks a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::SegMove
virtual uint32 SegMove(real64 arPosition, const char *apParam)
Add a move to arPosition. Velocity and acceleration in arPosition have to be 0.0.
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arPosition, SINOSRampParam *apParam)
Calc time [sec] a Move(adPosition) needs for the constant part.
CINOSBaseAxis::Move
virtual uint32 Move(real64 arPosition, real64 arSave1, real64 arSave2, const char *apParam1, const char *apParam2, real64 arPartner, const char *apPartner, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with speed set apParam. The move is done in a so called safe way (backward -> part...
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arPosition, real64 arDelta, const char *apParam)
Calc bus ticks a Move(adPosition) needs for the constant part.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks, const char *apParam)
Calc distance [unit] a Move(arPosition) progresses in auTicks [bus ticks].
CINOSBaseAxis::GetActual
SINOSRampData * GetActual(EActualType aeType=eActOutput, bool abCopy=true)
get pointer to actual control values
Definition cinosbaseaxis.h:3258
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta, const char *apParam)
Calc bus ticks a Move(adPosition) needs until arPosition-arDelta.
CINOSBaseAxis::SegBegin
virtual uint32 SegBegin(real64 arSlowMotion=REAL64(1.0), real64 arStartVelocity=REAL64(0.0))
Create a new segmentation move.
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calc bus ticks a Move(adPosition) needs for the constant part.
CINOSBaseAxis::InitializeLimitChecker
void InitializeLimitChecker()
Initializes the limit checker if requested.
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, const char *apParam)
Calculate time characteristics of a move.
CINOSBaseAxis::MoveDep
virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with speed set apParam. Ensure befor arPositionVel a velocity that is smaller than...
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arPosition, const char *apParam)
Calc bus ticks a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::WaitInPosition
virtual uint32 WaitInPosition()
Wait for any move to finish.
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arPosition, SINOSRampParam *apParam)
Calc bus ticks a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::EmergencyStop
virtual uint32 EmergencyStop(CINOSSync *apSync)
Stop a running move with the defined emergency deceleration/jerk.
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the deceleration part.
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] an according MoveApp needs until arEndPosition-arDelta.
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta, const char *apParam)
Calc time [sec] an according MoveApp needs until arPosition-arDelta.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arPosition, real64 arTime, SINOSRampParam *apParam)
Calc distance [unit] a Move(arPosition) progresses in arTime [sec].
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arPosition)
Calc time [sec] a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::Track
virtual uint32 Track(const char *apVarName, real64 arFactor, uint32 auFilterLength, uint32 auDirection, const char *apParam)
Track the variable with name apVarName.
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta)
Calc time [sec] a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calculate time characteristics of a move.
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the deceleration part.
CINOSBaseAxis::SegVelocity
virtual uint32 SegVelocity(real64 arVelocity, SINOSRampParam *apParam)
Directly change velocity to the new value.
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arPosition, const char *apParam)
Calc bus ticks a Move(adPosition) needs until arPosition.
CINOSBaseAxis::Move
virtual uint32 Move(real64 arPosition, real64 arSafe1, real64 arSafe2, SINOSRampParam *apParam1, SINOSRampParam *apParam2, real64 arPartner, SINOSRampParam *apPartner, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with speed set apParam. The move is done in a so called safe way (backward -> part...
CINOSBaseAxis::Enable
virtual uint32 Enable(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Enables a previously disabled axis. Only enabled axis can be activated.
CINOSBaseAxis::Move
virtual uint32 Move(real64 arPosition, const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with speed set apParam.
CINOSBaseAxis::StopLive
virtual uint32 StopLive()
Stop a running move with the currently selected speed set. The stop is calculated live and therefore ...
CINOSBaseAxis::Stop
virtual uint32 Stop(real64 arPosition, const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Stop a running move with the given speed set at requested position.
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arPosition, SINOSRampParam *apParam)
Calc time [sec] a Move(adPosition) needs until arPosition.
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arPosition)
Calc bus ticks a Move(adPosition) needs until arPosition.
CINOSBaseAxis::SetActPosition
virtual uint32 SetActPosition(real64 arPosition)
Sets the actual axis position. This method doesn't change a current following error and it is therefo...
CINOSBaseAxis::MoveTime
virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5=true, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition within the given time arTime. Actual commanded jerk, acc/deceleration and velocity...
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta)
Calculate time characteristics of a move.
CINOSBaseAxis::Update
virtual uint32 Update(SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_ASYNCHRONOUS)
Update a running Move to speed set apParam. Signal apSync if constant velocity reached (acc = 0).
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arPosition)
Calc bus ticks a Move(adPosition) needs for the constant part.
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the acceleration part.
CINOSBaseAxis::SegMove
virtual uint32 SegMove(real64 arPosition, real64 arVelocity)
Add a move to arPosition. Requested velocity in arPosition is arVelocity, the acceleration is 0....
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arPosition)
Calc time [sec] a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::SegMove
virtual uint32 SegMove(real64 arPosition, real64 arVelocity, SINOSRampParam *apParam)
Add a move to arPosition. Requested velocity in arPosition is arVelocity, the acceleration is 0....
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the acceleration part.
CINOSBaseAxis::EmergencyStopLive
virtual uint32 EmergencyStopLive(uint16 auType, uint16 auDelay=0xffff)
Stop a running move with the defined emergency deceleration/jerk. The stop is calculated live and the...
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta, const char *apParam)
Calc time [sec] a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calc bus ticks a Move(adPosition) needs until arPosition-arDelta.
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calc bus ticks a Move needs from arStartPosition until arEndPosition-arDelta.
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the const part.
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, SINOSRampParam *apParam)
Calc time [sec] an according MoveDep needs.
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calc time [sec] a Move needs from arStartPosition until arEndPosition-arDelta.
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta)
Calc time [sec] an according MoveDep needs until arEndPosition-arDelta.
CINOSBaseAxis::Relax
virtual uint32 Relax(uint32 auTimeMs, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Relax a coupled slave axis for a given time.
CINOSBaseAxis::Connect
virtual uint32 Connect()
Connect axis to hardware.
Definition cinosbaseaxis.h:737
CINOSBaseAxis::Sync
virtual uint32 Sync(real64 arSyncPos, const char *apParam, CINCOObject *apObject, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Search reference mark and set actual position to arSyncPos at mark.
CINOSBaseAxis::Stop
virtual uint32 Stop(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Stop a running move with the currently selected speed set.
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] a Move(adPosition) needs for the constant part.
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the const part.
CINOSBaseAxis::DisableRamp
void DisableRamp()
Disable the axis trajectory generator. Can be used to fill up a pull list without staring immediately...
Definition cinosbaseaxis.h:2456
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, const char *apParam)
Calc time [sec] an according MoveApp needs.
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the const part.
CINOSBaseAxis::Track
virtual uint32 Track(const char *apVarName, real64 arCmdValue, real64 arFactor, uint32 auFilterLength)
Track the variable with name apVarName to the commanded value arCmdValue.
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arPosition, SINOSRampParam *apParam)
Calc time [sec] a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::GetBusTicksPerAxisTick
virtual uint32 GetBusTicksPerAxisTick()
Get number of bus ticks an axis tick takes.
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arPosition, real64 arDelta)
Calc time [sec] a Move(adPosition) needs until arPosition-arDelta.
CINOSBaseAxis::m_pActControl
SINOSRampDataEx * m_pActControl
actual commanded values (valid if mapping active or after a SetActual)
Definition cinosbaseaxis.h:3723
CINOSBaseAxis::MoveApp
virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with actual commanded jerk, acc/deceleration and velocity. Ensure after arPosition...
CINOSBaseAxis::Continue
virtual uint32 Continue(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Continue a pause move.
CINOSBaseAxis::Cursor
virtual uint32 Cursor(real64 arPosition)
Moves one 'inc' in 'arPosition' direction, waits 500ms and then moves to arPosition....
CINOSBaseAxis::SetNormMode
virtual void SetNormMode(uint8 auNormMode)
Definition cinosbaseaxis.h:3239
CINOSBaseAxis::SetNormMoveDir
virtual void SetNormMoveDir(uint8 auNormMoveDir)
Definition cinosbaseaxis.h:3231
CINOSBaseAxis::Pull
virtual uint32 Pull(SINOSRampData &aData)
Add a path point to the actual pull list and start pull mode if not et done. If one is running an axi...
CINOSBaseAxis::Move
virtual uint32 Move(real64 arPosition, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with actual commanded jerk, acc/deceleration and velocity.
CINOSBaseAxis::MoveApp
virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity, const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with speed set apParam. Ensure after arPositionVel a velocity that is smaller than...
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calc time [sec] a Move needs from arStartPosition until arEndPosition-arDelta.
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the acceleration part.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition, uint32 auTicks, SINOSRampParam *apParam)
Calc distance [unit] a move from arStartPosition to arEndPosition progresses in auTicks [bus ticks].
CINOSBaseAxis::m_pActual
SINOSRampDataEx * m_pActual
actual commanded values (handed over to control)
Definition cinosbaseaxis.h:3719
CINOSBaseAxis::Break
virtual uint32 Break(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Pause a running move with the currently selected speed set. The move is still pending and can be cont...
CINOSBaseAxis::Cursor
virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime, real64 arStep)
Moves one step in 'arPosition' direction, waits auWaitTime ms and then moves to arPosition....
CINOSBaseAxis::Cursor
virtual uint32 Cursor(bool abPositive, uint32 auWaitTime, real64 arStep)
Moves one arStep in the requested direction, waits auWaitTime ms and starts an endless move to the de...
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arPosition, const char *apParam)
Calc time [sec] a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calc bus ticks a Move needs from arStartPosition until arEndPosition-arDelta.
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arPosition)
Calc time [sec] a Move(adPosition) needs until arPosition.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks, SINOSRampParam *apParam)
Calc distance [unit] a Move(arPosition) progresses in auTicks [bus ticks].
CINOSBaseAxis::GetTargetTicks
virtual uint64 GetTargetTicks()
Get absolut bus ticks the actual move reaches the target position.
CINOSBaseAxis::GetRealVrt
SINOSRampData * GetRealVrt()
get pointer to real values
Definition cinosbaseaxis.h:3282
CINOSBaseAxis::m_pActRamp
SINOSRampDataEx * m_pActRamp
actual commanded values from ramp geni
Definition cinosbaseaxis.h:3721
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arPosition, SINOSRampParam *apParam)
Calc bus ticks a Move(adPosition) needs for the constant part.
CINOSBaseAxis::Cursor
virtual uint32 Cursor(bool abPositive, uint32 auWaitTime, real64 arStep, const char *apParam)
Moves one arStep in the requested direction, waits auWaitTime ms and starts an endless move to the de...
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arPosition, const char *apParam)
Calc bus ticks a Move(adPosition) needs for the constant part.
CINOSBaseAxis::Break
virtual uint32 Break(SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Pause a running move with the given speed set. The move is still pending and can be continued with Co...
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta)
Calc time [sec] an according MoveApp needs until arPosition-arDelta.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arTime)
Calc distance [unit] a Move progresses in arTime [sec].
CINOSBaseAxis::NormPosition
double NormPosition(real64 arPosition) const
Returned the 'normed' value of arPosition.
Definition cinosbaseaxis.h:2775
CINOSBaseAxis::MoveDep
virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with actual commanded jerk, acc/deceleration and velocity. Ensure befor arPosition...
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arTime, SINOSRampParam *apParam)
Calc distance [unit] a Move progresses in arTime [sec].
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arPosition)
Calc bus ticks a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arPosition, real64 arDelta, const char *apParam)
Calc time [sec] a Move(adPosition) needs for the constant part.
CINOSBaseAxis::CINOSBaseAxis
CINOSBaseAxis(SINOSBaseAxis *apDesc)
Create an axis based on a descriptor (usually not used because this is done by the configuration syst...
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta, const char *apParam)
Calculate time characteristics of a move.
CINOSBaseAxis::Update
virtual uint32 Update(const char *apParam, CINOSSync *apSync=DF_INOS_ASYNCHRONOUS)
Update a running Move to speed set apParam. Signal apSync if constant velocity reached (acc = 0).
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta)
Calc bus ticks a Move(adPosition) needs until arPosition-arDelta.
CINOSBaseAxis::GetTargetTicks
virtual uint64 GetTargetTicks(real64 arDelta)
Get absolut bus ticks the actual move reaches the target position - arDelta.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arPosition, real64 arTime)
Calc distance [unit] a Move(arPosition) progresses in arTime [sec].
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the deceleration part.
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the const part.
CINOSBaseAxis::Stop
virtual uint32 Stop(real64 arPosition, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Stop a running move with the currently selected speed set at requested position.
CINOSBaseAxis::Toggle
virtual uint32 Toggle(real64 arPosition1, real64 arPosition2)
Start an endless toggle between arPosition1 and arPosition2 with actual commanded a jerk,...
CINOSBaseAxis::Sync
virtual uint32 Sync(real64 arPosition, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Search reference mark till arPosition and set actual position to 0.0 at mark.
CINOSBaseAxis::ToggleSection
virtual uint32 ToggleSection(real64 arPos1Min, real64 arPos1Max, real64 arPos2Min, real64 arPos2Max, uint32 auDelayMin, uint32 auDelayMax)
Start an endless section toggle between arPosition1 and arPosition2 with actual commanded a jerk,...
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta)
Calc bus ticks a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arPosition, SINOSRampParam *apParam)
Calc time [sec] a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::Track
virtual uint32 Track(const char *apVarName, real64 arFactor, uint32 auFilterLength, uint32 auDirection=0)
Track the variable with name apVarName.
CINOSBaseAxis::DisableNorm
virtual void DisableNorm()
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arPosition, real64 arDelta)
Calc time [sec] a Move(adPosition) needs for the constant part.
CINOSBaseAxis::Break
virtual uint32 Break(const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Pause a running move with the given speed set. The move is still pending and can be continued with Co...
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the acceleration part.
CINOSBaseAxis::GetActPosition
virtual void GetActPosition(real64 &arPosition, bool abRamp=true)
Gets the actual axis position.
CINOSBaseAxis::Stop
virtual uint32 Stop(SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Stop a running move with the given speed set.
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, SINOSRampParam *apParam)
Calc time [sec] an according MoveApp needs.
CINOSBaseAxis::SetTrackFactor
virtual uint32 SetTrackFactor(real64 arFactor)
Allows to live change the tracking factor of an active 'Track'.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks)
Calc distance [unit] a Move(arPosition) progresses in auTicks [bus ticks].
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel, real64 arVelocity)
Calc time [sec] an according MoveApp needs.
CINOSBaseAxis::GetExitTicks
virtual int32 GetExitTicks()
Calc bus ticks needed till exit in a safe move.
CINOSBaseAxis::GetTrqLimitAcceleration
SINOSBaseRampTrqLimit * GetTrqLimitAcceleration()
get torque limit acceleration
Definition cinosbaseaxis.h:3336
CINOSBaseAxis::Endless
virtual uint32 Endless(bool abPositive, const char *apParam, CINOSSync *apSync=DF_INOS_ASYNCHRONOUS)
Start and endless move in the requested direction with speed set apParam.
CINOSBaseAxis::SegBegin
virtual uint32 SegBegin(real64 arSlowMotion, real64 arStartPosition, real64 arStartVelocity)
Create a new segmentation move at given position.
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] an according MoveDep needs until arEndPosition-arDelta.
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the acceleration part.
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arPosition, real64 arDelta)
Calc bus ticks a Move(adPosition) needs for the constant part.
CINOSBaseAxis::GetActPhy
SINOSRampData * GetActPhy()
deprecated
Definition cinosbaseaxis.h:3288
CINOSBaseAxis::Cursor
virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime, real64 arStep, SINOSRampParam *apParam)
Moves one step in 'arPosition' direction, waits auWaitTime ms and then moves to arPosition....
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta)
Calc time [sec] an according MoveApp needs until arEndPosition-arDelta.
CINOSBaseAxis::MoveApp
virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with speed set apParam. Ensure after arPositionVel a velocity that is smaller than...
CINOSBaseAxis::SegConst
virtual uint32 SegConst(real64 arPosition)
Add a move to arPosition with actual velocity.
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calc bus ticks a Move from arStartPosition until arEndPosition needs for the deceleration part.
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arPosition, const char *apParam)
Calc time [sec] a Move(adPosition) needs for the constant part.
CINOSBaseAxis::WaitTicks
virtual uint32 WaitTicks(uint32 auTicks=1)
Wait for the given axis control cycle ticks. This method can be useful if it is necessary to synchron...
CINOSBaseAxis::InActivate
virtual uint32 InActivate(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Inactivate axis.
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition)
Calculate time characteristics of a move.
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition, real64 arTime, SINOSRampParam *apParam)
Calc distance [unit] a move from arStartPosition to arEndPosition progresses in arTime [sec].
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calculate time characteristics of a move.
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arPosition)
Calc bus ticks a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::Break
virtual uint32 Break(real64 arPosition, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Pause a running move with the currently selected speed set at requested position. The move is still p...
CINOSBaseAxis::m_uCoreId
uint8 m_uCoreId
id of core the axis is handled in
Definition cinosbaseaxis.h:3803
CINOSBaseAxis::Sync
virtual uint32 Sync(real64 arPosition, real64 arSyncPos, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Search reference mark till arPosition and set actual position to arSyncPos at mark.
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the const part.
CINOSBaseAxis::EnableNorm
virtual void EnableNorm(uint8 auMode=0x00, uint8 auMoveDir=0x00, real64 arNormPos=REAL64(0.0))
CINOSBaseAxis::Continue
virtual uint32 Continue(const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Continue a pause move with the given speed set.
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arPosition, const char *apParam)
Calc bus ticks a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::EmergencyStop
virtual uint32 EmergencyStop(uint16 auType=0xffff, uint16 auDelay=0xffff, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Stop a running move with the defined emergency deceleration/jerk.
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arPosition, const char *apParam)
Calc time [sec] a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::m_uBusTicksPerAxisTick
uint32 m_uBusTicksPerAxisTick
number of bus ticks an axis tick takes
Definition cinosbaseaxis.h:3865
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition, uint32 auTicks)
Calc distance [unit] a move from arStartPosition to arEndPosition progresses in auTicks [bus ticks].
CINOSBaseAxis::MoveDep
virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity, const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with speed set apParam. Ensure before arPositionVel a velocity that is smaller tha...
CINOSBaseAxis::Sync
virtual uint32 Sync(real64 arPosition, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Search reference mark till arPosition and set actual position to 0.0 at mark.
CINOSBaseAxis::Stop
virtual uint32 Stop(const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Stop a running move with the given speed set.
CINOSBaseAxis::SetToggleCnt
virtual void SetToggleCnt(uint32 auSetVal)
set toggle counter to given value
Definition cinosbaseaxis.h:3326
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calc bus ticks a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta)
Calc time [sec] an according MoveDep needs until arPosition-arDelta.
CINOSBaseAxis::Break
virtual uint32 Break(real64 arPosition, const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Pause a running move with the given speed set at requested position. The move is still pending and ca...
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calc bus ticks a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::Sync
virtual uint32 Sync(real64 arPosition, const char *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Search reference mark till arPosition and set actual position to 0.0 at mark.
CINOSBaseAxis::Break
virtual uint32 Break(real64 arPosition, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Pause a running move with the given speed set at requested position. The move is still pending and ca...
CINOSBaseAxis::Stop
virtual uint32 Stop(real64 arPosition, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Stop a running move with the given speed set at requested position.
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta, const char *apParam)
Calc time [sec] an according MoveDep needs until arPosition-arDelta.
CINOSBaseAxis::GetAxis
static CINOSBaseAxis * GetAxis(uint32 auNumber)
Get pointer to axis with a given number.
Definition cinosbaseaxis.h:710
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arPosition, real64 arTime, const char *apParam)
Calc distance [unit] a Move(arPosition) progresses in arTime [sec].
CINOSBaseAxis::CINOSBaseAxis
CINOSBaseAxis(SINOSBaseAxis *apDesc, CINOSBaseRamp *apRamp)
Create an axis based on a descriptor (usually not used because this is done by the configuration syst...
CINOSBaseAxis::Cursor
virtual uint32 Cursor(bool abPositive, uint32 auWaitTime)
Moves one 'inc' in the requested direction, waits auWaitTime ms and starts an endless move to the def...
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calculate time characteristics of a move.
CINOSBaseAxis::MoveTime
virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition within the given time arTime and the speedset apParam. The speed set values are tr...
CINOSBaseAxis::SegMove
virtual uint32 SegMove(real64 arPosition)
Add a move to arPosition. Velocity and acceleration in arPosition have to be 0.0.
CINOSBaseAxis::Continue
virtual uint32 Continue(SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Continue a pause move with the given speed set.
CINOSBaseAxis::GetActVrt
SINOSRampData * GetActVrt()
deprecated
Definition cinosbaseaxis.h:3285
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the deceleration part.
CINOSBaseAxis::Pull
virtual uint32 Pull(real64 arS, real64 arV, real64 arA, real64 arJ)
Add a path point to the actual pull list and start pull mode if not et done. If one is running an axi...
CINOSBaseAxis::StopLive
virtual uint32 StopLive(real64 arSlowMotion, SINOSRampParam *apParam)
Stop a running move with the given speed set and required slowmotion factor. The stop is calculated l...
CINOSBaseAxis::GetNormMode
virtual uint8 GetNormMode()
Definition cinosbaseaxis.h:3235
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arPosition, const char *apParam)
Calc time [sec] a Move(adPosition) needs until arPosition.
CINOSBaseAxis::Cursor
virtual uint32 Cursor(real64 arbPosition, uint32 auWaitTime, real64 arStep, const char *apParam)
Moves one step in 'arPosition' direction, waits auWaitTime ms and then moves to arPosition....
CINOSBaseAxis::Move
virtual uint32 Move(real64 arPosition, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with speed set apParam.
CINOSBaseAxis::~CINOSBaseAxis
virtual ~CINOSBaseAxis()
Destroy the axis (usually not used)
CINOSBaseAxis::GetTrqLimitDeceleration
SINOSBaseRampTrqLimit * GetTrqLimitDeceleration()
get torque limit deceleration
Definition cinosbaseaxis.h:3339
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta, const char *apParam)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the deceleration part.
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition, real64 arDelta)
Calculate time characteristics of a move.
CINOSBaseAxis::Cursor
virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime)
Moves one 'inc' in 'arPosition' direction, waits auWaitTime ms and then moves to arPosition....
CINOSBaseAxis::Cursor
virtual uint32 Cursor(bool abPositive=true)
Moves one 'inc' in the requested direction, waits 500ms and starts an endless move to the defined sof...
CINOSBaseAxis::SegMove
virtual uint32 SegMove(real64 arPosition, SINOSRampParam *apParam)
Add a move to arPosition. Velocity and acceleration in arPosition have to be 0.0.
CINOSBaseAxis::EmergencyStopLive
virtual uint32 EmergencyStopLive()
Stop a running move with the defined emergency deceleration/jerk. The stop is calculated live and the...
CINOSBaseAxis::Disable
virtual uint32 Disable(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Disables an enabled axis. Only inactivated axis can be disabled. Use 'Enable' to reenable the axis.
CINOSBaseAxis::StopLiveDelta
virtual uint32 StopLiveDelta(real64 arDelta, real64 arSlowMotion, SINOSRampParam *apParam=nullptr)
Stop a running move with the given speed set and required slowmotion factor. The stop is calculated l...
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, const char *apParam)
Calc time [sec] an according MoveDep needs.
CINOSBaseAxis::GetName
virtual const char * GetName()
CINOSBaseAxis::Sync
virtual uint32 Sync(real64 arPosition, real64 arSyncPos, SINOSRampParam *apParam, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Search reference mark till arPosition and set actual position to arSyncPos at mark.
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arPosition, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] a Move(adPosition) needs until arPosition-arDelta.
CINOSBaseAxis::EnableRamp
void EnableRamp()
Enable a recently disabled trajectory generator.
Definition cinosbaseaxis.h:2446
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] an according MoveDep needs until arPosition-arDelta.
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] an according MoveApp needs until arPosition-arDelta.
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta)
Calc time [sec] a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::GetNumber
static uint8 GetNumber(const char *apAxisName)
Get number of axis apAxisName.
CINOSBaseAxis::SegPos
virtual uint32 SegPos(real64 arTime)
stay at actual position for arTime [sec].
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta, const char *apParam)
Calc time [sec] a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::Activate
virtual uint32 Activate(bool abCheckPos=true, bool abSimulatePos=false, bool abSimulateOut=false, bool abSimulateAct=false, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Activate axis in a given mode, e.g Activate(true,true,true,true) enables the axis in a full simulated...
CINOSBaseAxis::GetToggleCnt
virtual uint32 GetToggleCnt()
get current toggle counter
Definition cinosbaseaxis.h:3323
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arPosition, SINOSRampParam *apParam)
Calc bus ticks a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::Endless
virtual uint32 Endless(bool abPositive=true)
Start and endless move in the requested direction with actual commanded acc/dec and velocity.
CINOSBaseAxis::GetNormMoveDir
virtual uint8 GetNormMoveDir()
Definition cinosbaseaxis.h:3227
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition, real64 arTime)
Calc distance [unit] a move from arStartPosition to arEndPosition progresses in arTime [sec].
CINOSBaseAxis::GetAxis
static CINOSBaseAxis * GetAxis(const char *apAxisName)
Get pointer to axis with name apAxisName.
CINOSBaseAxis::SetRealPosition
virtual uint32 SetRealPosition(real64 arPosition)
Sets the real axis position. This method ignores a current following error and should therefore NOT b...
CINOSBaseAxis::m_pRealVrt
SINOSRampDataEx * m_pRealVrt
actual real virtual values
Definition cinosbaseaxis.h:3725
CINOSBaseAxis::GetRealPosition
virtual void GetRealPosition(real64 &arPosition, bool abMapped=true)
Gets the real axis position.
CINOSBaseAxis::m_uCycleId
uint16 m_uCycleId
cycle id
Definition cinosbaseaxis.h:3868
CINOSBaseAxis::SegMove
virtual uint32 SegMove(real64 arPosition, real64 arVelocity, const char *apParam)
Add a move to arPosition. Requested velocity in arPosition is arVelocity, the acceleration is 0....
CINOSBaseAxis::SegTime
virtual real64 SegTime()
Returns time the actual segment move takes.
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition, real64 arDelta, SINOSRampParam *apParam)
Calc time [sec] a Move from arStartPosition until arEndPosition needs for the acceleration part.
CINOSBaseAxis::Cursor
virtual uint32 Cursor(bool abPositive, uint32 auWaitTime, real64 arStep, SINOSRampParam *apParam)
Moves one arStep in the requested direction, waits auWaitTime ms and starts an endless move to the de...
CINOSBaseAxis::GetCoreId
uint8 GetCoreId()
get core id the axis is running on
Definition cinosbaseaxis.h:3345
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arPosition)
Calc time [sec] a Move(adPosition) needs for the constant part.
CINOSBaseRampParamSet
Definition cinosbaseramp.h:697
CINOSBaseRamp
Definition cinosbaseramp.h:752
CINOSBaseRamp::GetTrqLimitAcceleration
SINOSBaseRampTrqLimit * GetTrqLimitAcceleration()
get torque limit acceleration
Definition cinosbaseramp.h:1343
CINOSBaseRamp::GetTrqLimitDeceleration
SINOSBaseRampTrqLimit * GetTrqLimitDeceleration()
get torque limit deceleration
Definition cinosbaseramp.h:1349
CINOSBus
Definition cinosbus.h:563
CINOSBus::AtomicGatherEnter
INOS_INLINE void AtomicGatherEnter(uint32 &ouToken)
Definition cinosbus.h:950
CINOSMutex
Definition cinosmutex.h:36
CINOSMutex::GetOwner
ICACHE class CINOSTask * GetOwner()
Return id of mutex owner.
Definition cinosmutex.h:118
CINOSPhysicalAxis
Provides physical aka real axis functionality.
Definition cinosphysicalaxis.h:286
CINOSSync
Definition inos_syn.h:67
INOS_INLINE
#define INOS_INLINE
Definition inosdefine.h:60
DF_INOS_CORE_DEFAULT
#define DF_INOS_CORE_DEFAULT
Definition inosdefine.h:170
INOS_OR
#define INOS_OR(variable, mask)
Definition inosmacro.h:201
DF_INOS_ASYNCHRONOUS
#define DF_INOS_ASYNCHRONOUS
Definition inosmacro.h:337
DF_INOS_SYNCHRONOUS
#define DF_INOS_SYNCHRONOUS
Definition inosmacro.h:332
INOS_AND
#define INOS_AND(variable, mask)
Definition inosmacro.h:210
tUid
uint32 tUid
Definition inostype.h:190
SINOSBaseAxis
Descriptor structure used to configure a base axis. It is usually only used in conjunction with SINOS...
Definition cinosbaseaxis.h:390
SINOSBaseAxis::m_rPosTolerance
real64 m_rPosTolerance
Default positioning tolerance [unit] for types DF_INOS_AXIS_PST_WINDOW and DF_INOS_AXIS_PST_WINDOW_OP...
Definition cinosbaseaxis.h:511
SINOSBaseAxis::m_cEmergencyParam
inosName32 m_cEmergencyParam
Name of the speed set to be used for emergency stops.
Definition cinosbaseaxis.h:555
SINOSBaseAxis::m_uCoreId
uint8 m_uCoreId
Id of core the axis has to run on. In the configuration file do not define this value or set it to 0x...
Definition cinosbaseaxis.h:411
SINOSBaseAxis::m_uCacheSize
uint32 m_uCacheSize
Used to define a cache size for the special safe move commands. Currently only used on a special cust...
Definition cinosbaseaxis.h:516
SINOSBaseAxis::m_uSafetyType
uint8 m_uSafetyType
Defines the behaviour in case of an SOS request DF_INOS_AXIS_SAFETY_EMGSTOP, DF_INOS_AXIS_SAFETY_AUTO...
Definition cinosbaseaxis.h:435
SINOSBaseAxis::m_uNormMode
uint8 m_uNormMode
Used to define the default axis norming mode, e.g. norm an turn axis to 0..360° see DF_INOS_AXIS_NORM...
Definition cinosbaseaxis.h:530
SINOSBaseAxis::m_uTrackFilterLength
uint32 m_uTrackFilterLength
Defines the default tracking filter length.
Definition cinosbaseaxis.h:487
SINOSBaseAxis::m_rTrackFactor
real64 m_rTrackFactor
Defines the default tracking factor.
Definition cinosbaseaxis.h:483
SINOSBaseAxis::m_rEmergencyPosition
real64 m_rEmergencyPosition
Emergency stop position (used in emergency types DF_INOS_AXIS_EMGT_STOP_POSITION and DF_INOS_AXIS_EMG...
Definition cinosbaseaxis.h:479
SINOSBaseAxis::m_rTestPos2
real64 m_rTestPos2
Test mode position 2, see also m_rTestPos1 and m_uTestDelay.
Definition cinosbaseaxis.h:470
SINOSBaseAxis::m_cName
inosName64 m_cName
Axis name.
Definition cinosbaseaxis.h:393
SINOSBaseAxis::m_rTestPos1Max
real64 m_rTestPos1Max
Test mode position 1 maximum, see also m_rTestPos1.
Definition cinosbaseaxis.h:466
SINOSBaseAxis::m_uNumber
uint16 m_uNumber
Optional axis number. This value is only used on specific Indel targets like e.g. a GIN-AX4x4 to defi...
Definition cinosbaseaxis.h:406
SINOSBaseAxis::m_cShort
uint16 m_cShort
Gives the user the possibility to define a short one character based axis alias. This option is depre...
Definition cinosbaseaxis.h:521
SINOSBaseAxis::m_uNormMoveDir
uint8 m_uNormMoveDir
Used to define the default axis norm moving direction, e.g. move always in positive direction,...
Definition cinosbaseaxis.h:540
SINOSBaseAxis::m_uEmergencyType
uint8 m_uEmergencyType
Defines the default behaviour in case of an emergency stop of the axis. An emergency stop is either i...
Definition cinosbaseaxis.h:447
SINOSBaseAxis::m_cDescription
inosName64 m_cDescription
Axis description.
Definition cinosbaseaxis.h:559
SINOSBaseAxis::m_uPosTime
uint32 m_uPosTime
Default positioning time [ms] for types DF_INOS_AXIS_PST_WINDOW and DF_INOS_AXIS_PST_WINDOW_OPT.
Definition cinosbaseaxis.h:501
SINOSBaseAxis::m_cRampType
inosName32 m_cRampType
Trajectory generator name. Valid types are INOSJerkRamp, INOSJerkTrqRamp, INOSTrapezeRamp or a custom...
Definition cinosbaseaxis.h:399
SINOSBaseAxis::m_cDefaultParam
inosName32 m_cDefaultParam
If this string is not empty and the axis ramps A,V,J are set to 0.0 (means undefined) then the speed ...
Definition cinosbaseaxis.h:551
SINOSBaseAxis::m_uReserved
uint8 m_uReserved
Reserved for future use.
Definition cinosbaseaxis.h:415
SINOSBaseAxis::m_rTestPos1
real64 m_rTestPos1
Test mode position 1, see also m_rTestPos2 and m_uTestDelay.
Definition cinosbaseaxis.h:462
SINOSBaseAxis::m_uOptions
uint32 m_uOptions
Axis options, see DF_INOS_BASE_AXIS_OPT_EARLY_DONE, DF_INOS_BASE_AXIS_OPT_AUTO_ACCEPT,...
Definition cinosbaseaxis.h:428
SINOSBaseAxis::m_uEmergencyDelay
uint16 m_uEmergencyDelay
The required default delay [ms] if working with emergency type DF_INOS_AXIS_EMGT_STOP_INACTIVATE.
Definition cinosbaseaxis.h:452
SINOSBaseAxis::m_uPosTimeout
uint32 m_uPosTimeout
Default positioning timeout [ms] for types DF_INOS_AXIS_PST_WINDOW and DF_INOS_AXIS_PST_WINDOW_OPT.
Definition cinosbaseaxis.h:506
SINOSBaseAxis::m_uTestDelay
uint32 m_uTestDelay
For testing purposes, an axis provides a test folder in the INCO tree where one can toggle the axis b...
Definition cinosbaseaxis.h:458
SINOSBaseAxis::m_rNormPos
real64 m_rNormPos
Defines the default norming position, e.g. 360.0 for a turning axis.
Definition cinosbaseaxis.h:544
SINOSBaseAxis::m_uPosType
uint32 m_uPosType
Tells the system how an end of a move is defined. There are three different type available,...
Definition cinosbaseaxis.h:496
SINOSBaseAxis::m_rTestPos2Max
real64 m_rTestPos2Max
Test mode position 2 maximum, see also m_rTestPos2.
Definition cinosbaseaxis.h:474
SINOSBaseRampTrqLimit
torque limitation
Definition cinosbaseramp.h:661
SINOSMovePathActual
Definition cinosmovepathtrajectory.h:50
SINOSRampDataEx
extended ramp data
Definition cinosbaseramp.h:617
SINOSRampData
ramp data
Definition cinosbaseramp.h:602
SINOSRampParam
ramp parameters
Definition cinosbaseramp.h:503
SINOSTimeCharacteristics
time characteristics of a move
Definition cinosbaseramp.h:627