ETH6045__API.c

/***********************************************************

文件名[FileName]: ETH6045.c

文件版本[File Version]: 1.0.0

创建日期[Created Date]: 2011.11.23

作者[Author]: cendom

描述[Discription]: 6045函数定义

修改记录[Modify Records]: 无

**********************************************************/

#include "ETH6045_API.h"

#include

/*

*

* 函数描述延迟ms

* 参数延时时间,单位ms

* 返回无

*

*/

void mmdelay(UINT32 ms)

{

unsigned int i, j;

for (i = 0; i

for (j = 0; j < /*30000*/9000; j++);

}

////////////////////////////////////////////PCL6045BL基础函数

unsigned int p645_rBUF1 (unsigned intbase_addr)// 读取BUFER0,BUFER1 {

// union udata

// {

// /*unsigned long*/UINT32 ldata;

// /*unsigned int*/UINT16 idata[2];

// }udt;

mmdelay(20);

/*udt. idata[1] =*/

return (*(volatile UINT16 *)(base_addr+0) ); // BUFER1

// mmdelay(20);

// udt. idata[0] = *(volatile UINT16 *)(base_addr+/*4*/2); // BUFER0

// return(udt. ldata);

}

void p645_wBUF1(unsigned int base_addr,UINT16 data) // 写BUFER0,BUFER1 {

// union udata

// {

// /*unsigned long*/UINT32 ldata;

// /*unsigned int*/UINT16 idata[2];

// }udt;

// udt.ldata = data;

// *(volatile UINT16 *)(base_addr+/*4*/2) = udt. idata[0]; // BUFER0 *(volatile UINT16 *)(base_addr+0) = data;//udt. idata[1]; // BUFER1

// mmdelay(20);

}

/*Write the command code and axis selection (写入命令代码及轴选择函数p645_wcom)*/ /*------------------------------------------------------------------------

Function name: p645_wcom

Operation: Writes a command code and an axis selection (comw) to a specified axis

(base_addr). Dummy argument:

base_addr --- Base address of the specified axis

comw --- Word data to write

Return value: None

------------------------------------------------------------------------*/

void p645_wcom (unsigned int base_addr,UINT16 comw)

{

*(volatile UINT16 *)(base_addr+0x0C) = comw; //COMW 6

//outpw (base_addr, comw);

}

/*Write to an output port (向端口写入函数p645_wotp)*/

/*------------------------------------------------------------------------

Function name: p645_wotp

Operation: Writes word data (otpw) to the output port of the specified axis (base_addr).

Dummy argument:

base_addr --- Base address of the specified axis

otpw --- Word data to write

Return value: None

------------------------------------------------------------------------*/

void p645_wotp (unsigned intbase_addr, UINT16 otpw)

{

*(volatile UINT16 *)(base_addr+/*2*/8) = otpw; // OTPW 4

//outpw (base_addr+2, otpw);

}

/*Read status (读状态函数p645_rsts)*/

/*------------------------------------------------------------------------

Function name: p645_rsts

Operation: Reads the status of the specified axis (base_addr)

Dummy argument:

base_addr --- Base address of the specified axis

Return value: Data read

------------------------------------------------------------------------*/

unsigned int p645_rsts (unsigned intbase_addr)

{

union udata

{

/* unsigned long*/UINT32 ldata;

/* unsigned int*/UINT16 idata[2];

}udt;

udt.idata[1] = *(volatile UINT16 *)(base_addr+0x0C); /* Main status 6 */

udt.idata[0] = *(volatile UINT16 *)(base_addr+8); /* Sub status, input/output port 4 */

// udt.idata[0] = inpw (base_addr); /* Main status */

// udt.idata[1] = inpw (base_addr+2); /* Sub status, input/output port */

return(udt. ldata);

}

/*Write register (向寄存器写入数据函数p645_wreg)*/

/*--------------------------------------------------------------------------

Function name: p645_wreg

Operation: Writes data (data) to the specified register in the specified axis (base_addr)

Dummy argument:

base_addr --- Base address of the specified axis

rwcom --- Register write command

data --- Data to write

Return value: None

--------------------------------------------------------------------------*/

void p645_wreg(unsigned int base_addr,UINT16 rwcom,UINT32 data)

