博客

固高运动控制卡学习1–运动模式介绍（1）–点位，Gear，Jog，插补

  • Post author:
  • Post category:其他


转载连接： https://blog.csdn.net/qq_30567891/article/details/80236106



运动模式是指规划一个或多个轴运动的方式。 运动控制器支持的运动模式有点位运动模式、




Jog


运动模式、电子齿轮（即


Gear


） 运动模式和插补运动模式


GT_PrfTrap
设置指定轴为点位模式

GT_PrfJog
设置指定轴为


Jog


模式

GT_PrfGear
设置指定轴为电子齿轮模式

GT_GetPrfMode
查询指定轴的运动模式



在设置或切换运动模式时，要保证轴处于规划静止状态。如果轴正在运动，请先调用



GT_Stop



指令停止一个或多个轴的运动，然后再调用上表中的指令切换到想要的运动模式下。

一·、点位模式（PT）


每一个轴在规划静止时都可以设置为点位运动。在点位运动模式下，各轴可以独立设置目标位置、目标速度、加速度、减速度、起跳速度、平滑时间等运动参数，能够独立运动或停止。


GT_PrfTrap
设置指定轴为点位运动模式

GT_SetTrapPrm
设置点位运动模式下的运动参数

GT_GetTrapPrm
读取点位运动模式下的运动参数

GT_SetPos
设置目标位置

GT_GetPos
读取目标位置

GT_SetVel
设置目标速度

GT_GetVel
读取目标速度

GT_Update
启动点位运动

JOG模式关键程序步骤：

（1）配置运动控制器  –GT_LoadConfig

（2）将 AXIS 轴设为点位模式  –GT_PrfTrap

（3）设置需要修改的运动参数   –GT_GetTrapPrm

public struct TTrapPrm

{


public double acc;//加速度

public double dec;//减速度

public double velStart;//起始速度

public short  smoothTime;//平滑时间

}

（4）设置 AXIS 轴的目标位置   –GT_SetPos

（5）设置 AXIS 轴的目标速度   –GT_SetVel

（6）启动AXIS轴运动     –GT_Update

（7）等待AXIS轴规划停止

（8）电机伺服关闭     –GT_AxisOff


例程：将第


1


轴设定为点位运动模式，并且以速度


50pulse/ms


，加速度


0.25pulse/ms


2


，减速度


0.125pulse/ms


2


，平滑时间为


25ms


的运动参数正向运动


50000


个脉冲。


[cpp]

view plain


