////////////////////////////////////////////////////////////////////////////////////////////////// // // ACS Motion Control Ltd. // Copyright © 1999 - 2022. All Rights Reserved. // // PROJECT : SPiiPlus // SUBSYSTEM : SPiiPlus C Library // FILE : ACSC.h // VERSION : 7.2.0.0 // OVERVIEW // ======== // // SPiiPlus C Library export functions definition // ////////////////////////////////////////////////////////////////////////////////////////////////// #ifndef ACSC_H #define ACSC_H #if defined(_WIN32) #include #include #include #define UnsignedInt64 unsigned __int64 #elif defined(__linux__) #define RPCTRY #define RPCTRYEND(n) #define WINAPI #include #include #include typedef void* HANDLE; typedef int BOOL; typedef unsigned int DWORD; typedef signed int INT32; typedef char BSTR; typedef uintptr_t DWORD_PTR; typedef int32_t __int32; #define UnsignedInt64 uint64_t #endif #include ////////////////////////////////////////////////////////////////////////////////////////////////// // General definitions ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_VER 0x7020000 #define ACSC_MAXCHANNEL 10 //Maximum number of communication channels #define ACSC_INVALID HANDLE(-1) //Invalid communication handle #define ACSC_NONE -1 #define ACSC_INT_BINARY 4 //Size of the controller integer variable #define ACSC_REAL_BINARY 8 //Size of the controller real variable #define ACSC_FILE -2 #define ACSC_DEFAULT_REMOTE_PORT 9999 #define ACSC_AXES_MAX_NUMBER 128 //Maximum number of supported axes #define ACSC_BUFFERS_MAX_NUMBER 65 //Maximum number of supported buffers (including D-Buffer) #define ACSC_SP_MAX_NUMBER 128 //Maximum number of supported Servo Processors (SP) #define ACSC_DC_VAR_MAX_NUMBER 10 //Maximum number of variables to be collected by one command #define ACSC_MAX_LINE 100000 //Maximum number of lines in program buffer #define ACSC_COUNTERCLOCKWISE 1 //Counterclockwise rotation #define ACSC_CLOCKWISE -1 //Clockwise rotation #define ACSC_POSITIVE_DIRECTION 1 //A move in positive direction #define ACSC_NEGATIVE_DIRECTION -1 //A move in negative direction // for compatibility with the previous library #define MAXCHANNEL 10 // Set/Get configuration keys #define ACSC_CONF_WORD1_KEY 1 #define ACSC_CONF_INT_EDGE_KEY 3 #define ACSC_CONF_ENCODER_KEY 4 #define ACSC_CONF_MFLAGS9_KEY 204 #define ACSC_CONF_DIGITAL_SOURCE_KEY 205 #define ACSC_CONF_SP_OUT_PINS_KEY 206 #define ACSC_CONF_OUT_KEY 29 #define ACSC_CONF_BRAKE_OUT_KEY 229 // System Information keys #define ACSC_SYS_MODEL_KEY 1 #define ACSC_SYS_VERSION_KEY 2 #define ACSC_SYS_NBUFFERS_KEY 10 #define ACSC_SYS_DBUF_INDEX_KEY 11 #define ACSC_SYS_NAXES_KEY 13 #define ACSC_SYS_NNODES_KEY 14 #define ACSC_SYS_NDCCH_KEY 15 #define ACSC_SYS_ECAT_KEY 16 ////////////////////////////////////////////////////////////////////////////////////////////////// // ACSPL+ variables types ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_INT_TYPE 1 //Integer type of the variable (Decimal representation) #define ACSC_REAL_TYPE 2 //Real type of the variable (Decimal representation) ////////////////////////////////////////////////////////////////////////////////////////////////// // Represintation types of file stored variables ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_DEC_REAL_TYPE 8 //Decimal representation of Real type variable #define ACSC_DEC_INT_TYPE 4 //Decimal representation of Integer type variable #define ACSC_BIN_INT_TYPE 2 //Binary representation of Integer type variable #define ACSC_OCT_INT_TYPE 1 //Octal representation of Integer type variable #define ACSC_HEX_INT_TYPE 16 //Hexadecimal representation of Integer type variable ////////////////////////////////////////////////////////////////////////////////////////////////// // Serial communication options ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_AUTO -1 ////////////////////////////////////////////////////////////////////////////////////////////////// // Ethernet communication options ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_SOCKET_DGRAM_PORT 700 #define ACSC_SOCKET_STREAM_PORT 701 ////////////////////////////////////////////////////////////////////////////////////////////////// // Old Axes Definitions ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_AXIS_X 0 #define ACSC_AXIS_Y 1 #define ACSC_AXIS_Z 2 #define ACSC_AXIS_T 3 #define ACSC_AXIS_A 4 #define ACSC_AXIS_B 5 #define ACSC_AXIS_C 6 #define ACSC_AXIS_D 7 ////////////////////////////////////////////////////////////////////////////////////////////////// // New Axes Definitions ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_PAR_ALL -2 #define ACSC_SYSTEM -3 #define ACSC_AXIS_0 0 #define ACSC_AXIS_1 1 #define ACSC_AXIS_2 2 #define ACSC_AXIS_3 3 #define ACSC_AXIS_4 4 #define ACSC_AXIS_5 5 #define ACSC_AXIS_6 6 #define ACSC_AXIS_7 7 #define ACSC_AXIS_8 8 #define ACSC_AXIS_9 9 #define ACSC_AXIS_10 10 #define ACSC_AXIS_11 11 #define ACSC_AXIS_12 12 #define ACSC_AXIS_13 13 #define ACSC_AXIS_14 14 #define ACSC_AXIS_15 15 #define ACSC_AXIS_16 16 #define ACSC_AXIS_17 17 #define ACSC_AXIS_18 18 #define ACSC_AXIS_19 19 #define ACSC_AXIS_20 20 #define ACSC_AXIS_21 21 #define ACSC_AXIS_22 22 #define ACSC_AXIS_23 23 #define ACSC_AXIS_24 24 #define ACSC_AXIS_25 25 #define ACSC_AXIS_26 26 #define ACSC_AXIS_27 27 #define ACSC_AXIS_28 28 #define ACSC_AXIS_29 29 #define ACSC_AXIS_30 30 #define ACSC_AXIS_31 31 #define ACSC_AXIS_32 32 #define ACSC_AXIS_33 33 #define ACSC_AXIS_34 34 #define ACSC_AXIS_35 35 #define ACSC_AXIS_36 36 #define ACSC_AXIS_37 37 #define ACSC_AXIS_38 38 #define ACSC_AXIS_39 39 #define ACSC_AXIS_40 40 #define ACSC_AXIS_41 41 #define ACSC_AXIS_42 42 #define ACSC_AXIS_43 43 #define ACSC_AXIS_44 44 #define ACSC_AXIS_45 45 #define ACSC_AXIS_46 46 #define ACSC_AXIS_47 47 #define ACSC_AXIS_48 48 #define ACSC_AXIS_49 49 #define ACSC_AXIS_50 50 #define ACSC_AXIS_51 51 #define ACSC_AXIS_52 52 #define ACSC_AXIS_53 53 #define ACSC_AXIS_54 54 #define ACSC_AXIS_55 55 #define ACSC_AXIS_56 56 #define ACSC_AXIS_57 57 #define ACSC_AXIS_58 58 #define ACSC_AXIS_59 59 #define ACSC_AXIS_60 60 #define ACSC_AXIS_61 61 #define ACSC_AXIS_62 62 #define ACSC_AXIS_63 63 #define ACSC_AXIS_64 64 #define ACSC_AXIS_65 65 #define ACSC_AXIS_66 66 #define ACSC_AXIS_67 67 #define ACSC_AXIS_68 68 #define ACSC_AXIS_69 69 #define ACSC_AXIS_70 70 #define ACSC_AXIS_71 71 #define ACSC_AXIS_72 72 #define ACSC_AXIS_73 73 #define ACSC_AXIS_74 74 #define ACSC_AXIS_75 75 #define ACSC_AXIS_76 76 #define ACSC_AXIS_77 77 #define ACSC_AXIS_78 78 #define ACSC_AXIS_79 79 #define ACSC_AXIS_80 80 #define ACSC_AXIS_81 81 #define ACSC_AXIS_82 82 #define ACSC_AXIS_83 83 #define ACSC_AXIS_84 84 #define ACSC_AXIS_85 85 #define ACSC_AXIS_86 86 #define ACSC_AXIS_87 87 #define ACSC_AXIS_88 88 #define ACSC_AXIS_89 89 #define ACSC_AXIS_90 90 #define ACSC_AXIS_91 91 #define ACSC_AXIS_92 92 #define ACSC_AXIS_93 93 #define ACSC_AXIS_94 94 #define ACSC_AXIS_95 95 #define ACSC_AXIS_96 96 #define ACSC_AXIS_97 97 #define ACSC_AXIS_98 98 #define ACSC_AXIS_99 99 #define ACSC_AXIS_100 100 #define ACSC_AXIS_101 101 #define ACSC_AXIS_102 102 #define ACSC_AXIS_103 103 #define ACSC_AXIS_104 104 #define ACSC_AXIS_105 105 #define ACSC_AXIS_106 106 #define ACSC_AXIS_107 107 #define ACSC_AXIS_108 108 #define ACSC_AXIS_109 109 #define ACSC_AXIS_110 110 #define ACSC_AXIS_111 111 #define ACSC_AXIS_112 112 #define ACSC_AXIS_113 113 #define ACSC_AXIS_114 114 #define ACSC_AXIS_115 115 #define ACSC_AXIS_116 116 #define ACSC_AXIS_117 117 #define ACSC_AXIS_118 118 #define ACSC_AXIS_119 119 #define ACSC_AXIS_120 120 #define ACSC_AXIS_121 121 #define ACSC_AXIS_122 122 #define ACSC_AXIS_123 123 #define ACSC_AXIS_124 124 #define ACSC_AXIS_125 125 #define ACSC_AXIS_126 126 #define ACSC_AXIS_127 127 ////////////////////////////////////////////////////////////////////////////////////////////////// // Buffers Definitions ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_BUFFER_ALL -2 #define ACSC_BUFFER_0 0 #define ACSC_BUFFER_1 1 #define ACSC_BUFFER_2 2 #define ACSC_BUFFER_3 3 #define ACSC_BUFFER_4 4 #define ACSC_BUFFER_5 5 #define ACSC_BUFFER_6 6 #define ACSC_BUFFER_7 7 #define ACSC_BUFFER_8 8 #define ACSC_BUFFER_9 9 #define ACSC_BUFFER_10 10 #define ACSC_BUFFER_11 11 #define ACSC_BUFFER_12 12 #define ACSC_BUFFER_13 13 #define ACSC_BUFFER_14 14 #define ACSC_BUFFER_15 15 #define ACSC_BUFFER_16 16 #define ACSC_BUFFER_17 17 #define ACSC_BUFFER_18 18 #define ACSC_BUFFER_19 19 #define ACSC_BUFFER_20 20 #define ACSC_BUFFER_21 21 #define ACSC_BUFFER_22 22 #define ACSC_BUFFER_23 23 #define ACSC_BUFFER_24 24 #define ACSC_BUFFER_25 25 #define ACSC_BUFFER_26 26 #define ACSC_BUFFER_27 27 #define ACSC_BUFFER_28 28 #define ACSC_BUFFER_29 29 #define ACSC_BUFFER_30 30 #define ACSC_BUFFER_31 31 #define ACSC_BUFFER_32 32 #define ACSC_BUFFER_33 33 #define ACSC_BUFFER_34 34 #define ACSC_BUFFER_35 35 #define ACSC_BUFFER_36 36 #define ACSC_BUFFER_37 37 #define ACSC_BUFFER_38 38 #define ACSC_BUFFER_39 39 #define ACSC_BUFFER_40 40 #define ACSC_BUFFER_41 41 #define ACSC_BUFFER_42 42 #define ACSC_BUFFER_43 43 #define ACSC_BUFFER_44 44 #define ACSC_BUFFER_45 45 #define ACSC_BUFFER_46 46 #define ACSC_BUFFER_47 47 #define ACSC_BUFFER_48 48 #define ACSC_BUFFER_49 49 #define ACSC_BUFFER_50 50 #define ACSC_BUFFER_51 51 #define ACSC_BUFFER_52 52 #define ACSC_BUFFER_53 53 #define ACSC_BUFFER_54 54 #define ACSC_BUFFER_55 55 #define ACSC_BUFFER_56 56 #define ACSC_BUFFER_57 57 #define ACSC_BUFFER_58 58 #define ACSC_BUFFER_59 59 #define ACSC_BUFFER_60 60 #define ACSC_BUFFER_61 61 #define ACSC_BUFFER_62 62 #define ACSC_BUFFER_63 63 #define ACSC_BUFFER_64 64 ////////////////////////////////////////////////////////////////////////////////////////////////// // Servo Processors Definitions ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_SP_ALL -2 #define ACSC_SP_0 0 #define ACSC_SP_1 1 #define ACSC_SP_2 2 #define ACSC_SP_3 3 #define ACSC_SP_4 4 #define ACSC_SP_5 5 #define ACSC_SP_6 6 #define ACSC_SP_7 7 #define ACSC_SP_8 8 #define ACSC_SP_9 9 #define ACSC_SP_10 10 #define ACSC_SP_11 11 #define ACSC_SP_12 12 #define ACSC_SP_13 13 #define ACSC_SP_14 14 #define ACSC_SP_15 15 #define ACSC_SP_16 16 #define ACSC_SP_17 17 #define ACSC_SP_18 18 #define ACSC_SP_19 19 #define ACSC_SP_20 20 #define ACSC_SP_21 21 #define ACSC_SP_22 22 #define ACSC_SP_23 23 #define ACSC_SP_24 24 #define ACSC_SP_25 25 #define ACSC_SP_26 26 #define ACSC_SP_27 27 #define ACSC_SP_28 28 #define ACSC_SP_29 29 #define ACSC_SP_30 30 #define ACSC_SP_31 31 #define ACSC_SP_32 32 #define ACSC_SP_33 33 #define ACSC_SP_34 34 #define ACSC_SP_35 35 #define ACSC_SP_36 36 #define ACSC_SP_37 37 #define ACSC_SP_38 38 #define ACSC_SP_39 39 #define ACSC_SP_40 40 #define ACSC_SP_41 41 #define ACSC_SP_42 42 #define ACSC_SP_43 43 #define ACSC_SP_44 44 #define ACSC_SP_45 45 #define ACSC_SP_46 46 #define ACSC_SP_47 47 #define ACSC_SP_48 48 #define ACSC_SP_49 49 #define ACSC_SP_50 50 #define ACSC_SP_51 51 #define ACSC_SP_52 52 #define ACSC_SP_53 53 #define ACSC_SP_54 54 #define ACSC_SP_55 55 #define ACSC_SP_56 56 #define ACSC_SP_57 57 #define ACSC_SP_58 58 #define ACSC_SP_59 59 #define ACSC_SP_60 60 #define ACSC_SP_61 61 #define ACSC_SP_62 62 #define ACSC_SP_63 63 #define ACSC_SP_64 64 #define ACSC_SP_65 65 #define ACSC_SP_66 66 #define ACSC_SP_67 67 #define ACSC_SP_68 68 #define ACSC_SP_69 69 #define ACSC_SP_70 70 #define ACSC_SP_71 71 #define ACSC_SP_72 72 #define ACSC_SP_73 73 #define ACSC_SP_74 74 #define ACSC_SP_75 75 #define ACSC_SP_76 76 #define ACSC_SP_77 77 #define ACSC_SP_78 78 #define ACSC_SP_79 79 #define ACSC_SP_80 80 #define ACSC_SP_81 81 #define ACSC_SP_82 82 #define ACSC_SP_83 83 #define ACSC_SP_84 84 #define ACSC_SP_85 85 #define ACSC_SP_86 86 #define ACSC_SP_87 87 #define ACSC_SP_88 88 #define ACSC_SP_89 89 #define ACSC_SP_90 90 #define ACSC_SP_91 91 #define ACSC_SP_92 92 #define ACSC_SP_93 93 #define ACSC_SP_94 94 #define ACSC_SP_95 95 #define ACSC_SP_96 96 #define ACSC_SP_97 97 #define ACSC_SP_98 98 #define ACSC_SP_99 99 #define ACSC_SP_100 100 #define ACSC_SP_101 101 #define ACSC_SP_102 102 #define ACSC_SP_103 103 #define ACSC_SP_104 104 #define ACSC_SP_105 105 #define ACSC_SP_106 106 #define ACSC_SP_107 107 #define ACSC_SP_108 108 #define ACSC_SP_109 109 #define ACSC_SP_110 110 #define ACSC_SP_111 111 #define ACSC_SP_112 112 #define ACSC_SP_113 113 #define ACSC_SP_114 114 #define ACSC_SP_115 115 #define ACSC_SP_116 116 #define ACSC_SP_117 117 #define ACSC_SP_118 118 #define ACSC_SP_119 119 #define ACSC_SP_120 120 #define ACSC_SP_121 121 #define ACSC_SP_122 122 #define ACSC_SP_123 123 #define ACSC_SP_124 124 #define ACSC_SP_125 125 #define ACSC_SP_126 126 #define ACSC_SP_127 127 ////////////////////////////////////////////////////////////////////////////////////////////////// // PCI interrupts flags ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_INTR_PEG 3 #define ACSC_INTR_MARK1 7 #define ACSC_INTR_MARK2 8 #define ACSC_INTR_EMERGENCY 15 #define ACSC_INTR_PHYSICAL_MOTION_END 16 #define ACSC_INTR_LOGICAL_MOTION_END 17 #define ACSC_INTR_MOTION_FAILURE 18 #define ACSC_INTR_MOTOR_FAILURE 19 #define ACSC_INTR_PROGRAM_END 20 #define ACSC_INTR_COMMAND 21 // FOR BACKWARD COMPATIBILITY #define ACSC_INTR_ACSPL_PROGRAM_EX 21 #define ACSC_INTR_ACSPL_PROGRAM 22 #define ACSC_INTR_INPUT 23 #define ACSC_INTR_MOTION_START 24 #define ACSC_INTR_MOTION_PHASE_CHANGE 25 #define ACSC_INTR_TRIGGER 26 #define ACSC_INTR_NEWSEGM 27 #define ACSC_INTR_SYSTEM_ERROR 28 #define ACSC_INTR_ETHERCAT_ERROR 29 #define ACSC_INTR_CYCLE 30 // FOR BACKWARD COMPATIBILITY #define ACSC_INTR_FPGA_UPGRADE 30 #define ACSC_INTR_MESSAGE 31 #define ACSC_INTR_COMM_CHANNEL_CLOSED 32 #define ACSC_INTR_SOFTWARE_ESTOP 33 ////////////////////////////////////////////////////////////////////////////////////////////////// // Bit masks definitions ////////////////////////////////////////////////////////////////////////////////////////////////// // Communication options #define ACSC_COMM_USE_CHECKSUM 0x00000001 #define ACSC_COMM_AUTORECOVER_HW_ERROR 0x00000002 // Motion flags #define ACSC_AMF_WAIT 0x00000001 // SAME AS ACSC_AMF_WEIGHT #define ACSC_AMF_WEIGHT 0x00000001 // SAME AS ACSC_AMF_WAIT #define ACSC_AMF_RELATIVE 0x00000002 #define ACSC_AMF_VELOCITY 0x00000004 #define ACSC_AMF_ENDVELOCITY 0x00000008 // SAME AS ACSC_AMF_REQUIRED_VELOCITY, ACSC_PEG_FASTLOADINGPEG #define ACSC_AMF_REQUIRED_VELOCITY 0x00000008 // SAME AS ACSC_AMF_ENDVELOCITY, ACSC_PEG_FASTLOADINGPEG #define ACSC_AMF_FASTLOADINGPEG 0x00000008 // SAME AS ACSC_AMF_ENDVELOCITY, ACSC_AMF_REQUIRED_VELOCITY #define ACSC_AMF_POSITIONLOCK 0x00000010 #define ACSC_AMF_VELOCITYLOCK 0x00000020 #define ACSC_AMF_CYCLIC 0x00000100 // SAME AS ACSC_AMF_CORNER #define ACSC_AMF_CORNER 0x00000100 // SAME AS ACSC_AMF_CYCLIC #define ACSC_AMF_VARTIME 0x00000200 // SAME AS ACSC_STALLED, ACSC_AMF_TIME #define ACSC_AMF_STALLED 0x00000200 // SAME AS ACSC_AMF_VARTIME, ACSC_AMF_TIME #define ACSC_AMF_TIME 0x00000200 // SAME AS ACSC_AMF_VARTIME, ACSC_AMF_STALLED #define ACSC_AMF_CUBIC 0x00000400 #define ACSC_AMF_2 0x00000800 #define ACSC_AMF_EXTRAPOLATED 0x00001000 // SAME AS ACSC_AMF_ENVELOPE #define ACSC_AMF_ENVELOPE 0x00001000 // SAME AS ACSC_AMF_EXTRAPOLATED #define ACSC_AMF_AXISLIMIT 0x00002000 // SAME AS ACSC_AMF_NURBS_EXCEPTION_LENGTH, ACSC_AMF_LOCAL #define ACSC_AMF_NURBS_EXCEPTION_LENGTH 0x00002000 // SAME AS ACSC_AMF_AXISLIMIT, ACSC_AMF_LOCAL #define ACSC_AMF_LOCAL 0x00002000 // SAME AS ACSC_AMF_AXISLIMIT, ACSC_AMF_NURBS_EXCEPTION_LENGTH #define ACSC_AMF_MAXIMUM 0x00004000 // SAME AS ACSC_AMF_BSEGTIME #define ACSC_AMF_BSEGTIME 0x00004000 // SAME AS ACSC_AMF_MAXIMUM #define ACSC_AMF_SYNCHRONOUS 0x00008000 // SAME AS ACSC_AMF_BSEGJERK #define ACSC_AMF_BSEGJERK 0x00008000 // SAME AS ACSC_AMF_SYNCHRONOUS #define ACSC_AMF_JUNCTIONVELOCITY 0x00010000 #define ACSC_AMF_ANGLE 0x00020000 // SAME AS ACSC_AMF_ACCURATE, ACSC_AMF_BSEGACC, ACSC_AMF_NURBS_EXCEPTION_ANGLE #define ACSC_AMF_ACCURATE 0x00020000 // SAME AS ACSC_AMF_ANGLE, ACSC_AMF_BSEGACC AND ACSC_AMF_NURBS_EXCEPTION_ANGLE #define ACSC_AMF_BSEGACC 0x00020000 // SAME AS ACSC_AMF_ANGLE, ACSC_AMF_ACCURATE, ACSC_AMF_BSEGACC #define ACSC_AMF_NURBS_EXCEPTION_ANGLE 0x00020000 // SAME AS ACSC_AMF_ANGLE, ACSC_AMF_ACCURATE, ACSC_AMF_BSEGACC #define ACSC_AMF_USERVARIABLES 0x00040000 #define ACSC_AMF_INVERT_OUTPUT 0x00080000 #define ACSC_AMF_CURVEVELOCITY 0x00100000 // SAME AS ACSC_AMF_DWELLTIME, ACSC_AMF_DUMMY, ACSC_AMF_FIXED_TIME, ACSC_PEG_DYNAMICLOADINGPEG #define ACSC_AMF_DWELLTIME 0x00100000 // SAME AS ACSC_AMF_CURVEVELOCITY, ACSC_AMF_DUMMY, ACSC_AMF_FIXED_TIME, ACSC_PEG_DYNAMICLOADINGPEG #define ACSC_AMF_DUMMY 0x00100000 // SAME AS ACSC_AMF_CURVEVELOCITY, ACSC_AMF_DWELLTIME, ACSC_AMF_FIXED_TIME, ACSC_PEG_DYNAMICLOADINGPEG #define ACSC_AMF_FIXED_TIME 0x00100000 // SAME AS ACSC_AMF_CURVEVELOCITY, ACSC_AMF_DWELLTIME, ACSC_AMF_DUMMY, ACSC_PEG_DYNAMICLOADINGPEG #define ACSC_AMF_DYNAMICLOADINGPEG 0x00100000 // SAME AS ACSC_AMF_CURVEVELOCITY, ACSC_AMF_DWELLTIME, ACSC_AMF_DUMMY, ACSC_AMF_FIXED_TIME #define ACSC_AMF_CORNERDEVIATION 0x00200000 // SAME AS ACSC_AMF_NURBS_CONSIDER_ACC #define ACSC_AMF_NURBS_CONSIDER_ACC 0x00200000 // SAME AS ACSC_AMF_CORNERDEVIATION #define ACSC_AMF_CORNERRADIUS 0x00400000 #define ACSC_AMF_CORNERLENGTH 0x00800000 #define ACSC_AMF_CURVEAUTO 0x01000000 #define ACSC_AMF_EXT_LOOP 0x02000000 #define ACSC_AMF_EXT_LOOP_SYNC 0x04000000 #define ACSC_AMF_DELAY_MOTION 0x08000000 #define ACSC_AMF_LCI_STATE 0x10000000 #define ACSC_AMF_LOCALCS 0x20000000 #define ACSC_AMF_KNOT 0x40000000 #define ACSC_AMF_ENDLESS 0x00001000 //SAME AS ACSC_AMF_ENVELOPE,ACSC_AMF_EXTRAPOLATED #define ACSC_AMF_MODULE 0x00004000 //SAME AS ACSC_AMF_MAXIMUM,ACSC_AMF_BSEGTIME // Data collection flags #define ACSC_DCF_TEMPORAL 0x00000001 #define ACSC_DCF_CYCLIC 0x00000002 #define ACSC_DCF_SYNC 0x00000004 #define ACSC_DCF_WAIT 0x00000008 // Motor states #define ACSC_MST_ENABLE 0x00000001 #define ACSC_MST_INPOS 0x00000010 #define ACSC_MST_MOVE 0x00000020 #define ACSC_MST_ACC 0x00000040 // Motion states #define ACSC_AST_LEAD 0x00000001 #define ACSC_AST_DC 0x00000002 #define ACSC_AST_PEG 0x00000004 #define ACSC_AST_PEGREADY 0x00000010 #define ACSC_AST_MOVE 0x00000020 #define ACSC_AST_ACC 0x00000040 #define ACSC_AST_SEGMENT 0x00000080 #define ACSC_AST_VELLOCK 0x00000100 #define ACSC_AST_POSLOCK 0x00000200 // Index states #define ACSC_IST_IND 0x00000001 #define ACSC_IST_IND2 0x00000002 #define ACSC_IST_MARK 0x00000004 #define ACSC_IST_MARK2 0x00000008 // Program states #define ACSC_PST_COMPILED 0x00000001 #define ACSC_PST_RUN 0x00000002 #define ACSC_PST_SUSPEND 0x00000004 #define ACSC_PST_DEBUG 0x00000020 #define ACSC_PST_AUTO 0x00000080 // Safety control masks #define ACSC_SAFETY_RL 0x00000001 #define ACSC_SAFETY_LL 0x00000002 #define ACSC_SAFETY_NETWORK 0x00000004 #define ACSC_SAFETY_HOT 0x00000010 #define ACSC_SAFETY_SRL 0x00000020 #define ACSC_SAFETY_SLL 0x00000040 #define ACSC_SAFETY_ENCNC 0x00000080 #define ACSC_SAFETY_ENC2NC 0x00000100 #define ACSC_SAFETY_DRIVE 0x00000200 #define ACSC_SAFETY_ENC 0x00000400 #define ACSC_SAFETY_ENC2 0x00000800 #define ACSC_SAFETY_PE 0x00001000 #define ACSC_SAFETY_CPE 0x00002000 #define ACSC_SAFETY_VL 0x00004000 #define ACSC_SAFETY_AL 0x00008000 #define ACSC_SAFETY_CL 0x00010000 #define ACSC_SAFETY_SP 0x00020000 #define ACSC_SAFETY_STO 0x00040000 #define ACSC_SAFETY_HSSINC 0x00100000 #define ACSC_SAFETY_EXTNT 0x00800000 #define ACSC_SAFETY_TEMP 0x01000000 #define ACSC_SAFETY_PROG 0x02000000 #define ACSC_SAFETY_MEM 0x04000000 #define ACSC_SAFETY_TIME 0x08000000 #define ACSC_SAFETY_ES 0x10000000 #define ACSC_SAFETY_INT 0x20000000 #define ACSC_SAFETY_INTGR 0x40000000 #define ACSC_SAFETY_FAILURE 0x80000000 // EtherCAT flags #define ACSC_ETHERCAT_1BYTE 0x00000001 #define ACSC_ETHERCAT_2BYTES 0x00000002 #define ACSC_ETHERCAT_4BYTES 0x00000004 #define ACSC_ETHERCAT_FLOAT 0x00000008 ////////////////////////////////////////////////////////////////////////////////////////////////// // Old Axes Masks ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_MASK_AXIS_X 0x00000001 #define ACSC_MASK_AXIS_Y 0x00000002 #define ACSC_MASK_AXIS_Z 0x00000004 #define ACSC_MASK_AXIS_T 0x00000008 #define ACSC_MASK_AXIS_A 0x00000010 #define ACSC_MASK_AXIS_B 0x00000020 #define ACSC_MASK_AXIS_C 0x00000040 #define ACSC_MASK_AXIS_D 0x00000080 ////////////////////////////////////////////////////////////////////////////////////////////////// // New Axes Masks ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_MASK_AXIS_0 0x0000000000000001 #define ACSC_MASK_AXIS_1 0x0000000000000002 #define ACSC_MASK_AXIS_2 0x0000000000000004 #define ACSC_MASK_AXIS_3 0x0000000000000008 #define ACSC_MASK_AXIS_4 0x0000000000000010 #define ACSC_MASK_AXIS_5 0x0000000000000020 #define ACSC_MASK_AXIS_6 0x0000000000000040 #define ACSC_MASK_AXIS_7 0x0000000000000080 #define ACSC_MASK_AXIS_8 0x0000000000000100 #define ACSC_MASK_AXIS_9 0x0000000000000200 #define ACSC_MASK_AXIS_10 0x0000000000000400 #define ACSC_MASK_AXIS_11 0x0000000000000800 #define ACSC_MASK_AXIS_12 0x0000000000001000 #define ACSC_MASK_AXIS_13 0x0000000000002000 #define ACSC_MASK_AXIS_14 0x0000000000004000 #define ACSC_MASK_AXIS_15 0x0000000000008000 #define ACSC_MASK_AXIS_16 0x0000000000010000 #define ACSC_MASK_AXIS_17 0x0000000000020000 #define ACSC_MASK_AXIS_18 0x0000000000040000 #define ACSC_MASK_AXIS_19 0x0000000000080000 #define ACSC_MASK_AXIS_20 0x0000000000100000 #define ACSC_MASK_AXIS_21 0x0000000000200000 #define ACSC_MASK_AXIS_22 0x0000000000400000 #define ACSC_MASK_AXIS_23 0x0000000000800000 #define ACSC_MASK_AXIS_24 0x0000000001000000 #define ACSC_MASK_AXIS_25 0x0000000002000000 #define ACSC_MASK_AXIS_26 0x0000000004000000 #define ACSC_MASK_AXIS_27 0x0000000008000000 #define ACSC_MASK_AXIS_28 0x0000000010000000 #define ACSC_MASK_AXIS_29 0x0000000020000000 #define ACSC_MASK_AXIS_30 0x0000000040000000 #define ACSC_MASK_AXIS_31 0x0000000080000000 #define ACSC_MASK_AXIS_32 0x0000000100000000 #define ACSC_MASK_AXIS_33 0x0000000200000000 #define ACSC_MASK_AXIS_34 0x0000000400000000 #define ACSC_MASK_AXIS_35 0x0000000800000000 #define ACSC_MASK_AXIS_36 0x0000001000000000 #define ACSC_MASK_AXIS_37 0x0000002000000000 #define ACSC_MASK_AXIS_38 0x0000004000000000 #define ACSC_MASK_AXIS_39 0x0000008000000000 #define ACSC_MASK_AXIS_40 0x0000010000000000 #define ACSC_MASK_AXIS_41 0x0000020000000000 #define ACSC_MASK_AXIS_42 0x0000040000000000 #define ACSC_MASK_AXIS_43 0x0000080000000000 #define ACSC_MASK_AXIS_44 0x0000100000000000 #define ACSC_MASK_AXIS_45 0x0000200000000000 #define ACSC_MASK_AXIS_46 0x0000400000000000 #define ACSC_MASK_AXIS_47 0x0000800000000000 #define ACSC_MASK_AXIS_48 0x0001000000000000 #define ACSC_MASK_AXIS_49 0x0002000000000000 #define ACSC_MASK_AXIS_50 0x0004000000000000 #define ACSC_MASK_AXIS_51 0x0008000000000000 #define ACSC_MASK_AXIS_52 0x0010000000000000 #define ACSC_MASK_AXIS_53 0x0020000000000000 #define ACSC_MASK_AXIS_54 0x0040000000000000 #define ACSC_MASK_AXIS_55 0x0080000000000000 #define ACSC_MASK_AXIS_56 0x0100000000000000 #define ACSC_MASK_AXIS_57 0x0200000000000000 #define ACSC_MASK_AXIS_58 0x0400000000000000 #define ACSC_MASK_AXIS_59 0x0800000000000000 #define ACSC_MASK_AXIS_60 0x1000000000000000 #define ACSC_MASK_AXIS_61 0x2000000000000000 #define ACSC_MASK_AXIS_62 0x4000000000000000 #define ACSC_MASK_AXIS_63 0x8000000000000000 #define ACSC_MASK_AXIS_64 0x0000000000000001 #define ACSC_MASK_AXIS_65 0x0000000000000002 #define ACSC_MASK_AXIS_66 0x0000000000000004 #define ACSC_MASK_AXIS_67 0x0000000000000008 #define ACSC_MASK_AXIS_68 0x0000000000000010 #define ACSC_MASK_AXIS_69 0x0000000000000020 #define ACSC_MASK_AXIS_70 0x0000000000000040 #define ACSC_MASK_AXIS_71 0x0000000000000080 #define ACSC_MASK_AXIS_72 0x0000000000000100 #define ACSC_MASK_AXIS_73 0x0000000000000200 #define ACSC_MASK_AXIS_74 0x0000000000000400 #define ACSC_MASK_AXIS_75 0x0000000000000800 #define ACSC_MASK_AXIS_76 0x0000000000001000 #define ACSC_MASK_AXIS_77 0x0000000000002000 #define ACSC_MASK_AXIS_78 0x0000000000004000 #define ACSC_MASK_AXIS_79 0x0000000000008000 #define ACSC_MASK_AXIS_80 0x0000000000010000 #define ACSC_MASK_AXIS_81 0x0000000000020000 #define ACSC_MASK_AXIS_82 0x0000000000040000 #define ACSC_MASK_AXIS_83 0x0000000000080000 #define ACSC_MASK_AXIS_84 0x0000000000100000 #define ACSC_MASK_AXIS_85 0x0000000000200000 #define ACSC_MASK_AXIS_86 0x0000000000400000 #define ACSC_MASK_AXIS_87 0x0000000000800000 #define ACSC_MASK_AXIS_88 0x0000000001000000 #define ACSC_MASK_AXIS_89 0x0000000002000000 #define ACSC_MASK_AXIS_90 0x0000000004000000 #define ACSC_MASK_AXIS_91 0x0000000008000000 #define ACSC_MASK_AXIS_92 0x0000000010000000 #define ACSC_MASK_AXIS_93 0x0000000020000000 #define ACSC_MASK_AXIS_94 0x0000000040000000 #define ACSC_MASK_AXIS_95 0x0000000080000000 #define ACSC_MASK_AXIS_96 0x0000000100000000 #define ACSC_MASK_AXIS_97 0x0000000200000000 #define ACSC_MASK_AXIS_98 0x0000000400000000 #define ACSC_MASK_AXIS_99 0x0000000800000000 #define ACSC_MASK_AXIS_100 0x0000001000000000 #define ACSC_MASK_AXIS_101 0x0000002000000000 #define ACSC_MASK_AXIS_102 0x0000004000000000 #define ACSC_MASK_AXIS_103 0x0000008000000000 #define ACSC_MASK_AXIS_104 0x0000010000000000 #define ACSC_MASK_AXIS_105 0x0000020000000000 #define ACSC_MASK_AXIS_106 0x0000040000000000 #define ACSC_MASK_AXIS_107 0x0000080000000000 #define ACSC_MASK_AXIS_108 0x0000100000000000 #define ACSC_MASK_AXIS_109 0x0000200000000000 #define ACSC_MASK_AXIS_110 0x0000400000000000 #define ACSC_MASK_AXIS_111 0x0000800000000000 #define ACSC_MASK_AXIS_112 0x0001000000000000 #define ACSC_MASK_AXIS_113 0x0002000000000000 #define ACSC_MASK_AXIS_114 0x0004000000000000 #define ACSC_MASK_AXIS_115 0x0008000000000000 #define ACSC_MASK_AXIS_116 0x0010000000000000 #define ACSC_MASK_AXIS_117 0x0020000000000000 #define ACSC_MASK_AXIS_118 0x0040000000000000 #define ACSC_MASK_AXIS_119 0x0080000000000000 #define ACSC_MASK_AXIS_120 0x0100000000000000 #define ACSC_MASK_AXIS_121 0x0200000000000000 #define ACSC_MASK_AXIS_122 0x0400000000000000 #define ACSC_MASK_AXIS_123 0x0800000000000000 #define ACSC_MASK_AXIS_124 0x1000000000000000 #define ACSC_MASK_AXIS_125 0x2000000000000000 #define ACSC_MASK_AXIS_126 0x4000000000000000 #define ACSC_MASK_AXIS_127 0x8000000000000000 // Buffer masks #define ACSC_MASK_BUFFER_0 0x0000000000000001 #define ACSC_MASK_BUFFER_1 0x0000000000000002 #define ACSC_MASK_BUFFER_2 0x0000000000000004 #define ACSC_MASK_BUFFER_3 0x0000000000000008 #define ACSC_MASK_BUFFER_4 0x0000000000000010 #define ACSC_MASK_BUFFER_5 0x0000000000000020 #define ACSC_MASK_BUFFER_6 0x0000000000000040 #define ACSC_MASK_BUFFER_7 0x0000000000000080 #define ACSC_MASK_BUFFER_8 0x0000000000000100 #define ACSC_MASK_BUFFER_9 0x0000000000000200 #define ACSC_MASK_BUFFER_10 0x0000000000000400 #define ACSC_MASK_BUFFER_11 0x0000000000000800 #define ACSC_MASK_BUFFER_12 0x0000000000001000 #define ACSC_MASK_BUFFER_13 0x0000000000002000 #define ACSC_MASK_BUFFER_14 0x0000000000004000 #define ACSC_MASK_BUFFER_15 0x0000000000008000 #define ACSC_MASK_BUFFER_16 0x0000000000010000 #define ACSC_MASK_BUFFER_17 0x0000000000020000 #define ACSC_MASK_BUFFER_18 0x0000000000040000 #define ACSC_MASK_BUFFER_19 0x0000000000080000 #define ACSC_MASK_BUFFER_20 0x0000000000100000 #define ACSC_MASK_BUFFER_21 0x0000000000200000 #define ACSC_MASK_BUFFER_22 0x0000000000400000 #define ACSC_MASK_BUFFER_23 0x0000000000800000 #define ACSC_MASK_BUFFER_24 0x0000000001000000 #define ACSC_MASK_BUFFER_25 0x0000000002000000 #define ACSC_MASK_BUFFER_26 0x0000000004000000 #define ACSC_MASK_BUFFER_27 0x0000000008000000 #define ACSC_MASK_BUFFER_28 0x0000000010000000 #define ACSC_MASK_BUFFER_29 0x0000000020000000 #define ACSC_MASK_BUFFER_30 0x0000000040000000 #define ACSC_MASK_BUFFER_31 0x0000000080000000 #define ACSC_MASK_BUFFER_32 0x0000000100000000 #define ACSC_MASK_BUFFER_33 0x0000000200000000 #define ACSC_MASK_BUFFER_34 0x0000000400000000 #define ACSC_MASK_BUFFER_35 0x0000000800000000 #define ACSC_MASK_BUFFER_36 0x0000001000000000 #define ACSC_MASK_BUFFER_37 0x0000002000000000 #define ACSC_MASK_BUFFER_38 0x0000004000000000 #define ACSC_MASK_BUFFER_39 0x0000008000000000 #define ACSC_MASK_BUFFER_40 0x0000010000000000 #define ACSC_MASK_BUFFER_41 0x0000020000000000 #define ACSC_MASK_BUFFER_42 0x0000040000000000 #define ACSC_MASK_BUFFER_43 0x0000080000000000 #define ACSC_MASK_BUFFER_44 0x0000100000000000 #define ACSC_MASK_BUFFER_45 0x0000200000000000 #define ACSC_MASK_BUFFER_46 0x0000400000000000 #define ACSC_MASK_BUFFER_47 0x0000800000000000 #define ACSC_MASK_BUFFER_48 0x0001000000000000 #define ACSC_MASK_BUFFER_49 0x0002000000000000 #define ACSC_MASK_BUFFER_50 0x0004000000000000 #define ACSC_MASK_BUFFER_51 0x0008000000000000 #define ACSC_MASK_BUFFER_52 0x0010000000000000 #define ACSC_MASK_BUFFER_53 0x0020000000000000 #define ACSC_MASK_BUFFER_54 0x0040000000000000 #define ACSC_MASK_BUFFER_55 0x0080000000000000 #define ACSC_MASK_BUFFER_56 0x0100000000000000 #define ACSC_MASK_BUFFER_57 0x0200000000000000 #define ACSC_MASK_BUFFER_58 0x0400000000000000 #define ACSC_MASK_BUFFER_59 0x0800000000000000 #define ACSC_MASK_BUFFER_60 0x1000000000000000 #define ACSC_MASK_BUFFER_61 0x2000000000000000 #define ACSC_MASK_BUFFER_62 0x4000000000000000 #define ACSC_MASK_BUFFER_63 0x8000000000000000 // Input masks #define ACSC_MASK_INPUT_0 0x00000001 #define ACSC_MASK_INPUT_1 0x00000002 #define ACSC_MASK_INPUT_2 0x00000004 #define ACSC_MASK_INPUT_3 0x00000008 #define ACSC_MASK_INPUT_4 0x00000010 #define ACSC_MASK_INPUT_5 0x00000020 #define ACSC_MASK_INPUT_6 0x00000040 #define ACSC_MASK_INPUT_7 0x00000080 #define ACSC_MASK_INPUT_8 0x00000100 #define ACSC_MASK_INPUT_9 0x00000200 #define ACSC_MASK_INPUT_10 0x00000400 #define ACSC_MASK_INPUT_11 0x00000800 #define ACSC_MASK_INPUT_12 0x00001000 #define ACSC_MASK_INPUT_13 0x00002000 #define ACSC_MASK_INPUT_14 0x00004000 #define ACSC_MASK_INPUT_15 0x00008000 #define ACSC_MASK_INPUT_16 0x00010000 #define ACSC_MASK_INPUT_17 0x00020000 #define ACSC_MASK_INPUT_18 0x00040000 #define ACSC_MASK_INPUT_19 0x00080000 #define ACSC_MASK_INPUT_20 0x00100000 #define ACSC_MASK_INPUT_21 0x00200000 #define ACSC_MASK_INPUT_22 0x00400000 #define ACSC_MASK_INPUT_23 0x00800000 #define ACSC_MASK_INPUT_24 0x01000000 #define ACSC_MASK_INPUT_25 0x02000000 #define ACSC_MASK_INPUT_26 0x04000000 #define ACSC_MASK_INPUT_27 0x08000000 #define ACSC_MASK_INPUT_28 0x10000000 #define ACSC_MASK_INPUT_29 0x20000000 #define ACSC_MASK_INPUT_30 0x40000000 #define ACSC_MASK_INPUT_31 0x80000000 ////////////////////////////////////////////////////////////////////////////////////////////////// // Errors codes ////////////////////////////////////////////////////////////////////////////////////////////////// #define ACSC_ERRORBASE 100 #define ACSC_UNKNOWNERROR ACSC_ERRORBASE //Unknown error #define ACSC_ONLYSYNCHRONOUS (ACSC_ERRORBASE+1) //Asynchronous call is not supported #define ACSC_ENOENTLOGFILE (ACSC_ERRORBASE+2) //No such file or directory #define ACSC_OLD_FW (ACSC_ERRORBASE+3) //FW does not support all desired features #define ACSC_MEMORY_OVERFLOW (ACSC_ERRORBASE+4) //Controllers reply is too long #define ACSC_EBADFLOGFILE (ACSC_ERRORBASE+9) //Invalid log file handle #define ACSC_RTOS_NOT_INITIALIZED (ACSC_ERRORBASE+10) //RTOS is not initialized #define ACSC_SHM_NOT_INITIALIZED (ACSC_ERRORBASE+11) //Shared Memory is not initialized #define ACSC_SHM_WRONG_TYPE (ACSC_ERRORBASE+12) //Wrong type of shared memory variable #define ACSC_SHM_INVALID_ADDRESS (ACSC_ERRORBASE+13) //Invalid address of shared memory variable #define ACSC_SHE_NOT_SUPPORTED (ACSC_ERRORBASE+14) //Shared Event is not supported #define ACSC_SHE_INITERROR (ACSC_ERRORBASE+15) //Shared Event initialization error #define ACSC_SHE_NOT_INITIALIZED (ACSC_ERRORBASE+16) //Shared Event is not initialized #define ACSC_SHE_ARG_READ_ERROR (ACSC_ERRORBASE+17) //Shared Event argument read error #define ACSC_SHE_CLOSE_ERROR (ACSC_ERRORBASE+18) //Shared Event close error #define ACSC_EINVALLOGFILE (ACSC_ERRORBASE+22) //Write error in Log file #define ACSC_EMFILELOGFILE (ACSC_ERRORBASE+24) //Unable to open file #define ACSC_ENOSPCLOGFILE (ACSC_ERRORBASE+28) //Cannot open Log file. The drive is full #define ACSC_TIMEOUT (ACSC_ERRORBASE+30) //The controller stopped responding #define ACSC_SIMULATOR_NOT_RUN (ACSC_ERRORBASE+31) //Atempted to stop simulator that was not running #define ACSC_INITFAILURE (ACSC_ERRORBASE+32) //Communication initialization failure #define ACSC_SIMULATOR_RUN_EXT (ACSC_ERRORBASE+33) //Stand-alone simulator has been executed not via UMD #define ACSC_INVALIDHANDLE (ACSC_ERRORBASE+34) //Invalid communication handle #define ACSC_ALLCHANNELSBUSY (ACSC_ERRORBASE+35) //All channels are busy #define ACSC_SIMULATOR_NOT_SET (ACSC_ERRORBASE+36) //Stand-alone simulator has not been set in UMD #define ACSC_RECEIVEDTOOLONG (ACSC_ERRORBASE+37) //Received message too long(more than size of user buffer) #define ACSC_INVALIDBUFSIZE (ACSC_ERRORBASE+38) //Functions acsc_DownloadBuffer: the program contains string longer than 2032 bytes #define ACSC_INVALIDPARAMETERS (ACSC_ERRORBASE+39) //Function parameters are invalid #define ACSC_CLOSEDHISTORYBUF (ACSC_ERRORBASE+40) //History buffer is closed #define ACSC_EMPTYNAMEVAR (ACSC_ERRORBASE+41) //Name variable must be specified #define ACSC_INPUTPAR (ACSC_ERRORBASE+42) //Error in index specification #define ACSC_RECEIVEDTOOSMALL (ACSC_ERRORBASE+43) //Controller reply contains less values than expected #define ACSC_FUNCTIONNOTSUPPORTED (ACSC_ERRORBASE+45) //Function is not supported in current version #define ACSC_INITHISTORYBUFFAILED (ACSC_ERRORBASE+47) //History buffer initialization failure #define ACSC_CLOSEDMESSAGEBUF (ACSC_ERRORBASE+50) //Unsolicited messages buffer is closed #define ACSC_SETCALLBACKERROR (ACSC_ERRORBASE+51) //Callback registration error #define ACSC_CALLBACKALREADYSET (ACSC_ERRORBASE+52) //Callback function has been already installed #define ACSC_CHECKSUMERROR (ACSC_ERRORBASE+53) //Checksum of controller reply error #define ACSC_REPLIESSEQUENCEERROR (ACSC_ERRORBASE+54) //Internal error: Replies sequence error #define ACSC_WAITFAILED (ACSC_ERRORBASE+55) //Internal error: WaitForSingleObject error #define ACSC_INITMESSAGEBUFFAILED (ACSC_ERRORBASE+57) //Unsolicited messages buffer initialization failure #define ACSC_OPERATIONABORTED (ACSC_ERRORBASE+58) //Non-waiting call has been aborted #define ACSC_CANCELOPERATIONERROR (ACSC_ERRORBASE+59) //Error of the non-waiting call cancellation #define ACSC_COMMANDSQUEUEFULL (ACSC_ERRORBASE+60) //Internal error: Queue of transmitted commands is full #define ACSC_SENDINGFAILED (ACSC_ERRORBASE+62) //Internal error: Sending is failed #define ACSC_RECEIVINGFAILED (ACSC_ERRORBASE+63) //Internal error: Receiving is failed #define ACSC_CHAINSENDINGFAILED (ACSC_ERRORBASE+64) //Internal error: Sending of chain is failed #define ACSC_DUPLICATED_IP (ACSC_ERRORBASE+65) //Specified IP address is duplicated #define ACSC_APPLICATION_NOT_FOUND (ACSC_ERRORBASE+66) //There is no Application with such Handle #define ACSC_ARRAY_EXPECTED (ACSC_ERRORBASE+67) //Array name was expected #define ACSC_INVALID_FILE_FORMAT (ACSC_ERRORBASE+68) //The file is not a valid ANSI data file #define ACSC_APPSL_CRC (ACSC_ERRORBASE+71) // Application Saver Loader CRC Error #define ACSC_APPSL_HEADERCRC (ACSC_ERRORBASE+72) // Application Saver Loader Header CRC Error #define ACSC_APPSL_FILESIZE (ACSC_ERRORBASE+73) // Application Saver Loader File Size Error #define ACSC_APPSL_FILEOPEN (ACSC_ERRORBASE+74) // Application Saver Loader File Open Error #define ACSC_APPSL_UNKNOWNFILE (ACSC_ERRORBASE+75) // Application Saver Loader Unknown File Error #define ACSC_APPSL_VERERROR (ACSC_ERRORBASE+76) // Application Saver Loader Format Version Error #define ACSC_APPSL_SECTION_SIZE (ACSC_ERRORBASE+77) // Application Saver Loader Section Size is Zero #define ACSC_TLSERROR (ACSC_ERRORBASE+79) //Internal error: Thread local storage error #define ACSC_INITDRIVERFAILED (ACSC_ERRORBASE+80) //PCI driver initialization failure #define ACSC_CAN_INITFAILURE (ACSC_ERRORBASE+81) //CAN library not found or initialization failure #define ACSC_CLOSED_BY_CONTROLLER (ACSC_ERRORBASE+82) //Communication closed by the controller #define ACSC_INVALIDPOINTER (ACSC_ERRORBASE+85) //Pointer to the buffer is invalid || Null pointer recieved instead of user allocated object #define ACSC_SETPRIORITYERROR (ACSC_ERRORBASE+89) //Specified priority for the callback thread cannot be set #define ACSC_DIRECTDPRAMACCESS (ACSC_ERRORBASE+90) //Attempt to access DPRAM not via PCI #define ACSC_DDERROR (ACSC_ERRORBASE+91) //Spii.vxd/sys can not be found or installed #define ACSC_INVALID_DPRAM_ADDR (ACSC_ERRORBASE+92) //Invalid DPRAM address #define ACSC_OLD_SIMULATOR (ACSC_ERRORBASE+93) //Old version of SPiiPlus Simulator #define ACSC_HW_PROBLEM (ACSC_ERRORBASE+94) //Hardware won't work properly #define ACSC_FILE_NOT_FOUND (ACSC_ERRORBASE+95) #define ACSC_SERVEREXCEPTION (ACSC_ERRORBASE+97) #define ACSC_STOPPED_RESPONDING (ACSC_ERRORBASE+98) #define ACSC_DLL_UMD_VERSION (ACSC_ERRORBASE+99) //DLL and Server are not of the same Version #define ACSC_FRF_INPUT_START_FREQUENCY_OUT_OF_RANGE (ACSC_ERRORBASE+100) #define ACSC_FRF_INPUT_END_FREQUENCY_OUT_OF_RANGE (ACSC_ERRORBASE+101) #define ACSC_FRF_INPUT_START_FREQUENCY_IS_HIGHER_THAN_END_FREQUENCY (ACSC_ERRORBASE+102) #define ACSC_FRF_INPUT_FREQPERDEC_OUT_OF_RANGE (ACSC_ERRORBASE+103) // Standard resolution frequency per decade is out of range #define ACSC_FRF_INPUT_HR_FREQPERDEC_OUT_OF_RANGE (ACSC_ERRORBASE+104) // High resolution frequency per decade is out of range #define ACSC_FRF_INPUT_FREQUENCY_RESOLUTION_LINEAR_OUT_OF_RANGE (ACSC_ERRORBASE+105) // Required freqeuncy resolution (linear distribution) is out of range #define ACSC_FRF_INPUT_AMPLITUDE_OUT_OF_RANGE (ACSC_ERRORBASE+106) //Excitation amplitude is out of range #define ACSC_FRF_INPUT_AXIS_OUT_OF_RANGE (ACSC_ERRORBASE+107) // Axis is out of range of Controller axes #define ACSC_FRF_INPUT_NUMBER_OF_REPETITIONS_OUT_OF_RANGE (ACSC_ERRORBASE+108) // Number of Excitation repetitions is out of range #define ACSC_FRF_INPUT_DURATION_OUT_OF_RANGE (ACSC_ERRORBASE+109) // Excitation duration is out of range #define ACSC_FRF_INPUT_ENUM_VALUE_OUT_OF_RANGE (ACSC_ERRORBASE + 110) // Excitation duration is out of range #define ACSC_FRF_MEMORY_ALLOCATION_FAILED_AT_HOST (ACSC_ERRORBASE+111) // Failed to allocate memory at PC #define ACSC_FRF_DATA_READ_FROM_CONTROLLER_INCONSISTENT (ACSC_ERRORBASE+112) // Internal error #define ACSC_FRF_DSP_DOESNT_HAVE_REQUIRED_PARAMETERS (ACSC_ERRORBASE+113) // DSP should have appropriate parameters #define ACSC_FRF_FAILED_TO_COMMUNICATE_WITH_CONTROLLER (ACSC_ERRORBASE+114) // Failed to send/receive command to/from controller #define ACSC_FRF_FAILED_TO_READ_SERVO_PARAMETERS (ACSC_ERRORBASE+115) //internal error #define ACSC_FRF_DUMMY_AXIS_NOT_SUPPORTED (ACSC_ERRORBASE+116) #define ACSC_FRF_MOTOR_SHOULD_BE_SET_TO_CLOSED_LOOP (ACSC_ERRORBASE+117) //MFLAGS.#OPEN should be set to 1 #define ACSC_FRF_MOTOR_SHOULD_BE_ENABLED (ACSC_ERRORBASE+118) #define ACSC_FRF_MOTOR_SHOULD_COMMUTATED (ACSC_ERRORBASE+119) // For brushless motors #define ACSC_FRF_SPDC_IS_ALREADY_IN_PROGRESS (ACSC_ERRORBASE+120) //SPDC command is already running #define ACSC_FRF_ABORTED_BY_USER (ACSC_ERRORBASE+121) // FRF abort issued by the user #define ACSC_FRF_MOTOR_DISABLED_DURING_MEASUREMENT (ACSC_ERRORBASE+122) #define ACSC_FRF_DISABLE_OR_FAULT_OCCURED_DURING_MEASUREMENT (ACSC_ERRORBASE+123) #define ACSC_FRF_FAULT_OCCURED_DURING_MEASUREMENT (ACSC_ERRORBASE+124) #define ACSC_FRF_ARRAY_SIZES_INCOMATIBLE (ACSC_ERRORBASE+125) //internal error #define ACSC_FRF_NUMBER_OF_POINTS_SHOULD_BE_POSITIVE (ACSC_ERRORBASE+126) //internal error #define ACSC_FRF_MEMORY_ALLOCATION_FAILED_AT_CONTROLLER (ACSC_ERRORBASE+127) // Failed to allocate memory in controller #define ACSC_FRF_EXCITATION_DURATION_IS_TOO_LONG (ACSC_ERRORBASE+128) //internal error #define ACSC_FRF_USER_DEFINED_EXCITATION_SIGNAL_REQUIRED_BUT_NOT_DEFINED (ACSC_ERRORBASE+129) // #define ACSC_FRF_USER_DEFINED_EXCITATION_SIGNAL_OUT_OF_BOUNDARIES (ACSC_ERRORBASE+130) // #define ACSC_FRF_FRD_LENGTH_TOO_SHORT (ACSC_ERRORBASE+131) // #define ACSC_FRF_FRD_FREQUENCIES_SHOULD_BE_CONTINUOUSLY_INCREASING (ACSC_ERRORBASE+132) // #define ACSC_JITTER_ANALYSIS_JITTER_ARRAY_TOO_SHORT (ACSC_ERRORBASE+133) #define ACSC_JITTER_ANALYSIS_SAMPLING_FREQUENCY_NOT_VALID (ACSC_ERRORBASE+134) // Frequency should not be >= 0 #define ACSC_JITTER_ANALYSIS_WINDOW_TYPE_NOT_SUPPORTED (ACSC_ERRORBASE+135) // #define ACSC_JITTER_ANALYSIS_FREQUENCY_RANGE_NOT_VALID (ACSC_ERRORBASE+136) // #define ACSC_JITTER_ANALYSIS_FREQUENCY_RESOLUTION_NOT_VALID (ACSC_ERRORBASE+137) // #define ACSC_LICENSE_COMMON_PROBLEM (ACSC_ERRORBASE+138) #define ACSC_LICENSE_DONGLE_NOT_FOUND (ACSC_ERRORBASE+139) #define ACSC_LICENSE_ENTRY_NOT_FOUND (ACSC_ERRORBASE+140) #define ACSC_LICENSE_INVALID_HANDLE (ACSC_ERRORBASE+141) #define ACSC_LICENSE_NO_DATA_AVAILABLE (ACSC_ERRORBASE+142) #define ACSC_LICENSE_INVALID_PN (ACSC_ERRORBASE+143) #define ACSC_SC_INCORRECT_PROC_ALLOC (ACSC_ERRORBASE+144) //SPiiPlusSC: Incorrect Windows Processor Allocation #define ACSC_SC_MISSING_DRIVERS (ACSC_ERRORBASE+145) //SPiiPlusSC: Missing drivers #define ACSC_SC_INCORRECT_MEMORY (ACSC_ERRORBASE+146) //SPiiPlusSC: Incorrect Memory Reservations #define ACSC_SC_RTOS_SERVICE (ACSC_ERRORBASE+147) //SPiiPlusSC: RTOS Service isn't running #define ACSC_SC_REBOOT (ACSC_ERRORBASE+148) //SPiiPlusSC: System requires reboot #define ACSC_SC_DONGLE_VERSION (ACSC_ERRORBASE+149) //SPiiPlusSC: Detected CmStick Version of Dongle is too old #define ACSC_LICENSE_NONLICENSED_FEATURE_MATLAB (ACSC_ERRORBASE+150) // MATLAB labrary is not licensed according to existing License PN #define ACSC_LICENSE_NONLICENSED_FEATURE_FRF (ACSC_ERRORBASE+151) // FRF library is not licensed according to existing License PN #define ACSC_LICENSE_NONLICENSED_FEATURE_COMMON (ACSC_ERRORBASE+152) // Feature is not licensed according to existing License PN #define ACSC_FRF_GENERAL_ERROR (ACSC_ERRORBASE+153) //General error mainly for .]resolving .NET library conflict when function returns 0 and errorCode is also 0 #define ACSC_FRF_RECALCULATE_INCOMPATIBLE_DATA (ACSC_ERRORBASE+154) //When recalculate required with raw data length different from durationSec*NumberOfRepetitions #define ACSC_FRF_LOOP_RECALCULATE_INCOMPATIBLE_DATA (ACSC_ERRORBASE+155) //when acsc_FRF_CalculateLoopDataFRD called with incompatibe measure and target loop types #define ACSC_FRF_SLVRAT_DATA_TOO_SHORT (ACSC_ERRORBASE+156) // #define ACSC_FRF_SLVRAT_CALCULATION_PHASE_IS_INCOMPATIBLE (ACSC_ERRORBASE+157) // #define ACSC_FRF_SLVRAT_CALCULATION_FAILED (ACSC_ERRORBASE+158) // #define ACSC_HW_ERRORBASE 500 // Hardware specific errors #define ACSC_HW_NO_INT (ACSC_HW_ERRORBASE+2) #define ACSC_HW_INT_PERIOD (ACSC_HW_ERRORBASE+4) #define ACSC_HW_NO_INT_NOTIF (ACSC_HW_ERRORBASE+6) #define ACSC_HW_SPiiFAILURE (ACSC_HW_ERRORBASE+8) #define ACSC_CANDEVICE_CUSTOM1 1 #define ACSC_CANDEVICE_CUSTOM2 2 #define ACSC_CANDEVICE_NI 11 #if defined (_ACSC_LIBRARY_DLL_) && defined (_WIN32) #define _ACSCLIB_ __declspec( dllexport ) #elif defined (_WIN32) #define _ACSCLIB_ __declspec( dllimport ) #elif defined (_ACSC_LIBRARY_DLL_) && defined(__linux__) #define _ACSCLIB_ __attribute__((visibility("default"))) #else #define _ACSCLIB_ #endif typedef enum { Plant, Controller, OpenLoop, ClosedLoop, Sensitivity } FRF_DATA_TYPE; typedef enum { PositionVelocity, Position, Velocity, Current, Open, DualLoopOpen, DualLoop } FRF_LOOP_TYPE; typedef enum { NoOverlap, HalfSignal } FRF_OVERLAP; typedef enum { WhiteNoise, ChirpPeriodic, UserDefined } FRF_EXCITATION_TYPE; typedef enum { LogarithmicChirp, LinearChirp } FRF_CHIRP_TYPE; typedef enum { Hanning, Rectangular, Hamming } FRF_WINDOW_TYPE; typedef enum { Logarithmic, Linear }FRF_FREQUENCY_DISTRIBUTION_TYPE; struct FRD { double* real; double* imag; double* frequencyHz; unsigned int length; }; struct FRF_STABILITY_MARGINS { double* gainMarginArray; double* gainMarginArrayFrequencyHz; unsigned int gainMarginArrayLength; double gainMarginWorst; double gainMarginWorstFrequencyHz; double* phaseMarginArray; double* phaseMarginArrayFrequencyHz; unsigned int phaseMarginArrayLength; double phaseMarginWorst; double phaseMarginWorstFrequencyHz; double modulusMargin; double modulusMarginFrequencyHz; double bandwidth; }; struct FRF_DURATION_CALCULATION_PARAMETERS { FRF_FREQUENCY_DISTRIBUTION_TYPE frequencyDistributionType; double startFreqHz; double endFreqHz; int freqPerDec; double highResolutionStart; int highResolutionFreqPerDec; double frequencyHzResolutionForLinear; }; // Structure used for defining FRF input parameters struct FRF_INPUT { int axis; FRF_LOOP_TYPE loopType; FRF_EXCITATION_TYPE excitationType; FRF_CHIRP_TYPE chirpType; FRF_WINDOW_TYPE windowType; FRF_FREQUENCY_DISTRIBUTION_TYPE frequencyDistributionType; FRF_OVERLAP overlap; double startFreqHz; double endFreqHz; int freqPerDec; double excitationAmplitudePercentIp; int numberOfRepetitions; double highResolutionStart; int highResolutionFreqPerDec; double durationSec; // applicable for Chirp and White Noise options // User defined excitation signal double* userDefinedExcitationSignal; int userDefinedExcitationSignalLength; // Quick recalculate without remeasuring double* inRaw; double* outRaw; int lengthRaw; BOOL recalculate; }; // Structure used for defining FRF output parameters struct FRF_OUTPUT { // Plant parameters FRD* plant; // P FRD* controller; //C FRD* openLoop; //L FRD* closedLoop; //T FRD* sensitivity; //S FRD* coherence; FRF_STABILITY_MARGINS* stabilityMargins; FRF_LOOP_TYPE loopType; double* inRaw; double* outRaw; int lengthRaw; double excitationAmplitude; FRD* plantVelocityToPosition; // Plant from Velocity to Position. 1/s for a rigid body. Some Transfer function in dual loop systems FRD* coherenceVelocityToPosition; }; struct SERVO_PARAMETERS { double SLIKP; double SLIKI; double SLILI; double SLPKP; double SLPKI; double SLPLI; double SLVKP; double SLVKI; double SLVLI; double SLVSOF; double SLVSOFD; double SLVNFRQ; double SLVNWID; double SLVNATT; double SLVB0NF; double SLVB0DF; double SLVB0ND; double SLVB0DD; double SLVB1NF; double SLVB1DF; double SLVB1ND; double SLVB1DD; double XVEL; double EFAC; double SLVRAT; double SLAFF; INT32 MFLAGS; INT32 MFLAGSX; }; struct FRF_CALCULATE_LOOP_DATA { // Plant parameters FRD* plant; // P FRD* plantVelocityToPosition; // Plant from Velocity to Position. 1/s for a rigid body. Some Transfer function in dual loop systems SERVO_PARAMETERS* servoParameters; FRF_DATA_TYPE dataType; FRF_LOOP_TYPE measureLoopType; FRF_LOOP_TYPE targetLoopType; }; struct FRF_CALCULATE_SLVRAT_DATA { FRD* plantVelocityToPosition; double startFrequencyHz; double endFrequencyHz; }; struct JITTER_ANALYSIS_INPUT { // Jitter array double* jitter; unsigned int jitterLength; unsigned int samplingFrequencyHz; double desiredFrequencyResolutionHz; // Parameters for frequency bands cumulative analysis double* jitterFrequencyBandsCumulativeAmplitudeRMSthreshold; double* frequencyBandsHz; unsigned int frequencyBandsHzLength; // Window type. Applied to a signal in time domain FRF_WINDOW_TYPE windowType; }; struct JITTER_ANALYSIS_OUTPUT { //following three arrays have the same length defined in frequencyLength double* jitterAmplitudeRMS; double* jitterCumulativeAmplitudeRMS; double* frequencyHz; unsigned int frequencyLength; // Result of frequency bands cumulative analysis double* jitterFrequencyBandsCumulativeAmplitudeRMS; double* frequencyBandsHz; unsigned int frequencyBandsHzLength; int jitterFrequencyBandsResultBool; double jitterRMS; double jitterAmplitudePeak2Peak; }; // Structure is used for non-waiting calls of the library functions typedef struct { HANDLE Event; //signal event int Ret; //code of return } ACSC_WAITBLOCK, *LP_ACSC_WAITBLOCK, WAITBLOCK, *LP_WAITBLOCK; //Defines for COMLib 6.5 #define ACSC_SYNCHRONOUS LP_ACSC_WAITBLOCK(NULL) // Synchronous call #define ACSC_IGNORE LP_ACSC_WAITBLOCK(-1) // Ignore result of Asyncronous call #define ACSC_ASYNCHRONOUS LP_ACSC_WAITBLOCK(-2) // Asynchronous call typedef enum { Default_Type = 0, String_Type = 0, Buffer_Type = 1, Integer_Type = 2, Real_Type = 3, Scalar_Type = 4, Vector_Type = 5, Matrix_Type = 6, Typeless_Type = 7, Binary_Type = 8 } ACSC_RETURN_TYPE; // Structure defines a physical location of PCI card typedef struct { unsigned int BusNumber; //PCI physical bus number of card unsigned int SlotNumber; //PCI physical slot number of card unsigned int Function; //PCI function of card } ACSC_PCI_SLOT, *LP_ACSC_PCI_SLOT, PCI_SLOT, *LP_PCI_SLOT; typedef enum { Minimum, Medium, Maximum } ACSC_LOG_DETALIZATION_LEVEL; typedef enum { Compact, Formatted, Full } ACSC_LOG_DATA_PRESENTATION; //This struct describes single UMD connection typedef struct { char Application[100]; // Application Name HANDLE Handle; // Channel's Handle DWORD ProcessId; } ACSC_CONNECTION_DESC; typedef enum { ACSC_NOT_CONNECTED = 0, ACSC_SERIAL = 1, ACSC_PCI = 2, ACSC_ETHERNET = 3, ACSC_DIRECT = 4 } ACSC_CONNECTION_TYPE; typedef struct { ACSC_CONNECTION_TYPE Type; int SerialPort; int SerialBaudRate; int PCISlot; int EthernetProtocol; char EthernetIP[100]; int EthernetPort; } ACSC_CONNECTION_INFO; //This structures used for Application Saver / Loader functions typedef struct { int length; char* string; } ACSC_APPSL_STRING; typedef enum { ACSC_ADJ, ACSC_SP, ACSC_ACSPL, ACSC_PAR, ACSC_USER, ACSC_PROT_STRING } ACSC_APPSL_FILETYPE; typedef struct { ACSC_APPSL_FILETYPE type; // section type ACSC_APPSL_STRING filename; // section file name ACSC_APPSL_STRING description; // section description unsigned int size; // data size unsigned int offset; // offset in the file data section unsigned int CRC; // data CRC int inuse; // selected for save/load int error; // error code char* data; // data as is } ACSC_APPSL_SECTION; // Atrriburte key-value pair structure typedef struct { ACSC_APPSL_STRING key; // attribute's key (name) ACSC_APPSL_STRING value; // key data } ACSC_APPSL_ATTRIBUTE; // Data file structure // Describe data file header, attributes array and file sections array typedef struct { ACSC_APPSL_STRING filename; // file name ACSC_APPSL_STRING description; // file description int isNewFile; // 1 - if writing new file, 0 - if adding int ErrCode; // Error code from controller unsigned int attributes_num; // attributes count ACSC_APPSL_ATTRIBUTE* attributes; // attributes array unsigned int sections_num; // sections count ACSC_APPSL_SECTION* sections; // sections array } ACSC_APPSL_INFO; // Structure of history and message buffer // Please never change data of this structure! struct ACSC_HISTORYBUFFER { int Max; //buffer size int Cur; //number of bytes currently stored in the buffer int Ring; //circular index in the buffer char* Buf; //pointer to buffer }; // struct for controller info //for acsc_GetEthernetCardsExt function struct ACSC_CONTROLLER_INFO { in_addr IpAddress; // controller ip adrress char SerialNumber[100]; // controller serial number char PartNumber[100]; // controller part number char Version[100]; // controller firmware version }; typedef struct ACSC_HISTORYBUFFER* LP_ACSC_HISTORYBUFFER; typedef struct _AXMASK_EXT { UnsignedInt64 AXMASK64; //0-63 axes UnsignedInt64 AXMASK128; //64-127 UnsignedInt64 Reserved1; UnsignedInt64 Reserved2; } AXMASK_EXT; typedef int (WINAPI *ACSC_INTR_CALLBACK_FUNC)(int Param); typedef int (WINAPI *ACSC_INTR_CALLBACK_FUNC_EXT)(int Param, void* CardContext); typedef int (WINAPI *ACSC_USER_CONDITION_FUNC)(HANDLE Handle); #define ACSC_DUMMY_CALLBACK (ACSC_INTR_CALLBACK_FUNC)-1 #define ACSC_DUMMY_CALLBACK_EXT (ACSC_INTR_CALLBACK_FUNC_EXT)-1 ////////////////////////////////////////////////////////////////////////////////////////////////// typedef int (WINAPI *ACSC_USER_CALLBACK_FUNCTION)(UnsignedInt64 Param, void* CardContext); #define ACSC_DUMMY_CALLBACK_FUNCTION (ACSC_USER_CALLBACK_FUNCTION)-1 ////////////////////////////////////////////////////////////////////////////////////////////////// typedef int (WINAPI* ACSC_USER_CALLBACK_FUNCTION_EXT)(AXMASK_EXT Mask, void* CardContext); #define ACSC_DUMMY_CALLBACK_FUNCTION_EXT (ACSC_USER_CALLBACK_FUNCTION_EXT)-1 #if defined(__cplusplus) extern "C" { #endif ////////////////////////////////////////////////////////////////////////////////////////////////// // If you want to load ACSC.dll dynamically at runtime, // define ACSC_RUNTIME_DYNAMIC_LINKING in your project before including this file // Otherwise load-time dynamic linking is implied ////////////////////////////////////////////////////////////////////////////////////////////////// #if !defined (ACSC_RUNTIME_DYNAMIC_LINKING) ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates communication via serial port ////////////////////////////////////////////////////////////////////////////////////////////////// HANDLE _ACSCLIB_ WINAPI acsc_OpenCommSerial(int Channel, int Rate); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates communication via Ethernet ////////////////////////////////////////////////////////////////////////////////////////////////// HANDLE _ACSCLIB_ WINAPI acsc_OpenCommEthernet(char* Address, int Port); // new functions with any custom port as parameter HANDLE _ACSCLIB_ WINAPI acsc_OpenCommEthernetTCP(char* Address, int Port); HANDLE _ACSCLIB_ WINAPI acsc_OpenCommEthernetUDP(char* Address, int Port); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates direct communication with simulator ////////////////////////////////////////////////////////////////////////////////////////////////// HANDLE _ACSCLIB_ WINAPI acsc_OpenCommDirect(); ////////////////////////////////////////////////////////////////////////////////////////////////// // The functions collects IP addresses of SPiiPlus cards connected to the local segment ///////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ acsc_GetEthernetCards(struct in_addr* IPaddresses, int Max, int* Ncontrollers, unsigned long BroadcastAddress); ////////////////////////////////////////////////////////////////////////////////////////////////// // The functions collects IP addresses,serial number and part number of SPiiPlus cards connected to the local segment ///////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ acsc_GetEthernetCardsExt(ACSC_CONTROLLER_INFO* ControllerInfo, unsigned long ControllerInfoSize, int Max, int* Ncontrollers, unsigned long BroadcastAddress); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates communication via PCI device driver ////////////////////////////////////////////////////////////////////////////////////////////////// HANDLE _ACSCLIB_ WINAPI acsc_OpenCommPCI(int SlotNumber); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a PCI bus information for the PCI cards installed ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetPCICards(ACSC_PCI_SLOT* Cards, int Count, int* ObtainedCards); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function closes communication (for all kinds of communications) ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CloseComm(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sends message ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Send(HANDLE Handle, char* Buf, int Count, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function receives message ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Receive(HANDLE Handle, char* Buf, int Count, int* Received, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function provides transaction: sends request and receives reply ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Transaction(HANDLE Handle, char* OutBuf, int OutCount, char* InBuf, int InCount, int* Received, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sends a command to the controller and analyzes the controller response. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Command(HANDLE Handle, char* OutBuf, int OutCount, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for completion of asynchronous call and retrieves a data. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitForAsyncCall(HANDLE Handle, void* Buf, int* Received, ACSC_WAITBLOCK* Wait, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function cancels any asynchronous (non-waiting) call ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CancelOperation(HANDLE Handle, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the last error code ////////////////////////////////////////////////////////////////////////////////////////////////// // function of the new library int _ACSCLIB_ WINAPI acsc_GetLastError(); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the explanation of an error code. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetErrorString(HANDLE Handle, int ErrorCode, char* ErrorStr, int Count, int* Received); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets communication call delay ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetQueueOverflowTimeout(HANDLE Handle, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves communication call delay ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetQueueOverflowTimeout(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets communication timeout ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetTimeout(HANDLE Handle, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves communication timeout ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetTimeout(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves default communication timeout ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetDefaultTimeout(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the number of iterations of one transaction ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetIterations(HANDLE Handle, int Iterations); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets communication options ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetCommOptions(HANDLE Handle, unsigned int Options); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves communication options ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetCommOptions(HANDLE Handle, unsigned int* Options); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function Clears breakpoints ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ClearBreakpoints(HANDLE handle, int Buffer, int line, ACSC_WAITBLOCK* wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function Sets a breakpoint ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetBreakpoint(HANDLE handle, int Buffer, int line, ACSC_WAITBLOCK* wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves breakpoints of a buffer ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetBreakpointsList(HANDLE handle, int Buffer, int* ArrayIn, int ArraySize, int* replySize, ACSC_WAITBLOCK* wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves ACSC Library version ////////////////////////////////////////////////////////////////////////////////////////////////// unsigned int _ACSCLIB_ WINAPI acsc_GetLibraryVersion(); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function loads ACSPL+ program to the specified program buffer. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_LoadBuffer(HANDLE Handle, int Buffer, char* Text, int Count, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function loads ACSPL+ program to the specified program buffer. // Service lines are ignored. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_LoadBufferIgnoreServiceLines(HANDLE Handle, int Buffer, char* Text, int Count, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function loads ACSPL+ programs to the specified program buffers. // From *.prg file ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_LoadBuffersFromFile(HANDLE Handle, char* Filename, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function appends one or more ACSPL+ lines to the program in the specified program buffer. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AppendBuffer(HANDLE Handle, int Buffer, char* Text, int Count, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function downloads text to a program buffer. The function is similar to the function acsc_AppendBuffer() ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DownloadBuffer(HANDLE Handle, int Buffer, char* Text, int Count, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function uploads text from a program buffer ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_UploadBuffer(HANDLE Handle, int Buffer, int Offset, char* Text, int Count, int* Received, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function deletes the specified ACSPL+ program lines in the specified program buffer. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ClearBuffer(HANDLE Handle, int Buffer, int FromLine, int ToLine, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function compiles ACSPL+ program in the specified program buffer(s). ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CompileBuffer(HANDLE Handle, int Buffer, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function starts up ACSPL+ program in the specified program buffer. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_RunBuffer(HANDLE Handle, int Buffer, char* Label, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function stops ACSPL+ program in the specified program buffer(s). ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_StopBuffer(HANDLE Handle, int Buffer, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function suspends ACSPL+ program in the specified program buffer(s). ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SuspendBuffer(HANDLE Handle, int Buffer, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function reads value(s) from integer variable ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ReadInteger(HANDLE Handle, int NBuf, char* Var, int From1, int To1, int From2, int To2, int* Values, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function writes value(s) to integer variable ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WriteInteger(HANDLE Handle, int NBuf, char* Var, int From1, int To1, int From2, int To2, int* Values, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function reads value(s) from real variable ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ReadReal(HANDLE Handle, int NBuf, char* Var, int From1, int To1, int From2, int To2, double* Values, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function writes value(s) to real variable ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WriteReal(HANDLE Handle, int NBuf, char* Var, int From1, int To1, int From2, int To2, double* Values, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function captures communication ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CaptureComm(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function releases communication ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ReleaseComm(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates history buffer ////////////////////////////////////////////////////////////////////////////////////////////////// LP_ACSC_HISTORYBUFFER _ACSCLIB_ WINAPI acsc_OpenHistoryBuffer(HANDLE Handle, int Size); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function closes history buffer ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CloseHistoryBuffer(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the contents of the history buffer ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetHistory(HANDLE Handle, char* Buf, int Count, int* Received, BOOL bClear); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates unsolicited messages buffer ////////////////////////////////////////////////////////////////////////////////////////////////// LP_ACSC_HISTORYBUFFER _ACSCLIB_ WINAPI acsc_OpenMessageBuffer(HANDLE Handle, int Size); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function closes unsolicited messages buffer ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CloseMessageBuffer(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves all stored unsolicited messages from buffer ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetMessage(HANDLE Handle, char* Buf, int Count, int* Received, BOOL bClear); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a single unsolicited message or exits by timeout ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetSingleMessage(HANDLE Handle, char* Buf, int Count, int* Received, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function opens logfile. Now all communication will be saved in the logfile. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_OpenLogFile(HANDLE Handle, char* FileName); int _ACSCLIB_ WINAPI acsc_OpenSCLogFile(HANDLE Handle, char* FileName); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function closes logfile. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CloseLogFile(HANDLE Handle); int _ACSCLIB_ WINAPI acsc_CloseSCLogFile(HANDLE Handle); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function writes to logfile. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WriteLogFile(HANDLE Handle, char* Buf, int Count); int _ACSCLIB_ WINAPI acsc_WriteSCLogFile(HANDLE Handle, char* Buf, int Count); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function writes to logfile. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_FlushLogFile(char* Filename); int _ACSCLIB_ WINAPI acsc_FlushSCLogFile(char* Filename, BOOL bClear); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the data of firmware log ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetLogData(HANDLE Handle, char* Buf, int Count, int* Received, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function defines a value of motion velocity. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetVelocity(HANDLE Handle, int Axis, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a value of motion velocity. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetVelocity(HANDLE Handle, int Axis, double* Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function defines a value of motion acceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetAcceleration(HANDLE Handle, int Axis, double Acceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a value of motion acceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetAcceleration(HANDLE Handle, int Axis, double* Acceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function defines a value of motion deceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetDeceleration(HANDLE Handle, int Axis, double Deceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a value of motion deceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetDeceleration(HANDLE Handle, int Axis, double* Deceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function defines a value of motion jerk. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetJerk(HANDLE Handle, int Axis, double Jerk, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a value of motion jerk. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetJerk(HANDLE Handle, int Axis, double* Jerk, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function defines a value of kill deceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetKillDeceleration(HANDLE Handle, int Axis, double KillDeceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a value of kill deceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetKillDeceleration(HANDLE Handle, int Axis, double* KillDeceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function provides on-the-fly change a value of motion velocity. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetVelocityImm(HANDLE Handle, int Axis, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function provides on-the-fly change a value of motion acceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetAccelerationImm(HANDLE Handle, int Axis, double Acceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function provides on-the-fly change a value of motion deceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetDecelerationImm(HANDLE Handle, int Axis, double Deceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function provides on-the-fly change a value of motion jerk. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetJerkImm(HANDLE Handle, int Axis, double Jerk, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function provides on-the-fly change a value of kill deceleration. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetKillDecelerationImm(HANDLE Handle, int Axis, double KillDeceleration, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function assigns a current value of target position for several axes. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetTargetPositionM(HANDLE Handle, int* Axes, double* TargetPositions, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function assigns a current value of target position. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetTargetPosition(HANDLE Handle, int Axis, double TargetPosition, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a current value of motor feedback position. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetTargetPosition(HANDLE Handle, int Axis, double* TargetPosition, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function assigns a current value of target position. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetFPosition(HANDLE Handle, int Axis, double FPosition, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a current value of motor feedback position. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetFPosition(HANDLE Handle, int Axis, double* FPosition, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function assigns a current value of reference position. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetRPosition(HANDLE Handle, int Axis, double RPosition, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a current value of reference position. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetRPosition(HANDLE Handle, int Axis, double* RPosition, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a current value of motor feedback velocity. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetFVelocity(HANDLE Handle, int Axis, double* FVelocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves a current value of reference velocity. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetRVelocity(HANDLE Handle, int Axis, double* RVelocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function activates a motor. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Enable(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function activates several motors. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_EnableM(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function shuts off a motor. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Disable(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function shuts off several motors. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DisableM(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function shuts off all motors. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DisableAll(HANDLE Handle, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function performs commutation to brushless motor. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Commut(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function performs commutation to brushless motor. Extended parameters ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CommutExt(HANDLE Handle, int Axis, float Current, int Settle, int Slope, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function creates a coordinate system for multi-axis motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Group(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function breaks down an axis group created before by the acsc_Group function. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Split(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function breaks down all axis groups created before by the acsc_Group function. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SplitAll(HANDLE Handle, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function starts up a motion that is waiting in the specified motion queue. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Go(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function synchronously starts up several motions // that are waiting in the specified motion queues. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GoM(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates a motion using the full deceleration profile. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Halt(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates several motions using the full deceleration profile. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_HaltM(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates a motion using reduced deceleration profile. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Kill(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates several motions using reduced deceleration profile. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_KillM(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates all currently executed motions. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_KillAll(HANDLE Handle, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates a motion immediately and // provides a smooth transition to the next motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Break(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates several motions immediately and // provides a smooth transition to the next motions. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_BreakM(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a single-axis motion to the specified point. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ToPoint(HANDLE Handle, int Flags, int Axis, double Point, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis motion to the specified point ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ToPointM(HANDLE Handle, int Flags, int* Axes, double* Point, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a single-axis motion to the specified point // using the specified velocity or end velocity. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtToPoint(HANDLE Handle, int Flags, int Axis, double Point, double Velocity, double EndVelocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis motion to the specified point // using the specified velocity or end velocity. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtToPointM(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a single-axis track motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Track(HANDLE Handle, int Flags, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multile-axis track motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_TrackM(HANDLE Handle, int Flags, int* Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function clears the current faults and results of previous faults stored in the MERR variable. // For single axis ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_FaultClear(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function clears the current faults and results of previous faults stored in the MERR variable. // For multiple axes ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_FaultClearM(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function reads number of available axes ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetAxesCount(HANDLE Handle, double* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function reads number of available ACSPL+ programming buffers ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetBuffersCount(HANDLE Handle, double* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function reads index of D-Buffer ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetDBufferIndex(HANDLE Handle, double* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function reads system information ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SysInfo(HANDLE Handle, int Key, double* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function writes system configuration ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetConf(HANDLE Handle, int Key, int Index, double Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function reads system configuration ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetConf(HANDLE Handle, int Key, int Index, double* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function writes system configuration-obsolete ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Setconf(HANDLE Handle, int Key, int Index, int Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function reads system configuration-obsolete ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Getconf(HANDLE Handle, int Key, int Index, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a single-axis jog motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Jog(HANDLE Handle, int Flags, int Axis, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis jog motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_JogM(HANDLE Handle, int Flags, int* Axes, int* Direction, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates calculating of master value for an axis. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetMaster(HANDLE Handle, int Axis, char* Formula, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a master-slave motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Slave(HANDLE Handle, int Flags, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a master-slave motion with a limited following area. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SlaveStalled(HANDLE Handle, int Flags, int Axis, double Left, double Right, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a single-axis multi-point motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_MultiPoint(HANDLE Handle, int Flags, int Axis, double Dwell, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis multi-point motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_MultiPointM(HANDLE Handle, int Flags, int* Axes, double Dwell, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function defines a motion profile using the MotionBoost Feature. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_BoostedPointToPointMotion(HANDLE Handle, int Flags, int* Axes, double* point, double Velocity, double FinalVelocity, double Time, double FixedTime, double MotionDelay, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function provides for positioning to specific target, // The motion profile is optimized to pass on a rounded path near the breaking point, minimizing changes in speedand direction that would cause unwanted vibrations in the system. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SmoothPointToPointMotion(HANDLE Handle, int Flags, int* Axes, double* point, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // If the axis is moving when the command is issued, the controller creates the motion and inserts it into the axis motion queue. // The motion waits in the queue until all motions before it finish, and only then starts. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SmoothTransitionPointToPointMotion(HANDLE Handle, int Flags, int* Axes, double* point, double Velocity, double MotionDelay, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a single-axis spline motion. // The motion follows an arbitrary path defined by a set of points. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Spline(HANDLE Handle, int Flags, int Axis, double Period, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis spline motion. // The motion follows an arbitrary path defined by a set of points. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SplineM(HANDLE Handle, int Flags, int* Axes, double Period, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Segment(HANDLE Handle, int Flags, int* Axes, double* Point, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentedMotion(HANDLE Handle, int Flags, int* Axes, double* Point, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis extended segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtendedSegmentedMotion(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double JunctionVelocity, double Angle, double StarvationMargin, char* Segments, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis extended segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtendedSegmentedMotionExt(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double JunctionVelocity, double Angle, double CurveVelocity, double Deviation, double Radius, double MaxLength, double StarvationMargin, char* Segments, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis extended segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtendedSegmentedMotionV2(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double JunctionVelocity, double Angle, double CurveVelocity, double Deviation, double Radius, double MaxLength, double StarvationMargin, char* Segments, int ExtLoopType, double MinSegmentLength, double MaxAllowedDeviation, int OutputIndex, int BitNumber, int Polarity, double MotionDelay, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates a multi-axis blended segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_BlendedSegmentMotion(HANDLE Handle, int Flags, int* Axes, double* Point, double SegmentTime, double AccelerationTime, double JerkTime, double DwellTime, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a linear segment to a blended segmented motion ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_BlendedLine(HANDLE Handle, int Flags, int* Axes, double* Point, double SegmentTime, double AccelerationTime, double JerkTime, double DwellTime, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, coordinates of the final point and the direction of rotation. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_BlendedArc1(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double SegmentTime, double AccelerationTime, double JerkTime, double DwellTime, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, rotation angle ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_BlendedArc2(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double SegmentTime, double AccelerationTime, double JerkTime, double DwellTime, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a linear segment to a segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Line(HANDLE Handle, int* Axes, double* Point, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a linear segment to a segmented motion and specifies a motion velocity. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtLine(HANDLE Handle, int* Axes, double* Point, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a linear segment to a segmented motion // Specifies motion velocity, end motion velocity, and user variables parameters // -- Obsolete -- ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentLine(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a linear segment to a segmented motion // Specifies motion velocity, end motion velocity, and user variables parameters ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentLineExt(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a linear segment to a segmented motion // Specifies motion velocity, end motion velocity, and user variables parameters ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentLineV2(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, int ExtLoopType, double MinSegmentLength, double MaxAllowedDeviation, int LciState, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, coordinates of the final point and the direction of rotation. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Arc1(HANDLE Handle, int* Axes, double* Center, double* FinalPoint, int Rotation, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, coordinates of the final point, direction of rotation and // the vector velocity for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtArc1(HANDLE Handle, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, coordinates of the final point, direction of rotation, vector velocity, // end motion velocity, and user variables parameters for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentArc1(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, double EndVelocity, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, coordinates of the final point, direction of rotation, vector velocity, // end motion velocity, and user variables parameters for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentArc1Ext(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, coordinates of the final point, direction of rotation, vector velocity, // end motion velocity, and user variables parameters for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtendedSegmentArc1(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, coordinates of the final point, direction of rotation, vector velocity, // end motion velocity, and user variables parameters for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentArc1V2(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, int ExtLoopType, double MinSegmentLength, double MaxAllowedDeviation, int LciState, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point and rotation angle. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Arc2(HANDLE Handle, int* Axes, double* Center, double Angle, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, rotation angle and the vector velocity for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtArc2(HANDLE Handle, int* Axes, double* Center, double Angle, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, rotation angle, vector velocity, // end motion velocity, and user variables parameters for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentArc2(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double Velocity, double EndVelocity, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, rotation angle, vector velocity, // end motion velocity, and user variables parameters for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentArc2Ext(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, rotation angle, final point for secondary axes, vector velocity, // end motion velocity, and user variables parameters for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtendedSegmentArc2(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double* FinalPoint, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an arc segment to a segmented motion and specifies the coordinates // of center point, rotation angle, final point for secondary axes, vector velocity, // end motion velocity, and user variables parameters for the current segment. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SegmentArc2V2(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double* FinalPoint, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, int ExtLoopType, double MinSegmentLength, double MaxAllowedDeviation, int LciState, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// //The function Create NURBS motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_NurbsMotion(HANDLE Handle, int Flags, int* Axes, double Velocity, double ExceptionAngle, double ExceptionLength, double MotionDelay, char* Segments, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// //The function Add next control point to Nurbs MG. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_NurbsPoints(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double Required_vel, double Knot, double Weight, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// //The function Initiate a Path Smoothing Motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SmoothPathMotion(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double ExceptionAngle, double ExceptionLength, double MotionDelay, char* Segments, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// //The function add a new control point to SPath MG. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SmoothPathSegment(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double Required_vel, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function provides a smooth transition between two segments of segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Stopper(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets a projection matrix for segmented motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Projection(HANDLE Handle, int* Axes, char* Matrix, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a point to a single-axis multi-point or spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AddPoint(HANDLE Handle, int Axis, double Point, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a point to a multi-axis multi-point or spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AddPointM(HANDLE Handle, int* Axes, double* Point, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a point to a single-axis multi-point or spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtAddPoint(HANDLE Handle, int Axis, double Point, double Rate, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a point to a multi-axis multi-point or spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ExtAddPointM(HANDLE Handle, int* Axes, double* Point, double Rate, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a point to a single-axis PVT spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AddPVTPoint(HANDLE Handle, int Axis, double Point, double Velocity, double TimeInterval, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a point to a multi-axis PVT spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AddPVTPointM(HANDLE Handle, int* Axis, double* Point, double* Velocity, double TimeInterval, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a point to a single-axis PV spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AddPVPoint(HANDLE Handle, int Axis, double Point, double Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds a point to a multi-axis PV spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AddPVPointM(HANDLE Handle, int* Axis, double* Point, double* Velocity, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an array of points to a single-axis multi-point or spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AddMPoint(HANDLE Handle, int Axis, char* Name, int Count, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function adds an array of points to a multi-axis multi-point or spline motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AddMPointM(HANDLE Handle, int* Axes, char* Name, int Count, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function informs the controller, that no more points will be specified for the current single-axis motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_EndSequence(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function informs the controller, that no more points or segments will be specified for the current multi-axis motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_EndSequenceM(HANDLE Handle, int* Axes, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates data collection. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Collect(HANDLE Handle, int Flags, char* Array, int NSample, int Period, char** Vars, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates data collection. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CollectB(HANDLE Handle, int Flags, char* Array, int NSample, int Period, char* Vars, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates data collection. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DataCollection(HANDLE Handle, int Flags, int Axis, char* Array, int NSample, int Period, char* Vars, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function initiates data collection. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DataCollectionExt(HANDLE Handle, int Flags, int Axis, char* Array, int NSample, double Period, char* Vars, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates data collection. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_StopCollect(HANDLE Handle, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current motor state. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetMotorState(HANDLE Handle, int Axis, int* State, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current axis state. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetAxisState(HANDLE Handle, int Axis, int* State, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the index and mark variables. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetIndexState(HANDLE Handle, int Axis, int* State, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function resets the specified bits of the index/mark state. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ResetIndexState(HANDLE Handle, int Axis, int Mask, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the program buffer. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetProgramState(HANDLE Handle, int Buffer, int* State, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified digital input. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetInput(HANDLE Handle, int Port, int Bit, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified digital input port. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetInputPort(HANDLE Handle, int Port, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified digital output. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetOutput(HANDLE Handle, int Port, int Bit, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified digital output port. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetOutputPort(HANDLE Handle, int Port, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the specified digital output to the specified value. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetOutput(HANDLE Handle, int Port, int Bit, int Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the specified digital output port to the specified value. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetOutputPort(HANDLE Handle, int Port, int Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current numerical value of the specified analog inputs. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetAnalogInput(HANDLE Handle, int Port, int* Value, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetAnalogInputNT(HANDLE Handle, int Port, double* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current numerical value of the specified analog outputs. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetAnalogOutput(HANDLE Handle, int Port, int* Value, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetAnalogOutputNT(HANDLE Handle, int Port, double* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function writes the current numerical value to the specified analog outputs. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetAnalogOutput(HANDLE Handle, int Port, int Value, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_SetAnalogOutputNT(HANDLE Handle, int Port, double Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified extended input. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetExtInput(HANDLE Handle, int Port, int Bit, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified extended input port. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetExtInputPort(HANDLE Handle, int Port, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified extended output. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetExtOutput(HANDLE Handle, int Port, int Bit, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified extended output port. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetExtOutputPort(HANDLE Handle, int Port, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the specified extended output to the specified value. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetExtOutput(HANDLE Handle, int Port, int Bit, int Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the specified extended output port to the specified value. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetExtOutputPort(HANDLE Handle, int Port, int Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the set of bits, that indicate the motor or system faults. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetFault(HANDLE Handle, int Axis, int* Fault, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the mask, that defines which controller faults are examined and processed. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetFaultMask(HANDLE Handle, int Axis, int* Mask, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the mask, that enables/disables the examination and processing of the controller faults. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetFaultMask(HANDLE Handle, int Axis, int Mask, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function enables the specified motor or system fault. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_EnableFault(HANDLE Handle, int Axis, int Fault, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function disables the specified motor or system fault. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DisableFault(HANDLE Handle, int Axis, int Fault, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the mask, that defines for which motor or system faults the controller provides default response. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetResponseMask(HANDLE Handle, int Axis, int* Mask, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the mask, that defines for which motor or system faults the controller provides default response. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetResponseMask(HANDLE Handle, int Axis, int Mask, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function enables the response to the specified motor or system fault. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_EnableResponse(HANDLE Handle, int Axis, int Response, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function disables the default response to the specified motor or system fault. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DisableResponse(HANDLE Handle, int Axis, int Response, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified safety input. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetSafetyInput(HANDLE Handle, int Axis, int Input, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the current state of the specified safety input port. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetSafetyInputPort(HANDLE Handle, int Axis, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the set of bits that define inversion for the specified safety input port. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetSafetyInputPortInv(HANDLE Handle, int Axis, int* Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the set of bits that define inversion for the specified safety input port. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetSafetyInputPortInv(HANDLE Handle, int Axis, int Value, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the end of a motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitMotionEnd(HANDLE Handle, int Axis, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the logical end of a motion. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitLogicalMotionEnd(HANDLE Handle, int Axis, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the end of data collection. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitCollectEnd(HANDLE Handle, int Timeout); //Deprecated ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the end of data collection. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitCollectEndExt(HANDLE Handle, int Timeout, int Axis); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the program termination in the specified buffer. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitProgramEnd(HANDLE Handle, int Buffer, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the specified state of the specified motor. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitMotorEnabled(HANDLE Handle, int Axis, int State, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the specified state of the specified motor. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitMotorCommutated(HANDLE Handle, int Axis, int State, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the specified state of digital input. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitInput(HANDLE Handle, int Port, int Bit, int State, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for user-defined condition. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitUserCondition(HANDLE Handle, ACSC_USER_CONDITION_FUNC UserCondition, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function waits for the readiness of the PEG engine. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitPegReadyNT(HANDLE Handle, int Axis, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function installs a user-defined callback function for the specified interrupt condition ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetCallback(HANDLE Handle, ACSC_INTR_CALLBACK_FUNC Callback, int Interrupt); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function installs a user-defined callback function for the specified interrupt condition // with specified card context ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetCallbackExt(HANDLE Handle, ACSC_INTR_CALLBACK_FUNC_EXT Callback, void* CardContext, int Interrupt); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function installs a user-defined callback function for the specified interrupt condition // with specified card context ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_InstallCallback(HANDLE Handle, ACSC_USER_CALLBACK_FUNCTION Callback, void* CardContext, int Interrupt); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function installs a user-defined callback function for the specified interrupt condition // with specified card context, supports more than 64 axes ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_InstallCallbackExt(HANDLE Handle, ACSC_USER_CALLBACK_FUNCTION_EXT Callback, void* CardContext, int Interrupt); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the priority for all callback threads. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetCallbackPriority(HANDLE Handle, int Priority); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the mask for specified interrupt ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetInterruptMask(HANDLE Handle, int Interrupt, unsigned int Mask); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the mask for specified interrupt, supports more than 64 axes ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetCallbackMaskExt(HANDLE Handle, int Interrupt, AXMASK_EXT Mask); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function sets the mask for specified callback ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetCallbackMask(HANDLE Handle, int Interrupt, UnsignedInt64 Mask); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the mask for specified interrupt ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetInterruptMask(HANDLE Handle, int Interrupt, unsigned int* Mask); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the mask for specified callback, supports more than 64 axes ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetCallbackMask(HANDLE Handle, int Interrupt, UnsignedInt64* Mask); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the mask for specified callback (up to 128 axes) ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetCallbackMaskExt(HANDLE Handle, int Interrupt, AXMASK_EXT* Mask); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function creates the persistent global variable. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DeclareVariable(HANDLE Handle, int Type, char* Name, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function deletes all persistent global variables. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ClearVariables(HANDLE Handle, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the firmware version of the controller. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetFirmwareVersion(HANDLE Handle, char* Version, int Count, int* Received, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the controller serial number. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetSerialNumber(HANDLE Handle, char* SerialNumber, int Count, int* Received, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function terminates a motion using reduced deceleration profile with Reason of kill. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_KillExt(HANDLE Handle, int Axis, int Reason, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function disables motor and sets Reason of disable. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DisableExt(HANDLE Handle, int Axis, int Reason, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the reason why the motor was disabled. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetMotorError(HANDLE Handle, int Axis, int* Error, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the termination code of the last executed motion of the specified axis. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetMotionError(HANDLE Handle, int Axis, int* Error, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the error code of the last program error encountered in the specified buffer. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetProgramError(HANDLE Handle, int Buffer, int* Error, ACSC_WAITBLOCK* Wait); //////////////////////////////////////////////////////////////////////////////////////////////// // Those functions access directly DPRAM via PCI bus only //////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ReadDPRAMInteger(HANDLE Handle, int index, int* result); int _ACSCLIB_ WINAPI acsc_WriteDPRAMInteger(HANDLE Handle, int index, int data); int _ACSCLIB_ WINAPI acsc_ReadDPRAMReal(HANDLE Handle, int index, double* result); int _ACSCLIB_ WINAPI acsc_WriteDPRAMReal(HANDLE Handle, int index, double data); //////////////////////////////////////////////////////////////////////////////////////////////// // Those functions provides access to Shared Memory variables //////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetSharedMemoryAddress(HANDLE Handle, int NBuf, char* Var, unsigned int* Address, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_ReadSharedMemoryReal(HANDLE Handle, unsigned int Address, int From1, int To1, int From2, int To2, double* Values); int _ACSCLIB_ WINAPI acsc_ReadSharedMemoryInteger(HANDLE Handle, unsigned int Address, int From1, int To1, int From2, int To2, int* Values); int _ACSCLIB_ WINAPI acsc_WriteSharedMemoryReal(HANDLE Handle, unsigned int Address, int From1, int To1, int From2, int To2, double* Values); int _ACSCLIB_ WINAPI acsc_WriteSharedMemoryInteger(HANDLE Handle, unsigned int Address, int From1, int To1, int From2, int To2, int* Values); ///////////////////////////////////////////////////////////////////////////////////////////////////// //This function defines communication server IP address ///////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetServer(char* IP); ///////////////////////////////////////////////////////////////////////////////////////////////////// //This function defines communication server IP address and Port ///////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_SetServerExt(char* IP, int Port); int _ACSCLIB_ WINAPI acsc_SetServerExtLogin(char* IP, int Port, char* Username, char* Password, char* Domain); ///////////////////////////////////////////////////////////////////////////////////////////////////// // These functions are related to Position Event Generation (PEG) ///////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_PegI(HANDLE Handle, int Flags, int Axis, double Width, int FirstPoint, int Interval, int LastPoint, int TbNumber, double TbPeriod, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_PegR(HANDLE Handle, int Flags, int Axis, double Width, char* PointArray, char* StateArray, int TbNumber, double TbPeriod, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_PegInc(HANDLE Handle, int Flags, int Axis, double Width, double FirstPoint, double Interval, double LastPoint, int TbNumber, double TbPeriod, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_PegRandom(HANDLE Handle, int Flags, int Axis, double Width, char* PointArray, char* StateArray, int TbNumber, double TbPeriod, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_AssignPins(HANDLE Handle, int Axis, unsigned short Mask, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_StopPeg(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_AssignPegNT(HANDLE Handle, int Axis, int EngToEncBitCode, int GpOutsBitCode, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_AssignPegNTV2(HANDLE Handle, int Flags, int Axis, int EngToEncBitCode, int GpOutsBitCode, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_AssignPegOutputsNT(HANDLE Handle, int Axis, int OutputIndex, int BitCode, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_AssignFastInputsNT(HANDLE Handle, int Axis, int InputIndex, int BitCode, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_PegIncNT(HANDLE Handle, int Flags, int Axis, double Width, double FirstPoint, double Interval, double LastPoint, int TbNumber, double TbPeriod, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_PegRandomNT(HANDLE Handle, int Flags, int Axis, double Width, int Mode, int FirstIndex, int LastIndex, char* PointArray, char* StateArray, int TbNumber, double TbPeriod, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_StartPegNT(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_StopPegNT(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); ///////////////////////////////////////////////////////////////////////////////////////////////////// //These functions are used for reading data from text files ///////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_LoadFileToIntegerVariable(HANDLE Handle, int NBuf, char* Var, int From1, int To1, int From2, int To2, char* Filename, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_LoadFileToRealVariable(HANDLE Handle, int NBuf, char* Var, int From1, int To1, int From2, int To2, char* Filename, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_DownloadBinVariableToFile(HANDLE Handle, int NBuf, char* Var, int Size, int From1, int To1, int From2, int To2, char* Filename, char* Format, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_SetLogFileOptions(HANDLE Handle, ACSC_LOG_DETALIZATION_LEVEL Detalization, ACSC_LOG_DATA_PRESENTATION Presentation); int _ACSCLIB_ WINAPI acsc_LoadDataToController(HANDLE Handle, int Dest, char* DestName, int From1, int To1, int From2, int To2, char* SrcFileName, int SrcNumFormat, BOOL bTranspose, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_UploadDataFromController(HANDLE Handle, int Src, char* SrcName, int SrcNumFormat, int From1, int To1, int From2, int To2, char* DestFileName, char* DestNumFormat, BOOL bTranspose, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function copies file to controller ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CopyFileToController(HANDLE Handle, char* SourceFileName, char* DestinationFileName, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function deletes file from controller ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_DeleteFileFromController(HANDLE Handle, char* FileName, ACSC_WAITBLOCK* Wait); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves the list of all currently opened communication channels(connections), on active Server.// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetConnectionsList(ACSC_CONNECTION_DESC* ConnectionsList, int MaxNumConnections, int* NumConnections); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // The function retrieves additional information of specified connection, on active Server. // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetConnectionInfo(HANDLE Handle, ACSC_CONNECTION_INFO* ConnectionInfo); //////////////////////////////////////////////////////////////////////////////////////// // The function terminates single communication channel(connection), on active Server.// //////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_TerminateConnection(ACSC_CONNECTION_DESC* Connection); //////////////////////////////////////////////////////////////////////////////////////// // The functions for managing new UMD EmergencyStop functionality // //////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_RegisterEmergencyStop(); int _ACSCLIB_ WINAPI acsc_UnregisterEmergencyStop(); //////////////////////////////////////////////////////////////////////////////////////// // The function returns version of UMD // //////////////////////////////////////////////////////////////////////////////////////// unsigned int _ACSCLIB_ WINAPI acsc_GetUMDVersion(); //////////////////////////////////////////////////////////////////////////////////////// // These functions for Application Saver Loader functionality // //////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_AnalyzeApplication(HANDLE Handle, const char* FileName, ACSC_APPSL_INFO** Info, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_FreeApplication(ACSC_APPSL_INFO* Info); int _ACSCLIB_ WINAPI acsc_SaveApplication(HANDLE Handle, const char* FileName, ACSC_APPSL_INFO* Info, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_LoadApplication(HANDLE Handle, const char* FileName, ACSC_APPSL_INFO* Info, ACSC_WAITBLOCK* Wait); //////////////////////////////////////////////////////////////////////////////////////// // These functions handles FRF // //////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_FFT(double* in, double* outReal, double* outImag, int length, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_Measure(HANDLE Handle, FRF_INPUT* inputParams, FRF_OUTPUT** outputParams, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_Stop(HANDLE Handle, int Axis, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_CalculateMeasurementDuration(FRF_DURATION_CALCULATION_PARAMETERS* params, double* duration, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_InitInput(FRF_INPUT* inputParams, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_FreeOutput(FRF_OUTPUT* inputParams, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_FreeCalculateLoopData(FRF_CALCULATE_LOOP_DATA* loopData, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_ReadServoParameters(HANDLE Handle, int axis, SERVO_PARAMETERS* servoParameters, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_CalculateLoopDataFRD(FRF_CALCULATE_LOOP_DATA* loopData, FRD** data, int* errorCode); //int _ACSCLIB_ WINAPI acsc_FRF_CalculatePlantFRDV2(FRF_CALCULATE_LOOP_DATA* loopData, FRD** plant, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_CalculateControllerFRD(SERVO_PARAMETERS* servoParameters, FRF_LOOP_TYPE loopType, double* frequencyHz, int frequencyLength, FRD** controller, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_CalculateOpenLoopFRD(SERVO_PARAMETERS* servoParameters, FRD* plant, FRF_LOOP_TYPE loopType, FRD** openLoop, int* errorCode); //int _ACSCLIB_ WINAPI acsc_FRF_CalculateOpenLoopFRDV2(FRF_CALCULATE_LOOP_DATA *loopData, FRD** openLoop, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_CalculateClosedLoopFRD(SERVO_PARAMETERS* servoParameters, FRD* plant, FRF_LOOP_TYPE loopType, FRD** closedLoop, int* errorCode); //int _ACSCLIB_ WINAPI acsc_FRF_CalculateClosedLoopFRDV2(FRF_CALCULATE_LOOP_DATA* loopData, FRD** openLoop, int* errorCode); //int _ACSCLIB_ WINAPI acsc_FRF_CalculateSensitivityFRDV2(FRF_CALCULATE_LOOP_DATA* loopData, FRD** sensitivity, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_CalculateStabilityMargins(FRD* openLoop, FRF_STABILITY_MARGINS** stabilityMargins, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_CalculateSLVRAT(FRF_CALCULATE_SLVRAT_DATA* inputParams, double *slvrat, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_FreeFRD(FRD* inputParams, int* errorCode); int _ACSCLIB_ WINAPI acsc_FRF_FreeStabilityMargins(FRF_STABILITY_MARGINS* inputParams, int* errorCode); int _ACSCLIB_ WINAPI acsc_JitterAnalysis(JITTER_ANALYSIS_INPUT* in, JITTER_ANALYSIS_OUTPUT** out, int* errorCode); int _ACSCLIB_ WINAPI acsc_JitterAnalysis_FreeOutput(JITTER_ANALYSIS_OUTPUT* inputParams, int* errorCode); ////////////////////////////////////////////////////////////////////////////////////////////////// // These functions reboot controler with or without restoring defaults ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ControllerReboot(HANDLE Handle, int Timeout); int _ACSCLIB_ WINAPI acsc_ControllerFactoryDefault(HANDLE Handle, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // This function saves to flash ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ControllerSaveToFlash(HANDLE Handle, int* Parameters, int* Buffers, int* SPPrograms, char* UserArrays); ////////////////////////////////////////////////////////////////////////////////////////////////// // These functions are related to EtherCAT ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetEtherCATState(HANDLE Handle, int* State, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetEtherCATError(HANDLE Handle, int* Error, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_MapEtherCATInput(HANDLE Handle, int Flags, int Offset, char* VariableName, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_MapEtherCATOutput(HANDLE Handle, int Flags, int Offset, char* VariableName, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_UnmapEtherCATInputsOutputs(HANDLE Handle, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetEtherCATSlaveIndex(HANDLE Handle, int VendorID, int ProductID, int Count, double* SlaveIndex, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetEtherCATSlaveOffset(HANDLE Handle, char* VariableName, int SlaveIndex, double* SlaveOffset, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetEtherCATSlaveVendorID(HANDLE Handle, int SlaveIndex, double* VendorID, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetEtherCATSlaveProductID(HANDLE Handle, int SlaveIndex, double* ProductID, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetEtherCATSlaveRevision(HANDLE Handle, int SlaveIndex, double* Revision, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetEtherCATSlaveType(HANDLE Handle, int VendorID, int ProductID, double* SlaveType, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetEtherCATSlaveState(HANDLE Handle, int SlaveIndex, double* SlaveState, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_DownloadFileOverEtherCAT(HANDLE Handle, char* Path, char* Filename, int SlaveIndex, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_ReadSDOValueOverEtherCAT(HANDLE Handle, int Flags, int SlaveIndex, int Index, int SubIndex, double* Value, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_WriteSDOValueOverEtherCAT(HANDLE Handle, int Flags, int SlaveIndex, int Index, int SubIndex, double Value, ACSC_WAITBLOCK* Wait); //////////////////////////////////////////////////////////////////////////////////////// // These functions returns RAM / Flash Information // //////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_GetVolatileMemoryUsage(HANDLE Handle, double* UsageInPercents, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetVolatileMemoryTotal(HANDLE Handle, double* TotalMemory, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetVolatileMemoryFree(HANDLE Handle, double* FreeMemory, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetNonVolatileMemoryUsage(HANDLE Handle, double* UsageInPercents, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetNonVolatileMemoryTotal(HANDLE Handle, double* TotalMemory, ACSC_WAITBLOCK* Wait); int _ACSCLIB_ WINAPI acsc_GetNonVolatileMemoryFree(HANDLE Handle, double* FreeMemory, ACSC_WAITBLOCK* Wait); //////////////////////////////////////////////////////////////////////////////////////// // These functions are used for starting / stopping SPiiPlusSC // //////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_StartSPiiPlusSC(); int _ACSCLIB_ WINAPI acsc_StopSPiiPlusSC(); //////////////////////////////////////////////////////////////////////////////////////// // These functions are used for starting / stopping SPiiPlus Simulator via RPC // //////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_CloseSimulator(); HANDLE _ACSCLIB_ WINAPI acsc_OpenCommSimulator(); ////////////////////////////////////////////////////////////////////////////////////////////////// // Undocumented: The function waits for completion of asynchronous call and retrieves a data. *Buf pointer must be freed after use. ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_WaitForResult(HANDLE Handle, void** Buf, int* Received, ACSC_RETURN_TYPE* ReturnType, ACSC_WAITBLOCK* Wait, int Timeout); ////////////////////////////////////////////////////////////////////////////////////////////////// // Undocumented: Read variable typeless ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ReadTypeless(HANDLE Handle, int NBuf, char* Var, int From1, int To1, int From2, int To2, void** pValues, int* DataSize, int* Dim1, int* Dim2, int* DataOffset, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // Undocumented: Read variable typeless ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_ReadTypeless2(HANDLE Handle, int NBuf, char* Var, int From1, int To1, int From2, int To2, void** pValues, int* DataSize, int* Dim1, int* Dim2, int* DataOffset, ACSC_RETURN_TYPE ReturnType, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // Undocumented: Raw Transaction ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_RawTransaction(HANDLE Handle, char* OutBuf, int OutCount, BSTR* Reply, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // Undocumented: Transaction2 ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Transaction2(HANDLE Handle, char* OutBuf, int OutCount, BSTR* Reply, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // Undocumented: Transaction3 ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_Transaction3(HANDLE Handle, char* OutBuf, int OutCount, void** Reply, unsigned long* N, ACSC_WAITBLOCK* Wait); ////////////////////////////////////////////////////////////////////////////////////////////////// // Undocumented: FreeBufferMemory ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_FreeBufferMemory(void* pbuf); ////////////////////////////////////////////////////////////////////////////////////////////////// // Undocumented: UploadEntireBuffer ////////////////////////////////////////////////////////////////////////////////////////////////// int _ACSCLIB_ WINAPI acsc_UploadEntireBuffer(HANDLE Handle, char* OutBuf, int OutCount, void** Reply, unsigned long* N, ACSC_WAITBLOCK* Wait); #else // defined (ACSC_RUNTIME_DYNAMIC_LINKING) // function type definitions typedef int (WINAPI *ACSC_AddMPoint)(HANDLE, int, char*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AddMPointM)(HANDLE, int*, char*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AddPoint)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AddPointM)(HANDLE, int*, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AppendBuffer)(HANDLE, int, char*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Arc1)(HANDLE, int*, double*, double*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Arc2)(HANDLE, int*, double*, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Break)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_BreakM)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_CancelOperation)(HANDLE, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_CaptureComm)(HANDLE); typedef int (WINAPI *ACSC_ClearBreakpoints)(HANDLE handle, int Buffer, int line, ACSC_WAITBLOCK* wait); typedef int (WINAPI *ACSC_ClearBuffer)(HANDLE, int, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ClearVariables)(HANDLE, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_CloseComm)(HANDLE); typedef int (WINAPI *ACSC_CloseHistoryBuffer)(HANDLE); typedef int (WINAPI *ACSC_CloseLogFile)(HANDLE); typedef int (WINAPI *ACSC_CloseSCLogFile)(HANDLE); typedef int (WINAPI *ACSC_CloseMessageBuffer)(HANDLE); typedef int (WINAPI *ACSC_Collect)(HANDLE, int, char*, int, int, char**, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Command)(HANDLE, char*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Commut)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_CommutExt)(HANDLE, int, float, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_CompileBuffer)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DeclareVariable)(HANDLE, int, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Disable)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DisableAll)(HANDLE, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DisableFault)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DisableM)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DisableResponse)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DownloadBuffer)(HANDLE, int, char*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Enable)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_EnableFault)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_EnableM)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_EnableResponse)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_EndSequence)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_EndSequenceM)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ExtAddPoint)(HANDLE, int, double, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ExtAddPointM)(HANDLE, int*, double*, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ExtArc1)(HANDLE, int*, double*, double*, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ExtArc2)(HANDLE, int*, double*, double, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ExtLine)(HANDLE, int*, double*, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ExtToPoint)(HANDLE, int, int, double, double, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ExtToPointM)(HANDLE, int, int*, double*, double, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_FlushLogFile)(char*); typedef int (WINAPI *ACSC_FlushSCLogFile)(char*); typedef int (WINAPI *ACSC_GetAcceleration)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetAnalogInput)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetAnalogOutput)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetAxisState)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetBreakpointsList)(HANDLE handle, int BufferNum, int* Array, int Size, int* replySize, ACSC_WAITBLOCK* wait); typedef int (WINAPI *ACSC_GetCommOptions)(HANDLE, unsigned int*); typedef int (WINAPI *ACSC_GetDeceleration)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetDefaultTimeout)(HANDLE); typedef int (WINAPI *ACSC_GetErrorString)(HANDLE, int, char*, int, int*); typedef int (WINAPI *ACSC_GetExtInput)(HANDLE, int, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetExtInputPort)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetExtOutput)(HANDLE, int, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetExtOutputPort)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetFPosition)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetFVelocity)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetFault)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetFaultMask)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetFirmwareVersion)(HANDLE, char*, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetHistory)(HANDLE, char*, int, int*, BOOL); typedef int (WINAPI *ACSC_GetIndexState)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetInput)(HANDLE, int, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetInputPort)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetInterruptMask)(HANDLE, int, unsigned int*); typedef int (WINAPI *ACSC_GetCallbackMask)(HANDLE, int, unsigned __int64*); typedef int (WINAPI* ACSC_GetCallbackMaskExt)(HANDLE, int, AXMASK_EXT*); typedef int (WINAPI *ACSC_GetJerk)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetKillDeceleration)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetLastError)(); typedef unsigned int (WINAPI *ACSC_GetLibraryVersion)(); typedef int (WINAPI *ACSC_GetMessage)(HANDLE, char*, int, int*, BOOL); typedef int (WINAPI *ACSC_GetMotionError)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetMotorError)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetMotorState)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetOutput)(HANDLE, int, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetOutputPort)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetPCICards)(ACSC_PCI_SLOT*, int, int*); typedef int (WINAPI *ACSC_GetEthernetCards) (struct in_addr*, int, int*, unsigned long); typedef int (WINAPI *ACSC_GetEthernetCardsExt) (struct ACSC_CONTROLLER_INFO*, unsigned long, int, int*, unsigned long); typedef int (WINAPI *ACSC_GetProgramError)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetProgramState)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetRPosition)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetRVelocity)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetResponseMask)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetSafetyInput)(HANDLE, int, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetSafetyInputPort)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetSafetyInputPortInv)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetSerialNumber)(HANDLE, char*, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetTimeout)(HANDLE); typedef int (WINAPI *ACSC_GetVelocity)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Go)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GoM)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Group)(HANDLE, int*, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_Halt)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_HaltM)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Jog)(HANDLE, int, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_JogM)(HANDLE, int, int*, int*, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Kill)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_KillExt)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DisableExt)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_KillAll)(HANDLE, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_KillM)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Line)(HANDLE, int*, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_LoadBuffer)(HANDLE, int, char*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_MultiPoint)(HANDLE, int, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_MultiPointM)(HANDLE, int, int*, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_BoostedPointToPointMotion)(HANDLE, int, int*, double*, double, double, double, double, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SmoothPointToPointMotion)(HANDLE, int, int*, double*, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SmoothTransitionPointToPointMotion)(HANDLE, int, int*, double*, double, double, ACSC_WAITBLOCK*); typedef HANDLE(WINAPI *ACSC_OpenCommDirect)(); typedef int (WINAPI *ACSC_CloseSimulator)(); typedef HANDLE(WINAPI *ACSC_OpenCommSimulator)(); typedef HANDLE(WINAPI *ACSC_OpenCommEthernet)(char*, int); typedef HANDLE(WINAPI *ACSC_OpenCommEthernetUDP)(char*, int); typedef HANDLE(WINAPI *ACSC_OpenCommEthernetTCP)(char*, int); typedef HANDLE(WINAPI *ACSC_OpenCommSerial)(int, int); typedef HANDLE(WINAPI *ACSC_OpenCommPCI)(int); typedef LP_ACSC_HISTORYBUFFER(WINAPI *ACSC_OpenHistoryBuffer)(HANDLE, int); typedef int (WINAPI *ACSC_OpenLogFile)(HANDLE, char*); typedef int (WINAPI *ACSC_OpenSCLogFile)(HANDLE, char*); typedef LP_ACSC_HISTORYBUFFER(WINAPI *ACSC_OpenMessageBuffer)(HANDLE, int); typedef int (WINAPI *ACSC_Projection)(HANDLE, int*, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ReadDPRAMInteger)(HANDLE, int, int*); typedef int (WINAPI *ACSC_ReadDPRAMReal)(HANDLE, int, double*); typedef int (WINAPI *ACSC_ReadInteger)(HANDLE, int, char*, int, int, int, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ReadReal)(HANDLE, int, char*, int, int, int, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Receive)(HANDLE, char*, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ReleaseComm)(HANDLE); typedef int (WINAPI *ACSC_ResetIndexState)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_RunBuffer)(HANDLE, int, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Segment)(HANDLE, int, int*, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Send)(HANDLE, char*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetAcceleration)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetAccelerationImm)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetAnalogOutput)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetBreakpoint)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetCallback)(HANDLE, ACSC_INTR_CALLBACK_FUNC, int); typedef int (WINAPI *ACSC_SetCallbackPriority)(HANDLE, int); typedef int (WINAPI *ACSC_SetCommOptions)(HANDLE, unsigned int); typedef int (WINAPI *ACSC_SetDeceleration)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetDecelerationImm)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetExtOutput)(HANDLE, int, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetExtOutputPort)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetFPosition)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetFaultMask)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetInterruptMask)(HANDLE, int, unsigned int); typedef int (WINAPI *ACSC_SetCallbackMask)(HANDLE, int, unsigned __int64); typedef int (WINAPI *ACSC_SetCallbackMaskExt)(HANDLE, int, AXMASK_EXT); typedef int (WINAPI *ACSC_SetIterations)(HANDLE, int); typedef int (WINAPI *ACSC_SetJerk)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetJerkImm)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetKillDeceleration)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetKillDecelerationImm)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetMaster)(HANDLE, int, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetOutput)(HANDLE, int, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetOutputPort)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetRPosition)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetResponseMask)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetSafetyInputPortInv)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetTimeout)(HANDLE, int); typedef int (WINAPI *ACSC_SetVelocity)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetVelocityImm)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Slave)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SlaveStalled)(HANDLE, int, int, double, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Spline)(HANDLE, int, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SplineM)(HANDLE, int, int*, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Split)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SplitAll)(HANDLE, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_StopBuffer)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_StopCollect)(HANDLE, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Stopper)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SuspendBuffer)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ToPoint)(HANDLE, int, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ToPointM)(HANDLE, int, int*, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Transaction)(HANDLE, char*, int, char*, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_UploadBuffer)(HANDLE, int, int, char*, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_WaitCollectEnd)(HANDLE, int); typedef int (WINAPI *ACSC_WaitCollectEndExt)(HANDLE, int, int); typedef int (WINAPI *ACSC_WaitForAsyncCall)(HANDLE, void*, int*, ACSC_WAITBLOCK*, int); typedef int (WINAPI *ACSC_WaitInput)(HANDLE, int, int, int, int); typedef int (WINAPI *ACSC_WaitLogicalMotionEnd)(HANDLE, int, int); typedef int (WINAPI *ACSC_WaitMotionEnd)(HANDLE, int, int); typedef int (WINAPI *ACSC_WaitMotorEnabled)(HANDLE, int, int, int); typedef int (WINAPI *ACSC_WaitMotorCommutated)(HANDLE, int, int, int); typedef int (WINAPI *ACSC_WaitProgramEnd)(HANDLE, int, int); typedef int (WINAPI *ACSC_WaitUserCondition)(HANDLE, ACSC_USER_CONDITION_FUNC, int); typedef int (WINAPI *ACSC_WriteDPRAMInteger)(HANDLE, int, int); typedef int (WINAPI *ACSC_WriteDPRAMReal)(HANDLE, int, double); typedef int (WINAPI *ACSC_WriteInteger)(HANDLE, int, char*, int, int, int, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_WriteLogFile)(HANDLE, char*, int); typedef int (WINAPI *ACSC_WriteSCLogFile)(HANDLE, char*, int); typedef int (WINAPI *ACSC_WriteReal)(HANDLE, int, char*, int, int, int, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_LoadBufferIgnoreServiceLines)(HANDLE, int, char*, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_LoadBuffersFromFile)(HANDLE, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_PegI)(HANDLE, int, int, double, int, int, int, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_PegR)(HANDLE, int, int, double, char*, char*, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_PegInc)(HANDLE, int, int, double, double, double, double, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_PegRandom)(HANDLE, int, int, double, char*, char*, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AssignPins)(HANDLE, int, unsigned short, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_StopPeg)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AssignPegNT)(HANDLE Handle, int Axis, int EngToEncBitCode, int GpOutsBitCode, ACSC_WAITBLOCK* Wait); typedef int (WINAPI* ACSC_AssignPegNTV2)(HANDLE Handle, int flags, int Axis, int EngToEncBitCode, int GpOutsBitCode, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_AssignPegOutputsNT)(HANDLE Handle, int Axis, int OutputIndex, int BitCode, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_AssignFastInputsNT)(HANDLE Handle, int Axis, int InputIndex, int BitCode, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_PegIncNT)(HANDLE Handle, int Flags, int Axis, double Width, double FirstPoint, double Interval, double LastPoint, int TbNumber, double TbPeriod, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_PegRandomNT)(HANDLE Handle, int Flags, int Axis, double Width, int Mode, int FirstIndex, int LastIndex, char* PointArray, char* StateArray, int TbNumber, double TbPeriod, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_WaitPegReadyNT)(HANDLE Handle, int Axis, int Timeout); typedef int (WINAPI *ACSC_StartPegNT)(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_StopPegNT)(HANDLE Handle, int Axis, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_CollectB)(HANDLE, int, char*, int, int, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DataCollection)(HANDLE, int, int, char*, int, int, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_DataCollectionExt)(HANDLE Handle, int Flags, int Axis, char* Array, int NSample, double Period, char* Vars, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_AddPVPoint)(HANDLE, int, double, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AddPVPointM)(HANDLE, int*, double*, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AddPVTPoint)(HANDLE, int, double, double, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_AddPVTPointM)(HANDLE, int*, double*, double*, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_LoadFileToRealVariable)(HANDLE, int, char*, int, int, int, int, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_LoadFileToIntegerVariable)(HANDLE, int, char*, int, int, int, int, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_LoadDataToController)(HANDLE, int, char*, int, int, int, int, char*, int, BOOL, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_UploadDataFromController)(HANDLE, int, char*, int, int, int, int, int, char*, char*, BOOL, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetQueueOverflowTimeout)(HANDLE, int); typedef int (WINAPI *ACSC_GetQueueOverflowTimeout)(HANDLE); typedef int (WINAPI *ACSC_SetTargetPosition)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetTargetPosition)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetTargetPositionM)(HANDLE, int*, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Track)(HANDLE, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_TrackM)(HANDLE, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_FaultClearM)(HANDLE, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_FaultClear)(HANDLE, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Getconf)(HANDLE, int, int, int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_Setconf)(HANDLE, int, int, int, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetCallbackExt)(HANDLE, ACSC_INTR_CALLBACK_FUNC_EXT, void*, int); typedef int (WINAPI *ACSC_InstallCallback)(HANDLE, ACSC_USER_CALLBACK_FUNCTION, void*, int); typedef int (WINAPI* ACSC_InstallCallbackExt)(HANDLE, ACSC_USER_CALLBACK_FUNCTION_EXT, void*, int); typedef int (WINAPI *ACSC_DownloadBinVariableToFile)(HANDLE, int, char*, int, int, int, int, int, char*, char*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetLogFileOptions)(HANDLE, ACSC_LOG_DETALIZATION_LEVEL, ACSC_LOG_DATA_PRESENTATION); typedef int (WINAPI *ACSC_GetConf)(HANDLE, int, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetConf)(HANDLE, int, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SysInfo)(HANDLE Handle, int Key, double* Value, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_GetAxesCount)(HANDLE Handle, double* Value, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_GetBuffersCount)(HANDLE Handle, double* Value, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_GetDBufferIndex)(HANDLE Handle, double* Value, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_SetServer)(char* IP); typedef int (WINAPI *ACSC_SetServerExt)(char*, int); typedef int (WINAPI *ACSC_SetServerExtLogin)(char*, int, char*, char*, char*); typedef int (WINAPI *ACSC_GetSingleMessage)(HANDLE Handle, char* Buf, int Count, int* Received, int Timeout); typedef int (WINAPI *ACSC_GetConnectionsList)(ACSC_CONNECTION_DESC* ConnectionsList, int MaxNumConnections, int* NumConnections); typedef int (WINAPI *ACSC_GetConnectionInfo)(HANDLE Handle, ACSC_CONNECTION_INFO* ConnectionInfo); typedef int (WINAPI *ACSC_TerminateConnection)(ACSC_CONNECTION_DESC* Connection); typedef int (WINAPI *ACSC_GetLogData)(HANDLE Handle, char* Buf, int Count, int* Received); typedef int (WINAPI *ACSC_RegisterEmergencyStop)(); typedef int (WINAPI *ACSC_UnregisterEmergencyStop)(); typedef unsigned int (WINAPI *ACSC_GetUMDVersion)(); typedef int (WINAPI* ACSC_AnalyzeApplication)(HANDLE, const char*, ACSC_APPSL_INFO**, ACSC_WAITBLOCK*); typedef int (WINAPI* ACSC_FreeApplication)(ACSC_APPSL_INFO*); typedef int (WINAPI* ACSC_SaveApplication)(HANDLE, const char*, ACSC_APPSL_INFO*, ACSC_WAITBLOCK*); typedef int (WINAPI* ACSC_LoadApplication)(HANDLE, const char*, ACSC_APPSL_INFO*, ACSC_WAITBLOCK*); typedef int (WINAPI* ACSC_FFT)(double*, double*, double*, int, int*); typedef int (WINAPI* ACSC_FRF_Measure)(HANDLE, FRF_INPUT*, FRF_OUTPUT**, int*); typedef int (WINAPI* ACSC_FRF_Stop)(HANDLE, int, int*); typedef int (WINAPI* ACSC_FRF_CalculateMeasurementDuration)(FRF_DURATION_CALCULATION_PARAMETERS*, double*, int*); typedef int (WINAPI* ACSC_FRF_InitInput)(FRF_INPUT*, int*); typedef int (WINAPI* ACSC_FRF_FreeOutput)(FRF_OUTPUT*, int*); typedef int (WINAPI* ACSC_FRF_ReadServoParameters)(HANDLE, int, SERVO_PARAMETERS*, int*); typedef int (WINAPI* ACSC_FRF_CalculateControllerFRD)(SERVO_PARAMETERS*, FRF_LOOP_TYPE, double*, int, FRD**, int*); typedef int (WINAPI* ACSC_FRF_CalculateOpenLoopFRD)(SERVO_PARAMETERS*, FRD*, FRF_LOOP_TYPE, FRD**, int*); typedef int (WINAPI* ACSC_FRF_CalculateClosedLoopFRD)(SERVO_PARAMETERS*, FRD*, FRF_LOOP_TYPE, FRD**, int*); typedef int (WINAPI* ACSC_FRF_CalculateStabilityMargins)(FRD*, FRF_STABILITY_MARGINS**, int*); typedef int (WINAPI* ACSC_FRF_FreeFRD)(FRD*, int*); typedef int (WINAPI* ACSC_FRF_FreeStabilityMargins)(FRF_STABILITY_MARGINS*, int*); typedef int (WINAPI* ACSC_JitterAnalysis)(JITTER_ANALYSIS_INPUT*, JITTER_ANALYSIS_OUTPUT**, int*); typedef int (WINAPI* ACSC_JitterAnalysis_FreeOutput)(JITTER_ANALYSIS_OUTPUT*, int*); typedef int (WINAPI *ACSC_ControllerReboot)(HANDLE, int); typedef int (WINAPI *ACSC_ControllerFactoryDefault)(HANDLE, int); typedef int (WINAPI *ACSC_ControllerSaveToFlash)(HANDLE, int*, int*, int*, char*); typedef int (WINAPI *ACSC_GetSharedMemoryAddress)(HANDLE, int, char*, unsigned int*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_ReadSharedMemoryReal)(HANDLE, unsigned int, int, int, int, int, double*); typedef int (WINAPI *ACSC_ReadSharedMemoryInteger)(HANDLE, unsigned int, int, int, int, int, int*); typedef int (WINAPI *ACSC_WriteSharedMemoryReal)(HANDLE, unsigned int, int, int, int, int, double*); typedef int (WINAPI *ACSC_WriteSharedMemoryInteger)(HANDLE, unsigned int, int, int, int, int, int*); typedef HANDLE(WINAPI *ACSC_GetEtherCATState)(HANDLE Handle, int* State, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_GetEtherCATError)(HANDLE Handle, int* Error, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_MapEtherCATInput)(HANDLE Handle, int Flags, int Offset, char* VariableName, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_MapEtherCATOutput)(HANDLE Handle, int Flags, int Offset, char* VariableName, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_UnmapEtherCATInputsOutputs)(HANDLE Handle, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_GetEtherCATSlaveIndex)(HANDLE Handle, int VendorID, int ProductID, int Count, int* SlaveIndex, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_GetEtherCATSlaveOffset)(HANDLE Handle, char* VariableName, int SlaveIndex, double* SlaveOffset, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_GetEtherCATSlaveVendorID)(HANDLE Handle, int SlaveIndex, double* VendorID, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_GetEtherCATSlaveProductID)(HANDLE Handle, int SlaveIndex, double* ProductID, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_GetEtherCATSlaveRevision)(HANDLE Handle, int SlaveIndex, double* Revision, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_GetEtherCATSlaveType)(HANDLE Handle, int SlaveIndex, double* SlaveType, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_GetEtherCATSlaveState)(HANDLE Handle, int SlaveIndex, double* SlaveState, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_DownloadFileOverEtherCAT)(HANDLE Handle, char* Path, char* Filename, int SlaveIndex, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_ReadSDOValueOverEtherCAT)(HANDLE Handle, int Flags, int SlaveIndex, int Index, int SubIndex, double* Value, ACSC_WAITBLOCK* Wait); typedef HANDLE(WINAPI *ACSC_WriteSDOValueOverEtherCAT)(HANDLE Handle, int Flags, int SlaveIndex, int Index, int SubIndex, double Value, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_CopyFileToController)(HANDLE Handle, char* SourceFileName, char* DestinationFileName, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_DeleteFileFromController)(HANDLE Handle, char* FileName, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_SegmentedMotion)(HANDLE Handle, int Flags, int* Axes, double* Point, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_ExtendedSegmentedMotion)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double JunctionVelocity, double Angle, double StarvationMargin, char* Segments, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_ExtendedSegmentedMotionExt)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double JunctionVelocity, double Angle, double CurveVelocity, double Deviation, double Radius, double MaxLength, double StarvationMargin, char* Segments, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_ExtendedSegmentedMotionV2)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double JunctionVelocity, double Angle, double CurveVelocity, double Deviation, double Radius, double MaxLength, double StarvationMargin, char* Segments, int ExtLoopType, double MinSegmentLength, double MaxAllowedDeviation, int OutputIndex, int BitNumber, int Polarity, double MotionDelay, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_SegmentLine)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_SegmentLineExt)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); typedef int (WINAPI* ACSC_SegmentLineV2)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double EndVelocity, double Time, char* Values, char* Variables,int Index, char* Masks, int ExtLoopType, double MimSegmentLength, double MaxAllowedDeviation, int LciState, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_SegmentArc1)(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, double EndVelocity, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_SegmentArc2)(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double Velocity, double EndVelocity, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_SegmentArc1Ext)(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_SegmentArc2Ext)(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_ExtendedSegmentArc1)(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_ExtendedSegmentArc2)(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double* FinalPoint, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, ACSC_WAITBLOCK* Wait); typedef int (WINAPI* ACSC_SegmentArc1V2)(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, int ExtLoopType, double MimSegmentLength, double MaxAllowedDeviation, int LciState, ACSC_WAITBLOCK* Wait); typedef int (WINAPI* ACSC_SegmentArc2V2)(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double* FinalPoint, double Velocity, double EndVelocity, double Time, char* Values, char* Variables, int Index, char* Masks, int ExtLoopType, double MimSegmentLength, double MaxAllowedDeviation, int LciState, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_BlendedSegmentMotion)(HANDLE Handle, int Flags, int* Axes, double* Point, double SegmentTime, double AccelerationTime, double JerkTime, double DwellTime, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_BlendedLine)(HANDLE Handle, int Flags, int* Axes, double* Point, double SegmentTime, double AccelerationTime, double JerkTime, double DwellTime, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_BlendedArc1)(HANDLE Handle, int Flags, int* Axes, double* Center, double* FinalPoint, int Rotation, double SegmentTime, double AccelerationTime, double JerkTime, double DwellTime, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_BlendedArc2)(HANDLE Handle, int Flags, int* Axes, double* Center, double Angle, double SegmentTime, double AccelerationTime, double JerkTime, double DwellTime, ACSC_WAITBLOCK* Wait); typedef int (WINAPI *ACSC_GetAnalogInputNT)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetAnalogOutputNT)(HANDLE, int, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_SetAnalogOutputNT)(HANDLE, int, double, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetVolatileMemoryUsage)(HANDLE, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetVolatileMemoryTotal)(HANDLE, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetVolatileMemoryFree)(HANDLE, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetNonVolatileMemoryUsage)(HANDLE, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetNonVolatileMemoryTotal)(HANDLE, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_GetNonVolatileMemoryFree)(HANDLE, double*, ACSC_WAITBLOCK*); typedef int (WINAPI *ACSC_StartSPiiPlusSC)(); typedef int (WINAPI *ACSC_StopSPiiPlusSC)(); typedef int (WINAPI* ACSC_NurbsMotion)(HANDLE Handle, int Flags, int* Axes, double Velocity, double ExceptionAngle, double ExceptionLength, double MotionDelay, char* Segments, ACSC_WAITBLOCK* Wait); typedef int (WINAPI* ACSC_NurbsPoints)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double Required_vel, double Knot, double Weight, ACSC_WAITBLOCK* Wait); typedef int (WINAPI* ACSC_SmoothPathMotion)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double ExceptionAngle, double ExceptionLength, double MotionDelay, char* Segments, ACSC_WAITBLOCK* Wait); typedef int (WINAPI* ACSC_SmoothPathSegment)(HANDLE Handle, int Flags, int* Axes, double* Point, double Velocity, double Required_vel, ACSC_WAITBLOCK* Wait); #if !defined (ACSC_RUNTIME_DYNAMIC_VARIABLES) ACSC_AddMPoint acsc_AddMPoint; ACSC_AddMPointM acsc_AddMPointM; ACSC_AddPoint acsc_AddPoint; ACSC_AddPointM acsc_AddPointM; ACSC_AppendBuffer acsc_AppendBuffer; ACSC_Arc1 acsc_Arc1; ACSC_Arc2 acsc_Arc2; ACSC_Break acsc_Break; ACSC_BreakM acsc_BreakM; ACSC_CancelOperation acsc_CancelOperation; ACSC_CaptureComm acsc_CaptureComm; ACSC_ClearBuffer acsc_ClearBuffer; ACSC_ClearBreakpoints acsc_ClearBreakpoints; ACSC_ClearVariables acsc_ClearVariables; ACSC_CloseComm acsc_CloseComm; ACSC_CloseHistoryBuffer acsc_CloseHistoryBuffer; ACSC_CloseLogFile acsc_CloseLogFile; ACSC_CloseSCLogFile acsc_CloseSCLogFile; ACSC_CloseMessageBuffer acsc_CloseMessageBuffer; ACSC_Collect acsc_Collect; ACSC_Command acsc_Command; ACSC_Commut acsc_Commut; ACSC_CommutExt acsc_CommutExt; ACSC_CompileBuffer acsc_CompileBuffer; ACSC_DeclareVariable acsc_DeclareVariable; ACSC_Disable acsc_Disable; ACSC_DisableAll acsc_DisableAll; ACSC_DisableFault acsc_DisableFault; ACSC_DisableM acsc_DisableM; ACSC_DisableResponse acsc_DisableResponse; ACSC_DownloadBuffer acsc_DownloadBuffer; ACSC_Enable acsc_Enable; ACSC_EnableFault acsc_EnableFault; ACSC_EnableM acsc_EnableM; ACSC_EnableResponse acsc_EnableResponse; ACSC_EndSequence acsc_EndSequence; ACSC_EndSequenceM acsc_EndSequenceM; ACSC_ExtAddPoint acsc_ExtAddPoint; ACSC_ExtAddPointM acsc_ExtAddPointM; ACSC_ExtArc1 acsc_ExtArc1; ACSC_ExtArc2 acsc_ExtArc2; ACSC_ExtLine acsc_ExtLine; ACSC_ExtToPoint acsc_ExtToPoint; ACSC_ExtToPointM acsc_ExtToPointM; ACSC_FlushLogFile acsc_FlushLogFile; ACSC_FlushSCLogFile acsc_FlushSCLogFile; ACSC_GetAcceleration acsc_GetAcceleration; ACSC_GetAnalogInput acsc_GetAnalogInput; ACSC_GetAnalogOutput acsc_GetAnalogOutput; ACSC_GetAxisState acsc_GetAxisState; ACSC_GetBreakpointsList acsc_GetBreakpointsList; ACSC_GetCommOptions acsc_GetCommOptions; ACSC_GetDeceleration acsc_GetDeceleration; ACSC_GetDefaultTimeout acsc_GetDefaultTimeout; ACSC_GetErrorString acsc_GetErrorString; ACSC_GetExtInput acsc_GetExtInput; ACSC_GetExtInputPort acsc_GetExtInputPort; ACSC_GetExtOutput acsc_GetExtOutput; ACSC_GetExtOutputPort acsc_GetExtOutputPort; ACSC_GetFPosition acsc_GetFPosition; ACSC_GetFVelocity acsc_GetFVelocity; ACSC_GetFault acsc_GetFault; ACSC_GetFaultMask acsc_GetFaultMask; ACSC_GetFirmwareVersion acsc_GetFirmwareVersion; ACSC_GetHistory acsc_GetHistory; ACSC_GetIndexState acsc_GetIndexState; ACSC_GetInput acsc_GetInput; ACSC_GetInputPort acsc_GetInputPort; ACSC_GetInterruptMask acsc_GetInterruptMask; ACSC_GetCallbackMask acsc_GetCallbackMask; ACSC_GetCallbackMaskExt acsc_GetCallbackMaskExt; ACSC_GetJerk acsc_GetJerk; ACSC_GetKillDeceleration acsc_GetKillDeceleration; ACSC_GetLastError acsc_GetLastError; ACSC_GetLibraryVersion acsc_GetLibraryVersion; ACSC_GetMessage acsc_GetMessage; ACSC_GetMotionError acsc_GetMotionError; ACSC_GetMotorError acsc_GetMotorError; ACSC_GetMotorState acsc_GetMotorState; ACSC_GetOutput acsc_GetOutput; ACSC_GetOutputPort acsc_GetOutputPort; ACSC_GetPCICards acsc_GetPCICards; ACSC_GetEthernetCards acsc_GetEthernetCards; ACSC_GetEthernetCardsExt acsc_GetEthernetCardsExt; ACSC_GetProgramError acsc_GetProgramError; ACSC_GetProgramState acsc_GetProgramState; ACSC_GetRPosition acsc_GetRPosition; ACSC_GetRVelocity acsc_GetRVelocity; ACSC_GetResponseMask acsc_GetResponseMask; ACSC_GetSafetyInput acsc_GetSafetyInput; ACSC_GetSafetyInputPort acsc_GetSafetyInputPort; ACSC_GetSafetyInputPortInv acsc_GetSafetyInputPortInv; ACSC_GetSerialNumber acsc_GetSerialNumber; ACSC_GetTimeout acsc_GetTimeout; ACSC_GetVelocity acsc_GetVelocity; ACSC_Go acsc_Go; ACSC_GoM acsc_GoM; ACSC_Group acsc_Group; ACSC_Halt acsc_Halt; ACSC_HaltM acsc_HaltM; ACSC_Jog acsc_Jog; ACSC_JogM acsc_JogM; ACSC_Kill acsc_Kill; ACSC_KillExt acsc_KillExt; ACSC_DisableExt acsc_DisableExt; ACSC_KillAll acsc_KillAll; ACSC_KillM acsc_KillM; ACSC_Line acsc_Line; ACSC_LoadBuffer acsc_LoadBuffer; ACSC_MultiPoint acsc_MultiPoint; ACSC_MultiPointM acsc_MultiPointM; ACSC_BoostedPointToPointMotion acsc_BoostedPointToPointMotion; ACSC_SmoothPointToPointMotion acsc_SmoothPointToPointMotion; ACSC_SmoothTransitionPointToPointMotion acsc_SmoothTransitionPointToPointMotion; ACSC_OpenCommDirect acsc_OpenCommDirect; ACSC_CloseSimulator acsc_CloseSimulator; ACSC_OpenCommSimulator acsc_OpenCommSimulator; ACSC_OpenCommEthernet acsc_OpenCommEthernet; ACSC_OpenCommEthernetUDP acsc_OpenCommEthernetUDP; ACSC_OpenCommEthernetTCP acsc_OpenCommEthernetTCP; ACSC_OpenCommSerial acsc_OpenCommSerial; ACSC_OpenCommPCI acsc_OpenCommPCI; ACSC_OpenHistoryBuffer acsc_OpenHistoryBuffer; ACSC_OpenLogFile acsc_OpenLogFile; ACSC_OpenSCLogFile acsc_OpenSCLogFile; ACSC_OpenMessageBuffer acsc_OpenMessageBuffer; ACSC_Projection acsc_Projection; ACSC_ReadDPRAMInteger acsc_ReadDPRAMInteger; ACSC_ReadDPRAMReal acsc_ReadDPRAMReal; ACSC_ReadInteger acsc_ReadInteger; ACSC_ReadReal acsc_ReadReal; ACSC_Receive acsc_Receive; ACSC_ReleaseComm acsc_ReleaseComm; ACSC_ResetIndexState acsc_ResetIndexState; ACSC_RunBuffer acsc_RunBuffer; ACSC_Segment acsc_Segment; ACSC_Send acsc_Send; ACSC_SetAcceleration acsc_SetAcceleration; ACSC_SetAccelerationImm acsc_SetAccelerationImm; ACSC_SetAnalogOutput acsc_SetAnalogOutput; ACSC_SetBreakpoint acsc_SetBreakpoint; ACSC_SetCallback acsc_SetCallback; ACSC_SetCallbackPriority acsc_SetCallbackPriority; ACSC_SetCommOptions acsc_SetCommOptions; ACSC_SetDeceleration acsc_SetDeceleration; ACSC_SetDecelerationImm acsc_SetDecelerationImm; ACSC_SetExtOutput acsc_SetExtOutput; ACSC_SetExtOutputPort acsc_SetExtOutputPort; ACSC_SetFPosition acsc_SetFPosition; ACSC_SetFaultMask acsc_SetFaultMask; ACSC_SetInterruptMask acsc_SetInterruptMask; ACSC_SetCallbackMask acsc_SetCallbackMask; ACSC_SetCallbackMaskExt acsc_SetCallbackMaskExt; ACSC_SetIterations acsc_SetIterations; ACSC_SetJerk acsc_SetJerk; ACSC_SetJerkImm acsc_SetJerkImm; ACSC_SetKillDeceleration acsc_SetKillDeceleration; ACSC_SetKillDecelerationImm acsc_SetKillDecelerationImm; ACSC_SetMaster acsc_SetMaster; ACSC_SetOutput acsc_SetOutput; ACSC_SetOutputPort acsc_SetOutputPort; ACSC_SetRPosition acsc_SetRPosition; ACSC_SetResponseMask acsc_SetResponseMask; ACSC_SetSafetyInputPortInv acsc_SetSafetyInputPortInv; ACSC_SetTimeout acsc_SetTimeout; ACSC_SetVelocity acsc_SetVelocity; ACSC_SetVelocityImm acsc_SetVelocityImm; ACSC_Slave acsc_Slave; ACSC_SlaveStalled acsc_SlaveStalled; ACSC_Spline acsc_Spline; ACSC_SplineM acsc_SplineM; ACSC_Split acsc_Split; ACSC_SplitAll acsc_SplitAll; ACSC_StopBuffer acsc_StopBuffer; ACSC_StopCollect acsc_StopCollect; ACSC_Stopper acsc_Stopper; ACSC_SuspendBuffer acsc_SuspendBuffer; ACSC_ToPoint acsc_ToPoint; ACSC_ToPointM acsc_ToPointM; ACSC_Transaction acsc_Transaction; ACSC_UploadBuffer acsc_UploadBuffer; ACSC_WaitCollectEnd acsc_WaitCollectEnd; ACSC_WaitCollectEndExt acsc_WaitCollectEndExt; ACSC_WaitForAsyncCall acsc_WaitForAsyncCall; ACSC_WaitInput acsc_WaitInput; ACSC_WaitLogicalMotionEnd acsc_WaitLogicalMotionEnd; ACSC_WaitMotionEnd acsc_WaitMotionEnd; ACSC_WaitMotorEnabled acsc_WaitMotorEnabled; ACSC_WaitMotorCommutated acsc_WaitMotorCommutated; ACSC_WaitProgramEnd acsc_WaitProgramEnd; ACSC_WaitUserCondition acsc_WaitUserCondition; ACSC_WriteDPRAMInteger acsc_WriteDPRAMInteger; ACSC_WriteDPRAMReal acsc_WriteDPRAMReal; ACSC_WriteInteger acsc_WriteInteger; ACSC_WriteLogFile acsc_WriteLogFile; ACSC_WriteSCLogFile acsc_WriteSCLogFile; ACSC_WriteReal acsc_WriteReal; ACSC_LoadBufferIgnoreServiceLines acsc_LoadBufferIgnoreServiceLines; ACSC_LoadBuffersFromFile acsc_LoadBuffersFromFile; ACSC_PegI acsc_PegI; ACSC_PegR acsc_PegR; ACSC_PegInc acsc_PegInc; ACSC_PegRandom acsc_PegRandom; ACSC_AssignPins acsc_AssignPins; ACSC_StopPeg acsc_StopPeg; ACSC_AssignPegNT acsc_AssignPegNT; ACSC_AssignPegNTV2 acsc_AssignPegNTV2; ACSC_AssignPegOutputsNT acsc_AssignPegOutputsNT; ACSC_AssignFastInputsNT acsc_AssignFastInputsNT; ACSC_PegIncNT acsc_PegIncNT; ACSC_PegRandomNT acsc_PegRandomNT; ACSC_WaitPegReadyNT acsc_WaitPegReadyNT; ACSC_StartPegNT acsc_StartPegNT; ACSC_StopPegNT acsc_StopPegNT; ACSC_CollectB acsc_CollectB; ACSC_DataCollection acsc_DataCollection; ACSC_DataCollectionExt acsc_DataCollectionExt; ACSC_AddPVPoint acsc_AddPVPoint; ACSC_AddPVPointM acsc_AddPVPointM; ACSC_AddPVTPoint acsc_AddPVTPoint; ACSC_AddPVTPointM acsc_AddPVTPointM; ACSC_LoadFileToRealVariable acsc_LoadFileToRealVariable; ACSC_LoadFileToIntegerVariable acsc_LoadFileToIntegerVariable; ACSC_LoadDataToController acsc_LoadDataToController; ACSC_UploadDataFromController acsc_UploadDataFromController; ACSC_SetQueueOverflowTimeout acsc_SetQueueOverflowTimeout; ACSC_GetQueueOverflowTimeout acsc_GetQueueOverflowTimeout; ACSC_SetTargetPosition acsc_SetTargetPosition; ACSC_GetTargetPosition acsc_GetTargetPosition; ACSC_SetTargetPositionM acsc_SetTargetPositionM; ACSC_Track acsc_Track; ACSC_TrackM acsc_TrackM; ACSC_FaultClearM acsc_FaultClearM; ACSC_FaultClear acsc_FaultClear; ACSC_Getconf acsc_Getconf; ACSC_Setconf acsc_Setconf; ACSC_GetConf acsc_GetConf; ACSC_SetConf acsc_SetConf; ACSC_SysInfo acsc_SysInfo; ACSC_GetAxesCount acsc_GetAxesCount; ACSC_GetBuffersCount acsc_GetBuffersCount; ACSC_GetDBufferIndex acsc_GetDBufferIndex; ACSC_SetCallbackExt acsc_SetCallbackExt; ACSC_InstallCallback acsc_InstallCallback; ACSC_InstallCallbackExt acsc_InstallCallbackExt; ACSC_DownloadBinVariableToFile acsc_DownloadBinVariableToFile; ACSC_SetLogFileOptions acsc_SetLogFileOptions; ACSC_SetServer acsc_SetServer; ACSC_SetServerExt acsc_SetServerExt; ACSC_SetServerExtLogin acsc_SetServerExtLogin; ACSC_GetSingleMessage acsc_GetSingleMessage; ACSC_GetConnectionsList acsc_GetConnectionsList; ACSC_GetConnectionInfo acsc_GetConnectionInfo; ACSC_TerminateConnection acsc_TerminateConnection; ACSC_GetLogData acsc_GetLogData; ACSC_RegisterEmergencyStop acsc_RegisterEmergencyStop; ACSC_UnregisterEmergencyStop acsc_UnregisterEmergencyStop; ACSC_GetUMDVersion acsc_GetUMDVersion; ACSC_AnalyzeApplication acsc_AnalyzeApplication; ACSC_FreeApplication acsc_FreeApplication; ACSC_SaveApplication acsc_SaveApplication; ACSC_LoadApplication acsc_LoadApplication; ACSC_FFT acsc_FFT; ACSC_FRF_Measure acsc_FRF_Measure; ACSC_FRF_Stop acsc_FRF_Stop; ACSC_FRF_CalculateMeasurementDuration acsc_FRF_CalculateMeasurementDuration; ACSC_FRF_InitInput acsc_FRF_InitInput; ACSC_FRF_FreeOutput acsc_FRF_FreeOutput; ACSC_FRF_ReadServoParameters acsc_FRF_ReadServoParameters; ACSC_FRF_CalculateControllerFRD acsc_FRF_CalculateControllerFRD; ACSC_FRF_CalculateOpenLoopFRD acsc_FRF_CalculateOpenLoopFRD; ACSC_FRF_CalculateClosedLoopFRD acsc_FRF_CalculateClosedLoopFRD; ACSC_FRF_CalculateStabilityMargins acsc_FRF_CalculateStabilityMargins; ACSC_FRF_FreeFRD acsc_FRF_FreeFRD; ACSC_FRF_FreeStabilityMargins acsc_FRF_FreeStabilityMargins; ACSC_JitterAnalysis acsc_JitterAnalysis; ACSC_JitterAnalysis_FreeOutput acsc_JitterAnalysis_FreeOutput; ACSC_ControllerReboot acsc_ControllerReboot; ACSC_ControllerFactoryDefault acsc_ControllerFactoryDefault; ACSC_ControllerSaveToFlash acsc_ControllerSaveToFlash; ACSC_GetSharedMemoryAddress acsc_GetSharedMemoryAddress; ACSC_ReadSharedMemoryReal acsc_ReadSharedMemoryReal; ACSC_ReadSharedMemoryInteger acsc_ReadSharedMemoryInteger; ACSC_WriteSharedMemoryReal acsc_WriteSharedMemoryReal; ACSC_WriteSharedMemoryInteger acsc_WriteSharedMemoryInteger; ACSC_GetEtherCATState acsc_GetEtherCATState; ACSC_GetEtherCATError acsc_GetEtherCATError; ACSC_MapEtherCATInput acsc_MapEtherCATInput; ACSC_MapEtherCATOutput acsc_MapEtherCATOutput; ACSC_UnmapEtherCATInputsOutputs acsc_UnmapEtherCATInputsOutputs; ACSC_GetEtherCATSlaveIndex acsc_GetEtherCATSlaveIndex; ACSC_GetEtherCATSlaveOffset acsc_GetEtherCATSlaveOffset; ACSC_GetEtherCATSlaveVendorID acsc_GetEtherCATSlaveVendorID; ACSC_GetEtherCATSlaveProductID acsc_GetEtherCATSlaveProductID; ACSC_GetEtherCATSlaveRevision acsc_GetEtherCATSlaveRevision; ACSC_GetEtherCATSlaveType acsc_GetEtherCATSlaveType; ACSC_GetEtherCATSlaveState acsc_GetEtherCATSlaveState; ACSC_DownloadFileOverEtherCAT acsc_DownloadFileOverEtherCAT; ACSC_ReadSDOValueOverEtherCAT acsc_ReadSDOValueOverEtherCAT; ACSC_WriteSDOValueOverEtherCAT acsc_WriteSDOValueOverEtherCAT; ACSC_CopyFileToController acsc_CopyFileToController; ACSC_DeleteFileFromController acsc_DeleteFileFromController; ACSC_SegmentedMotion acsc_SegmentedMotion; ACSC_ExtendedSegmentedMotion acsc_ExtendedSegmentedMotion; ACSC_ExtendedSegmentedMotionExt acsc_ExtendedSegmentedMotionExt; ACSC_ExtendedSegmentedMotionV2 acsc_ExtendedSegmentedMotionV2; ACSC_SegmentLine acsc_SegmentLine; ACSC_SegmentLineExt acsc_SegmentLineExt; ACSC_SegmentLineV2 acsc_SegmentLineV2; ACSC_SegmentArc1 acsc_SegmentArc1; ACSC_SegmentArc1Ext acsc_SegmentArc1Ext; ACSC_SegmentArc2 acsc_SegmentArc2; ACSC_SegmentArc2Ext acsc_SegmentArc2Ext; ACSC_ExtendedSegmentArc1 acsc_ExtendedSegmentArc1; ACSC_ExtendedSegmentArc2 acsc_ExtendedSegmentArc2; ACSC_SegmentArc1V2 acsc_SegmentArc1V2; ACSC_SegmentArc2V2 acsc_SegmentArc2V2; ACSC_BlendedSegmentMotion acsc_BlendedSegmentMotion; ACSC_BlendedLine acsc_BlendedLine; ACSC_BlendedArc1 acsc_BlendedArc1; ACSC_BlendedArc2 acsc_BlendedArc2; ACSC_GetAnalogInputNT acsc_GetAnalogInputNT; ACSC_GetAnalogOutputNT acsc_GetAnalogOutputNT; ACSC_SetAnalogOutputNT acsc_SetAnalogOutputNT; ACSC_GetVolatileMemoryUsage acsc_GetVolatileMemoryUsage; ACSC_GetVolatileMemoryTotal acsc_GetVolatileMemoryTotal; ACSC_GetVolatileMemoryFree acsc_GetVolatileMemoryFree; ACSC_GetNonVolatileMemoryUsage acsc_GetNonVolatileMemoryUsage; ACSC_GetNonVolatileMemoryTotal acsc_GetNonVolatileMemoryTotal; ACSC_GetNonVolatileMemoryFree acsc_GetNonVolatileMemoryFree; ACSC_StartSPiiPlusSC acsc_StartSPiiPlusSC; ACSC_StopSPiiPlusSC acsc_StopSPiiPlusSC; ACSC_NurbsMotion acsc_NurbsMotion; ACSC_NurbsPoints acsc_NurbsPoints; ACSC_SmoothPathMotion acsc_SmoothPathMotion; ACSC_SmoothPathSegment acsc_SmoothPathSegment; static HMODULE hACSCLibraryModule; ////////////////////////////////////////////////////////////////////////////////////////////////// // The function loads ACSCL_x86.DLL and obtains addresses for all exported functions. // Call this function before any using of ACSC API. // Check return value for success. ////////////////////////////////////////////////////////////////////////////////////////////////// static int InitACSCLibrary() { hACSCLibraryModule = LoadLibrary("ACSCL_x86.dll"); if (hACSCLibraryModule == NULL) return 0; acsc_AddMPoint = (ACSC_AddMPoint)GetProcAddress(hACSCLibraryModule, "_acsc_AddMPoint@20"); // 2 acsc_AddMPointM = (ACSC_AddMPointM)GetProcAddress(hACSCLibraryModule, "_acsc_AddMPointM@20"); // 3 acsc_AddPoint = (ACSC_AddPoint)GetProcAddress(hACSCLibraryModule, "_acsc_AddPoint@20"); // 4 acsc_AddPointM = (ACSC_AddPointM)GetProcAddress(hACSCLibraryModule, "_acsc_AddPointM@16"); // 5 acsc_AppendBuffer = (ACSC_AppendBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_AppendBuffer@20"); // 6 acsc_Arc1 = (ACSC_Arc1)GetProcAddress(hACSCLibraryModule, "_acsc_Arc1@24"); // 7 acsc_Arc2 = (ACSC_Arc2)GetProcAddress(hACSCLibraryModule, "_acsc_Arc2@24"); // 8 acsc_Break = (ACSC_Break)GetProcAddress(hACSCLibraryModule, "_acsc_Break@12"); // 9 acsc_BreakM = (ACSC_BreakM)GetProcAddress(hACSCLibraryModule, "_acsc_BreakM@12"); // 10 acsc_CancelOperation = (ACSC_CancelOperation)GetProcAddress(hACSCLibraryModule, "_acsc_CancelOperation@8"); // 11 acsc_CaptureComm = (ACSC_CaptureComm)GetProcAddress(hACSCLibraryModule, "_acsc_CaptureComm@4"); // 12 acsc_ClearBuffer = (ACSC_ClearBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_ClearBuffer@20"); // 13 acsc_ClearVariables = (ACSC_ClearVariables)GetProcAddress(hACSCLibraryModule, "_acsc_ClearVariables@8"); // 14 acsc_CloseComm = (ACSC_CloseComm)GetProcAddress(hACSCLibraryModule, "_acsc_CloseComm@4"); // 15 acsc_CloseHistoryBuffer = (ACSC_CloseHistoryBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_CloseHistoryBuffer@4"); // 16 acsc_CloseLogFile = (ACSC_CloseLogFile)GetProcAddress(hACSCLibraryModule, "_acsc_CloseLogFile@4"); // 17 acsc_CloseMessageBuffer = (ACSC_CloseMessageBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_CloseMessageBuffer@4"); // 18 acsc_Collect = (ACSC_Collect)GetProcAddress(hACSCLibraryModule, "_acsc_Collect@28"); // 19 acsc_Command = (ACSC_Command)GetProcAddress(hACSCLibraryModule, "_acsc_Command@16"); // 20 acsc_CompileBuffer = (ACSC_CompileBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_CompileBuffer@12"); // 21 acsc_DeclareVariable = (ACSC_DeclareVariable)GetProcAddress(hACSCLibraryModule, "_acsc_DeclareVariable@16"); // 22 acsc_Disable = (ACSC_Disable)GetProcAddress(hACSCLibraryModule, "_acsc_Disable@12"); // 23 acsc_DisableAll = (ACSC_DisableAll)GetProcAddress(hACSCLibraryModule, "_acsc_DisableAll@8"); // 24 acsc_DisableFault = (ACSC_DisableFault)GetProcAddress(hACSCLibraryModule, "_acsc_DisableFault@16"); // 25 acsc_DisableM = (ACSC_DisableM)GetProcAddress(hACSCLibraryModule, "_acsc_DisableM@12"); // 26 acsc_DisableResponse = (ACSC_DisableResponse)GetProcAddress(hACSCLibraryModule, "_acsc_DisableResponse@16"); // 27 acsc_DownloadBuffer = (ACSC_DownloadBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_DownloadBuffer@20"); // 28 acsc_Enable = (ACSC_Enable)GetProcAddress(hACSCLibraryModule, "_acsc_Enable@12"); // 29 acsc_EnableFault = (ACSC_EnableFault)GetProcAddress(hACSCLibraryModule, "_acsc_EnableFault@16"); // 30 acsc_EnableM = (ACSC_EnableM)GetProcAddress(hACSCLibraryModule, "_acsc_EnableM@12"); // 31 acsc_EnableResponse = (ACSC_EnableResponse)GetProcAddress(hACSCLibraryModule, "_acsc_EnableResponse@16"); // 32 acsc_EndSequence = (ACSC_EndSequence)GetProcAddress(hACSCLibraryModule, "_acsc_EndSequence@12"); // 33 acsc_EndSequenceM = (ACSC_EndSequenceM)GetProcAddress(hACSCLibraryModule, "_acsc_EndSequenceM@12"); // 34 acsc_ExtAddPoint = (ACSC_ExtAddPoint)GetProcAddress(hACSCLibraryModule, "_acsc_ExtAddPoint@28"); // 35 acsc_ExtAddPointM = (ACSC_ExtAddPointM)GetProcAddress(hACSCLibraryModule, "_acsc_ExtAddPointM@24"); // 36 acsc_ExtArc1 = (ACSC_ExtArc1)GetProcAddress(hACSCLibraryModule, "_acsc_ExtArc1@32"); // 37 acsc_ExtArc2 = (ACSC_ExtArc2)GetProcAddress(hACSCLibraryModule, "_acsc_ExtArc2@32"); // 38 acsc_ExtLine = (ACSC_ExtLine)GetProcAddress(hACSCLibraryModule, "_acsc_ExtLine@24"); // 39 acsc_ExtToPoint = (ACSC_ExtToPoint)GetProcAddress(hACSCLibraryModule, "_acsc_ExtToPoint@40"); // 40 acsc_ExtToPointM = (ACSC_ExtToPointM)GetProcAddress(hACSCLibraryModule, "_acsc_ExtToPointM@36"); // 41 acsc_GetAcceleration = (ACSC_GetAcceleration)GetProcAddress(hACSCLibraryModule, "_acsc_GetAcceleration@16"); // 42 acsc_GetAnalogInput = (ACSC_GetAnalogInput)GetProcAddress(hACSCLibraryModule, "_acsc_GetAnalogInput@16"); // 43 acsc_GetAnalogOutput = (ACSC_GetAnalogOutput)GetProcAddress(hACSCLibraryModule, "_acsc_GetAnalogOutput@16"); // 44 acsc_GetAxisState = (ACSC_GetAxisState)GetProcAddress(hACSCLibraryModule, "_acsc_GetAxisState@16"); // 45 acsc_GetCommOptions = (ACSC_GetCommOptions)GetProcAddress(hACSCLibraryModule, "_acsc_GetCommOptions@8"); // 46 acsc_GetDeceleration = (ACSC_GetDeceleration)GetProcAddress(hACSCLibraryModule, "_acsc_GetDeceleration@16"); // 47 acsc_GetDefaultTimeout = (ACSC_GetDefaultTimeout)GetProcAddress(hACSCLibraryModule, "_acsc_GetDefaultTimeout@4"); // 48 acsc_GetErrorString = (ACSC_GetErrorString)GetProcAddress(hACSCLibraryModule, "_acsc_GetErrorString@20"); // 49 acsc_GetExtInput = (ACSC_GetExtInput)GetProcAddress(hACSCLibraryModule, "_acsc_GetExtInput@20"); // 50 acsc_GetExtInputPort = (ACSC_GetExtInputPort)GetProcAddress(hACSCLibraryModule, "_acsc_GetExtInputPort@16"); // 51 acsc_GetExtOutput = (ACSC_GetExtOutput)GetProcAddress(hACSCLibraryModule, "_acsc_GetExtOutput@20"); // 52 acsc_GetExtOutputPort = (ACSC_GetExtOutputPort)GetProcAddress(hACSCLibraryModule, "_acsc_GetExtOutputPort@16"); // 53 acsc_GetFPosition = (ACSC_GetFPosition)GetProcAddress(hACSCLibraryModule, "_acsc_GetFPosition@16"); // 54 acsc_GetFVelocity = (ACSC_GetFVelocity)GetProcAddress(hACSCLibraryModule, "_acsc_GetFVelocity@16"); // 55 acsc_GetFault = (ACSC_GetFault)GetProcAddress(hACSCLibraryModule, "_acsc_GetFault@16"); // 56 acsc_GetFaultMask = (ACSC_GetFaultMask)GetProcAddress(hACSCLibraryModule, "_acsc_GetFaultMask@16"); // 57 acsc_GetFirmwareVersion = (ACSC_GetFirmwareVersion)GetProcAddress(hACSCLibraryModule, "_acsc_GetFirmwareVersion@20"); // 58 acsc_GetHistory = (ACSC_GetHistory)GetProcAddress(hACSCLibraryModule, "_acsc_GetHistory@20"); // 59 acsc_GetIndexState = (ACSC_GetIndexState)GetProcAddress(hACSCLibraryModule, "_acsc_GetIndexState@16"); // 60 acsc_GetInput = (ACSC_GetInput)GetProcAddress(hACSCLibraryModule, "_acsc_GetInput@20"); // 61 acsc_GetInputPort = (ACSC_GetInputPort)GetProcAddress(hACSCLibraryModule, "_acsc_GetInputPort@16"); // 62 acsc_GetInterruptMask = (ACSC_GetInterruptMask)GetProcAddress(hACSCLibraryModule, "_acsc_GetInterruptMask@12"); // 63 acsc_GetJerk = (ACSC_GetJerk)GetProcAddress(hACSCLibraryModule, "_acsc_GetJerk@16"); // 64 acsc_GetKillDeceleration = (ACSC_GetKillDeceleration)GetProcAddress(hACSCLibraryModule, "_acsc_GetKillDeceleration@16"); // 65 acsc_GetLastError = (ACSC_GetLastError)GetProcAddress(hACSCLibraryModule, "_acsc_GetLastError@0"); // 66 acsc_GetLibraryVersion = (ACSC_GetLibraryVersion)GetProcAddress(hACSCLibraryModule, "_acsc_GetLibraryVersion@0"); // 67 acsc_GetMessage = (ACSC_GetMessage)GetProcAddress(hACSCLibraryModule, "_acsc_GetMessage@20"); // 68 acsc_GetMotionError = (ACSC_GetMotionError)GetProcAddress(hACSCLibraryModule, "_acsc_GetMotionError@16"); // 69 acsc_GetMotorError = (ACSC_GetMotorError)GetProcAddress(hACSCLibraryModule, "_acsc_GetMotorError@16"); // 70 acsc_GetMotorState = (ACSC_GetMotorState)GetProcAddress(hACSCLibraryModule, "_acsc_GetMotorState@16"); // 71 acsc_GetOutput = (ACSC_GetOutput)GetProcAddress(hACSCLibraryModule, "_acsc_GetOutput@20"); // 72 acsc_GetOutputPort = (ACSC_GetOutputPort)GetProcAddress(hACSCLibraryModule, "_acsc_GetOutputPort@16"); // 73 acsc_GetPCICards = (ACSC_GetPCICards)GetProcAddress(hACSCLibraryModule, "_acsc_GetPCICards@12"); // 74 acsc_GetProgramError = (ACSC_GetProgramError)GetProcAddress(hACSCLibraryModule, "_acsc_GetProgramError@16"); // 75 acsc_GetProgramState = (ACSC_GetProgramState)GetProcAddress(hACSCLibraryModule, "_acsc_GetProgramState@16"); // 76 acsc_GetRPosition = (ACSC_GetRPosition)GetProcAddress(hACSCLibraryModule, "_acsc_GetRPosition@16"); // 77 acsc_GetRVelocity = (ACSC_GetRVelocity)GetProcAddress(hACSCLibraryModule, "_acsc_GetRVelocity@16"); // 78 acsc_GetResponseMask = (ACSC_GetResponseMask)GetProcAddress(hACSCLibraryModule, "_acsc_GetResponseMask@16"); // 79 acsc_GetSafetyInput = (ACSC_GetSafetyInput)GetProcAddress(hACSCLibraryModule, "_acsc_GetSafetyInput@20"); // 80 acsc_GetSafetyInputPort = (ACSC_GetSafetyInputPort)GetProcAddress(hACSCLibraryModule, "_acsc_GetSafetyInputPort@16"); // 81 acsc_GetSafetyInputPortInv = (ACSC_GetSafetyInputPortInv)GetProcAddress(hACSCLibraryModule, "_acsc_GetSafetyInputPortInv@16"); // 82 acsc_GetSerialNumber = (ACSC_GetSerialNumber)GetProcAddress(hACSCLibraryModule, "_acsc_GetSerialNumber@20"); // 83 acsc_GetTimeout = (ACSC_GetTimeout)GetProcAddress(hACSCLibraryModule, "_acsc_GetTimeout@4"); // 84 acsc_GetVelocity = (ACSC_GetVelocity)GetProcAddress(hACSCLibraryModule, "_acsc_GetVelocity@16"); // 85 acsc_Go = (ACSC_Go)GetProcAddress(hACSCLibraryModule, "_acsc_Go@12"); // 86 acsc_GoM = (ACSC_GoM)GetProcAddress(hACSCLibraryModule, "_acsc_GoM@12"); // 87 acsc_Group = (ACSC_Group)GetProcAddress(hACSCLibraryModule, "_acsc_Group@12"); // 88 acsc_Halt = (ACSC_Halt)GetProcAddress(hACSCLibraryModule, "_acsc_Halt@12"); // 89 acsc_HaltM = (ACSC_HaltM)GetProcAddress(hACSCLibraryModule, "_acsc_HaltM@12"); // 90 acsc_Jog = (ACSC_Jog)GetProcAddress(hACSCLibraryModule, "_acsc_Jog@24"); // 91 acsc_JogM = (ACSC_JogM)GetProcAddress(hACSCLibraryModule, "_acsc_JogM@28"); // 92 acsc_Kill = (ACSC_Kill)GetProcAddress(hACSCLibraryModule, "_acsc_Kill@12"); // 93 acsc_KillAll = (ACSC_KillAll)GetProcAddress(hACSCLibraryModule, "_acsc_KillAll@8"); // 94 acsc_KillM = (ACSC_KillM)GetProcAddress(hACSCLibraryModule, "_acsc_KillM@12"); // 95 acsc_Line = (ACSC_Line)GetProcAddress(hACSCLibraryModule, "_acsc_Line@16"); // 96 acsc_LoadBuffer = (ACSC_LoadBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_LoadBuffer@20"); // 97 acsc_MultiPoint = (ACSC_MultiPoint)GetProcAddress(hACSCLibraryModule, "_acsc_MultiPoint@24"); // 98 acsc_MultiPointM = (ACSC_MultiPointM)GetProcAddress(hACSCLibraryModule, "_acsc_MultiPointM@24"); // 99 acsc_OpenCommDirect = (ACSC_OpenCommDirect)GetProcAddress(hACSCLibraryModule, "_acsc_OpenCommDirect@0"); // 100 acsc_OpenCommEthernet = (ACSC_OpenCommEthernet)GetProcAddress(hACSCLibraryModule, "_acsc_OpenCommEthernet@8"); // 101 acsc_OpenCommPCI = (ACSC_OpenCommPCI)GetProcAddress(hACSCLibraryModule, "_acsc_OpenCommPCI@4"); // 102 acsc_OpenCommSerial = (ACSC_OpenCommSerial)GetProcAddress(hACSCLibraryModule, "_acsc_OpenCommSerial@8"); // 103 acsc_OpenHistoryBuffer = (ACSC_OpenHistoryBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_OpenHistoryBuffer@8"); // 104 acsc_OpenLogFile = (ACSC_OpenLogFile)GetProcAddress(hACSCLibraryModule, "_acsc_OpenLogFile@8"); // 105 acsc_OpenMessageBuffer = (ACSC_OpenMessageBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_OpenMessageBuffer@8"); // 106 acsc_Projection = (ACSC_Projection)GetProcAddress(hACSCLibraryModule, "_acsc_Projection@16"); // 107 acsc_ReadDPRAMInteger = (ACSC_ReadDPRAMInteger)GetProcAddress(hACSCLibraryModule, "_acsc_ReadDPRAMInteger@12"); // 108 acsc_ReadDPRAMReal = (ACSC_ReadDPRAMReal)GetProcAddress(hACSCLibraryModule, "_acsc_ReadDPRAMReal@12"); // 109 acsc_ReadInteger = (ACSC_ReadInteger)GetProcAddress(hACSCLibraryModule, "_acsc_ReadInteger@36"); // 110 acsc_ReadReal = (ACSC_ReadReal)GetProcAddress(hACSCLibraryModule, "_acsc_ReadReal@36"); // 111 acsc_Receive = (ACSC_Receive)GetProcAddress(hACSCLibraryModule, "_acsc_Receive@20"); // 112 acsc_ReleaseComm = (ACSC_ReleaseComm)GetProcAddress(hACSCLibraryModule, "_acsc_ReleaseComm@4"); // 113 acsc_ResetIndexState = (ACSC_ResetIndexState)GetProcAddress(hACSCLibraryModule, "_acsc_ResetIndexState@16"); // 114 acsc_RunBuffer = (ACSC_RunBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_RunBuffer@16"); // 115 acsc_Segment = (ACSC_Segment)GetProcAddress(hACSCLibraryModule, "_acsc_Segment@20"); // 116 acsc_Send = (ACSC_Send)GetProcAddress(hACSCLibraryModule, "_acsc_Send@16"); // 117 acsc_SetAcceleration = (ACSC_SetAcceleration)GetProcAddress(hACSCLibraryModule, "_acsc_SetAcceleration@20"); // 118 acsc_SetAccelerationImm = (ACSC_SetAccelerationImm)GetProcAddress(hACSCLibraryModule, "_acsc_SetAccelerationImm@20"); // 119 acsc_SetAnalogOutput = (ACSC_SetAnalogOutput)GetProcAddress(hACSCLibraryModule, "_acsc_SetAnalogOutput@16"); // 120 acsc_SetCallback = (ACSC_SetCallback)GetProcAddress(hACSCLibraryModule, "_acsc_SetCallback@12"); // 121 acsc_SetCallbackPriority = (ACSC_SetCallbackPriority)GetProcAddress(hACSCLibraryModule, "_acsc_SetCallbackPriority@8"); // 122 acsc_SetCommOptions = (ACSC_SetCommOptions)GetProcAddress(hACSCLibraryModule, "_acsc_SetCommOptions@8"); // 123 acsc_SetDeceleration = (ACSC_SetDeceleration)GetProcAddress(hACSCLibraryModule, "_acsc_SetDeceleration@20"); // 124 acsc_SetDecelerationImm = (ACSC_SetDecelerationImm)GetProcAddress(hACSCLibraryModule, "_acsc_SetDecelerationImm@20"); // 125 acsc_SetExtOutput = (ACSC_SetExtOutput)GetProcAddress(hACSCLibraryModule, "_acsc_SetExtOutput@20"); // 126 acsc_SetExtOutputPort = (ACSC_SetExtOutputPort)GetProcAddress(hACSCLibraryModule, "_acsc_SetExtOutputPort@16"); // 127 acsc_SetFPosition = (ACSC_SetFPosition)GetProcAddress(hACSCLibraryModule, "_acsc_SetFPosition@20"); // 128 acsc_SetFaultMask = (ACSC_SetFaultMask)GetProcAddress(hACSCLibraryModule, "_acsc_SetFaultMask@16"); // 129 acsc_SetInterruptMask = (ACSC_SetInterruptMask)GetProcAddress(hACSCLibraryModule, "_acsc_SetInterruptMask@12"); // 130 acsc_SetIterations = (ACSC_SetIterations)GetProcAddress(hACSCLibraryModule, "_acsc_SetIterations@8"); // 131 acsc_SetJerk = (ACSC_SetJerk)GetProcAddress(hACSCLibraryModule, "_acsc_SetJerk@20"); // 132 acsc_SetJerkImm = (ACSC_SetJerkImm)GetProcAddress(hACSCLibraryModule, "_acsc_SetJerkImm@20"); // 133 acsc_SetKillDeceleration = (ACSC_SetKillDeceleration)GetProcAddress(hACSCLibraryModule, "_acsc_SetKillDeceleration@20"); // 134 acsc_SetKillDecelerationImm = (ACSC_SetKillDecelerationImm)GetProcAddress(hACSCLibraryModule, "_acsc_SetKillDecelerationImm@20"); // 135 acsc_SetMaster = (ACSC_SetMaster)GetProcAddress(hACSCLibraryModule, "_acsc_SetMaster@16"); // 136 acsc_SetOutput = (ACSC_SetOutput)GetProcAddress(hACSCLibraryModule, "_acsc_SetOutput@20"); // 137 acsc_SetOutputPort = (ACSC_SetOutputPort)GetProcAddress(hACSCLibraryModule, "_acsc_SetOutputPort@16"); // 138 acsc_SetRPosition = (ACSC_SetRPosition)GetProcAddress(hACSCLibraryModule, "_acsc_SetRPosition@20"); // 139 acsc_SetResponseMask = (ACSC_SetResponseMask)GetProcAddress(hACSCLibraryModule, "_acsc_SetResponseMask@16"); // 140 acsc_SetSafetyInputPortInv = (ACSC_SetSafetyInputPortInv)GetProcAddress(hACSCLibraryModule, "_acsc_SetSafetyInputPortInv@16"); // 141 acsc_SetTimeout = (ACSC_SetTimeout)GetProcAddress(hACSCLibraryModule, "_acsc_SetTimeout@8"); // 142 acsc_SetVelocity = (ACSC_SetVelocity)GetProcAddress(hACSCLibraryModule, "_acsc_SetVelocity@20"); // 143 acsc_SetVelocityImm = (ACSC_SetVelocityImm)GetProcAddress(hACSCLibraryModule, "_acsc_SetVelocityImm@20"); // 144 acsc_Slave = (ACSC_Slave)GetProcAddress(hACSCLibraryModule, "_acsc_Slave@16"); // 145 acsc_SlaveStalled = (ACSC_SlaveStalled)GetProcAddress(hACSCLibraryModule, "_acsc_SlaveStalled@32"); // 146 acsc_Spline = (ACSC_Spline)GetProcAddress(hACSCLibraryModule, "_acsc_Spline@24"); // 147 acsc_SplineM = (ACSC_SplineM)GetProcAddress(hACSCLibraryModule, "_acsc_SplineM@24"); // 148 acsc_Split = (ACSC_Split)GetProcAddress(hACSCLibraryModule, "_acsc_Split@12"); // 149 acsc_SplitAll = (ACSC_SplitAll)GetProcAddress(hACSCLibraryModule, "_acsc_SplitAll@8"); // 150 acsc_StopBuffer = (ACSC_StopBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_StopBuffer@12"); // 151 acsc_StopCollect = (ACSC_StopCollect)GetProcAddress(hACSCLibraryModule, "_acsc_StopCollect@8"); // 152 acsc_Stopper = (ACSC_Stopper)GetProcAddress(hACSCLibraryModule, "_acsc_Stopper@12"); // 153 acsc_SuspendBuffer = (ACSC_SuspendBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_SuspendBuffer@12"); // 154 acsc_ToPoint = (ACSC_ToPoint)GetProcAddress(hACSCLibraryModule, "_acsc_ToPoint@24"); // 155 acsc_ToPointM = (ACSC_ToPointM)GetProcAddress(hACSCLibraryModule, "_acsc_ToPointM@20"); // 156 acsc_Transaction = (ACSC_Transaction)GetProcAddress(hACSCLibraryModule, "_acsc_Transaction@28"); // 157 acsc_UploadBuffer = (ACSC_UploadBuffer)GetProcAddress(hACSCLibraryModule, "_acsc_UploadBuffer@28"); // 158 acsc_WaitCollectEnd = (ACSC_WaitCollectEnd)GetProcAddress(hACSCLibraryModule, "_acsc_WaitCollectEnd@8"); // 159 acsc_WaitForAsyncCall = (ACSC_WaitForAsyncCall)GetProcAddress(hACSCLibraryModule, "_acsc_WaitForAsyncCall@20"); // 160 acsc_WaitInput = (ACSC_WaitInput)GetProcAddress(hACSCLibraryModule, "_acsc_WaitInput@20"); // 161 acsc_WaitLogicalMotionEnd = (ACSC_WaitLogicalMotionEnd)GetProcAddress(hACSCLibraryModule, "_acsc_WaitLogicalMotionEnd@12"); // 162 acsc_WaitMotionEnd = (ACSC_WaitMotionEnd)GetProcAddress(hACSCLibraryModule, "_acsc_WaitMotionEnd@12"); // 163 acsc_WaitMotorEnabled = (ACSC_WaitMotorEnabled)GetProcAddress(hACSCLibraryModule, "_acsc_WaitMotorEnabled@16"); // 164 acsc_WaitProgramEnd = (ACSC_WaitProgramEnd)GetProcAddress(hACSCLibraryModule, "_acsc_WaitProgramEnd@12"); // 165 acsc_WaitUserCondition = (ACSC_WaitUserCondition)GetProcAddress(hACSCLibraryModule, "_acsc_WaitUserCondition@12"); // 166 acsc_WriteDPRAMInteger = (ACSC_WriteDPRAMInteger)GetProcAddress(hACSCLibraryModule, "_acsc_WriteDPRAMInteger@12"); // 167 acsc_WriteDPRAMReal = (ACSC_WriteDPRAMReal)GetProcAddress(hACSCLibraryModule, "_acsc_WriteDPRAMReal@16"); // 168 acsc_WriteInteger = (ACSC_WriteInteger)GetProcAddress(hACSCLibraryModule, "_acsc_WriteInteger@36"); // 169 acsc_WriteLogFile = (ACSC_WriteLogFile)GetProcAddress(hACSCLibraryModule, "_acsc_WriteLogFile@12"); // 170 acsc_WriteReal = (ACSC_WriteReal)GetProcAddress(hACSCLibraryModule, "_acsc_WriteReal@36"); // 171 acsc_LoadBufferIgnoreServiceLines = (ACSC_LoadBufferIgnoreServiceLines)GetProcAddress(hACSCLibraryModule, "_acsc_LoadBufferIgnoreServiceLines@20"); // 196 acsc_PegI = (ACSC_PegI)GetProcAddress(hACSCLibraryModule, "_acsc_PegI@48"); // 197 acsc_PegR = (ACSC_PegR)GetProcAddress(hACSCLibraryModule, "_acsc_PegR@44"); // 198 acsc_AssignPins = (ACSC_AssignPins)GetProcAddress(hACSCLibraryModule, "_acsc_AssignPins@16"); // 199 acsc_StopPeg = (ACSC_StopPeg)GetProcAddress(hACSCLibraryModule, "_acsc_StopPeg@12"); // 200 acsc_CollectB = (ACSC_CollectB)GetProcAddress(hACSCLibraryModule, "_acsc_CollectB@28"); // 201 acsc_AddPVPoint = (ACSC_AddPVPoint)GetProcAddress(hACSCLibraryModule, "_acsc_AddPVPoint@28"); // 202 acsc_AddPVPointM = (ACSC_AddPVPointM)GetProcAddress(hACSCLibraryModule, "_acsc_AddPVPointM@20"); // 203 acsc_AddPVTPoint = (ACSC_AddPVTPoint)GetProcAddress(hACSCLibraryModule, "_acsc_AddPVTPoint@36"); // 204 acsc_AddPVTPointM = (ACSC_AddPVTPointM)GetProcAddress(hACSCLibraryModule, "_acsc_AddPVTPointM@28"); // 205 acsc_LoadFileToRealVariable = (ACSC_LoadFileToRealVariable)GetProcAddress(hACSCLibraryModule, "_acsc_LoadFileToRealVariable@36"); // 206 acsc_LoadFileToIntegerVariable = (ACSC_LoadFileToIntegerVariable)GetProcAddress(hACSCLibraryModule, "_acsc_LoadFileToIntegerVariable@36"); // 207 acsc_SetQueueOverflowTimeout = (ACSC_SetQueueOverflowTimeout)GetProcAddress(hACSCLibraryModule, "_acsc_SetQueueOverflowTimeout@8"); // 208 acsc_GetQueueOverflowTimeout = (ACSC_GetQueueOverflowTimeout)GetProcAddress(hACSCLibraryModule, "_acsc_GetQueueOverflowTimeout@4"); // 209 acsc_LoadBuffersFromFile = (ACSC_LoadBuffersFromFile)GetProcAddress(hACSCLibraryModule, "_acsc_LoadBuffersFromFile@12"); // 210 acsc_SetTargetPosition = (ACSC_SetTargetPosition)GetProcAddress(hACSCLibraryModule, "_acsc_SetTargetPosition@20"); // 211 acsc_GetTargetPosition = (ACSC_GetTargetPosition)GetProcAddress(hACSCLibraryModule, "_acsc_GetTargetPosition@16"); // 212 acsc_SetTargetPositionM = (ACSC_SetTargetPositionM)GetProcAddress(hACSCLibraryModule, "_acsc_SetTargetPositionM@16"); // 213 acsc_Track = (ACSC_Track)GetProcAddress(hACSCLibraryModule, "_acsc_Track@16"); // 214 acsc_TrackM = (ACSC_TrackM)GetProcAddress(hACSCLibraryModule, "_acsc_TrackM@16"); // 215 acsc_FaultClearM = (ACSC_FaultClearM)GetProcAddress(hACSCLibraryModule, "_acsc_FaultClearM@12"); // 216 acsc_FaultClear = (ACSC_FaultClear)GetProcAddress(hACSCLibraryModule, "_acsc_FaultClear@12"); // 217 acsc_Getconf = (ACSC_Getconf)GetProcAddress(hACSCLibraryModule, "_acsc_Getconf@20"); // 218 acsc_Setconf = (ACSC_Setconf)GetProcAddress(hACSCLibraryModule, "_acsc_Setconf@20"); // 219 acsc_SetCallbackExt = (ACSC_SetCallbackExt)GetProcAddress(hACSCLibraryModule, "_acsc_SetCallbackExt@16"); // 222 acsc_DownloadBinVariableToFile = (ACSC_DownloadBinVariableToFile)GetProcAddress(hACSCLibraryModule, "_acsc_DownloadBinVariableToFile@44"); // 223 acsc_SetLogFileOptions = (ACSC_SetLogFileOptions)GetProcAddress(hACSCLibraryModule, "_acsc_SetLogFileOptions@12"); // 224 acsc_KillExt = (ACSC_KillExt)GetProcAddress(hACSCLibraryModule, "_acsc_KillExt@16"); // 225 acsc_DisableExt = (ACSC_DisableExt)GetProcAddress(hACSCLibraryModule, "_acsc_DisableExt@16"); // 226 acsc_GetConf = (ACSC_GetConf)GetProcAddress(hACSCLibraryModule, "_acsc_GetConf@20"); // 228 acsc_SetConf = (ACSC_SetConf)GetProcAddress(hACSCLibraryModule, "_acsc_SetConf@24"); // 229 acsc_SetServer = (ACSC_SetServer)GetProcAddress(hACSCLibraryModule, "_acsc_SetServer@4"); // 230 acsc_GetSingleMessage = (ACSC_GetSingleMessage)GetProcAddress(hACSCLibraryModule, "_acsc_GetSingleMessage@20"); // 231 acsc_GetCallbackMask = (ACSC_GetCallbackMask)GetProcAddress(hACSCLibraryModule, "_acsc_GetCallbackMask@12"); // 232 acsc_SetCallbackMask = (ACSC_SetCallbackMask)GetProcAddress(hACSCLibraryModule, "_acsc_SetCallbackMask@16"); // 233 acsc_InstallCallback = (ACSC_InstallCallback)GetProcAddress(hACSCLibraryModule, "_acsc_InstallCallback@16"); // 234 acsc_PegInc = (ACSC_PegInc)GetProcAddress(hACSCLibraryModule, "_acsc_PegInc@60"); // 235 acsc_PegRandom = (ACSC_PegRandom)GetProcAddress(hACSCLibraryModule, "_acsc_PegRandom@44"); // 236 acsc_Commut = (ACSC_Commut)GetProcAddress(hACSCLibraryModule, "_acsc_Commut@12"); // 237 acsc_WaitMotorCommutated = (ACSC_WaitMotorCommutated)GetProcAddress(hACSCLibraryModule, "_acsc_WaitMotorCommutated@16"); // 238 acsc_GetConnectionsList = (ACSC_GetConnectionsList)GetProcAddress(hACSCLibraryModule, "_acsc_GetConnectionsList@12"); // 245 acsc_TerminateConnection = (ACSC_TerminateConnection)GetProcAddress(hACSCLibraryModule, "_acsc_TerminateConnection@4"); // 246 acsc_SetServerExt = (ACSC_SetServerExt)GetProcAddress(hACSCLibraryModule, "_acsc_SetServerExt@8"); // 247 acsc_SetServerExtLogin = (ACSC_SetServerExtLogin)GetProcAddress(hACSCLibraryModule, "_acsc_SetServerExtLogin@20"); // 248 acsc_DataCollection = (ACSC_DataCollection)GetProcAddress(hACSCLibraryModule, "_acsc_DataCollection@32"); // 249 acsc_LoadDataToController = (ACSC_LoadDataToController)GetProcAddress(hACSCLibraryModule, "_acsc_LoadDataToController@44"); // 250 acsc_RegisterEmergencyStop = (ACSC_RegisterEmergencyStop)GetProcAddress(hACSCLibraryModule, "_acsc_RegisterEmergencyStop@0"); // 251 acsc_UnregisterEmergencyStop = (ACSC_UnregisterEmergencyStop)GetProcAddress(hACSCLibraryModule, "_acsc_UnregisterEmergencyStop@0"); // 252 acsc_UploadDataFromController = (ACSC_UploadDataFromController)GetProcAddress(hACSCLibraryModule, "_acsc_UploadDataFromController@48"); // 253 acsc_AnalyzeApplication = (ACSC_AnalyzeApplication)GetProcAddress(hACSCLibraryModule, "_acsc_AnalyzeApplication@16"); // 254 acsc_FreeApplication = (ACSC_FreeApplication)GetProcAddress(hACSCLibraryModule, "_acsc_FreeApplication@4"); // 255 acsc_SaveApplication = (ACSC_SaveApplication)GetProcAddress(hACSCLibraryModule, "_acsc_SaveApplication@16"); // 256 acsc_LoadApplication = (ACSC_LoadApplication)GetProcAddress(hACSCLibraryModule, "_acsc_LoadApplication@16"); // 257 acsc_GetUMDVersion = (ACSC_GetUMDVersion)GetProcAddress(hACSCLibraryModule, "_acsc_GetUMDVersion@0"); // 258 acsc_OpenCommEthernetTCP = (ACSC_OpenCommEthernetTCP)GetProcAddress(hACSCLibraryModule, "_acsc_OpenCommEthernetTCP@8"); // 259 acsc_OpenCommEthernetUDP = (ACSC_OpenCommEthernetUDP)GetProcAddress(hACSCLibraryModule, "_acsc_OpenCommEthernetUDP@8"); // 260 acsc_ControllerReboot = (ACSC_ControllerReboot)GetProcAddress(hACSCLibraryModule, "_acsc_ControllerReboot@8"); // 262 acsc_ControllerFactoryDefault = (ACSC_ControllerFactoryDefault)GetProcAddress(hACSCLibraryModule, "_acsc_ControllerFactoryDefault@8"); // 263 acsc_GetSharedMemoryAddress = (ACSC_GetSharedMemoryAddress)GetProcAddress(hACSCLibraryModule, "_acsc_GetSharedMemoryAddress@20"); // 264 acsc_ReadSharedMemoryReal = (ACSC_ReadSharedMemoryReal)GetProcAddress(hACSCLibraryModule, "_acsc_ReadSharedMemoryReal@28"); // 265 acsc_ReadSharedMemoryInteger = (ACSC_ReadSharedMemoryInteger)GetProcAddress(hACSCLibraryModule, "_acsc_ReadSharedMemoryInteger@28"); // 266 acsc_WriteSharedMemoryReal = (ACSC_WriteSharedMemoryReal)GetProcAddress(hACSCLibraryModule, "_acsc_WriteSharedMemoryReal@28"); // 267 acsc_WriteSharedMemoryInteger = (ACSC_WriteSharedMemoryInteger)GetProcAddress(hACSCLibraryModule, "_acsc_WriteSharedMemoryInteger@28"); // 268 acsc_SysInfo = (ACSC_SysInfo)GetProcAddress(hACSCLibraryModule, "_acsc_SysInfo@16"); // 269 acsc_GetAxesCount = (ACSC_GetAxesCount)GetProcAddress(hACSCLibraryModule, "_acsc_GetAxesCount@12"); // 270 acsc_GetBuffersCount = (ACSC_GetBuffersCount)GetProcAddress(hACSCLibraryModule, "_acsc_GetBuffersCount@12"); // 271 acsc_GetDBufferIndex = (ACSC_GetDBufferIndex)GetProcAddress(hACSCLibraryModule, "_acsc_GetDBufferIndex@12"); // 272 acsc_AssignPegNT = (ACSC_AssignPegNT)GetProcAddress(hACSCLibraryModule, "_acsc_AssignPegNT@20"); // 273 acsc_AssignPegOutputsNT = (ACSC_AssignPegOutputsNT)GetProcAddress(hACSCLibraryModule, "_acsc_AssignPegOutputsNT@20"); // 274 acsc_AssignFastInputsNT = (ACSC_AssignFastInputsNT)GetProcAddress(hACSCLibraryModule, "_acsc_AssignFastInputsNT@20"); // 275 acsc_PegIncNT = (ACSC_PegIncNT)GetProcAddress(hACSCLibraryModule, "_acsc_PegIncNT@60"); // 276 acsc_PegRandomNT = (ACSC_PegRandomNT)GetProcAddress(hACSCLibraryModule, "_acsc_PegRandomNT@56"); // 277 acsc_WaitPegReadyNT = (ACSC_WaitPegReadyNT)GetProcAddress(hACSCLibraryModule, "_acsc_WaitPegReadyNT@12"); // 278 acsc_StartPegNT = (ACSC_StartPegNT)GetProcAddress(hACSCLibraryModule, "_acsc_StartPegNT@12"); // 279 acsc_StopPegNT = (ACSC_StopPegNT)GetProcAddress(hACSCLibraryModule, "_acsc_StopPegNT@12"); // 280 acsc_GetEtherCATState = (ACSC_GetEtherCATState)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATState@12"); // 281 acsc_GetEtherCATError = (ACSC_GetEtherCATError)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATError@12"); // 282 acsc_MapEtherCATInput = (ACSC_MapEtherCATInput)GetProcAddress(hACSCLibraryModule, "_acsc_MapEtherCATInput@20"); // 283 acsc_MapEtherCATOutput = (ACSC_MapEtherCATOutput)GetProcAddress(hACSCLibraryModule, "_acsc_MapEtherCATOutput@20"); // 284 acsc_UnmapEtherCATInputsOutputs = (ACSC_UnmapEtherCATInputsOutputs)GetProcAddress(hACSCLibraryModule, "_acsc_UnmapEtherCATInputsOutputs@8"); // 285 acsc_GetEtherCATSlaveIndex = (ACSC_GetEtherCATSlaveIndex)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATSlaveIndex@24"); // 286 acsc_GetEtherCATSlaveOffset = (ACSC_GetEtherCATSlaveOffset)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATSlaveOffset@20"); // 287 acsc_GetEtherCATSlaveVendorID = (ACSC_GetEtherCATSlaveVendorID)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATSlaveVendorID@16"); // 288 acsc_GetEtherCATSlaveProductID = (ACSC_GetEtherCATSlaveProductID)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATSlaveProductID@16"); // 289 acsc_GetEtherCATSlaveRevision = (ACSC_GetEtherCATSlaveRevision)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATSlaveRevision@16"); // 290 acsc_GetEtherCATSlaveType = (ACSC_GetEtherCATSlaveType)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATSlaveType@20"); // 291 acsc_GetEtherCATSlaveState = (ACSC_GetEtherCATSlaveState)GetProcAddress(hACSCLibraryModule, "_acsc_GetEtherCATSlaveState@16"); // 292 acsc_DownloadFileOverEtherCAT = (ACSC_DownloadFileOverEtherCAT)GetProcAddress(hACSCLibraryModule, "_acsc_DownloadFileOverEtherCAT@20"); // 293 acsc_ReadSDOValueOverEtherCAT = (ACSC_ReadSDOValueOverEtherCAT)GetProcAddress(hACSCLibraryModule, "_acsc_ReadSDOValueOverEtherCAT@28"); // 294 acsc_WriteSDOValueOverEtherCAT = (ACSC_WriteSDOValueOverEtherCAT)GetProcAddress(hACSCLibraryModule, "_acsc_WriteSDOValueOverEtherCAT@32"); // 295 acsc_GetConnectionInfo = (ACSC_GetConnectionInfo)GetProcAddress(hACSCLibraryModule, "_acsc_GetConnectionInfo@8"); // 296 acsc_GetLogData = (ACSC_GetLogData)GetProcAddress(hACSCLibraryModule, "_acsc_GetLogData@20"); // 297 acsc_OpenSCLogFile = (ACSC_OpenSCLogFile)GetProcAddress(hACSCLibraryModule, "_acsc_OpenSCLogFile@8"); // 298 acsc_CloseSCLogFile = (ACSC_CloseSCLogFile)GetProcAddress(hACSCLibraryModule, "_acsc_CloseSCLogFile@4"); // 299 acsc_WriteSCLogFile = (ACSC_WriteSCLogFile)GetProcAddress(hACSCLibraryModule, "_acsc_WriteSCLogFile@12"); // 300 acsc_FlushSCLogFile = (ACSC_FlushSCLogFile)GetProcAddress(hACSCLibraryModule, "_acsc_FlushSCLogFile@8"); // 301 acsc_FlushLogFile = (ACSC_FlushLogFile)GetProcAddress(hACSCLibraryModule, "_acsc_FlushLogFile@4"); // 302 acsc_DataCollectionExt = (ACSC_DataCollectionExt)GetProcAddress(hACSCLibraryModule, "_acsc_DataCollectionExt@36"); // 303 acsc_CopyFileToController = (ACSC_CopyFileToController)GetProcAddress(hACSCLibraryModule, "_acsc_CopyFileToController@16"); // 304 acsc_SegmentedMotion = (ACSC_SegmentedMotion)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentedMotion@20"); // 305 acsc_ExtendedSegmentedMotion = (ACSC_ExtendedSegmentedMotion)GetProcAddress(hACSCLibraryModule, "_acsc_ExtendedSegmentedMotion@64"); // 306 acsc_SegmentLine = (ACSC_SegmentLine)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentLine@52"); // 307 acsc_SegmentArc1 = (ACSC_SegmentArc1)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentArc1@60"); // 308 acsc_SegmentArc2 = (ACSC_SegmentArc2)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentArc2@60"); // 309 acsc_GetAnalogInputNT = (ACSC_GetAnalogInputNT)GetProcAddress(hACSCLibraryModule, "_acsc_GetAnalogInputNT@16"); // 310 acsc_GetAnalogOutputNT = (ACSC_GetAnalogOutputNT)GetProcAddress(hACSCLibraryModule, "_acsc_GetAnalogOutputNT@16"); // 311 acsc_SetAnalogOutputNT = (ACSC_SetAnalogOutputNT)GetProcAddress(hACSCLibraryModule, "_acsc_SetAnalogOutputNT@20"); // 312 acsc_GetVolatileMemoryUsage = (ACSC_GetVolatileMemoryUsage)GetProcAddress(hACSCLibraryModule, "_acsc_GetVolatileMemoryUsage@12"); // 313 acsc_GetVolatileMemoryTotal = (ACSC_GetVolatileMemoryTotal)GetProcAddress(hACSCLibraryModule, "_acsc_GetVolatileMemoryTotal@12"); // 314 acsc_GetVolatileMemoryFree = (ACSC_GetVolatileMemoryFree)GetProcAddress(hACSCLibraryModule, "_acsc_GetVolatileMemoryFree@12"); // 315 acsc_GetNonVolatileMemoryUsage = (ACSC_GetNonVolatileMemoryUsage)GetProcAddress(hACSCLibraryModule, "_acsc_GetNonVolatileMemoryUsage@12"); // 316 acsc_GetNonVolatileMemoryTotal = (ACSC_GetNonVolatileMemoryTotal)GetProcAddress(hACSCLibraryModule, "_acsc_GetNonVolatileMemoryTotal@12"); // 317 acsc_GetNonVolatileMemoryFree = (ACSC_GetNonVolatileMemoryFree)GetProcAddress(hACSCLibraryModule, "_acsc_GetNonVolatileMemoryFree@12"); // 318 acsc_DeleteFileFromController = (ACSC_DeleteFileFromController)GetProcAddress(hACSCLibraryModule, "_acsc_DeleteFileFromController@12"); // 319 acsc_ControllerSaveToFlash = (ACSC_ControllerSaveToFlash)GetProcAddress(hACSCLibraryModule, "_acsc_ControllerSaveToFlash@20"); // 320 acsc_StartSPiiPlusSC = (ACSC_StartSPiiPlusSC)GetProcAddress(hACSCLibraryModule, "_acsc_StartSPiiPlusSC@0"); // 321 acsc_StopSPiiPlusSC = (ACSC_StopSPiiPlusSC)GetProcAddress(hACSCLibraryModule, "_acsc_StopSPiiPlusSC@0"); // 322 acsc_OpenCommSimulator = (ACSC_OpenCommSimulator)GetProcAddress(hACSCLibraryModule, "_acsc_OpenCommSimulator@4"); // 323 acsc_CloseSimulator = (ACSC_CloseSimulator)GetProcAddress(hACSCLibraryModule, "_acsc_CloseSimulator@0"); // 324 acsc_ClearBreakpoints = (ACSC_ClearBreakpoints)GetProcAddress(hACSCLibraryModule, "_acsc_ClearBreakpoints@16"); // 325 acsc_SetBreakpoint = (ACSC_SetBreakpoint)GetProcAddress(hACSCLibraryModule, "_acsc_SetBreakpoints@16"); // 326 acsc_GetBreakpointsList = (ACSC_GetBreakpointsList)GetProcAddress(hACSCLibraryModule, "_acsc_GetBreakpointsList@24"); // 327 acsc_GetEthernetCards = (ACSC_GetEthernetCards)GetProcAddress(hACSCLibraryModule, "_acsc_GetEthernetCards"); // 328 acsc_WaitCollectEndExt = (ACSC_WaitCollectEndExt)GetProcAddress(hACSCLibraryModule, "_acsc_WaitCollectEndExt@12"); // 329 acsc_CommutExt = (ACSC_CommutExt)GetProcAddress(hACSCLibraryModule, "_acsc_CommutExt@24"); // 330 acsc_SegmentLineExt = (ACSC_SegmentLineExt)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentLine@52"); // 331 acsc_SegmentArc1Ext = (ACSC_SegmentArc1Ext)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentArc1@60"); // 332 acsc_SegmentArc2Ext = (ACSC_SegmentArc2Ext)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentArc2@60"); // 333 acsc_ExtendedSegmentedMotionExt = (ACSC_ExtendedSegmentedMotionExt)GetProcAddress(hACSCLibraryModule, "_acsc_ExtendedSegmentedMotion@64"); // 334 acsc_BlendedSegmentMotion = (ACSC_BlendedSegmentMotion)GetProcAddress(hACSCLibraryModule, "_acsc_BlendedSegmentMotion@52"); // 335 acsc_BlendedLine = (ACSC_BlendedLine)GetProcAddress(hACSCLibraryModule, "_acsc_BlendedLine@52"); // 336 acsc_BlendedArc1 = (ACSC_BlendedArc1)GetProcAddress(hACSCLibraryModule, "_acsc_BlendedArc1@60"); // 337 acsc_BlendedArc2 = (ACSC_BlendedArc2)GetProcAddress(hACSCLibraryModule, "_acsc_BlendedArc2@60"); // 338 acsc_ExtendedSegmentArc1 = (ACSC_ExtendedSegmentArc1)GetProcAddress(hACSCLibraryModule, "_acsc_ExtendedSegmentArc1@68"); // 339 acsc_ExtendedSegmentArc2 = (ACSC_ExtendedSegmentArc2)GetProcAddress(hACSCLibraryModule, "_acsc_ExtendedSegmentArc2@72"); // 340 acsc_FFT = (ACSC_FFT)GetProcAddress(hACSCLibraryModule, "_acsc_FFT@20"); // 341 acsc_FRF_CalculateClosedLoopFRD = (ACSC_FRF_CalculateClosedLoopFRD)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_CalculateClosedLoopFRD@20"); // 342 acsc_FRF_CalculateControllerFRD = (ACSC_FRF_CalculateControllerFRD)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_CalculateControllerFRD@24"); // 343 acsc_FRF_CalculateMeasurementDuration = (ACSC_FRF_CalculateMeasurementDuration)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_CalculateMeasurementDuration@12"); // 344! acsc_FRF_CalculateOpenLoopFRD = (ACSC_FRF_CalculateOpenLoopFRD)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_CalculateOpenLoopFRD@20"); // 345 acsc_FRF_CalculateStabilityMargins = (ACSC_FRF_CalculateStabilityMargins)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_CalculateStabilityMargins@12"); // 346 acsc_FRF_FreeFRD = (ACSC_FRF_FreeFRD)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_FreeFRD@8"); // 347 acsc_FRF_FreeOutput = (ACSC_FRF_FreeOutput)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_FreeOutput@8"); // 348 acsc_FRF_FreeStabilityMargins = (ACSC_FRF_FreeStabilityMargins)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_FreeStabilityMargins@8"); // 349 acsc_FRF_InitInput = (ACSC_FRF_InitInput)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_InitInput@8"); // 350 acsc_FRF_Measure = (ACSC_FRF_Measure)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_Measure@16"); // 351 acsc_FRF_ReadServoParameters = (ACSC_FRF_ReadServoParameters)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_ReadServoParameters@16"); // 352 acsc_FRF_Stop = (ACSC_FRF_Stop)GetProcAddress(hACSCLibraryModule, "_acsc_FRF_Stop@12"); // 353 acsc_JitterAnalysis = (ACSC_JitterAnalysis)GetProcAddress(hACSCLibraryModule, "_acsc_JitterAnalysis@12"); // 354 acsc_JitterAnalysis_FreeOutput = (ACSC_JitterAnalysis_FreeOutput)GetProcAddress(hACSCLibraryModule, "_acsc_JitterAnalysis_FreeOutput@8"); // 355 acsc_InstallCallbackExt = (ACSC_InstallCallbackExt)GetProcAddress(hACSCLibraryModule, "_acsc_InstallCallbackExt@16"); // 356 acsc_SetCallbackMaskExt = (ACSC_SetCallbackMaskExt)GetProcAddress(hACSCLibraryModule, "_acsc_SetCallbackMaskExt@40"); // 357 acsc_GetCallbackMaskExt = (ACSC_GetCallbackMaskExt)GetProcAddress(hACSCLibraryModule, "_acsc_GetCallbackMaskExt@12"); // 358 acsc_GetEthernetCardsExt = (ACSC_GetEthernetCardsExt)GetProcAddress(hACSCLibraryModule, "_acsc_GetEthernetCardsExt"); // 359 acsc_ExtendedSegmentedMotionV2 = (ACSC_ExtendedSegmentedMotionV2)GetProcAddress(hACSCLibraryModule, "_acsc_ExtendedSegmentedMotionV2@136"); // 360 acsc_SegmentLineV2 = (ACSC_SegmentLineV2)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentLineV2@84"); // 361 acsc_SegmentArc1V2 = (ACSC_SegmentArc1V2)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentArc1V2@92"); // 362 acsc_SegmentArc2V2 = (ACSC_SegmentArc2V2)GetProcAddress(hACSCLibraryModule, "_acsc_SegmentArc2V2@96"); // 363 acsc_NurbsMotion = (ACSC_NurbsMotion)GetProcAddress(hACSCLibraryModule, "_acsc_NurbsMotion@52"); // 364 acsc_NurbsPoints = (ACSC_NurbsPoints)GetProcAddress(hACSCLibraryModule, "_acsc_NurbsPoints@52"); // 365 acsc_SmoothPathMotion = (ACSC_SmoothPathMotion)GetProcAddress(hACSCLibraryModule, "_acsc_SmoothPathMotion@56"); // 366 acsc_SmoothPathSegment = (ACSC_SmoothPathSegment)GetProcAddress(hACSCLibraryModule, "_acsc_SmoothPathSegment@36"); // 367 acsc_BoostedPointToPointMotion = (ACSC_BoostedPointToPointMotion)GetProcAddress(hACSCLibraryModule, "_acsc_BoostedPointToPointMotion@60"); // 368 acsc_AssignPegNTV2 = (ACSC_AssignPegNTV2)GetProcAddress(hACSCLibraryModule, "_acsc_AssignPegNTV2@24"); // 369 acsc_SmoothPointToPointMotion = (ACSC_SmoothPointToPointMotion)GetProcAddress(hACSCLibraryModule, "_acsc_SmoothPointToPointMotion@28"); // 370 acsc_SmoothTransitionPointToPointMotion = (ACSC_SmoothTransitionPointToPointMotion)GetProcAddress(hACSCLibraryModule, "_acsc_SmoothTransitionPointToPointMotion@36"); // 371 return 1; } ////////////////////////////////////////////////////////////////////////////////////////////////// // The function unmapps from the address space of the calling process. ////////////////////////////////////////////////////////////////////////////////////////////////// static int FreeACSCLibrary() { return FreeLibrary(hACSCLibraryModule); } #else // defined (ACSC_RUNTIME_DYNAMIC_VARIABLES) extern ACSC_AddMPoint acsc_AddMPoint; extern ACSC_AddMPointM acsc_AddMPointM; extern ACSC_AddPoint acsc_AddPoint; extern ACSC_AddPointM acsc_AddPointM; extern ACSC_AppendBuffer acsc_AppendBuffer; extern ACSC_Arc1 acsc_Arc1; extern ACSC_Arc2 acsc_Arc2; extern ACSC_Break acsc_Break; extern ACSC_BreakM acsc_BreakM; extern ACSC_CancelOperation acsc_CancelOperation; extern ACSC_CaptureComm acsc_CaptureComm; extern ACSC_ClearBuffer acsc_ClearBuffer; extern ACSC_ClearVariables acsc_ClearVariables; extern ACSC_CloseComm acsc_CloseComm; extern ACSC_CloseHistoryBuffer acsc_CloseHistoryBuffer; extern ACSC_CloseLogFile acsc_CloseLogFile; extern ACSC_CloseSCLogFile acsc_CloseSCLogFile; extern ACSC_CloseMessageBuffer acsc_CloseMessageBuffer; extern ACSC_Collect acsc_Collect; extern ACSC_Command acsc_Command; extern ACSC_Commut acsc_Commut; extern ACSC_CommutExt acsc_CommutExt; extern ACSC_CompileBuffer acsc_CompileBuffer; extern ACSC_DeclareVariable acsc_DeclareVariable; extern ACSC_Disable acsc_Disable; extern ACSC_DisableAll acsc_DisableAll; extern ACSC_DisableFault acsc_DisableFault; extern ACSC_DisableM acsc_DisableM; extern ACSC_DisableResponse acsc_DisableResponse; extern ACSC_DownloadBuffer acsc_DownloadBuffer; extern ACSC_Enable acsc_Enable; extern ACSC_EnableFault acsc_EnableFault; extern ACSC_EnableM acsc_EnableM; extern ACSC_EnableResponse acsc_EnableResponse; extern ACSC_EndSequence acsc_EndSequence; extern ACSC_EndSequenceM acsc_EndSequenceM; extern ACSC_ExtAddPoint acsc_ExtAddPoint; extern ACSC_ExtAddPointM acsc_ExtAddPointM; extern ACSC_ExtArc1 acsc_ExtArc1; extern ACSC_ExtArc2 acsc_ExtArc2; extern ACSC_ExtLine acsc_ExtLine; extern ACSC_ExtToPoint acsc_ExtToPoint; extern ACSC_ExtToPointM acsc_ExtToPointM; extern ACSC_FlushLogFile acsc_FlushLogFile; extern ACSC_FlushSCLogFile acsc_FlushSCLogFile; extern ACSC_GetAcceleration acsc_GetAcceleration; extern ACSC_GetAnalogInput acsc_GetAnalogInput; extern ACSC_GetAnalogOutput acsc_GetAnalogOutput; extern ACSC_GetAxisState acsc_GetAxisState; extern ACSC_GetCommOptions acsc_GetCommOptions; extern ACSC_GetDeceleration acsc_GetDeceleration; extern ACSC_GetDefaultTimeout acsc_GetDefaultTimeout; extern ACSC_GetErrorString acsc_GetErrorString; extern ACSC_GetExtInput acsc_GetExtInput; extern ACSC_GetExtInputPort acsc_GetExtInputPort; extern ACSC_GetExtOutput acsc_GetExtOutput; extern ACSC_GetExtOutputPort acsc_GetExtOutputPort; extern ACSC_GetFPosition acsc_GetFPosition; extern ACSC_GetFVelocity acsc_GetFVelocity; extern ACSC_GetFault acsc_GetFault; extern ACSC_GetFaultMask acsc_GetFaultMask; extern ACSC_GetFirmwareVersion acsc_GetFirmwareVersion; extern ACSC_GetHistory acsc_GetHistory; extern ACSC_GetIndexState acsc_GetIndexState; extern ACSC_GetInput acsc_GetInput; extern ACSC_GetInputPort acsc_GetInputPort; extern ACSC_GetInterruptMask acsc_GetInterruptMask; extern ACSC_GetCallbackMask acsc_GetCallbackMask; extern ACSC_GetCallbackMaskExt acsc_GetCallbackMaskExt; extern ACSC_GetJerk acsc_GetJerk; extern ACSC_GetKillDeceleration acsc_GetKillDeceleration; extern ACSC_GetLastError acsc_GetLastError; extern ACSC_GetLibraryVersion acsc_GetLibraryVersion; extern ACSC_GetMessage acsc_GetMessage; extern ACSC_GetMotionError acsc_GetMotionError; extern ACSC_GetMotorError acsc_GetMotorError; extern ACSC_GetMotorState acsc_GetMotorState; extern ACSC_GetOutput acsc_GetOutput; extern ACSC_GetOutputPort acsc_GetOutputPort; extern ACSC_GetPCICards acsc_GetPCICards; extern ACSC_GetEthernetCards acsc_GetEthernetCards; extern ACSC_GetEthernetCardsExt acsc_GetEthernetCardsExt; extern ACSC_GetProgramError acsc_GetProgramError; extern ACSC_GetProgramState acsc_GetProgramState; extern ACSC_GetRPosition acsc_GetRPosition; extern ACSC_GetRVelocity acsc_GetRVelocity; extern ACSC_GetResponseMask acsc_GetResponseMask; extern ACSC_GetSafetyInput acsc_GetSafetyInput; extern ACSC_GetSafetyInputPort acsc_GetSafetyInputPort; extern ACSC_GetSafetyInputPortInv acsc_GetSafetyInputPortInv; extern ACSC_GetSerialNumber acsc_GetSerialNumber; extern ACSC_GetTimeout acsc_GetTimeout; extern ACSC_GetVelocity acsc_GetVelocity; extern ACSC_Go acsc_Go; extern ACSC_GoM acsc_GoM; extern ACSC_Group acsc_Group; extern ACSC_Halt acsc_Halt; extern ACSC_HaltM acsc_HaltM; extern ACSC_Jog acsc_Jog; extern ACSC_JogM acsc_JogM; extern ACSC_Kill acsc_Kill; extern ACSC_KillExt acsc_KillExt; extern ACSC_DisableExt acsc_DisableExt; extern ACSC_KillAll acsc_KillAll; extern ACSC_KillM acsc_KillM; extern ACSC_Line acsc_Line; extern ACSC_LoadBuffer acsc_LoadBuffer; extern ACSC_MultiPoint acsc_MultiPoint; extern ACSC_MultiPointM acsc_MultiPointM; extern ACSC_BoostedPointToPointMotion acsc_BoostedPointToPointMotion; extern ACSC_SmoothPointToPointMotion acsc_SmoothPointToPointMotion; extern ACSC_SmoothTransitionPointToPointMotion acsc_SmoothTransitionPointToPointMotion; extern ACSC_OpenCommDirect acsc_OpenCommDirect; extern ACSC_OpenCommSimulator acsc_OpenCommSimulator; extern ACSC_CloseSimulator acsc_CloseSimulator; extern ACSC_OpenCommEthernet acsc_OpenCommEthernet; extern ACSC_OpenCommEthernetUDP acsc_OpenCommEthernetUDP; extern ACSC_OpenCommEthernetTCP acsc_OpenCommEthernetTCP; extern ACSC_OpenCommSerial acsc_OpenCommSerial; extern ACSC_OpenCommPCI acsc_OpenCommPCI; extern ACSC_OpenHistoryBuffer acsc_OpenHistoryBuffer; extern ACSC_OpenLogFile acsc_OpenLogFile; extern ACSC_OpenSCLogFile acsc_OpenSCLogFile; extern ACSC_OpenMessageBuffer acsc_OpenMessageBuffer; extern ACSC_Projection acsc_Projection; extern ACSC_ReadDPRAMInteger acsc_ReadDPRAMInteger; extern ACSC_ReadDPRAMReal acsc_ReadDPRAMReal; extern ACSC_ReadInteger acsc_ReadInteger; extern ACSC_ReadReal acsc_ReadReal; extern ACSC_Receive acsc_Receive; extern ACSC_ReleaseComm acsc_ReleaseComm; extern ACSC_ResetIndexState acsc_ResetIndexState; extern ACSC_RunBuffer acsc_RunBuffer; extern ACSC_Segment acsc_Segment; extern ACSC_Send acsc_Send; extern ACSC_SetAcceleration acsc_SetAcceleration; extern ACSC_SetAccelerationImm acsc_SetAccelerationImm; extern ACSC_SetAnalogOutput acsc_SetAnalogOutput; extern ACSC_SetCallback acsc_SetCallback; extern ACSC_SetCallbackPriority acsc_SetCallbackPriority; extern ACSC_SetCommOptions acsc_SetCommOptions; extern ACSC_SetDeceleration acsc_SetDeceleration; extern ACSC_SetDecelerationImm acsc_SetDecelerationImm; extern ACSC_SetExtOutput acsc_SetExtOutput; extern ACSC_SetExtOutputPort acsc_SetExtOutputPort; extern ACSC_SetFPosition acsc_SetFPosition; extern ACSC_SetFaultMask acsc_SetFaultMask; extern ACSC_SetInterruptMask acsc_SetInterruptMask; extern ACSC_SetCallbackMask acsc_SetCallbackMask; extern ACSC_SetCallbackMaskExt acsc_SetCallbackMaskExt; extern ACSC_SetIterations acsc_SetIterations; extern ACSC_SetJerk acsc_SetJerk; extern ACSC_SetJerkImm acsc_SetJerkImm; extern ACSC_SetKillDeceleration acsc_SetKillDeceleration; extern ACSC_SetKillDecelerationImm acsc_SetKillDecelerationImm; extern ACSC_SetMaster acsc_SetMaster; extern ACSC_SetOutput acsc_SetOutput; extern ACSC_SetOutputPort acsc_SetOutputPort; extern ACSC_SetRPosition acsc_SetRPosition; extern ACSC_SetResponseMask acsc_SetResponseMask; extern ACSC_SetSafetyInputPortInv acsc_SetSafetyInputPortInv; extern ACSC_SetTimeout acsc_SetTimeout; extern ACSC_SetVelocity acsc_SetVelocity; extern ACSC_SetVelocityImm acsc_SetVelocityImm; extern ACSC_Slave acsc_Slave; extern ACSC_SlaveStalled acsc_SlaveStalled; extern ACSC_Spline acsc_Spline; extern ACSC_SplineM acsc_SplineM; extern ACSC_Split acsc_Split; extern ACSC_SplitAll acsc_SplitAll; extern ACSC_StopBuffer acsc_StopBuffer; extern ACSC_StopCollect acsc_StopCollect; extern ACSC_Stopper acsc_Stopper; extern ACSC_SuspendBuffer acsc_SuspendBuffer; extern ACSC_ToPoint acsc_ToPoint; extern ACSC_ToPointM acsc_ToPointM; extern ACSC_Transaction acsc_Transaction; extern ACSC_UploadBuffer acsc_UploadBuffer; extern ACSC_WaitCollectEnd acsc_WaitCollectEnd; extern ACSC_WaitCollectEndExt acsc_WaitCollectEndExt; extern ACSC_WaitForAsyncCall acsc_WaitForAsyncCall; extern ACSC_WaitInput acsc_WaitInput; extern ACSC_WaitLogicalMotionEnd acsc_WaitLogicalMotionEnd; extern ACSC_WaitMotionEnd acsc_WaitMotionEnd; extern ACSC_WaitMotorEnabled acsc_WaitMotorEnabled; extern ACSC_WaitMotorCommutated acsc_WaitMotorCommutated; extern ACSC_WaitProgramEnd acsc_WaitProgramEnd; extern ACSC_WaitUserCondition acsc_WaitUserCondition; extern ACSC_WriteDPRAMInteger acsc_WriteDPRAMInteger; extern ACSC_WriteDPRAMReal acsc_WriteDPRAMReal; extern ACSC_WriteInteger acsc_WriteInteger; extern ACSC_WriteLogFile acsc_WriteLogFile; extern ACSC_WriteSCLogFile acsc_WriteSCLogFile; extern ACSC_WriteReal acsc_WriteReal; extern ACSC_LoadBufferIgnoreServiceLines acsc_LoadBufferIgnoreServiceLines; extern ACSC_LoadBuffersFromFile acsc_LoadBuffersFromFile; extern ACSC_PegI acsc_PegI; extern ACSC_PegR acsc_PegR; extern ACSC_PegInc acsc_PegInc; extern ACSC_PegRandom acsc_PegRandom; extern ACSC_AssignPins acsc_AssignPins; extern ACSC_StopPeg acsc_StopPeg; extern ACSC_AssignPegNT acsc_AssignPegNT; extern ACSC_AssignPegNTV2 acsc_AssignPegNTV2; extern ACSC_AssignPegOutputsNT acsc_AssignPegOutputsNT; extern ACSC_AssignFastInputsNT acsc_AssignFastInputsNT; extern ACSC_PegIncNT acsc_PegIncNT; extern ACSC_PegRandomNT acsc_PegRandomNT; extern ACSC_WaitPegReadyNT acsc_WaitPegReadyNT; extern ACSC_StartPegNT acsc_StartPegNT; extern ACSC_StopPegNT acsc_StopPegNT; extern ACSC_CollectB acsc_CollectB; extern ACSC_DataCollection acsc_DataCollection; extern ACSC_DataCollectionExt acsc_DataCollectionExt; extern ACSC_AddPVPoint acsc_AddPVPoint; extern ACSC_AddPVPointM acsc_AddPVPointM; extern ACSC_AddPVTPoint acsc_AddPVTPoint; extern ACSC_AddPVTPointM acsc_AddPVTPointM; extern ACSC_LoadFileToRealVariable acsc_LoadFileToRealVariable; extern ACSC_LoadFileToIntegerVariable acsc_LoadFileToIntegerVariable; extern ACSC_LoadDataToController acsc_LoadDataToController; extern ACSC_UploadDataFromController acsc_UploadDataFromController; extern ACSC_SetQueueOverflowTimeout acsc_SetQueueOverflowTimeout; extern ACSC_GetQueueOverflowTimeout acsc_GetQueueOverflowTimeout; extern ACSC_SetTargetPosition acsc_SetTargetPosition; extern ACSC_GetTargetPosition acsc_GetTargetPosition; extern ACSC_SetTargetPositionM acsc_SetTargetPositionM; extern ACSC_Track acsc_Track; extern ACSC_TrackM acsc_TrackM; extern ACSC_FaultClearM acsc_FaultClearM; extern ACSC_FaultClear acsc_FaultClear; extern ACSC_Getconf acsc_Getconf; extern ACSC_Setconf acsc_Setconf; extern ACSC_GetConf acsc_GetConf; extern ACSC_SetConf acsc_SetConf; extern ACSC_SysInfo acsc_SysInfo; extern ACSC_GetAxesCount acsc_GetAxesCount; extern ACSC_GetBuffersCount acsc_GetBuffersCount; extern ACSC_GetDBufferIndex acsc_GetDBufferIndex; extern ACSC_SetCallbackExt acsc_SetCallbackExt; extern ACSC_InstallCallback acsc_InstallCallback; extern ACSC_InstallCallbackExt acsc_InstallCallbackExt; extern ACSC_DownloadBinVariableToFile acsc_DownloadBinVariableToFile; extern ACSC_SetLogFileOptions acsc_SetLogFileOptions; extern ACSC_SetServer acsc_SetServer; extern ACSC_SetServerExt acsc_SetServerExt; extern ACSC_SetServerExtLogin acsc_SetServerExtLogin; extern ACSC_GetSingleMessage acsc_GetSingleMessage; extern ACSC_GetConnectionsList acsc_GetConnectionsList; extern ACSC_GetConnectionInfo acsc_GetConnectionInfo; extern ACSC_TerminateConnection acsc_TerminateConnection; extern ACSC_GetLogData acsc_GetLogData; extern ACSC_RegisterEmergencyStop acsc_RegisterEmergencyStop; extern ACSC_UnregisterEmergencyStop acsc_UnregisterEmergencyStop; extern ACSC_GetUMDVersion acsc_GetUMDVersion; extern ACSC_AnalyzeApplication acsc_AnalyzeApplication; extern ACSC_FreeApplication acsc_FreeApplication; extern ACSC_SaveApplication acsc_SaveApplication; extern ACSC_LoadApplication acsc_LoadApplication; extern ACSC_FFT acsc_FFT; extern ACSC_FRF_Measure acsc_FRF_Measure; extern ACSC_FRF_Stop acsc_FRF_Stop; extern ACSC_FRF_CalculateMeasurementDuration acsc_FRF_CalculateMeasurementDuration; extern ACSC_FRF_InitInput acsc_FRF_InitInput; extern ACSC_FRF_FreeOutput acsc_FRF_FreeOutput; extern ACSC_FRF_ReadServoParameters acsc_FRF_ReadServoParameters; extern ACSC_FRF_CalculateControllerFRD acsc_FRF_CalculateControllerFRD; extern ACSC_FRF_CalculateOpenLoopFRD acsc_FRF_CalculateOpenLoopFRD; extern ACSC_FRF_CalculateClosedLoopFRD acsc_FRF_CalculateClosedLoopFRD; extern ACSC_FRF_CalculateStabilityMargins acsc_FRF_CalculateStabilityMargins; extern ACSC_FRF_FreeFRD acsc_FRF_FreeFRD; extern ACSC_FRF_FreeStabilityMargins acsc_FRF_FreeStabilityMargins; extern ACSC_JitterAnalysis acsc_JitterAnalysis; extern ACSC_JitterAnalysis_FreeOutput acsc_JitterAnalysis_FreeOutput; extern ACSC_ControllerReboot acsc_ControllerReboot; extern ACSC_ControllerFactoryDefault acsc_ControllerFactoryDefault; extern ACSC_ControllerSaveToFlash acsc_ControllerSaveToFlash; extern ACSC_GetSharedMemoryAddress acsc_GetSharedMemoryAddress; extern ACSC_ReadSharedMemoryReal acsc_ReadSharedMemoryReal; extern ACSC_ReadSharedMemoryInteger acsc_ReadSharedMemoryInteger; extern ACSC_WriteSharedMemoryReal acsc_WriteSharedMemoryReal; extern ACSC_WriteSharedMemoryInteger acsc_WriteSharedMemoryInteger; extern ACSC_GetEtherCATState acsc_GetEtherCATState; extern ACSC_GetEtherCATError acsc_GetEtherCATError; extern ACSC_MapEtherCATInput acsc_MapEtherCATInput; extern ACSC_MapEtherCATOutput acsc_MapEtherCATOutput; extern ACSC_UnmapEtherCATInputsOutputs acsc_UnmapEtherCATInputsOutputs; extern ACSC_GetEtherCATSlaveIndex acsc_GetEtherCATSlaveIndex; extern ACSC_GetEtherCATSlaveOffset acsc_GetEtherCATSlaveOffset; extern ACSC_GetEtherCATSlaveVendorID acsc_GetEtherCATSlaveVendorID; extern ACSC_GetEtherCATSlaveProductID acsc_GetEtherCATSlaveProductID; extern ACSC_GetEtherCATSlaveRevision acsc_GetEtherCATSlaveRevision; extern ACSC_GetEtherCATSlaveType acsc_GetEtherCATSlaveType; extern ACSC_GetEtherCATSlaveState acsc_GetEtherCATSlaveState; extern ACSC_DownloadFileOverEtherCAT acsc_DownloadFileOverEtherCAT; extern ACSC_ReadSDOValueOverEtherCAT acsc_ReadSDOValueOverEtherCAT; extern ACSC_WriteSDOValueOverEtherCAT acsc_WriteSDOValueOverEtherCAT; extern ACSC_CopyFileToController acsc_CopyFileToController; extern ACSC_DeleteFileFromController acsc_DeleteFileFromController; extern ACSC_SegmentedMotion acsc_SegmentedMotion; extern ACSC_ExtendedSegmentedMotion acsc_ExtendedSegmentedMotion; extern ACSC_ExtendedSegmentedMotionExt acsc_ExtendedSegmentedMotionExt; extern ACSC_ExtendedSegmentedMotionV2 acsc_ExtendedSegmentedMotionV2; extern ACSC_SegmentLine acsc_SegmentLine; extern ACSC_SegmentLineExt acsc_SegmentLineExt; extern ACSC_SegmentLineV2 acsc_SegmentLineV2; extern ACSC_SegmentArc1 acsc_SegmentArc1; extern ACSC_SegmentArc2 acsc_SegmentArc2; extern ACSC_SegmentArc1Ext acsc_SegmentArc1Ext; extern ACSC_SegmentArc2Ext acsc_SegmentArc2Ext; extern ACSC_ExtendedSegmentArc1 acsc_ExtendedSegmentArc1; extern ACSC_ExtendedSegmentArc2 acsc_ExtendedSegmentArc2; extern ACSC_SegmentArc1V2 acsc_SegmentArc1V2; extern ACSC_SegmentArc2V2 acsc_SegmentArc2V2; extern ACSC_BlendedSegmentMotion acsc_BlendedSegmentMotion; extern ACSC_BlendedLine acsc_BlendedLine; extern ACSC_BlendedArc1 acsc_BlendedArc1; extern ACSC_BlendedArc2 acsc_BlendedArc2; extern ACSC_NurbsMotion acsc_NurbsMotion; extern ACSC_NurbsPoints acsc_NurbsPoints; extern ACSC_SmoothPathMotion acsc_SmoothPathMotion; extern ACSC_SmoothPathSegment acsc_SmoothPathSegment; extern ACSC_ClearBreakpoints acsc_ClearBreakpoints; extern ACSC_SetBreakpoint acsc_SetBreakpoint; extern ACSC_GetBreakpointsList acsc_GetBreakpointsList; extern ACSC_GetAnalogInputNT acsc_GetAnalogInputNT; extern ACSC_GetAnalogOutputNT acsc_GetAnalogOutputNT; extern ACSC_SetAnalogOutputNT acsc_SetAnalogOutputNT; extern ACSC_GetVolatileMemoryUsage acsc_GetVolatileMemoryUsage; extern ACSC_GetVolatileMemoryTotal acsc_GetVolatileMemoryTotal; extern ACSC_GetVolatileMemoryFree acsc_GetVolatileMemoryFree; extern ACSC_GetNonVolatileMemoryUsage acsc_GetNonVolatileMemoryUsage; extern ACSC_GetNonVolatileMemoryTotal acsc_GetNonVolatileMemoryTotal; extern ACSC_GetNonVolatileMemoryFree acsc_GetNonVolatileMemoryFree; extern ACSC_StartSPiiPlusSC acsc_StartSPiiPlusSC; extern ACSC_StopSPiiPlusSC acsc_StopSPiiPlusSC; extern HMODULE hACSCLibraryModule; extern ACSC_GetEthernetCardsExt acsc_GetEthernetCardsExt; ////////////////////////////////////////////////////////////////////////////////////////////////// // The function loads ACSC.DLL and obtains addresses for all exported functions. // Call this function before any using of ACSC API. // Check return value for success. ////////////////////////////////////////////////////////////////////////////////////////////////// extern int InitACSCLibrary(); ////////////////////////////////////////////////////////////////////////////////////////////////// // The function unmapps from the address space of the calling process. ////////////////////////////////////////////////////////////////////////////////////////////////// extern int FreeACSCLibrary(); #endif #endif #if defined(__cplusplus) } #endif ////////////////////////////////////////////////////////////////////////////////////////////////// // Internal functions that save and read a global errors ////////////////////////////////////////////////////////////////////////////////////////////////// // Save last global error void SetGlobalError(DWORD dwError); // Read last global error DWORD GetGlobalError(); #endif