{

union udata

{

/*unsigned long*/UINT32 ldata;

/*unsigned int*/UINT16 idata[2];

}udt;

udt.ldata = data;

*(volatile UINT16 *)(base_addr+4) = udt. idata[0]; // BUFER0 2

// mmdelay(20);

*(volatile UINT16 *)(base_addr+0) = udt. idata[1]; // BUFER1 0

// mmdelay(20);

*(volatile UINT16 *)(base_addr+0x0c) = rwcom; // COMW 6 // outpw (base_addr+4, udt. idata[0]); /* Write to an input/output buffer (bits 0 to 15) */

// outpw (base_addr+6, udt. idata[1]); /* Write to an input/output buffer (bits 16 to 31) */ // outpw (base_addr, rwcom); /* Write command */

}

/*Read register (读寄存器函数p645_rreg)*/

/*--------------------------------------------------------------------------

Function name: p645_rreg

Operation: Reads contents of the register for the axis that was specified (base_addr)

Dummy argument:

base_addr --- Base address of the specified axis

rrcom --- Reigster read command

Return value: Read data

--------------------------------------------------------------------------*/

unsigned int p645_rreg (unsigned intbase_addr, UINT16 rrcom)

{

union udata

{

/*unsigned long*/UINT32 ldata;

/*unsigned int*/UINT16 idata[2];

}udt;

*(volatile UINT16 *)(base_addr+0x0c) = rrcom; // COMW 6

// mmdelay(20);

udt. idata[1] = *(volatile UINT16 *)(base_addr+0) ; // BUFER1 0

// mmdelay(20);

udt. idata[0] = *(volatile UINT16 *)(base_addr+4); // BUFER0 2

// outpw(base_addr, rrcom); /* Write a register read command */

// udt.idata[0] = inpw (base_addr+4); /* Read input/output buffer (bits 0 to 15) */

// udt.idata[1] = inpw (base_addr+6); /* Read the input/output buffer (bits 16 to 31) */ return(udt. ldata);

}

/*Wait for the end of the operation (等待运行结束函数p645_wait)*/

/*--------------------------------------------------------------------------

Function name: p645_wait

Operation: Waits until bit 3 (SEND) in the specified axis (base_addr) main status register goes to "1" (operation complete).

Dummy argument:

base_addr --- Base address of the specified axis

Return value: None

--------------------------------------------------------------------------*/

void p645_wait(unsigned intbase_addr)

{

/*unsigned int*/UINT16 msts; /* Axis main status */

while(1)

{

msts = *(volatile UINT16 *)(base_addr+0x0C); /* Main status 6 */

//msts=inpw(base_addr);

if((msts& 0x0008)!=0) break;

}

}

/************************************************************************/

/* 设置速度模式函数*/

//unsigned intbase_addr /* Specified axis base address */ //unsigned long fldata /* Initial speed (pps) */

//unsigned long fhdata /* Operation speed (pps) */

//unsigned long utime /* Acceleration time (ms) */

//unsigned long dtime /* Deceleration time (ms) */

//unsigned intusdata /* Acceleration S-curve range */ //unsigned intdsdata /* Deceleration S-curve range */ //char curve /* L: linear S: S-curve */

//unsigned long fadata /* Compensated speed (pps) */ */

/************************************************************************/

void p645_vset(unsigned int base_addr,UINT32 fldata,UINT32 fhdata, UINT32 utime,

UINT32 dtime,UINT32 usdata,UINT32 dsdata,char curve,UINT32 fadata)