copy



  1. <span


    class


    =


    “fontstyle0”


    >


    int


    </span><span


    class


    =


    “fontstyle0”


    style=


    “color:rgb(136,0,0);”


    >main</span><span


    class


    =


    “fontstyle0”


    style=


    “color:rgb(0,0,0);”


    >(</span><span


    class


    =


    “fontstyle0”


    >


    int


    </span><span


    class


    =


    “fontstyle0”


    style=


    “color:rgb(128,128,128);”


    >argc</span><span


    class


    =


    “fontstyle0”


    style=


    “color:rgb(0,0,0);”


    >, </span><span


    class


    =


    “fontstyle0”


    >


    char


    </span><span


    class


    =


    “fontstyle0”


    style=


    “color:rgb(0,0,0);”


    >* </span><span


    class


    =


    “fontstyle0”


    style=


    “color:rgb(128,128,128);”


    >argv</span><span


    class


    =


    “fontstyle0”


    style=


    “color:rgb(0,0,0);”


    >[])

  2. {</span>


  3. short


    sRtn;

  4. TTrapPrm trap;


  5. long


    sts;


  6. double


    prfPos;


  7. // 1、打开运动控制器

  8. sRtn = GT_Open();



  10. //2、复位运动控制器

  11. sRtn = GT_Reset();

  12. commandhandler(

    “GT_Reset”


    , sRtn);


  13. //3、 配置运动控制器


  14. // 注意：配置文件取消了各轴的报警和限位

  15. sRtn = GT_LoadConfig(

    “test.cfg”


    );



  17. // 4、清除各轴的报警和限位

  18. sRtn =GT_ClrSts(1, 8);



  20. ///5、伺服使能

  21. sRtn =GT_AxisOn(AXIS);



  23. // 位置清零

  24. sRt6、n = GT_ZeroPos(AXIS);



  26. //7、将 AXIS 轴设为点位模式

  27. sRtn = GT_PrfTrap(AXIS);



  29. //8、读取点位运动参数(需要读取所有运动参数到上位机变量)

  30. sRtn = GT_GetTrapPrm(AXIS, &trap);



  32. //9、设置需要修改的运动参数

  33. trap.acc = 0.25;

  34. trap.dec = 0.125;

  35. trap.smoothTime = 25;


  36. //10、设置点位运动参数

  37. sRtn = GT_SetTrapPrm(AXIS, &trap);



  39. //11、设置 AXIS 轴的目标位置

  40. sRtn = GT_SetPos(AXIS, 50000L);



  42. //12、设置AXIS轴的目标速度

  43. sRtn = GT_SetVel(AXIS, 50);



  45. //13、启动AXIS轴的运动

  46. sRtn = GT_Update(1<<(AXIS-1));



  48. do

  49. {


  50. // 读取AXIS轴的状态

  51. sRtn = GT_GetSts(AXIS, &sts);


  52. // 读取AXIS轴的规划位置

  53. sRtn = GT_GetPrfPos(AXIS, &prfPos);

  54. printf(

    “sts=0x%-10lxprfPos=%-10.1lf\r”


    , sts, prfPos);

  55. }

    while


    (sts&0x400);


  56. //14、等待AXIS轴规划停止


  57. //15、伺服关闭

  58. sRtn = GT_AxisOff(AXIS);

  59. printf(

    “\nGT_AxisOff()=%d\n”


    , sRtn);

  60. getch();


  61. return


    0;

  62. }

二、JOG运动模式


在


Jog


运动模式下，各轴可以独立设置

目标速度、加速度、减速度、平滑系数

等运动参数，能够独立运动或停止


GT_PrfJog
设置指定轴为


Jog


运动模式

GT_SetJogPrm
设置


Jog


运动模式下的运动参数

GT_GetJogPrm
读取


Jog


运动模式下的运动参数

GT_SetVel
设置目标速度

GT_GetVel
读取目标速度

GT_Update
启动


Jog


运动

JOG模式关键程序步骤：

（1）配置运动控制器  –GT_LoadConfig

（2）将 AXIS 轴设为JOG模式  —

GT_PrfJog

（3）设置JOG运动参数  —

GT_SetJogPrm



public struct TJogPrm

{

public double acc;

public double dec;

public double smooth;


}


（4）设目标速度    —


GT_SetVel


（5）


启动


AXIS


轴的运动




—


GT_Update




（6）在运动过程中可以更改运动速度     —

GT_SetVel

GT_Update


（7）伺服关闭      –GT_AxisOff




例程：

轴


1


运动在


Jog


模式下，初始目标速度为


100pulse/ms


。动态改变目标速度，当规划位置超过


100000pulse


时，修改目标速度为


50 pulse/ms


。


[cpp]

view plain


