ACS SPiiPlus 运动控制器的核心托管接口

于 2025-05-30 10:42:56 发布
阅读量451 收藏 3
点赞数 8
分类专栏： C# 激光微加工 设备制造 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkmrobot/article/details/148333470
版权 
#region 程序集 ACS.SPiiPlusNET, Version=3.13.1.20165, Culture=neutral, PublicKeyToken=null
// E:\ACS.SPiiPlusNET.dll
#endregion

using System;
using System.Collections.Generic;
using System.Net;

namespace ACS.SPiiPlusNET
{
    public class Api
    {
        public const int ACSC_NONE = -1;

        public Api();

        ~Api();

        public bool IsConnected { get; }

        public event DefaultAxisExtEventHandler SYSTEMERROR_EXT;
        public event DefaultAxisExtEventHandler SOFTWAREESTOP_EXT;
        public event BufferExtEventHandler PROGRAMEND_EXT;
        public event AxisExtEventHandler PHYSICALMOTIONEND_EXT;
        public event AxisExtEventHandler PEG_EXT;
        public event DefaultAxisExtEventHandler NEWSEGM_EXT;
        public event AxisExtEventHandler MOTORFAILURE_EXT;
        public event AxisExtEventHandler MOTIONSTART_EXT;
        public event AxisExtEventHandler MOTIONPHASECHANGE_EXT;
        public event AxisExtEventHandler MOTIONFAILURE_EXT;
        public event AxisExtEventHandler MARK2_EXT;
        public event AxisExtEventHandler TRIGGER_EXT;
        public event AxisExtEventHandler MARK1_EXT;
        public event InputExtEventHandler INPUT_EXT;
        public event DefaultAxisExtEventHandler ETHERCATERROR_EXT;
        public event DefaultAxisExtEventHandler EMERGENCY_EXT;
        public event DefaultAxisExtEventHandler CYCLE_EXT;
        public event DefaultAxisExtEventHandler COMMCHANNELCLOSED_EXT;
        public event DefaultAxisExtEventHandler ACSPLPROGRAMEX_EXT;
        public event BufferExtEventHandler ACSPLPROGRAM_EXT;
        public event DefaultAxisExtEventHandler MESSAGE_EXT;
        public event BufferEventHandler ACSPLPROGRAM;
        public event AxisExtEventHandler LOGICALMOTIONEND_EXT;
        public event DefaultAxisEventHandler COMMCHANNELCLOSED;
        public event DefaultAxisEventHandler ACSPLPROGRAMEX;
        public event AxisEventHandler TRIGGER;
        public event DefaultAxisEventHandler SYSTEMERROR;
        public event DefaultAxisEventHandler SOFTWAREESTOP;
        public event BufferEventHandler PROGRAMEND;
        public event AxisEventHandler PHYSICALMOTIONEND;
        public event AxisEventHandler PEG;
        public event AxisEventHandler MOTORFAILURE;
        public event AxisEventHandler MOTIONSTART;
        public event AxisEventHandler MOTIONPHASECHANGE;
        public event DefaultAxisEventHandler NEWSEGM;
        public event DefaultAxisEventHandler MESSAGE;
        public event DefaultAxisEventHandler CYCLE;
        public event DefaultAxisEventHandler EMERGENCY;
        public event DefaultAxisEventHandler ETHERCATERROR;
        public event AxisEventHandler MOTIONFAILURE;
        public event AxisEventHandler LOGICALMOTIONEND;
        public event InputEventHandler INPUT;
        public event AxisEventHandler MARK1;
        public event AxisEventHandler MARK2;