{

/*unsigned int*/UINT16 rfldt,rfhdt,rurdt,rdrdt,rmgdt,rfadt;

/* unsigned long */UINT32 rmddt;

double a,b;

rmgdt = 299; /* x1 Mode */

if(fhdata>65535L) rmgdt = 149; /* x2 Mode */

if(fhdata>131070L) rmgdt = 99; /* x3 Mode */

if(fhdata>196605L) rmgdt = 74; /* x4 Mode */

if(fhdata>262140L) rmgdt = 59; /* x5 Mode */

if(fhdata>327675L) rmgdt = 29; /* x10 Mode */

if(fhdata>655350L) rmgdt = 14; /* x20 Mode */

if(fhdata>1310700L) rmgdt = 5; /* x50 Mode */

if(fhdata>3276750L) rmgdt = 2; /* x100 Mode */

rfldt = fldata/(300/(rmgdt+1));

rfhdt = fhdata/(300/(rmgdt+1));

rfadt = fadata/(300/(rmgdt+1));

if((curve=='L')||(curve=='l'))

{ /* Linear acceleration / deceleration*/

a = (double)((rfhdt-rfldt)*4);

b = (double)((rfhdt-rfldt)*4);

rmddt = p645_rreg(base_addr,0x00C7)& 0xFFFFFBFF; /* RMD MSMD(Bit10)=0 */ }

else

{ /* S-curve acceleration/deceleration */

if(usdata==0){ /* Without linear part */

a = (double)((rfhdt-rfldt)*8);

}

else { /* With linear part */

a = (double)((rfhdt-rfldt+2*usdata)*4);

}

if(dsdata==0){ /* Without linear part */

b = (double)((rfhdt-rfldt)*8);

}

else { /* With linear part */

b = (double)((rfhdt-rfldt+2*dsdata)*4);

}

rmddt = p645_rreg(base_addr,0x00C7) | 0x00000400; /* RMD MSMD(Bit10)=1 */ }

if(utime==0) rurdt =0;

else rurdt = ((double)utime*19660.8 / a ) - 1.0;

if(dtime==0) rdrdt =0; /* When rdrdt = 0, deceleration rate*/

else rdrdt = ((double)dtime*19660.8 / b ) - 1.0; /* will the set value of rurdt.*/

p645_wreg(base_addr, WPRFL, (UINT32) rfldt);

p645_wreg(base_addr, WPRFH, (UINT32) rfhdt);

p645_wreg(base_addr, WPRUR, (UINT32) rurdt);

p645_wreg(base_addr, WPRDR, (UINT32) rdrdt);

p645_wreg(base_addr, WPRMG, (UINT32) rmgdt);

p645_wreg(base_addr, WPRDP, (UINT32) usdata);

p645_wreg(base_addr, WPRDS, (UINT32) dsdata);

p645_wreg(base_addr, WPRMD, rmddt);

p645_wreg(base_addr, WRFA, (UINT32) rfadt);

}

////////////////////////////////////////////

/*

*

* 函数描述设置输出脉冲模式的设置函数

* 参数Chip_Axis 轴选择(通过基地址已经可以确认A片和B片地址)

OutMode 脉冲的输出模式0~7

* 返回无

*

*/

void ETH6045_set_pulse_optmode(/*U8 iChipNum,*/U32 Chip_Axis,U8 OutMode) {

U32 Renv1_data;

//U8 ret=0;

Renv1_data = p645_rreg(Chip_Axis, RRENV1); //读取环境变量1的值

Renv1_data = (Renv1_data & 0xFFFFFFF8); //消除环境变量1的低3位

Renv1_data = (Renv1_data | OutMode); //低3位就是脉冲输出模式的设置位

p645_wreg(Chip_Axis,WRENV1,Renv1_data);

//ret |= p645_wreg(unsigned intbase_addr, UINT16 rwcom, UINT32 data);

//if(ret != 0)

// ERR_flag=6;

//return ERR_flag;

}

/*

*

* 函数描述原点输入信号的逻辑设置函数

* 参数Chip_Axis 轴选择(通过基地址已经可以确认A片和B片地址)

org_logic 原点逻辑电平(1,0)

* 返回无

*

*/

void ETH6045_set_org_logic(U32 Chip_Axis, U8 org_logic)