copy



  1. int


    main(


    int


    argc,


    char


    * argv[])

  2. {


  3. short


    sRtn;

  4. TJogPrm jog;


  5. long


    sts;


  6. double


    prfPos, prfVel;


  7. // 打开运动控制器

  8. sRtn = GT_Open();


  9. // 指令返回值检测，请查阅例程 3-1



  11. // 复位运动控制器

  12. sRtn = GT_Reset();



  14. // 配置运动控制器


  15. // 注意：配置文件取消了各轴的报警和限位

  16. sRtn = GT_LoadConfig(

    “test.cfg”


    );



  18. // 清除各轴的报警和限位

  19. sRtn =GT_ClrSts(1, 8);



  21. // 伺服使能

  22. sRtn = GT_AxisOn(AXIS);



  24. // 位置清零

  25. sRtn = GT_ZeroPos(AXIS);



  27. // 将 AXIS 轴设为 Jog 模式

  28. sRtn = GT_PrfJog(AXIS);



  30. // 读取 Jog 运动参数(需要读取全部运动参数到上位机变量)

  31. sRtn =GT_GetJogPrm(AXIS, &jog);



  33. //设置需要修改的运动参数

  34. jog.acc = 0.0625;

  35. jog.dec = 0.0625;


  36. // 设置 Jog 运动参数

  37. sRtn = GT_SetJogPrm(AXIS, &jog);



  39. // 设置 AXIS 轴的目标速度

  40. sRtn = GT_SetVel(AXIS, 100);



  42. // 启动 AXIS 轴的运动

  43. sRtn = GT_Update(1<<(AXIS-1));



  45. while


    (1)

  46. {


  47. // 读取AXIS轴的状态

  48. sRtn = GT_GetSts(AXIS, &sts);


  49. // 读取AXIS轴的规划位置

  50. sRtn = GT_GetPrfPos(AXIS, &prfPos);


  51. // 读取AXIS轴的规划速度

  52. sRtn = GT_GetPrfVel(AXIS, &prfVel);

  53. printf(

    “sts=0x%-10lxprfPos=%-10.1lfprfVel=%-10.1lf\r”


    , sts, prfPos, prfVel);


  54. if


    (prfPos>= 100000)

  55. {


  56. // 设置AXIS轴新的目标速度

  57. sRtn = GT_SetVel(AXIS, 50);



  59. // AXIS轴新的目标速度生效

  60. sRtn = GT_Update(1<<(AXIS-1));



  62. break


    ;

  63. }

  64. }


  65. while


    (!kbhit())

  66. {


  67. // 读取AXIS轴的状态

  68. sRtn = GT_GetSts(AXIS, &sts);


  69. // 读取AXIS轴的规划位置

  70. sRtn = GT_GetPrfPos(AXIS, &prfPos);


  71. // 读取AXIS轴的规划速度

  72. sRtn = GT_GetPrfVel(AXIS, &prfVel);

  73. printf(

    “sts=0x%-10lxprfPos=%-10.1lfprfVel=%-10.1lf\r”


    , sts, prfPos, prfVel);

  74. }


  75. // 伺服关闭

  76. sRtn = GT_AxisOff (AXIS);

  77. printf(

    “\nGT_AxisOff()=%d\n”


    , sRtn);

  78. getch();


  79. return


    0;

  80. }

三、电子齿轮模式（Gear）


电子齿轮模式能够将两轴或多轴联系起来，实现精确的同步运动，从而替代传统的机械齿轮连接。

我们把被跟随的轴叫主轴，把跟随的轴叫从轴。电子齿轮模式下，


1


个主轴能够驱动多个从轴，从轴可以跟随主轴的规划位置、编码器位置。


传动比：主轴速度与从轴速度的比例。电子齿轮模式能够灵活的设置传动比，节省机械系统的安装时间。当主轴速度变化时，从轴会根据设定好的传动比自动改变速度。电子齿轮模式也能够在运动过程中修改传动比。


GT_PrfGear
设置指定轴为电子齿轮运动模式

GT_SetGearMaster
设置电子齿轮运动跟随主轴

GT_GetGearMaster
读取电子齿轮运动跟随主轴

GT_SetGearRatio
设置电子齿轮比

GT_GetGearRatio
读取电子齿轮比

GT_GearStart
启动电子齿轮运动

Gear模式关键程序步骤：

1、控制卡配置

（1）配置运动控制器  –GT_LoadConfig

2、主轴配置

（1）将 AXIS 轴设为JOG模式  —

GT_PrfJog

（2）设置JOG运动参数  —

GT_SetJogPrm



public struct TJogPrm

{


public double acc;

public double dec;

public double smooth;


}


（3）设目标速度    —


GT_SetVel


（4）


启动主


轴的运动




—


GT_Update


3、从轴配置


（1）将从轴设为


Gear


模式

—

GT_PrfGear


（2）设置主轴，默认跟随主轴规划位置  —

GT_SetGearMaster


(


SLAVE


,


MASTER


)





（3）设置从轴的传动比和离合区   —

GT_SetGearRatio

(


SLAVE


, 2, 1, 100000)








说明：


1)


调 用


GT_SetGearRatio


(short profile, long masterEven, long slaveEven, long masterSlope)



指令来设置传动比和离合区。