        public void AddMPoint(Axis axis, string name);
        public ACSC_WAITBLOCK AddMPointAsync(Axis axis, string name);
        public void AddMPointM(Axis[] axes, string name);
        public ACSC_WAITBLOCK AddMPointMAsync(Axis[] axes, string name);
        public void AddPoint(Axis axis, double point);
        public ACSC_WAITBLOCK AddPointAsync(Axis axis, double point);
        public void AddPointM(Axis[] axes, double[] point);
        public ACSC_WAITBLOCK AddPointMAsync(Axis[] axes, double[] point);
        public void AddPVPoint(Axis axis, double point, double velocity);
        public ACSC_WAITBLOCK AddPVPointAsync(Axis axis, double point, double velocity);
        public void AddPVPointM(Axis[] axis, double[] point, double[] velocity);
        public ACSC_WAITBLOCK AddPVPointMAsync(Axis[] axis, double[] point, double[] velocity);
        public void AddPVTPoint(Axis axis, double point, double velocity, double timeInterval);
        public ACSC_WAITBLOCK AddPVTPointAsync(Axis axis, double point, double velocity, double timeInterval);
        public void AddPVTPointM(Axis[] axis, double[] point, double[] velocity, double timeInterval);
        public ACSC_WAITBLOCK AddPVTPointMAsync(Axis[] axis, double[] point, double[] velocity, double timeInterval);
        public ApplicationFileInfo AnalyzeApplication(string fileName);
        public void AppendBuffer(ProgramBuffer buffer, string text);
        public ACSC_WAITBLOCK AppendBufferAsync(ProgramBuffer buffer, string text);
        public void Arc1(Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation);
        public ACSC_WAITBLOCK Arc1Async(Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation);
        public void Arc2(Axis[] axes, double[] center, double angle);
        public ACSC_WAITBLOCK Arc2Async(Axis[] axes, double[] center, double angle);
        public void AssignFastInputsNT(Axis axis, int inputIndex, int bitCode);
        public ACSC_WAITBLOCK AssignFastInputsNTAsync(Axis axis, int inputIndex, int bitCode);
        public void AssignPegNT(Axis axis, int engToEncBitCode, int gpOutsBitCode);
        public ACSC_WAITBLOCK AssignPegNTAsync(Axis axis, int engToEncBitCode, int gpOutsBitCode);
        public void AssignPegNTV2(MotionFlags flags, Axis axis, int engToEncBitCode, int gpOutsBitCode);
        public ACSC_WAITBLOCK AssignPegNTV2Async(MotionFlags flags, Axis axis, int engToEncBitCode, int gpOutsBitCode);
        public void AssignPegOutputsNT(Axis axis, int outputIndex, int bitCode);
        public ACSC_WAITBLOCK AssignPegOutputsNTAsync(Axis axis, int outputIndex, int bitCode);
        public void BlendedArc1(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double segmentTime, double accelerationTime, double jerkTime, double dwellTime);
        public ACSC_WAITBLOCK BlendedArc1Async(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double segmentTime, double accelerationTime, double jerkTime, double dwellTime);
        public void BlendedArc2(MotionFlags flags, Axis[] axes, double[] center, double angle, double segmentTime, double accelerationTime, double jerkTime, double dwellTime);
        public ACSC_WAITBLOCK BlendedArc2Async(MotionFlags flags, Axis[] axes, double[] center, double angle, double segmentTime, double accelerationTime, double jerkTime, double dwellTime);
        public void BlendedLine(MotionFlags flags, Axis[] axes, double[] point, double segmentTime, double accelerationTime, double jerkTime, double dwellTime);
        public ACSC_WAITBLOCK BlendedLineAsync(MotionFlags flags, Axis[] axes, double[] point, double segmentTime, double accelerationTime, double jerkTime, double dwellTime);
        public void BlendedSegmentMotion(MotionFlags flags, Axis[] axes, double[] point, double segmentTime, double accelerationTime, double jerkTime, double dwellTime);
        public ACSC_WAITBLOCK BlendedSegmentMotionAsync(MotionFlags flags, Axis[] axes, double[] point, double segmentTime, double accelerationTime, double jerkTime, double dwellTime);
        public void BoostedPointToPointMotion(MotionFlags flags, Axis[] axes, double[] point, double velocity, double finalVelocity, double time, double fixedTime, double motionDelay);
        public ACSC_WAITBLOCK BoostedPointToPointMotionAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double finalVelocity, double time, double fixedTime, double motionDelay);
        public void Break(Axis axis);
        public ACSC_WAITBLOCK BreakAsync(Axis axis);
        public void BreakM(Axis[] axes);
        public ACSC_WAITBLOCK BreakMAsync(Axis[] axes);
        public void CalculateFFT(double[] @in, double[] outReal, double[] outImag);
        public void CancelOperation(ACSC_WAITBLOCK wait);
        public void CaptureComm();
        public void ClearBreakpoints(ProgramBuffer buffer, int line);
        public ACSC_WAITBLOCK ClearBreakpointsAsync(ProgramBuffer buffer, int line);
        public void ClearBuffer(ProgramBuffer buffer, int fromLine, int toLine);
        public ACSC_WAITBLOCK ClearBufferAsync(ProgramBuffer buffer, int fromLine, int toLine);
        public void ClearEtherCATSlaveRegister(EtherCATFlags flags, int slaveIndex, int offset);
        public ACSC_WAITBLOCK ClearEtherCATSlaveRegisterAsync(EtherCATFlags flags, int slaveIndex, int offset);
        public void ClearVariables();
        public ACSC_WAITBLOCK ClearVariablesAsync();
        public void CloseComm();
        public void CloseHistoryBuffer();
        public void CloseLogFile();
        public void CloseMessageBuffer();
        public void CloseSCLogFile();
        public void CloseSimulator();
        public void CollectB(DataCollectionFlags flags, string array, int nSample, int period, string vars);
        public ACSC_WAITBLOCK CollectBAsync(DataCollectionFlags flags, string array, int nSample, int period, string vars);
        public void Command(string outBuf);
        public ACSC_WAITBLOCK CommandAsync(string outBuf);
        public void Commut(Axis axis);
        public ACSC_WAITBLOCK CommutAsync(Axis axis);
        public void CommutExt(Axis axis, float current, int settle, int slope);
        public ACSC_WAITBLOCK CommutExtAsync(Axis axis, float current, int settle, int slope);
        public void CompileBuffer(ProgramBuffer buffer);
        public ACSC_WAITBLOCK CompileBufferAsync(ProgramBuffer buffer);
        public void ControllerFactoryDefault(int timeout);
        public void ControllerReboot(int timeout);
        public void ControllerSaveToFlash(Axis[] parameters, ProgramBuffer[] buffers, ServoProcessor[] sPPrograms, string userArrays);
        public void CopyFileToController(string sourceFileName, string destinationFileName);
        public ACSC_WAITBLOCK CopyFileToControllerAsync(string sourceFileName, string destinationFileName);
        public void DataCollection(DataCollectionFlags flags, Axis axis, string array, int nSample, int period, string vars);
        public ACSC_WAITBLOCK DataCollectionAsync(DataCollectionFlags flags, Axis axis, string array, int nSample, int period, string vars);
        public void DataCollectionExt(DataCollectionFlags flags, Axis axis, string array, int nSample, double period, string vars);
        public ACSC_WAITBLOCK DataCollectionExtAsync(DataCollectionFlags flags, Axis axis, string array, int nSample, double period, string vars);
        public void DeclareVariable(AcsplVariableType type, string name);
        public ACSC_WAITBLOCK DeclareVariableAsync(AcsplVariableType type, string name);
        public void DeleteFileFromController(string fileName);
        public ACSC_WAITBLOCK DeleteFileFromControllerAsync(string fileName);
        public void Disable(Axis axis);
        public void DisableAll();
        public ACSC_WAITBLOCK DisableAllAsync();
        public ACSC_WAITBLOCK DisableAsync(Axis axis);
        public void DisableEvent(Interrupts flags);
        public void DisableEventExt(Interrupts flags);
        public void DisableExt(Axis axis, int reason);
        public ACSC_WAITBLOCK DisableExtAsync(Axis axis, int reason);
        public void DisableFault(Axis axis, SafetyControlMasks fault);
        public ACSC_WAITBLOCK DisableFaultAsync(Axis axis, SafetyControlMasks fault);
        public void DisableM(Axis[] axes);
        public ACSC_WAITBLOCK DisableMAsync(Axis[] axes);
        public void DisableResponse(Axis axis, SafetyControlMasks response);
        public ACSC_WAITBLOCK DisableResponseAsync(Axis axis, SafetyControlMasks response);
        public void DownloadBuffer(ProgramBuffer buffer, string text);
        public ACSC_WAITBLOCK DownloadBufferAsync(ProgramBuffer buffer, string text);
        public void DownloadFileOverEtherCAT(string path, string filename, int slaveIndex);
        public ACSC_WAITBLOCK DownloadFileOverEtherCATAsync(string path, string filename, int slaveIndex);
        public void DynamicErrorCompensation1D(DynamicErrorCompensationFlags flags, Axis axis, Zone zone, double base0, double step0, string correctionMapVariable, int referencedAxisOrAnalogInput);
        public ACSC_WAITBLOCK DynamicErrorCompensation1DAsync(DynamicErrorCompensationFlags flags, Axis axis, Zone zone, double base0, double step0, string correctionMapVariable, int referencedAxisOrAnalogInput);
        public void DynamicErrorCompensation2D(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Zone zone, double base0, double step0, double base1, double step1, string correctionMapVariable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1);
        public ACSC_WAITBLOCK DynamicErrorCompensation2DAsync(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Zone zone, double base0, double step0, double base1, double step1, string correctionMapVariable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1);
        public void DynamicErrorCompensation3D2(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, double base0, double step0, double base1, double step1, double base2, double step2, string correctionMap0Variable, string correctionMap1Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public ACSC_WAITBLOCK DynamicErrorCompensation3D2Async(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, double base0, double step0, double base1, double step1, double base2, double step2, string correctionMap0Variable, string correctionMap1Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public void DynamicErrorCompensation3D3(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, double base0, double step0, double base1, double step1, double base2, double step2, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public ACSC_WAITBLOCK DynamicErrorCompensation3D3Async(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, double base0, double step0, double base1, double step1, double base2, double step2, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public void DynamicErrorCompensation3D5(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, double base0, double step0, double base1, double step1, double base2, double step2, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, string correctionMap3Variable, string correctionMap4Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public ACSC_WAITBLOCK DynamicErrorCompensation3D5Async(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, double base0, double step0, double base1, double step1, double base2, double step2, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, string correctionMap3Variable, string correctionMap4Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public void DynamicErrorCompensation3DA(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, double base0, double step0, double base1, double step1, double base2, double step2, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, string correctionMap3Variable, string correctionMap4Variable, string correctionMap5Variable, string correctionMap6Variable, string correctionMap7Variable, string correctionMap8Variable, string correctionMap9Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public ACSC_WAITBLOCK DynamicErrorCompensation3DAAsync(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, double base0, double step0, double base1, double step1, double base2, double step2, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, string correctionMap3Variable, string correctionMap4Variable, string correctionMap5Variable, string correctionMap6Variable, string correctionMap7Variable, string correctionMap8Variable, string correctionMap9Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public void DynamicErrorCompensationA1D(DynamicErrorCompensationFlags flags, Axis axis, Zone zone, double scalingFactor, double offset);
        public ACSC_WAITBLOCK DynamicErrorCompensationA1DAsync(DynamicErrorCompensationFlags flags, Axis axis, Zone zone, double scalingFactor, double offset);
        public void DynamicErrorCompensationA2D(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Zone zone, double angle);
        public ACSC_WAITBLOCK DynamicErrorCompensationA2DAsync(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Zone zone, double angle);
        public void DynamicErrorCompensationN1D(DynamicErrorCompensationFlags flags, Axis axis, Zone zone, string axisCommands, string correctionMapVariable, int referencedAxisOrAnalogInput);
        public ACSC_WAITBLOCK DynamicErrorCompensationN1DAsync(DynamicErrorCompensationFlags flags, Axis axis, Zone zone, string axisCommands, string correctionMapVariable, int referencedAxisOrAnalogInput);
        public void DynamicErrorCompensationN2D(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Zone zone, string axis0Commands, string axis1Commands, string correctionMapVariable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1);
        public ACSC_WAITBLOCK DynamicErrorCompensationN2DAsync(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Zone zone, string axis0Commands, string axis1Commands, string correctionMapVariable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1);
        public void DynamicErrorCompensationN3D2(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, string axis0Commands, string axis1Commands, string axis2Commands, string correctionMap0Variable, string correctionMap1Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public ACSC_WAITBLOCK DynamicErrorCompensationN3D2Async(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, string axis0Commands, string axis1Commands, string axis2Commands, string correctionMap0Variable, string correctionMap1Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public void DynamicErrorCompensationN3D3(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, string axis0Commands, string axis1Commands, string axis2Commands, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public ACSC_WAITBLOCK DynamicErrorCompensationN3D3Async(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, string axis0Commands, string axis1Commands, string axis2Commands, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public void DynamicErrorCompensationN3D5(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, string axis0Commands, string axis1Commands, string axis2Commands, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, string correctionMap3Variable, string correctionMap4Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public ACSC_WAITBLOCK DynamicErrorCompensationN3D5Async(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, string axis0Commands, string axis1Commands, string axis2Commands, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, string correctionMap3Variable, string correctionMap4Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public void DynamicErrorCompensationN3DA(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, string axis0Commands, string axis1Commands, string axis2Commands, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, string correctionMap3Variable, string correctionMap4Variable, string correctionMap5Variable, string correctionMap6Variable, string correctionMap7Variable, string correctionMap8Variable, string correctionMap9Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public ACSC_WAITBLOCK DynamicErrorCompensationN3DAAsync(DynamicErrorCompensationFlags flags, Axis axis0, Axis axis1, Axis axis2, Zone zone, string axis0Commands, string axis1Commands, string axis2Commands, string correctionMap0Variable, string correctionMap1Variable, string correctionMap2Variable, string correctionMap3Variable, string correctionMap4Variable, string correctionMap5Variable, string correctionMap6Variable, string correctionMap7Variable, string correctionMap8Variable, string correctionMap9Variable, int referencedAxisOrAnalogInput0, int referencedAxisOrAnalogInput1, int referencedAxisOrAnalogInput2);
        public void DynamicErrorCompensationOff(Axis axis, Zone zone);
        public ACSC_WAITBLOCK DynamicErrorCompensationOffAsync(Axis axis, Zone zone);
        public void DynamicErrorCompensationOn(Axis axis, Zone zone);
        public ACSC_WAITBLOCK DynamicErrorCompensationOnAsync(Axis axis, Zone zone);
        public void DynamicErrorCompensationRemove(Axis axis, Zone zone);
        public ACSC_WAITBLOCK DynamicErrorCompensationRemoveAsync(Axis axis, Zone zone);
        public void Enable(Axis axis);
        public ACSC_WAITBLOCK EnableAsync(Axis axis);
        public void EnableEvent(Interrupts flags);
        public void EnableEventExt(Interrupts flags);
        public void EnableFault(Axis axis, SafetyControlMasks fault);
        public ACSC_WAITBLOCK EnableFaultAsync(Axis axis, SafetyControlMasks fault);
        public void EnableM(Axis[] axes);
        public ACSC_WAITBLOCK EnableMAsync(Axis[] axes);
        public void EnableResponse(Axis axis, SafetyControlMasks response);
        public ACSC_WAITBLOCK EnableResponseAsync(Axis axis, SafetyControlMasks response);
        public void EndSequence(Axis axis);
        public ACSC_WAITBLOCK EndSequenceAsync(Axis axis);
        public void EndSequenceM(Axis[] axes);
        public ACSC_WAITBLOCK EndSequenceMAsync(Axis[] axes);
        public void ExtAddPoint(Axis axis, double point, double rate);
        public ACSC_WAITBLOCK ExtAddPointAsync(Axis axis, double point, double rate);
        public void ExtAddPointM(Axis[] axes, double[] point, double rate);
        public ACSC_WAITBLOCK ExtAddPointMAsync(Axis[] axes, double[] point, double rate);
        public void ExtArc1(Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity);
        public ACSC_WAITBLOCK ExtArc1Async(Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity);
        public void ExtArc2(Axis[] axes, double[] center, double angle, double velocity);
        public ACSC_WAITBLOCK ExtArc2Async(Axis[] axes, double[] center, double angle, double velocity);
        public void ExtendedSegmentArc1(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public ACSC_WAITBLOCK ExtendedSegmentArc1Async(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public void ExtendedSegmentArc2(MotionFlags flags, Axis[] axes, double[] center, double angle, double[] finalPoint, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public ACSC_WAITBLOCK ExtendedSegmentArc2Async(MotionFlags flags, Axis[] axes, double[] center, double angle, double[] finalPoint, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public void ExtendedSegmentedMotion(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double junctionVelocity, double angle, double starvationMargin, string segments);
        public ACSC_WAITBLOCK ExtendedSegmentedMotionAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double junctionVelocity, double angle, double starvationMargin, string segments);
        public void ExtendedSegmentedMotionExt(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double junctionVelocity, double angle, double curveVelocity, double deviation, double radius, double maxLength, double starvationMargin, string segments);
        public ACSC_WAITBLOCK ExtendedSegmentedMotionExtAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double junctionVelocity, double angle, double curveVelocity, double deviation, double radius, double maxLength, double starvationMargin, string segments);
        public void ExtendedSegmentedMotionV2(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double junctionVelocity, double angle, double curveVelocity, double deviation, double radius, double maxLength, double starvationMargin, string segments, int extLoopType, double minSegmentLength, double maxAllowedDeviation, int outputIndex, int bitNumber, int polarity, double motionDelay);
        public ACSC_WAITBLOCK ExtendedSegmentedMotionV2Async(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double junctionVelocity, double angle, double curveVelocity, double deviation, double radius, double maxLength, double starvationMargin, string segments, int extLoopType, double minSegmentLength, double maxAllowedDeviation, int outputIndex, int bitNumber, int polarity, double motionDelay);
        public void ExtLine(Axis[] axes, double[] point, double velocity);
        public ACSC_WAITBLOCK ExtLineAsync(Axis[] axes, double[] point, double velocity);
        public void ExtToPoint(MotionFlags flags, Axis axis, double point, double velocity, double endVelocity);
        public ACSC_WAITBLOCK ExtToPointAsync(MotionFlags flags, Axis axis, double point, double velocity, double endVelocity);
        public void ExtToPointM(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity);
        public ACSC_WAITBLOCK ExtToPointMAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity);
        public void FaultClear(Axis axis);
        public ACSC_WAITBLOCK FaultClearAsync(Axis axis);
        public void FaultClearM(Axis[] axes);
        public ACSC_WAITBLOCK FaultClearMAsync(Axis[] axes);
        public void FlushLogFile(string filename);
        public void FlushSCLogFile(string filename, bool bClear);
        public void FreeApplication(ApplicationFileInfo info);
        public FRD FRFCalculateClosedLoopFRD(ServoParameters servoParameters, FRF_LOOP_TYPE loopType, FRD plant);
        public FRD FRFCalculateControllerFRD(ServoParameters servoParameters, FRF_LOOP_TYPE loopType, double[] frequencyHz);
        public double FRFCalculateDuration(FRF_DURATION_CALCULATION_PARAMETERS durationCalculationParameters);
        public FRD FRFCalculateLoopDataFRD(FrfCalculateLoopData loopData);
        public FRD FRFCalculateOpenLoopFRD(ServoParameters servoParameters, FRF_LOOP_TYPE openType, FRD plant);
        public double FRFCalculateSLVRAT(FrfCalculateSlvratData data);
        public FRFStabilityMargins FRFCalculateStabilityMargins(FRD openLoop);
        public FRFCrossCouplingOutput FRFCrossCouplingMeasure(FRFCrossCouplingInput input);
        public FRFOutput FRFMeasure(FRFInput input);
        public ServoParameters FRFReadServoParameters(Axis axis);
        public void FRFStop(Axis axis);
        public int GeneralCallbackAsyncFunction(ulong param, IntPtr cardContext);
        public int GeneralExtCallbackAsyncFunction(AXMASK_EXT param, IntPtr cardContext);
        public double GetAcceleration(Axis axis);
        public ACSC_WAITBLOCK GetAccelerationAsync(Axis axis);
        public IntPtr GetACSCHandle();
        public int GetAnalogInput(int port);
        public ACSC_WAITBLOCK GetAnalogInputAsync(int port);
        public double GetAnalogInputNT(int port);
        public ACSC_WAITBLOCK GetAnalogInputNTAsync(int port);
        public int GetAnalogOutput(int port);
        public ACSC_WAITBLOCK GetAnalogOutputAsync(int port);
        public double GetAnalogOutputNT(int port);
        public ACSC_WAITBLOCK GetAnalogOutputNTAsync(int port);
        public double GetAxesCount();
        public ACSC_WAITBLOCK GetAxesCountAsync();
        public AxisStates GetAxisState(Axis axis);
        public ACSC_WAITBLOCK GetAxisStateAsync(Axis axis);
        public int[] GetBreakpointsList(ProgramBuffer bufferNum);
        public double GetBuffersCount();
        public ACSC_WAITBLOCK GetBuffersCountAsync();
        public ulong GetCallbackMask(Interrupts interrupt);
        public AXMASK_EXT GetCallbackMaskExt(Interrupts interrupt);
        public CommOptions GetCommOptions();
        public double GetConf(int key, int index);
        public ACSC_WAITBLOCK GetConfAsync(int key, int index);
        public ACSC_CONNECTION_INFO GetConnectionInfo();
        public ACSC_CONNECTION_DESC[] GetConnectionsList();
        public double GetDBufferIndex();
        public ACSC_WAITBLOCK GetDBufferIndexAsync();
        public double GetDeceleration(Axis axis);
        public ACSC_WAITBLOCK GetDecelerationAsync(Axis axis);
        public int GetDefaultTimeout();
        public string GetErrorString(int errorCode);
        public int GetEtherCATError();
        public ACSC_WAITBLOCK GetEtherCATErrorAsync();
        public double GetEtherCATSlaveIndex(int vendorID, int productID, int count);
        public ACSC_WAITBLOCK GetEtherCATSlaveIndexAsync(int vendorID, int productID, int count);
        public double GetEtherCATSlaveOffset(string variableName, int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveOffsetAsync(string variableName, int slaveIndex);
        public double GetEtherCATSlaveOffsetV2(EtherCATFlags flags, string variableName, int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveOffsetV2Async(EtherCATFlags flags, string variableName, int slaveIndex);
        public double GetEtherCATSlaveProductID(int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveProductIDAsync(int slaveIndex);
        public double GetEtherCATSlaveProductIDV2(EtherCATFlags flags, int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveProductIDV2Async(EtherCATFlags flags, int slaveIndex);
        public double GetEtherCATSlaveRegister(EtherCATFlags flags, int slaveIndex, int offset);
        public ACSC_WAITBLOCK GetEtherCATSlaveRegisterAsync(EtherCATFlags flags, int slaveIndex, int offset);
        public double GetEtherCATSlaveRevision(int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveRevisionAsync(int slaveIndex);
        public double GetEtherCATSlaveRevisionV2(EtherCATFlags flags, int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveRevisionV2Async(EtherCATFlags flags, int slaveIndex);
        public double GetEtherCATSlavesCount(EtherCATFlags flags);
        public ACSC_WAITBLOCK GetEtherCATSlavesCountAsync(EtherCATFlags flags);
        public double GetEtherCATSlaveSerialNumber(EtherCATFlags flags, int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveSerialNumberAsync(EtherCATFlags flags, int slaveIndex);
        public double GetEtherCATSlaveState(int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveStateAsync(int slaveIndex);
        public double GetEtherCATSlaveStateV2(EtherCATFlags flags, int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveStateV2Async(EtherCATFlags flags, int slaveIndex);
        public double GetEtherCATSlaveType(int vendorID, int productID);
        public ACSC_WAITBLOCK GetEtherCATSlaveTypeAsync(int vendorID, int productID);
        public double GetEtherCATSlaveVendorID(int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveVendorIDAsync(int slaveIndex);
        public double GetEtherCATSlaveVendorIDV2(EtherCATFlags flags, int slaveIndex);
        public ACSC_WAITBLOCK GetEtherCATSlaveVendorIDV2Async(EtherCATFlags flags, int slaveIndex);
        public EtherCATFlags GetEtherCATState();
        public ACSC_WAITBLOCK GetEtherCATStateAsync();
        public IPAddress[] GetEthernetCards(IPAddress broadcast);
        public ICollection<AcscControllerInfo> GetEthernetCardsExt(IPAddress broadcast, int bufferArraySize = 100);
        public int GetExtInput(int port, int bit);
        public ACSC_WAITBLOCK GetExtInputAsync(int port, int bit);
        public int GetExtInputPort(int port);
        public ACSC_WAITBLOCK GetExtInputPortAsync(int port);
        public int GetExtOutput(int port, int bit);
        public ACSC_WAITBLOCK GetExtOutputAsync(int port, int bit);
        public int GetExtOutputPort(int port);
        public ACSC_WAITBLOCK GetExtOutputPortAsync(int port);
        public SafetyControlMasks GetFault(Axis axis);
        public ACSC_WAITBLOCK GetFaultAsync(Axis axis);
        public SafetyControlMasks GetFaultMask(Axis axis);
        public ACSC_WAITBLOCK GetFaultMaskAsync(Axis axis);
        public string GetFirmwareVersion();
        public ACSC_WAITBLOCK GetFirmwareVersionAsync();
        public double GetFPosition(Axis axis);
        public ACSC_WAITBLOCK GetFPositionAsync(Axis axis);
        public double GetFVelocity(Axis axis);
        public ACSC_WAITBLOCK GetFVelocityAsync(Axis axis);
        public string GetHistory(bool bClear);
        public IndexStates GetIndexState(Axis axis);
        public ACSC_WAITBLOCK GetIndexStateAsync(Axis axis);
        public int GetInput(int port, int bit);
        public ACSC_WAITBLOCK GetInputAsync(int port, int bit);
        public int GetInputPort(int port);
        public ACSC_WAITBLOCK GetInputPortAsync(int port);
        public uint GetInterruptMask(Interrupts interrupt);
        public double GetJerk(Axis axis);
        public ACSC_WAITBLOCK GetJerkAsync(Axis axis);
        public double GetKillDeceleration(Axis axis);
        public ACSC_WAITBLOCK GetKillDecelerationAsync(Axis axis);
        public int GetLastError();
        public uint GetLibraryVersion();
        public string GetLogData();
        public ACSC_WAITBLOCK GetLogDataAsync();
        public string GetMessage(bool bClear);
        public int GetMotionError(Axis axis);
        public ACSC_WAITBLOCK GetMotionErrorAsync(Axis axis);
        public int GetMotorError(Axis axis);
        public ACSC_WAITBLOCK GetMotorErrorAsync(Axis axis);
        public MotorStates GetMotorState(Axis axis);
        public ACSC_WAITBLOCK GetMotorStateAsync(Axis axis);
        public uint GetNETLibraryVersion();
        public double GetNonVolatileMemoryFree();
        public ACSC_WAITBLOCK GetNonVolatileMemoryFreeAsync();
        public double GetNonVolatileMemoryTotal();
        public ACSC_WAITBLOCK GetNonVolatileMemoryTotalAsync();
        public double GetNonVolatileMemoryUsage();
        public ACSC_WAITBLOCK GetNonVolatileMemoryUsageAsync();
        public int GetOutput(int port, int bit);
        public ACSC_WAITBLOCK GetOutputAsync(int port, int bit);
        public int GetOutputPort(int port);
        public ACSC_WAITBLOCK GetOutputPortAsync(int port);
        public ACSC_PCI_SLOT[] GetPCICards();
        public int GetProgramError(ProgramBuffer buffer);
        public ACSC_WAITBLOCK GetProgramErrorAsync(ProgramBuffer buffer);
        public ProgramStates GetProgramState(ProgramBuffer buffer);
        public ACSC_WAITBLOCK GetProgramStateAsync(ProgramBuffer buffer);
        public int GetQueueOverflowTimeout();
        public SafetyControlMasks GetResponseMask(Axis axis);
        public ACSC_WAITBLOCK GetResponseMaskAsync(Axis axis);
        public object GetResult(ACSC_WAITBLOCK waitBlock, int timeout);
        public double GetRPosition(Axis axis);
        public ACSC_WAITBLOCK GetRPositionAsync(Axis axis);
        public double GetRVelocity(Axis axis);
        public ACSC_WAITBLOCK GetRVelocityAsync(Axis axis);
        public SafetyControlMasks GetSafetyInput(Axis axis, SafetyControlMasks input);
        public ACSC_WAITBLOCK GetSafetyInputAsync(Axis axis, SafetyControlMasks input);
        public SafetyControlMasks GetSafetyInputPort(Axis axis);
        public ACSC_WAITBLOCK GetSafetyInputPortAsync(Axis axis);
        public SafetyControlMasks GetSafetyInputPortInv(Axis axis);
        public ACSC_WAITBLOCK GetSafetyInputPortInvAsync(Axis axis);
        public string GetSerialNumber();
        public ACSC_WAITBLOCK GetSerialNumberAsync();
        public uint GetSharedMemoryAddress(ProgramBuffer nBuf, string var);
        public ACSC_WAITBLOCK GetSharedMemoryAddressAsync(ProgramBuffer nBuf, string var);
        public string GetSingleMessage(int timeout);
        public double GetSPAddress(ServoProcessorDataCollectionFlags flags, ServoProcessor sP_Index, string sP_Variable);
        public ACSC_WAITBLOCK GetSPAddressAsync(ServoProcessorDataCollectionFlags flags, ServoProcessor sP_Index, string sP_Variable);
        public double GetTargetPosition(Axis axis);
        public ACSC_WAITBLOCK GetTargetPositionAsync(Axis axis);
        public int GetTimeout();
        public uint GetUMDVersion();
        public double GetVelocity(Axis axis);
        public ACSC_WAITBLOCK GetVelocityAsync(Axis axis);
        public double GetVolatileMemoryFree();
        public ACSC_WAITBLOCK GetVolatileMemoryFreeAsync();
        public double GetVolatileMemoryTotal();
        public ACSC_WAITBLOCK GetVolatileMemoryTotalAsync();
        public double GetVolatileMemoryUsage();
        public ACSC_WAITBLOCK GetVolatileMemoryUsageAsync();
        public void Go(Axis axis);
        public ACSC_WAITBLOCK GoAsync(Axis axis);
        public void GoM(Axis[] axes);
        public ACSC_WAITBLOCK GoMAsync(Axis[] axes);
        public void Group(Axis[] axes);
        public ACSC_WAITBLOCK GroupAsync(Axis[] axes);
        public void Halt(Axis axis);
        public ACSC_WAITBLOCK HaltAsync(Axis axis);
        public void HaltM(Axis[] axes);
        public ACSC_WAITBLOCK HaltMAsync(Axis[] axes);
        public void InstallCallback(ACSC_USER_CALLBACK_FUNCTION callback, IntPtr cardContext, Interrupts interrupt);
        public void InstallCallbackExt(ACSC_USER_CALLBACK_FUNCTION_EXT callback, IntPtr cardContext, Interrupts interrupt);
        public JitterAnalysisOutput JitterAnalysis(JitterAnalysisInput analysisInput);
        public void Jog(MotionFlags flags, Axis axis, double velocity);
        public ACSC_WAITBLOCK JogAsync(MotionFlags flags, Axis axis, double velocity);
        public void JogM(MotionFlags flags, Axis[] axes, GlobalDirection[] direction, double velocity);
        public ACSC_WAITBLOCK JogMAsync(MotionFlags flags, Axis[] axes, GlobalDirection[] direction, double velocity);
        public void Kill(Axis axis);
        public void KillAll();
        public ACSC_WAITBLOCK KillAllAsync();
        public ACSC_WAITBLOCK KillAsync(Axis axis);
        public void KillExt(Axis axis, int reason);
        public ACSC_WAITBLOCK KillExtAsync(Axis axis, int reason);
        public void KillM(Axis[] axes);
        public ACSC_WAITBLOCK KillMAsync(Axis[] axes);
        public void Line(Axis[] axes, double[] point);
        public ACSC_WAITBLOCK LineAsync(Axis[] axes, double[] point);
        public string LoadApplication(string fileName, ApplicationFileInfo info, bool isPreview);
        public ACSC_WAITBLOCK LoadApplicationAsync(string fileName, ApplicationFileInfo info, bool isPreview, out string preview);
        public void LoadBuffer(ProgramBuffer buffer, string text);
        public ACSC_WAITBLOCK LoadBufferAsync(ProgramBuffer buffer, string text);
        public void LoadBufferIgnoreServiceLines(ProgramBuffer buffer, string text);
        public ACSC_WAITBLOCK LoadBufferIgnoreServiceLinesAsync(ProgramBuffer buffer, string text);
        public void LoadBuffersFromFile(string filename);
        public ACSC_WAITBLOCK LoadBuffersFromFileAsync(string filename);
        public void LoadDataToController(int dest, string destName, int from1, int to1, int from2, int to2, string srcFileName, int srcNumFormat, bool bTranspose);
        public ACSC_WAITBLOCK LoadDataToControllerAsync(int dest, string destName, int from1, int to1, int from2, int to2, string srcFileName, int srcNumFormat, bool bTranspose);
        public void LoadFileToIntegerVariable(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, string filename);
        public ACSC_WAITBLOCK LoadFileToIntegerVariableAsync(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, string filename);
        public void LoadFileToRealVariable(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, string filename);
        public ACSC_WAITBLOCK LoadFileToRealVariableAsync(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, string filename);
        public void MapEtherCATInput(EtherCATFlags flags, int offset, string variableName);
        public ACSC_WAITBLOCK MapEtherCATInputAsync(EtherCATFlags flags, int offset, string variableName);
        public void MapEtherCATOutput(EtherCATFlags flags, int offset, string variableName);
        public ACSC_WAITBLOCK MapEtherCATOutputAsync(EtherCATFlags flags, int offset, string variableName);
        public void MultiPoint(MotionFlags flags, Axis axis, double dwell);
        public ACSC_WAITBLOCK MultiPointAsync(MotionFlags flags, Axis axis, double dwell);
        public void MultiPointM(MotionFlags flags, Axis[] axes, double dwell);
        public ACSC_WAITBLOCK MultiPointMAsync(MotionFlags flags, Axis[] axes, double dwell);
        public void NurbsMotion(MotionFlags flags, Axis[] axes, double velocity, double exceptionAngle, double exceptionLength, double motionDelay, string segments);
        public ACSC_WAITBLOCK NurbsMotionAsync(MotionFlags flags, Axis[] axes, double velocity, double exceptionAngle, double exceptionLength, double motionDelay, string segments);
        public void NurbsPoints(MotionFlags flags, Axis[] axes, double[] point, double velocity, double required_vel, double knot, double weight);
        public ACSC_WAITBLOCK NurbsPointsAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double required_vel, double knot, double weight);
        public void OpenCommEthernet(string address, int port);
        public void OpenCommEthernetTCP(string address, int port);
        public void OpenCommEthernetUDP(string address, int port);
        public void OpenCommPCI(int slotNumber);
        public void OpenCommSerial(int channel, int rate);
        public void OpenCommSimulator();
        public void OpenHistoryBuffer(int size);
        public void OpenLogFile(string fileName);
        public void OpenMessageBuffer(int size);
        public void OpenSCLogFile(string fileName);
        public void PegI(MotionFlags flags, Axis axis, double width, int firstPoint, int interval, int lastPoint, int tbNumber, double tbPeriod);
        public ACSC_WAITBLOCK PegIAsync(MotionFlags flags, Axis axis, double width, int firstPoint, int interval, int lastPoint, int tbNumber, double tbPeriod);
        public void PegIncNT(MotionFlags flags, Axis axis, double width, double firstPoint, double interval, double lastPoint, int tbNumber, double tbPeriod);
        public ACSC_WAITBLOCK PegIncNTAsync(MotionFlags flags, Axis axis, double width, double firstPoint, double interval, double lastPoint, int tbNumber, double tbPeriod);
        public void PegIncNTV2(MotionFlags flags, Axis axis, double width, double firstPoint, double interval, double lastPoint, int errMapAxis1, double axisCoord1, int errMapAxis2, double axisCoord2, int errMapMaxSize, double minDirDistance, int tbNumber, double tbPeriod);
        public ACSC_WAITBLOCK PegIncNTV2Async(MotionFlags flags, Axis axis, double width, double firstPoint, double interval, double lastPoint, int errMapAxis1, double axisCoord1, int errMapAxis2, double axisCoord2, int errMapMaxSize, double minDirDistance, int tbNumber, double tbPeriod);
        public void PegR(MotionFlags flags, Axis axis, double width, string pointArray, string stateArray, int tbNumber, double tbPeriod);
        public void PegRandomNT(MotionFlags flags, Axis axis, double width, int mode, int firstIndex, int lastIndex, string pointArray, string stateArray, int tbNumber, double tbPeriod);
        public ACSC_WAITBLOCK PegRandomNTAsync(MotionFlags flags, Axis axis, double width, int mode, int firstIndex, int lastIndex, string pointArray, string stateArray, int tbNumber, double tbPeriod);
        public void PegRandomNTV2(MotionFlags flags, Axis axis, double width, int mode, int firstIndex, int lastIndex, string pointArray, string stateArray, int errMapAxis1, double axisCoord1, int errMapAxis2, double axisCoord2, double minDirDistance, int tbNumber, double tbPeriod);
        public ACSC_WAITBLOCK PegRandomNTV2Async(MotionFlags flags, Axis axis, double width, int mode, int firstIndex, int lastIndex, string pointArray, string stateArray, int errMapAxis1, double axisCoord1, int errMapAxis2, double axisCoord2, double minDirDistance, int tbNumber, double tbPeriod);
        public ACSC_WAITBLOCK PegRAsync(MotionFlags flags, Axis axis, double width, string pointArray, string stateArray, int tbNumber, double tbPeriod);
        public void Projection(Axis[] axes, string matrix);
        public ACSC_WAITBLOCK ProjectionAsync(Axis[] axes, string matrix);
        public string RawTransaction(string outBuf);
        public ACSC_WAITBLOCK RawTransactionAsync(string outBuf);
        public double ReadSDOValueOverEtherCAT(EtherCATFlags flags, int slaveIndex, int index, int subIndex);
        public ACSC_WAITBLOCK ReadSDOValueOverEtherCATAsync(EtherCATFlags flags, int slaveIndex, int index, int subIndex);
        public object ReadSharedMemoryInteger(uint address, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public object ReadSharedMemoryReal(uint address, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public void ReadString(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, string strings, ushort stringSize);
        public ACSC_WAITBLOCK ReadStringAsync(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, string strings, ushort stringSize);
        public void ReadTypeless(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, ref IntPtr pValues, ref int dataSize, ref int dim1, ref int dim2, ref int dataOffset);
        public ACSC_WAITBLOCK ReadTypelessAsync(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, ref IntPtr pValues, ref int dataSize, ref int dim1, ref int dim2, ref int dataOffset);
        public object ReadVariable(string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public object ReadVariableAsMatrix(string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public ACSC_WAITBLOCK ReadVariableAsMatrixAsync(string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public object ReadVariableAsObject(string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public object ReadVariableAsScalar(string variable, ProgramBuffer nBuf, int ind1 = -1, int ind2 = -1);
        public ACSC_WAITBLOCK ReadVariableAsScalarAsync(string variable, ProgramBuffer nBuf, int ind1 = -1, int ind2 = -1);
        public object ReadVariableAsVector(string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public ACSC_WAITBLOCK ReadVariableAsVectorAsync(string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public ACSC_WAITBLOCK ReadVariableAsync(string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public string Receive();
        public ACSC_WAITBLOCK ReceiveAsync();
        public void RegisterEmergencyStop();
        public void RegisterFRFUser(byte[] regKey, out int errorCode);
        public void ReleaseComm();
        public void ResetIndexState(Axis axis, IndexStates mask);
        public ACSC_WAITBLOCK ResetIndexStateAsync(Axis axis, IndexStates mask);
        public void RunBuffer(ProgramBuffer buffer, string label);
        public ACSC_WAITBLOCK RunBufferAsync(ProgramBuffer buffer, string label);
        public string SaveApplication(string fileName, ApplicationFileInfo info);
        public ACSC_WAITBLOCK SaveApplicationAsync(string fileName, ApplicationFileInfo info, out string preview);
        public void Segment(MotionFlags flags, Axis[] axes, double[] point);
        public void SegmentArc1(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity, double endVelocity, string values, string variables, int index, string masks);
        public ACSC_WAITBLOCK SegmentArc1Async(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity, double endVelocity, string values, string variables, int index, string masks);
        public void SegmentArc1Ext(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public ACSC_WAITBLOCK SegmentArc1ExtAsync(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public void SegmentArc1V2(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity, double endVelocity, double time, string values, string variables, int index, string masks, int extLoopType, double minSegmentLength, double maxAllowedDeviation, int lciState);
        public ACSC_WAITBLOCK SegmentArc1V2Async(MotionFlags flags, Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation, double velocity, double endVelocity, double time, string values, string variables, int index, string masks, int extLoopType, double minSegmentLength, double maxAllowedDeviation, int lciState);
        public void SegmentArc2(MotionFlags flags, Axis[] axes, double[] center, double angle, double velocity, double endVelocity, string values, string variables, int index, string masks);
        public ACSC_WAITBLOCK SegmentArc2Async(MotionFlags flags, Axis[] axes, double[] center, double angle, double velocity, double endVelocity, string values, string variables, int index, string masks);
        public void SegmentArc2Ext(MotionFlags flags, Axis[] axes, double[] center, double angle, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public ACSC_WAITBLOCK SegmentArc2ExtAsync(MotionFlags flags, Axis[] axes, double[] center, double angle, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public void SegmentArc2V2(MotionFlags flags, Axis[] axes, double[] center, double angle, double[] finalPoint, double velocity, double endVelocity, double time, string values, string variables, int index, string masks, int extLoopType, double minSegmentLength, double maxAllowedDeviation, int lciState);
        public ACSC_WAITBLOCK SegmentArc2V2Async(MotionFlags flags, Axis[] axes, double[] center, double angle, double[] finalPoint, double velocity, double endVelocity, double time, string values, string variables, int index, string masks, int extLoopType, double minSegmentLength, double maxAllowedDeviation, int lciState);
        public ACSC_WAITBLOCK SegmentAsync(MotionFlags flags, Axis[] axes, double[] point);
        public void SegmentedMotion(MotionFlags flags, Axis[] axes, double[] point);
        public ACSC_WAITBLOCK SegmentedMotionAsync(MotionFlags flags, Axis[] axes, double[] point);
        public void SegmentLine(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, string values, string variables, int index, string masks);
        public ACSC_WAITBLOCK SegmentLineAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, string values, string variables, int index, string masks);
        public void SegmentLineExt(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public ACSC_WAITBLOCK SegmentLineExtAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double time, string values, string variables, int index, string masks);
        public void SegmentLineV2(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double time, string values, string variables, int index, string masks, int extLoopType, double minSegmentLength, double maxAllowedDeviation, int lciState);
        public ACSC_WAITBLOCK SegmentLineV2Async(MotionFlags flags, Axis[] axes, double[] point, double velocity, double endVelocity, double time, string values, string variables, int index, string masks, int extLoopType, double minSegmentLength, double maxAllowedDeviation, int lciState);
        public void Send(string buf);
        public ACSC_WAITBLOCK SendAsync(string buf);
        public void SetAcceleration(Axis axis, double acceleration);
        public ACSC_WAITBLOCK SetAccelerationAsync(Axis axis, double acceleration);
        public void SetAccelerationImm(Axis axis, double acceleration);
        public ACSC_WAITBLOCK SetAccelerationImmAsync(Axis axis, double acceleration);
        public void SetAnalogOutput(int port, int value);
        public ACSC_WAITBLOCK SetAnalogOutputAsync(int port, int value);
        public void SetAnalogOutputNT(int port, double value);
        public ACSC_WAITBLOCK SetAnalogOutputNTAsync(int port, double value);
        public void SetBreakpoint(ProgramBuffer buffer, int line);
        public ACSC_WAITBLOCK SetBreakpointAsync(ProgramBuffer buffer, int line);
        public void SetCallback(ACSC_INTR_CALLBACK_FUNC callback, Interrupts interrupt);
        public void SetCallbackExt(ACSC_INTR_CALLBACK_FUNC_EXT callback, IntPtr cardContext, Interrupts interrupt);
        public void SetCallbackMask(Interrupts interrupt, ulong mask);
        public void SetCallbackMaskExt(Interrupts interrupt, AXMASK_EXT mask);
        public void SetCallbackPriority(int priority);
        public void SetCommOptions(CommOptions options);
        public void SetConf(int key, int index, double value);
        public ACSC_WAITBLOCK SetConfAsync(int key, int index, double value);
        public void SetDeceleration(Axis axis, double deceleration);
        public ACSC_WAITBLOCK SetDecelerationAsync(Axis axis, double deceleration);
        public void SetDecelerationImm(Axis axis, double deceleration);
        public ACSC_WAITBLOCK SetDecelerationImmAsync(Axis axis, double deceleration);
        public void SetExtOutput(int port, int bit, int value);
        public ACSC_WAITBLOCK SetExtOutputAsync(int port, int bit, int value);
        public void SetExtOutputPort(int port, int value);
        public ACSC_WAITBLOCK SetExtOutputPortAsync(int port, int value);
        public void SetFaultMask(Axis axis, SafetyControlMasks mask);
        public ACSC_WAITBLOCK SetFaultMaskAsync(Axis axis, SafetyControlMasks mask);
        public void SetFPosition(Axis axis, double fPosition);
        public ACSC_WAITBLOCK SetFPositionAsync(Axis axis, double fPosition);
        public void SetInterruptMask(Interrupts interrupt, uint mask);
        public void SetIterations(int iterations);
        public void SetJerk(Axis axis, double jerk);
        public ACSC_WAITBLOCK SetJerkAsync(Axis axis, double jerk);
        public void SetJerkImm(Axis axis, double jerk);
        public ACSC_WAITBLOCK SetJerkImmAsync(Axis axis, double jerk);
        public void SetKillDeceleration(Axis axis, double killDeceleration);
        public ACSC_WAITBLOCK SetKillDecelerationAsync(Axis axis, double killDeceleration);
        public void SetKillDecelerationImm(Axis axis, double killDeceleration);
        public ACSC_WAITBLOCK SetKillDecelerationImmAsync(Axis axis, double killDeceleration);
        public void SetLogFileOptions(ACSC_LOG_DETALIZATION_LEVEL detalization, ACSC_LOG_DATA_PRESENTATION presentation);
        public void SetMaster(Axis axis, string formula);
        public ACSC_WAITBLOCK SetMasterAsync(Axis axis, string formula);
        public void SetOutput(int port, int bit, int value);
        public ACSC_WAITBLOCK SetOutputAsync(int port, int bit, int value);
        public void SetOutputPort(int port, int value);
        public ACSC_WAITBLOCK SetOutputPortAsync(int port, int value);
        public void SetQueueOverflowTimeout(int timeout);
        public void SetResponseMask(Axis axis, SafetyControlMasks mask);
        public ACSC_WAITBLOCK SetResponseMaskAsync(Axis axis, SafetyControlMasks mask);
        public void SetRPosition(Axis axis, double rPosition);
        public ACSC_WAITBLOCK SetRPositionAsync(Axis axis, double rPosition);
        public void SetSafetyInputPortInv(Axis axis, SafetyControlMasks value);
        public ACSC_WAITBLOCK SetSafetyInputPortInvAsync(Axis axis, SafetyControlMasks value);
        public void SetServerExt(string iP, int port);
        public void SetServerExtLogin(string iP, int port, string username, string password, string domain);
        public void SetTargetPosition(Axis axis, double targetPosition);
        public ACSC_WAITBLOCK SetTargetPositionAsync(Axis axis, double targetPosition);
        public void SetTargetPositionM(Axis[] axes, double[] targetPositions);
        public ACSC_WAITBLOCK SetTargetPositionMAsync(Axis[] axes, double[] targetPositions);
        public void SetTimeout(int timeout);
        public void SetVelocity(Axis axis, double velocity);
        public ACSC_WAITBLOCK SetVelocityAsync(Axis axis, double velocity);
        public void SetVelocityImm(Axis axis, double velocity);
        public ACSC_WAITBLOCK SetVelocityImmAsync(Axis axis, double velocity);
        public void Slave(MotionFlags flags, Axis axis);
        public ACSC_WAITBLOCK SlaveAsync(MotionFlags flags, Axis axis);
        public void SlaveStalled(MotionFlags flags, Axis axis, double left, double right);
        public ACSC_WAITBLOCK SlaveStalledAsync(MotionFlags flags, Axis axis, double left, double right);
        public void SmoothPathMotion(MotionFlags flags, Axis[] axes, double[] point, double velocity, double exceptionAngle, double exceptionLength, double motionDelay, string segments);
        public ACSC_WAITBLOCK SmoothPathMotionAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double exceptionAngle, double exceptionLength, double motionDelay, string segments);
        public void SmoothPathSegment(MotionFlags flags, Axis[] axes, double[] point, double velocity, double required_vel);
        public ACSC_WAITBLOCK SmoothPathSegmentAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double required_vel);
        public void SmoothPointToPointMotion(MotionFlags flags, Axis[] axes, double[] point, double velocity);
        public ACSC_WAITBLOCK SmoothPointToPointMotionAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity);
        public void SmoothTransitionPointToPointMotion(MotionFlags flags, Axis[] axes, double[] point, double velocity, double motionDelay);
        public ACSC_WAITBLOCK SmoothTransitionPointToPointMotionAsync(MotionFlags flags, Axis[] axes, double[] point, double velocity, double motionDelay);
        public void SPDataCollectionStart(ServoProcessorDataCollectionFlags flags, string array, int nSample, double period, ServoProcessor sP_Index, int sP_Address1, int sP_Address2, int sP_Address3, int sP_Address4);
        public ACSC_WAITBLOCK SPDataCollectionStartAsync(ServoProcessorDataCollectionFlags flags, string array, int nSample, double period, ServoProcessor sP_Index, int sP_Address1, int sP_Address2, int sP_Address3, int sP_Address4);
        public void SPDataCollectionStop(ServoProcessor sP_Index);
        public ACSC_WAITBLOCK SPDataCollectionStopAsync(ServoProcessor sP_Index);
        public void Spline(MotionFlags flags, Axis axis, double period);
        public ACSC_WAITBLOCK SplineAsync(MotionFlags flags, Axis axis, double period);
        public void SplineM(MotionFlags flags, Axis[] axes, double period);
        public ACSC_WAITBLOCK SplineMAsync(MotionFlags flags, Axis[] axes, double period);
        public void Split(Axis[] axes);
        public void SplitAll();
        public ACSC_WAITBLOCK SplitAllAsync();
        public ACSC_WAITBLOCK SplitAsync(Axis[] axes);
        public void StartPegNT(Axis axis);
        public ACSC_WAITBLOCK StartPegNTAsync(Axis axis);
        public void StartSPiiPlusSC();
        public void StopBuffer(ProgramBuffer buffer);
        public ACSC_WAITBLOCK StopBufferAsync(ProgramBuffer buffer);
        public void StopCollect();
        public ACSC_WAITBLOCK StopCollectAsync();
        public void StopPegNT(Axis axis);
        public ACSC_WAITBLOCK StopPegNTAsync(Axis axis);
        public void Stopper(Axis[] axes);
        public ACSC_WAITBLOCK StopperAsync(Axis[] axes);
        public void StopSPiiPlusSC();
        public void SuspendBuffer(ProgramBuffer buffer);
        public ACSC_WAITBLOCK SuspendBufferAsync(ProgramBuffer buffer);
        public double SysInfo(int key);
        public ACSC_WAITBLOCK SysInfoAsync(int key);
        public void TerminateConnection(ACSC_CONNECTION_DESC connection);
        public void ToPoint(MotionFlags flags, Axis axis, double point);
        public ACSC_WAITBLOCK ToPointAsync(MotionFlags flags, Axis axis, double point);
        public void ToPointM(MotionFlags flags, Axis[] axes, double[] point);
        public ACSC_WAITBLOCK ToPointMAsync(MotionFlags flags, Axis[] axes, double[] point);
        public void Track(MotionFlags flags, Axis axis);
        public ACSC_WAITBLOCK TrackAsync(MotionFlags flags, Axis axis);
        public void TrackM(MotionFlags flags, Axis[] axis);
        public ACSC_WAITBLOCK TrackMAsync(MotionFlags flags, Axis[] axis);
        public string Transaction(string outBuf);
        public ACSC_WAITBLOCK TransactionAsync(string outBuf);
        public byte[] TransactionBinary(byte[] outBuf);
        public byte[] TransactionBinary(string command);
        public ACSC_WAITBLOCK TransactionBinaryAsync(byte[] outBuf);
        public ACSC_WAITBLOCK TransactionBinaryAsync(string command);
        public void UnmapEtherCATInputsOutputs();
        public ACSC_WAITBLOCK UnmapEtherCATInputsOutputsAsync();
        public void UnregisterEmergencyStop();
        public string UploadBuffer(ProgramBuffer buffer);
        public ACSC_WAITBLOCK UploadBufferAsync(ProgramBuffer buffer);
        public void UploadDataFromController(int src, string srcName, int srcNumFormat, int from1, int to1, int from2, int to2, string destFileName, string destNumFormat, bool bTranspose);
        public ACSC_WAITBLOCK UploadDataFromControllerAsync(int src, string srcName, int srcNumFormat, int from1, int to1, int from2, int to2, string destFileName, string destNumFormat, bool bTranspose);
        public void WaitCollectEndExt(int timeout, Axis axis);
        public void WaitInput(int port, int bit, int state, int timeout);
        public void WaitLogicalMotionEnd(Axis axis, int timeout);
        public void WaitMotionEnd(Axis axis, int timeout);
        public void WaitMotorCommutated(Axis axis, int state, int timeout);
        public void WaitMotorEnabled(Axis axis, int state, int timeout);
        public void WaitPegReadyNT(Axis axis, int timeout);
        public void WaitProgramEnd(ProgramBuffer buffer, int timeout);
        public void WaitSPDataCollectionEnd(int timeout, ServoProcessor sP_Index);
        public void WaitUserCondition(ACSC_USER_CONDITION_FUNC userCondition, int timeout);
        public void WriteLogFile(string buf);
        public void WriteSCLogFile(string buf);
        public void WriteSDOValueOverEtherCAT(EtherCATFlags flags, int slaveIndex, int index, int subIndex, double value);
        public ACSC_WAITBLOCK WriteSDOValueOverEtherCATAsync(EtherCATFlags flags, int slaveIndex, int index, int subIndex, double value);
        public void WriteSharedMemoryVariable(object value, uint address, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public void WriteString(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, string strings, ushort stringSize);
        public ACSC_WAITBLOCK WriteStringAsync(ProgramBuffer nBuf, string var, int from1, int to1, int from2, int to2, string strings, ushort stringSize);
        public void WriteVariable(object value, string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);
        public ACSC_WAITBLOCK WriteVariableAsync(object value, string variable, ProgramBuffer nBuf = ProgramBuffer.ACSC_NONE, int from1 = -1, int to1 = -1, int from2 = -1, int to2 = -1);

        public delegate void DefaultAxisExtEventHandler(DefaultAxisMasksStruct data);
        public delegate void AxisExtEventHandler(AxisMasksStruct axisData);
        public delegate void BufferExtEventHandler(BufferMasksStruct bufferData);
        public delegate void InputExtEventHandler(InputsMasksStruct inputData);
        public delegate void DefaultAxisEventHandler(ulong param);
        public delegate void AxisEventHandler(AxisMasks axis);
        public delegate void BufferEventHandler(BufferMasks axis);
        public delegate void InputEventHandler(InputMasks axis);
    }
}

以下是针对 ACS.SPiiPlusNET.Api 类的全面解析，结合其功能架构和实现细节：

1. 类概述

Api 类是 ACS SPiiPlus 运动控制器的核心托管接口，封装了与硬件控制器通信的所有功能。主要特点：

  • 连接管理：支持以太网/PCI/串口/模拟器多种连接方式

  • 实时控制：提供超过 500 个运动控制方法

  • 异步编程：所有方法均有同步/异步版本（Async 后缀）

  • 事件驱动：定义 30+ 事件类型处理控制器状态变化

2. 核心功能模块

(1) 连接管理
public bool IsConnected { get; }
public void OpenCommEthernet(string address, int port);
public void OpenCommPCI(int slotNumber);
public void CloseComm();

  • 支持多协议连接（TCP/UDP/PCI/Serial）

  • 提供连接状态监控

(2) 轴控制
// 单轴控制
public void Enable(Axis axis); 
public void Jog(MotionFlags flags, Axis axis, double velocity);

// 多轴协同
public void Line(Axis[] axes, double[] point);  // 直线插补
public void Arc1(Axis[] axes, double[] center, double[] finalPoint, RotationDirection rotation); // 圆弧插补

  • 支持点到点、速度、同步控制

  • 提供急停(Kill)/暂停(Halt)等安全功能

(3) 程序缓冲区
public void DownloadBuffer(ProgramBuffer buffer, string text);
public void RunBuffer(ProgramBuffer buffer, string label);

  • 管理 8 个程序缓冲区（ProgramBuffer.ACSC_BUFFER_0~7）

  • 支持动态加载/执行 ACSL 运动控制语言

(4) 数据采集
public void DataCollection(DataCollectionFlags flags, Axis axis, string array, int nSample, int period, string vars);

  • 实时采集位置/速度等运动数据

  • 支持自定义采样周期和触发条件

(5) EtherCAT 集成
public double GetEtherCATSlaveRegister(EtherCATFlags flags, int slaveIndex, int offset);
public void WriteSDOValueOverEtherCAT(EtherCATFlags flags, int slaveIndex, int index, int subIndex, double value);

  • 完整的 EtherCAT 主站功能

  • 支持 SDO/PDO 配置和实时监控

3. 关键设计模式

(1) 异步模式

每个同步方法都有对应的异步版本：

// 同步
public void Enable(Axis axis); 

// 异步
public ACSC_WAITBLOCK EnableAsync(Axis axis);

使用 ACSC_WAITBLOCK 结构管理异步操作状态

(2) 事件系统

定义多种事件委托类型：

public event AxisEventHandler MOTIONSTART;  // 运动开始事件
public event BufferEventHandler PROGRAMEND; // 程序结束事件

典型事件处理流程：

(3) 资源管理

实现隐式资源释放：

 

~Api() { CloseComm(); }  // 析构函数确保连接关闭

4. 重要数据结构

(1) 枚举类型
public enum MotionFlags {
    ACSC_NONE = -1,
    ACSC_AMF_COORDINATE = 0x01  // 坐标运动模式
}

public enum RotationDirection {
    ACSC_CCW = 0,  // 逆时针
    ACSC_CW = 1     // 顺时针
}
(2) 结构体
public struct AxisMasksStruct {
    public Axis Axis;
    public ulong Mask;
}

public struct FRD {  // 频率响应数据
    public double[] Frequency;
    public double[] Magnitude; 
    public double[] Phase;
}

5. 典型使用流程

(1) 初始化连接
var api = new Api();
api.OpenCommEthernet("192.168.1.100", 7010);
api.Enable(0);  // 使能轴0
(2) 执行运动程序
// 下载并运行ACS程序
api.DownloadBuffer(ProgramBuffer.ACSC_BUFFER_0, 
    "FPGA=0.5\nMOVEABS 0,100");
api.RunBuffer(ProgramBuffer.ACSC_BUFFER_0, "");
(3) 事件订阅
api.MOTIONSTART += (axisMask) => {
    Console.WriteLine($"Axis {axisMask.Axis} started moving");
};

6. 扩展性设计

  1. 自定义运动算法：

public void CustomSpline(Axis[] axes, SplineParams param) {
    api.SplineM(MotionFlags.ACSC_AMF_USER_DEFINED, 
        axes, param.Tolerance);
}

插件架构

public interface IMotionPlugin {
    void Configure(Api api);
}

总结

该 API 类体现了工业级运动控制库的典型设计：

  • 全面性：覆盖从底层 IO 到高级轨迹规划的完整功能链

  • 实时性：通过异步模式和事件系统保证响应速度

  • 可靠性：内置硬件状态监控和错误恢复机制

  • 扩展性：支持 EtherCAT 等工业总线扩展

适合需要高精度多轴协调控制的场景，如半导体设备、激光加工等工业自动化领域。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值