{

U32 Renv1_data;

Renv1_data = p645_rreg(Chip_Axis, RRENV1);//读取环境变量1的值

if(org_logic == 0)

{

Renv1_data = (Renv1_data & 0xFFFFFF7F);//将环境变量1的第7位置0 }

else

{

Renv1_data = (Renv1_data | 0x00000080);

}

}

/*

*

* 函数描述减速开关输入信号的设置函数

* 参数Chip_Axis 轴选择(通过基地址已经可以确认A片和B片地址)

sd_logic 减速开关逻辑电平(1,0)

* 返回无

*

*/

void ETH6045_set_sd_logic(U32 Chip_Axis,U8 sd_logic)

{

U32 Renv1_data;

Renv1_data = p645_rreg(Chip_Axis,RRENV1);

if(sd_logic == 0)

{

Renv1_data = (Renv1_data & 0xFFFFFFBF);

}

else

{

Renv1_data = (Renv1_data | 0x00000040);

}

}

/*

*

* 函数描述XY轴直线插补(默认A片)

* 参数DistX X(主轴)结束点坐标

DistY Y(从轴)结束点坐标

StrVel 初始速度单位:PP/S(脉冲每秒)

MaxVel 运动速度单位:PP/S(脉冲每秒)

Tacc 加速度时间单位:ms

Tdec 减速时间单位:ms

* 返回无

*

*/

void ETH6045_start_linear_interpolation_XY(U8 ChipSelect,U32 DistX,U32 DistY,U32 StrVel,U32 MaxVel,U32 Tacc,U32 Tdec)

{

if(ChipSelect == 'B')

{

p645_vset(AXS_AX_B,StrVel,MaxVel,Tacc,Tdec,0,0,0,0); //插补主轴速度设置

p645_wreg(AXS_AX_B,WRMD,0x00000061); //插补轴指令

p645_wreg(AXS_AY_B,WRMD,0x00000061);

p645_wreg(AXS_AX_B,WRMV,DistX); //插补距离

p645_wreg(AXS_AY_B,WRMV,DistY);

p645_wcom(AXS_AX_B,SEL_X|SEL_Y|STAFL); //启动插补

}

else

{

p645_vset(AXS_AX,StrVel,MaxVel,Tacc,Tdec,0,0,0,0); //插补主轴速度设置

p645_wreg(AXS_AX,WRMD,0x00000061); //插补轴指令

p645_wreg(AXS_AY,WRMD,0x00000061);

p645_wreg(AXS_AX,WRMV,DistX); //插补距离

p645_wreg(AXS_AY,WRMV,DistY);

p645_wcom(AXS_AX,SEL_X|SEL_Y|STAFL) ; //启动插补

}

}

/*

*

* 函数描述XY轴圆弧插补(默认A片)

* 参数OffsetCx 插补圆心x 轴坐标

OffsetCy 插补圆心y 轴坐标

OffsetEx 插补终点x 轴坐标

OffsetEy 插补终点y 轴坐标

DIR 正反圆弧插补标志

MaxVel 插补速度

* 返回无

*

*/

void ETH6045_start_circular_interpolation_XY(U8 ChipSelect,U32 OffsetCx,U32 OffsetCy,U32 OffsetEx,U32 OffsetEy,U8 DIR,U32 MaxVel)

{

if(ChipSelect == 'B')

{

if(DIR == 0) //顺时针圆弧插补

{

p645_wreg(AXS_AX_B,WRMD,0x08000064); //插补指令

p645_wreg(AXS_AY_B,WRMD,0x08000064);

}

else //逆时针圆弧插补

{

p645_wreg(AXS_AX_B,WRMD,0x08000065); //插补指令

p645_wreg(AXS_AY_B,WRMD,0x08000065);

}

p645_vset(AXS_AX_B,100,MaxVel,100,100,10,10,'S',0); //插补速度设置

p645_wreg(AXS_AX_B,WRMV,/*0x00000000*/OffsetEx); //插补终点坐标

p645_wreg(AXS_AY_B,WRMV,/*0x00000000*/OffsetEy);

p645_wreg(AXS_AX_B,WRIP,/*0x00008000*/OffsetCx); //插补圆心坐标

p645_wreg(AXS_AY_B,WRIP,/*0x00000000*/OffsetCy);

p645_wcom(AXS_AX_B,(SEL_X|SEL_Y|STAUD)); //启动插补}

else

{

if(DIR == 0) //顺时针圆弧插补{

p645_wreg(AXS_AX,WPRMD,0x08000064); //插补指令

p645_wreg(AXS_AY,WPRMD,0x08000064);

}

else //逆时针圆弧插补{

p645_wreg(AXS_AX,WPRMD,0x08000065); //插补指令

p645_wreg(AXS_AY,WPRMD,0x08000065);

}

p645_vset(AXS_AX,100,MaxVel,100,100,10,10,'S',0); //插补速度设置

p645_wreg(AXS_AX,WPRMV,/*0x00000000*/OffsetEx); //插补终点坐标

p645_wreg(AXS_AY,WPRMV,/*0x00000000*/OffsetEy);

p645_wreg(AXS_AX,WPRIP,/*0x00008000*/OffsetCx); //插补圆心坐标

p645_wreg(AXS_AY,WPRIP,/*0x00000000*/OffsetCy);

p645_wcom(AXS_AX,SEL_X|SEL_Y|STAUD); //启动插补

}

}