profile


是从轴轴号；


masterEven


是主轴位

移，


slaveEven


是从轴位移，


masterEven/slaveEven


等于传动比；


slope


是主轴离合

区位移，即主轴在离合区内走过的位移，用户应自行计算出来。



2)


如果从轴轴号为


slave


，当主轴位移


alpha


时从轴位移


beta


，主轴运动


slope


位移后从



轴到达设定传动比，应当调用以下指令：


GT_SetGearRatio


(slave, alpha, beta, slope);


（4）启动从轴


—


GT_GearStart

示例：

主轴为


Jog


模式，从轴为电子齿轮模式，传动比为主轴速度：从轴速度


=2


：


1


，主轴运动离合

区位移后（图中阴影部分的区域），从轴达到设定的传动比


。

[cpp]

view plain


copy



  1. int


    main(


    int


    argc,


    char


    * argv[])

  2. {


  3. short


    sRtn;


  4. double


    prfVel[8];

  5. TJogPrm jog;


  6. // 打开运动控制器

  7. sRtn = GT_Open();



  9. // 复位运动控制器

  10. sRtn = GT_Reset();



  12. // 配置运动控制器


  13. // 注意：配置文件 test.cfg 取消了各轴的报警和限位

  14. sRtn = GT_LoadConfig(

    “test.cfg”


    );



  16. // 清除各轴的报警和限位

  17. sRtn =GT_ClrSts(1, 8);



  19. // 伺服使能

  20. sRtn = GT_AxisOn(MASTER);


  22. sRtn = GT_AxisOn(SLAVE);



  24. // 位置清零

  25. sRtn = GT_ZeroPos(MASTER);

  26. sRtn = GT_ZeroPos(SLAVE);



  28. // 1、将主轴设为 Jog 模式

  29. sRtn = GT_PrfJog(MASTER);



  31. //2、设置主轴运动参数

  32. sRtn =GT_GetJogPrm(MASTER, &jog);

  33. jog.acc = 1;

  34. sRtn = GT_SetJogPrm(MASTER, &jog);

  35. sRtn = GT_SetVel(MASTER, 100);



  37. //3、启动主轴

  38. sRtn = GT_Update(1<<(MASTER-1));



  40. // 将从轴设为 Gear 模式

  41. sRtn = GT_PrfGear(SLAVE);



  43. // 设置主轴，默认跟随主轴规划位置

  44. sRtn = GT_SetGearMaster(SLAVE, MASTER);



  46. // 设置从轴的传动比和离合区

  47. sRtn = GT_SetGearRatio(SLAVE, 2, 1, 100000);



  49. // 启动从轴

  50. sRtn =GT_GearStart(1<<(SLAVE-1));



  52. while


    (!kbhit())

  53. {


  54. // 查询各轴的规划速度

  55. sRtn = GT_GetPrfVel(1, prfVel, 8);

  56. printf(

    “master vel=%-10.2lf\tslave vel=%-10.2lf\r”


    ,

  57. prfVel[MASTER-1], prfVel[SLAVE-1]);

  58. }


  59. // 伺服关闭

  60. sRtn = GT_AxisOff (MASTER);

  61. printf(

    “\nGT_AxisOff()=%d, Axis:%d\n”


    , sRtn, MASTER);

  62. sRtn = GT_AxisOff (SLAVE);

  63. printf(

    “\nGT_AxisOff()=%d, Axis:%d\n”


    , sRtn, SLAVE);

  64. getch();


  65. return


    0;

  66. }

四、插补运动模式


GT_SetCrdPrm
设置坐标系参数，确立坐标系映射，建立坐标系

GT_GetCrdPrm
查询坐标系参数

GT_CrdData
向插补缓存区增加插补数据

GT_LnXY
缓存区指令，二维直线插补

GT_LnXYZ
缓存区指令，三维直线插补

GT_LnXYZA
缓存区指令，四维直线插补

GT_LnXYG0
缓存区指令，二维直线插补


(


终点速度始终为


0)

GT_LnXYZG0
缓存区指令，三维直线插补


(


终点速度始终为


0)

GT_LnXYZAG0
缓存区指令，四维直线插补


(


终点速度始终为


0)

GT_ArcXYR
缓存区指令，


XY


平面圆弧插补


(


以终点位置和半径为输入参数


)

GT_ArcXYC
缓存区指令，


XY


平面圆弧插补


(


以终点位置和圆心位置为输入参数


)

GT_ArcYZR
缓存区指令，


YZ


平面圆弧插补


(


以终点位置和半径为输入参数


)

GT_ArcYZC
缓存区指令，


YZ


平面圆弧插补


(


以终点位置和圆心位置为输入参数


)

GT_ArcZXR
缓存区指令，


ZX


平面圆弧插补


(


以终点位置和半径为输入参数


)

GT_ArcZXC
缓存区指令，


ZX


平面圆弧插补


(


以终点位置和圆心位置为输入参数


)

GT_BufIO
缓存区指令，缓存区内数字量


IO


输出设置指令

GT_BufDelay
缓存区指令，缓存区内延时设置指令

GT_BufDA
缓存区指令，缓存区内输出


DA


值

GT_BufLmtsOn
缓存区指令，缓存区内有效限位开关

GT_BufLmtsOff
缓存区指令，缓存区内无效限位开关

GT_BufSetStopIo
缓存区指令，缓存区内设置


axis


的停止


IO


信息

GT_BufMove
缓存区指令，实现刀向跟随功能，启动某个轴点位运动

GT_BufGear
缓存区指令，实现刀向跟随功能，启动某个轴跟随运动

GT_CrdSpace
查询插补缓存区剩余空间

GT_CrdClear
清除插补缓存区内的插补数据

GT_CrdStart
启动插补运动

GT_CrdStatus
查询插补运动坐标系状态

GT_SetUserSegNum
缓存区指令，设置自定义插补段段号

GT_GetUserSegNum
读取自定义插补段段号

GT_GetRemainderSegNum
读取未完成的插补段段数

GT_SetOverride
设置插补运动目标合成速度倍率

GT_SetCrdStopDec
设置插补运动平滑停止、急停合成加速度

GT_GetCrdStopDec
查询插补运动平滑停止、急停合成加速度

GT_GetCrdPos
查询该坐标系的当前坐标位置值

GT_GetCrdVel
查询该坐标系的合成速度值

GT_InitLookAhead
初始化插补前瞻缓存区


使用插补模式需要至少两步操作：

建立坐标系

和

向缓存区存入数据

。下面分别就这两个步骤分别进行详细讲解。

（一）建立坐标系

建立坐标系就是初始化

TCrdPrm

结构体。

[cpp]

view plain


copy



  1. public




    struct


    TCrdPrm

  2. {


  3. public




    short


    dimension;


    //<span class=”fontstyle0″>表示所建立的坐标系的维数，取值范围：</span><span class=”fontstyle2″>[1, 4]</span>


  4. public




    short


    profile1;


    // 分别规划轴1~8.如果规划轴.没有对应到该坐标系，则 profile[x]的值为 0；


  5. public




    short


    profile2;


  6. public




    short


    profile3;


    //如果对应到了 X 轴，则 profile[x]为 1，Y 轴对应为 2， Z 轴对应为 3， A 轴对应为 4。


  7. public




    short


    profile4;


  8. public




    short


    profile5;


    //每个元素的取值范围： [0, 4]


  9. public




    short


    profile6;


  10. public




    short


    profile7;


  11. public




    short


    profile8;



  13. public




    double


    synVelMax;


    //<span class=”fontstyle0″>该坐标系所能承受的最大合成速度</span> ,取值范围： (0, 32767)


  14. public




    double


    synAccMax;


    //<span class=”fontstyle0″>该坐标系所能承受的最大合成加速度</span> ,取值范围： (0, 32767)


  15. public




    short


    evenTime;


    //最小匀速时间 ,取值范围： (0, 32767)


  16. public




    short


    setOriginFlag;


    //是否需要指定坐标系的原点坐标的规划位置.0：不需要指定原点坐标值，则坐标系


  17. //的原点在当前规划位置上。 1：需要指定原点坐标值，坐标系的原点在 originPos指


  18. //定的规划位置上。


  19. public




    int


    originPos1;


  20. public




    int


    originPos2;


    //指定的坐标系原点的规划位置值


  21. public




    int


    originPos3;


  22. public




    int


    originPos4;


  23. public




    int


    originPos5;


  24. public




    int


    originPos6;


  25. public




    int


    originPos7;


  26. public




    int


    originPos8;

  27. }