/*

*

* 函数描述位置改变函数

* 参数Chip_Axis 轴选择

new_position 新的位置

* 返回无

*

*/

void ETH6045_position_change(U32 Chip_Axis,U32 new_position)

{

p645_wreg(Chip_Axis,WRMV,new_position); //设置新的位置

p645_wcom(Chip_Axis,STAON); //写入位置变更指令

}

/*

*

* 函数描述速度改变函数

* 参数Chip_Axis 轴选择

new_speed 新的速度

* 返回无

*

*/

void ETH6045_speed_change(U32 Chip_Axis,U32 new_speed)

{

p645_wreg(Chip_Axis,WPRMV,new_speed); //设置新的速度

p645_wcom(Chip_Axis,0x41); //写入速度变更指令

}

/*

*

* 函数描述手脉API函数:调用此函数之前,需要设置所选择轴的速度

* 参数Chip_Axis 轴选择

SpeedLimit 手脉倍率(1~32)

* 返回无

*

*/

void ETH6045_set_pulser_select_and_rate(U32 Chip_Axis,U32 SpeedLimit)

{

U32 Renv6_data;

Renv6_data = (p645_rreg(Chip_Axis,RRENV6)&0x7FFFFFFF); //读取环境变量

Renv6_data = (Renv6_data | (SpeedLimit<< 27)); //设置手脉倍率

}

/*

*

* 函数描述手脉API函数:点动函数

* 参数Chip_Axis 轴选择

rate 倍率

fldata 启动速度

fhdata 运行时间

utime 加速时间

dtime 减速时间

usdata s曲线加速范围

dstata s曲线减速范围

Line_or_s 直线曲线选择("L"直线,"S"曲线)

fadata 补偿速度(脉冲/S)

* 返回无

*

*/

void ETH6045_start_inching(U32 Chip_Axis,U32 rate,U32 fldata,U32 fhdata,U32 utime,U32 dtime,U32 usdata,U32 dsdata,U32 Line_or_s,U32 fadata)

{

p645_wreg(Chip_Axis,WPRMD,0x00000041); //定量指令

p645_vset(Chip_Axis,fldata,fhdata,utime,dtime,usdata,dsdata,Line_or_s,fadata);

p645_wreg(Chip_Axis,WRMV,(rate+1)); //设置点动倍率

p645_wcom(Chip_Axis,0x53); //启动执行

}

/*

*

* 函数描述原点反回的有关API函数:返回模式设置函数

* 参数Chip_Axis 轴选择

mode 模式选择(0~12)

* 返回无

*

*/

void ETH6045_set_org_mode(U32 Chip_Axis,U8 mode)

{

U32 Renv3_data;

Renv3_data = p645_rreg(Chip_Axis,RRENV3);//环境变量3的低4位就原点返回模式的设置位

Renv3_data = (Renv3_data & 0xFFFFFFF0);

Renv3_data = Renv3_data | mode;

p645_wreg(Chip_Axis,WRENV3,Renv3_data);

}

/*

*

* 函数描述原点反回的有关API函数:返回要数的EZ脉冲个数

* 参数Chip_Axis 轴选择

Ez_count EZ个数(1~16)

* 返回无

*

*/

void ETH6045_set_org_ezcount(U32 Chip_Axis,U16 Ez_count)

{

U32 Renv3_data;

Renv3_data = p645_rreg(Chip_Axis,RRENV3); //环境变量3的第4,5,6,7位就是设置EZ个数的对应位

Renv3_data = (Renv3_data & 0xFFFFFF0F);

Renv3_data = (Renv3_data |(Ez_count<<4));

p645_wreg(Chip_Axis,WRENV3,Renv3_data);

}

/*

*

* 函数描述原点反回的有关API函数:原点返回完成是否输出ERC

* 参数Chip_Axis 轴选择

ERC_flag 输出标志(1:输出;0:不输出)

* 返回无

*

*/

void ETH6045_set_org_erc(U32 Chip_Axis,U8 ERC_flag)

{

U32 Renv1_data;

Renv1_data = p645_rreg(Chip_Axis,RRENV1);

if(ERC_flag == 0)

{

Renv1_data = (Renv1_data & 0xFFFFF7FF);

}

else

{

Renv1_data = (Renv1_data| 0x00000800);

}

p645_wreg(Chip_Axis,WRENV1,Renv1_data);

}