例程：

建立了一个二维坐标系，规划轴


1


对应为


x


轴，规划轴


2


对应为


y


轴，坐标系原点的规划位置是


(100, 100)


， 单位：


pulse


，在此坐标系内运动的最大合成速度为


500pulse/ms


，最大合成加速度为


1pulse/ms^2


， 最小匀速时间为


50ms


。

[cpp]

view plain


copy



  1. TCrdPrm crdPrm;


  2. // 将结构体变量初始化为0

  3. memset(&crdPrm, 0,

    sizeof


    (crdPrm));


  4. // 为结构体赋值

  5. crdPrm.dimension=2;

    // 坐标系为二维坐标系

  6. crdPrm.synVelMax=500;

    // 最大合成速度： 500pulse/ms

  7. crdPrm.synAccMax=1;

    // 最大加速度： 1pulse/ms^2

  8. crdPrm.evenTime = 50;

    // 最小匀速时间： 50ms

  9. crdPrm.profile[0] = 1;

    // 规划器1对应到X轴

  10. crdPrm.profile[1] = 2;

    // 规划器2对应到Y轴

  11. crdPrm.setOriginFlag = 1;

    // 表示需要指定坐标系的原点坐标的规划位置

  12. crdPrm.originPos[0] = 100;

    // 坐标系的原点坐标的规划位置为（100, 100）

  13. crdPrm.originPos[1] = 100;


  14. // <span style=”font-size:16px;color:#ff0000;”>建立1号坐标系，设置坐标系参数</span>

  15. sRtn = GT_SetCrdPrm(<span style=

    “font-size:16px;”


    ><span style=


    “color:#333333;”


    >1</span></span>, &crdPrm);


（二）

向缓存区存入数据


步骤：


（a）首先清除缓存区中的数据。–GT_CrdClear（坐标系号，缓冲区号）


（b）向对应坐标系的相应缓冲区添加运行或动作数据。  –GT_ArcXYR，GT_LnXYZG0，GT_LnXY，GT_BufDelay等


（c）启动插补运动。  –GT_CrdStart


（1）直线插补例程


假设某数控机床刀具在


xy


平面从原点出发，走一段如图


6-12


所示的正六边形轨迹。一共需要

走七段轨迹，图中标号已标出。每走完一段轨迹会输出一次


IO


信号，并且暂停


400ms。

[cpp]

view plain


copy



  1. // 即将把数据存入坐标系1的FIFO0中，所以要首先清除此缓存区中的数据

  2. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_CrdClear</span>(1, 0);


  3. // 向缓存区写入第一段插补数据

  4. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_LnXY</span>(

  5. 1,

    // 该插补段的坐标系是坐标系1

  6. 200000, 0,

    // 该插补段的终点坐标(200000, 0)

  7. 100,

    // 该插补段的目标速度： 100pulse/ms

  8. 0.1,

    // 插补段的加速度： 0.1pulse/ms^2

  9. 0,

    // 终点速度为0

  10. 0);

    // 向坐标系1的FIFO0缓存区传递该直线插补数据


  11. // 向缓存区写入第二段插补数据

  12. sRtn = GT_LnXY(1, 100000, 173205, 100, 0.1, 0, 0);


  13. // 缓存区数字量输出

  14. sRtn =<span style=

    “font-size:16px;color:#ff0000;”


    >GT_BufIO</span>(

  15. 1,

    // 坐标系是坐标系1

  16. MC_GPO,

    // 数字量输出类型：通用输出

  17. 0xffff,

    // bit0~bit15全部都输出

  18. 0x55,

    // 输出的数值为0x55

  19. 0);

    // 向坐标系1的FIFO0缓存区传递该数字量输出


  20. // 缓存区延时指令

  21. sRtn =<span style=

    “font-size:16px;color:#ff0000;”


    >GT_BufDelay</span>(

  22. 1,

    // 坐标系是坐标系1

  23. 400,

    // 延时400ms

  24. 0);

    // 向坐标系1的FIFO0缓存区传递该延时


  25. // 启动坐标系1的FIFO0的插补运动

  26. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_CrdStart</span>(1, 0);


  27. do

  28. {


  29. // 查询坐标系1的FIFO的插补运动状态

  30. sRtn =<span style=

    “font-size:16px;color:#ff0000;”


    > GT_CrdStatus</span>(

  31. 1,

    // 坐标系是坐标系1

  32. &run,

    // 读取插补运动状态

  33. &segment,

    // 读取当前已经完成的插补段数

  34. 0);

    // 查询坐标系1的FIFO0缓存区


  35. // 坐标系在运动, 查询到的run的值为1

  36. }

    while


    (run == 1);

  37. ……

（2）圆弧插补指令分为两种：


a)


半径描述方法

—

GT_ArcXYR


、


GT_ArcYZR


、


GT_ArcZXR


b)


圆心坐标描述方法   — GT_ArcXYC、 GT_ArcYZC、 GT_ArcZXC

[cpp]

view plain


copy



  1. // 即将把数据存入坐标系1的FIFO0中，所以要首先清除此缓存区中的数据

  2. sRtn = GT_CrdClear(1, 0);



  4. // 向缓存区写入第一段插补数据

  5. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_LnXY</span>(

  6. 1,

    // 该插补段的坐标系是坐标系1

  7. 200000, 0,

    // 该插补段的终点坐标(200000, 0)

  8. 100,

    // 该插补段的目标速度： 100pulse/ms

  9. 0.1,

    // 插补段的加速度： 0.1pulse/ms^2

  10. 0,

    // 终点速度为0

  11. 0);

    // 向坐标系1的FIFO0缓存区传递该直线插补数据



  13. // 向缓存区写入第二段插补数据，该段数据是以圆心描述方法描述了一个整圆

  14. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_ArcXYC</span>(

  15. 1,

    // 坐标系是坐标系1

  16. 200000, 0,

    // 该圆弧的终点坐标(200000, 0)

  17. -100000, 0,

    // 圆弧插补的圆心相对于起点位置的偏移量(-100000, 0)

  18. 0,

    // 该圆弧是顺时针圆弧

  19. 100,

    // 该插补段的目标速度： 100pulse/ms

  20. 0.1,

    // 该插补段的加速度： 0.1pulse/ms^2

  21. 0,

    // 终点速度为0

  22. 0);

    // 向坐标系1的FIFO0缓存区传递该直线插补数据



  24. // 向缓存区写入第三段插补数据，该段数据是以半径描述方法描述了一个1/4圆弧

  25. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_ArcXYR</span>(

  26. 1,

    // 坐标系是坐标系1

  27. 0, 200000,

    // 该圆弧的终点坐标(0, 200000)

  28. 200000,

    // 半径： 200000pulse

  29. 1,

    // 该圆弧是逆时针圆弧

  30. 100,

    // 该插补段的目标速度： 100pulse/ms

  31. 0.1,

    // 该插补段的加速度： 0.1pulse/ms^2

  32. 0,

    // 终点速度为0

  33. 0);

    // 向坐标系1的FIFO0缓存区传递该直线插补数据



  35. // 向缓存区写入第四段插补数据，回到原点位置

  36. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_LnXY</span>(1, 0, 0, 100, 0.1, 0, 0);



  38. //启动坐标系1的FIFO0的插补运动

  39. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_CrdStart</span>(1, 0);



  41. do

  42. {


  43. // 查询坐标系1的FIFO的插补运动状态

  44. sRtn = <span style=

    “font-size:16px;color:#ff0000;”


    >GT_CrdStatus</span>(

  45. 1,

    // 坐标系是坐标系1

  46. &run,

    // 读取插补运动状态

  47. &segment,

    // 读取当前已经完成的插补段数

  48. 0);

    // 查询坐标系1的FIFO0缓存区


  49. // 坐标系在运动, 查询到的run的值为1

  50. }

    while


    (run == 1);

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_30567891/article/details/80236106