/*

*

* 函数描述回零函数

* 参数Chip_Axis 轴选择

StrVel 初始速度单位:PP/S(脉冲每秒)

MaxVel 运动速度单位:PP/S(脉冲每秒)

Tacc 加速度时间单位:ms

Tdec 减速时间单位:ms

SVacc s加速范围

SVdec s减速范围

Line_or_s 直线曲线选择("L"直线,"S"曲线)

fadata 补偿速度单位:PP/S(脉冲/S)

* 返回无

*

*/

void ETH6045_clear(U32 Chip_Axis,U32 StrVel,U32 MaxVel,U32 Tacc,U32 Tdec,U32 SVacc,U32 SVdec,U32 Line_or_s,U32 fadata)

{

p645_wreg(Chip_Axis,WPRMD,0x00000044); //回零指令速度设置

p645_vset(Chip_Axis,StrVel,MaxVel,Tacc,Tdec,SVacc,SVdec,Line_or_s,fadata);

p645_wcom(AXS_AX,0x53); //启动回零操作

}

/*

*

* 函数描述通用I/O端口置0或1

* 参数Chip_Axis 轴选择

IO_num IO端口号(0~7)

IO_logic IO端口电平(1或0)

* 返回无

*

*/

void ETH6045_set_IO(U32 Chip_Axis,U8 IO_num,U8 IO_logic)

{

U32 temp,temp1;

U8 Prst,Pset;

temp = p645_rreg(Chip_Axis,RRENV2); //读取环境变量2

temp = temp | (1<<((IO_num)*2)); //设置IO口为通用输出(要设置2位),置某位为1

temp = temp & (~(1<<((IO_num)*2+1))); //置某位为0

//printf("temp=%x\n",temp);

p645_wreg(Chip_Axis,WRENV2,temp);

temp1 = p645_rsts(Chip_Axis); //读取状态寄存器取出IO口状态

//printf("temp1=%x\n",temp1);

Prst = (U8)temp1 &( ~(1<<(IO_num))); //置某位为0

Pset = (U8)temp1 | (1<<(IO_num)); //置某位为1

//printf("prst=%x\n",Prst);

//printf("pset=%x\n",Pset);

if(IO_logic == 0)

{

p645_wotp(Chip_Axis,Prst);

}

else

{

p645_wotp(Chip_Axis,Pset);

}

//p645_wreg(Chip_Axis,WRENV2,0xC0005555); // 设置P0X~P7X 引脚为输出

//p645_wotp(AXS_AX,0x0000); //置P0X~P7X为低电平

//p645_wotp(AXS_AX, 0x00FF); //置P0X~P7X为高电平

}

/*

*

* 函数描述连续驱动

* 参数Chip_Axis 轴选择

Dir 方向选择(0,正方向,1负方向)

fldata 启动速度

fhdata 运行时间

utime 加速时间

dtime 减速时间

usdata s曲线加速范围

dstata s曲线减速范围

* 返回无

*

*/

void ETH6045_start_Continuous_move(U32 Chip_Axis,U32 Dir,U32 fldata,U32 fhdata,U32 utime,U32 dtime,U32 usdata,U32 dsdata)

{

if(Dir == 0)

{

p645_wreg(Chip_Axis,WPRMD,0x00000008);

printf("zheng");

}

else

{

p645_wreg(Chip_Axis,WPRMD,0x00000000);

printf("fan");

}

p645_vset(Chip_Axis,fldata,fhdata,utime,dtime,usdata,dsdata,'L',0);

p645_wcom(Chip_Axis,STAUD);

}

/*

*

* 函数描述增量模式的直线或曲线动作执行函数(执行完后立即返回)

* 参数

Chip_Axis 轴选择

Dist 运动距离

StrVel 初始速度单位:PP/S(脉冲每秒)

MaxVel 运动速度单位:PP/S(脉冲每秒)

Tacc 加速度时间单位:ms

Tdec 减速时间单位:ms

SVacc s加速范围

SVdec s减速范围

Line_or_s 直线曲线选择("L"直线,"S"曲线)

fadata 补偿速度单位:PP/S(脉冲/S)

* 返回无

*

*/

void ETH6045_start_increment_mode_move(U32 Chip_Axis,U32 Dist,U32 StrVel,U32

MaxVel,U32 Tacc,U32 Tdec,U32 SVacc,U32 SVdec,U32 Line_or_s,U32 fadata)

{

p645_wreg(Chip_Axis,WPRMD,0x00000041); //相对定长运动指令设置

p645_vset(Chip_Axis,StrVel,MaxVel,Tacc,Tdec,SVacc,SVdec,Line_or_s,fadata);

p645_wreg(Chip_Axis,WPRMV,Dist); //设定运动距离

p645_wcom(Chip_Axis,STAUD);

//printf("wait..\n");

p645_wait(Chip_Axis); //等待电机停止

//printf("stop..\n");

p645_wreg(Chip_Axis,WPRMV,-Dist); //执行返回指令

p645_wcom(Chip_Axis,STAUD);

}

/*

*

* 函数描述绝对模式的直线或曲线动作执行函数(执行完后立即返回)

* 参数Chip_Axis 轴选择

Dist 运动距离

StrVel 初始速度单位:PP/S(脉冲每秒)

MaxVel 运动速度单位:PP/S(脉冲每秒)

Tacc 加速度时间单位:ms

Tdec 减速时间单位:ms

SVacc s加速范围

SVdec s减速范围

Line_or_s 直线曲线选择("L"直线,"S"曲线)

fadata 补偿速度单位:PP/S(脉冲/S)

* 返回无

*

*/

void ETH6045_start_absolute_mode_move(U32 Chip_Axis,U32 Dist,U32 StrVel,U32 MaxVel,U32 Tacc,U32 Tdec,U32 SVacc,U32 SVdec,U32 Line_or_s,U32 fadata)

{

p645_wreg(Chip_Axis,WPRMD,0x00000042); //绝对定长运动指令设置

p645_vset(Chip_Axis,StrVel,MaxVel,Tacc,Tdec,SVacc,SVdec,Line_or_s,fadata);

p645_wreg(Chip_Axis,WPRMV,Dist); //设定运动距离

p645_wcom(Chip_Axis,STAUD);

p645_wait(Chip_Axis); //等待电机停止

p645_wreg(Chip_Axis,WPRMV,-Dist); //执行返回指令

p645_wcom(Chip_Axis,STAUD);

}

/*

*

* 函数描述运动状态查询函数

* 参数Chip_Axis 轴选择

* 返回轴的运行状态

*/

U32 ETH6045_move_state(U32 Chip_Axis)

{

U32 state;

state = p645_rreg(Chip_Axis,RRSTS);

return state;

}

/*

*

* 函数描述限位运动控制函数

* 参数Chip_Axis 轴选择

Dir 方向(0:正方向,1:负方向)

MaxVel 运行速度

* 返回

*

*/

void ETH6045_limit_move(U32 Chip_Axis,U8 Dir,U32 MaxVel)

{

if(Dir == 0)

p645_wreg(Chip_Axis,WPRMD,0x00000020); //正方向限位运动指令else

p645_wreg(Chip_Axis,WPRMD,0x00000028); //负方向限位运动指令p645_vset(Chip_Axis,100,MaxVel,300,0,0,0,'L',0);

p645_wcom(Chip_Axis,STAFH);

}

/*

*

* 函数描述减速停止

* 参数Chip_Axis 轴选择

* 返回

*

*/

void ETH6045_sd_stop(U32 Chip_Axis)

{

p645_wcom(Chip_Axis,SDSTP);

}

/*

*

* 函数描述紧急停止

* 参数Chip_Axis 轴选择

* 返回

*/

void ETH6045__emg_stop(U32 Chip_Axis)

{

p645_wcom(Chip_Axis,CMEMG);

}

/*

*

* 函数描述系统复位(功能和置RST为lov(低)相同) * 参数Chip_Axis 轴选择

* 返回

*

*/

void ETH6045__system_rst(U32 Chip_Axis)

{

p645_wcom(Chip_Axis,SRST);

}

/*

*

* 函数描述当前速度

* 参数Chip_Axis 轴选择

* 返回

*

*/

U16 ETH6045__Speed(U32 Chip_Axis)

{

U32 data;

data = p645_rreg(Chip_Axis,RRSPD);

return (U16)data;

}

相关推荐
相关主题
热门推荐