基于linux环境和ethecat的igh库控制汇川620N的主站代码

最新推荐文章于 2024-05-24 17:18:09 发布
最新推荐文章于 2024-05-24 17:18:09 发布
阅读量2.5k 收藏 29
点赞数 4
分类专栏： ethercat linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42186805/article/details/108603423
版权
c语言 同时被 3 个专栏收录
17 篇文章 0 订阅
订阅专栏
linux
9 篇文章 1 订阅
订阅专栏
ethercat
3 篇文章 0 订阅
订阅专栏 
#include "ecrt.h"
#include <stdio.h>
#include "ethercatdef.h"
#include "initInovance.h"
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>
#include <sys/mman.h>
#include <malloc.h>

static struct timespec timespec_add(struct timespec time1, struct timespec time2);

#define CLOCK_TO_USE CLOCK_REALTIME

#define DIFF_NS(A, B) (((B).tv_sec - (A).tv_sec) * NSEC_PER_SEC + \
	(B).tv_nsec - (A).tv_nsec)

#define TIMESPEC2NS(T) ((uint64_t) (T).tv_sec * NSEC_PER_SEC + (T).tv_nsec)

//https://etherlab.org/download/ethercat/ethercat-1.1.1-htmldoc/group__RealtimeInterface.html


#define PERIOD_NS (NSEC_PER_SEC / FREQUENCY)
#define SHIFT_NS  (NSEC_PER_SEC / FREQUENCY /4)






static slave_info servo_config [MAX_SLAVES] ={
{POS0_620N,INFO_620N},
{POS1_620N,INFO_620N},
{}
};








/* Offsets for PDO entries */
typedef struct  {
//RxPDO
unsigned int control_word; //0x6040:控制字,subindex:0,bitlen:16
unsigned int target_position;//0x607A:目标位置,subindex:0,bitlen:32
unsigned int touch_probe; //0x60B8:探针,subindex:0,bitlen:16
unsigned int pysical_outputs;//0x60FE:pysical_outputs,subindex:1,bitlen:32
unsigned int target_velocity;//0x60FF:target_velocity,subindex:0,bitlen:32
unsigned int target_torque;//0x6071:int target_torque,subindex:0,bitlen:16
unsigned int modes_operation;//0x6060:Modes of operation,subindex:0,bitlen:8
unsigned int max_profile_velocity;//0x607F:max_profile_velocity,subindex:0,bitlen:32
unsigned int positive_torque_limit_value;//0x60E0:positive_torque_limit_value,subindex:0,bitlen:16
unsigned int negative_torque_limit_value;//0x60E1:negaitive_torque_limit_value,subindex:0,bitlen:16
unsigned int torque_offset;//0x60B2:torque offset,subindex:0,bitlen:16

//TxPDo
unsigned int status_word;//0x6041:status_word,subindex:0,bitlen:16
unsigned int position_actual_value;//0x6064:position_actual_value,subindex:0,bitlen:32
unsigned int touch_probe_status;//0x60B9,subindex:0,bitlen:16
unsigned int touch_probe_pos1_pos_value;//0x60BA,subindex:0,bitlen:32
unsigned int touch_probe_pos2_pos_value;//0x60BC ,subindex:0,bitlen:32
unsigned int error_code;//0x603F,subindex:0,bitlen:16
unsigned int digital_inputs;//0x60FD,subindex:0,bitlen:32
unsigned int torque_actual_value;//0x6077,subindex:0,bitlen:16
unsigned int following_error_actual_value;//0x60F4,subindex:0,bitlen:32
unsigned int modes_of_operation_display;//0x6061,subindex:0,bitlen:8
unsigned int velocity_actual_value;//0x606C,subindex:0,bitlen:32


//input
unsigned int position;

}IS620N_offset;




IS620N_offset offsetOfIs620n_0;
IS620N_offset offsetOfIs620n_1;

static IS620N_offset *is620n[MAX_SLAVES]=
{
	&offsetOfIs620n_0,
	&offsetOfIs620n_1,
	NULL,
};


 struct timespec cycletime = {0, PERIOD_NS};

static struct timespec timespec_add(struct timespec time1, struct timespec time2)
{
	struct timespec result;

	if ((time1.tv_nsec + time2.tv_nsec) >= NSEC_PER_SEC) {
		result.tv_sec = time1.tv_sec + time2.tv_sec + 1;
		result.tv_nsec = time1.tv_nsec + time2.tv_nsec - NSEC_PER_SEC;
	} else {
		result.tv_sec = time1.tv_sec + time2.tv_sec;
		result.tv_nsec = time1.tv_nsec + time2.tv_nsec;
	}

	return result;
}




int handleTask(IS620N_offset* targetSlave,uint8_t **domain1_pd)
{
	uint16_t state = 0 ,error_code = 0;
	state = EC_READ_U16(*domain1_pd + targetSlave->status_word);
  	error_code = EC_READ_U16(*domain1_pd + targetSlave->error_code);
    printf( " status_word: %x \n  error_code: %x \n",state,error_code);
	switch (state){                                                      //伺服初始化状态机
		case SERVO_STAT_SWION_DIS:
			EC_WRITE_U16(*domain1_pd + targetSlave->control_word ,0x0006);
			break;
		case SERVO_STAT_RDY_SWION:
			EC_WRITE_U16(*domain1_pd + targetSlave->control_word  ,0x0007);
			break;
		case 	SERVO_STAT_SWION_ENA:
			EC_WRITE_U16(*domain1_pd + targetSlave->control_word  ,0x000f);
			break;
	    case SERVO_STAT_OP_ENA:
			EC_WRITE_U8(*domain1_pd + targetSlave->modes_operation ,8);
			break;
		case 	SERVO_STAT_ERROR:
			EC_WRITE_U16(*domain1_pd + targetSlave->control_word ,0x0080);
			break;	
		case SERVO_STAT_POSITION_END:
			if(targetSlave->position>=10000000) return 1;
			targetSlave->position += 10000;
		default :
			if(error_code) 
			{
				EC_WRITE_U16(*domain1_pd + targetSlave->control_word ,0x0080);
				 printf( " resetting  servo\n");
				break;	
			}
			EC_WRITE_U32(*domain1_pd + targetSlave->target_position,targetSlave->position);
			printf(" offset:%d\n",(targetSlave->position - EC_READ_U32(*domain1_pd + targetSlave->position_actual_value) )  );
			break;

		}
	return 0;
}


//每个PERIOD_NS周期进行一次时钟同步，PERIOD_NS*REQUEST_FREQUENCY执行一次任务

void cyclic_task(ec_master_t* master,unsigned slave_cnt ,ec_domain_t* domain1, uint8_t **domain1_pd )
{
    static unsigned int task_counter = 0;
	struct timespec wakeupTime, time;
	clock_gettime(CLOCK_TO_USE, &wakeupTime);
	unsigned int cnt = 0;
	int position[MAX_SLAVES];
	memset(position,0,sizeof(position));
	
	while(1) 
	{
		wakeupTime = timespec_add(wakeupTime, cycletime);
        clock_nanosleep(CLOCK_TO_USE, TIMER_ABSTIME, &wakeupTime, NULL);
     	/* receive process data */
      	ecrt_master_receive(master);
      	ecrt_domain_process(domain1);
        
      	if (task_counter) {
      	    task_counter--;
      	} else { /* do this at 1 Hz */
     	     task_counter = REQUEST_FREQUENCY;
    	     /* read process data */
  		   for(cnt =0;cnt<slave_cnt;cnt++)
  		   	{
				 handleTask(is620n[cnt],domain1_pd) ;
  		   	}
			
     	 }

  		clock_gettime(CLOCK_TO_USE, &time);
  		ecrt_master_application_time(master, TIMESPEC2NS(time));
  	

  		ecrt_master_sync_reference_clock(master);

  		ecrt_master_sync_slave_clocks(master);
  
      	ecrt_domain_queue(domain1);
      	ecrt_master_send(master);
	}
}





//从站0 的pdo配置

static ec_pdo_entry_reg_t domain0_regs[] = {

	{POS0_620N,INFO_620N, 0x6040, 0, &offsetOfIs620n_0.control_word},
	{POS0_620N,INFO_620N, 0x607A, 0, &offsetOfIs620n_0.target_position},
	{POS0_620N,INFO_620N, 0x60FF, 0, &offsetOfIs620n_0.target_velocity},
	{POS0_620N,INFO_620N, 0x6071, 0, &offsetOfIs620n_0.target_torque},
	{POS0_620N,INFO_620N, 0x6060, 0, &offsetOfIs620n_0.modes_operation},
	{POS0_620N,INFO_620N, 0x60B8, 0, &offsetOfIs620n_0.touch_probe},
	{POS0_620N,INFO_620N, 0x607F, 0, &offsetOfIs620n_0.max_profile_velocity},

	{POS0_620N,INFO_620N, 0x603F, 0, &offsetOfIs620n_0.error_code},			
	{POS0_620N,INFO_620N, 0x6041, 0, &offsetOfIs620n_0.status_word},		   
	{POS0_620N,INFO_620N, 0x6064, 0, &offsetOfIs620n_0.position_actual_value}, 
	{POS0_620N,INFO_620N, 0x6077, 0, &offsetOfIs620n_0.torque_actual_value},	
	{POS0_620N,INFO_620N, 0x6061, 0, &offsetOfIs620n_0.touch_probe_status},	
	{POS0_620N,INFO_620N, 0x60B9, 0, &offsetOfIs620n_0.touch_probe_pos1_pos_value}, 
	{POS0_620N,INFO_620N, 0x60BA, 0, &offsetOfIs620n_0.touch_probe_pos2_pos_value}, 
	{POS0_620N,INFO_620N, 0x60BC, 0, &offsetOfIs620n_0.modes_of_operation_display},	
	{POS0_620N,INFO_620N, 0x60FD, 0, &offsetOfIs620n_0.digital_inputs},	
	{}

};



//从站1 的pdo配置
static ec_pdo_entry_reg_t domain1_regs[] = {

	{POS1_620N,INFO_620N, 0x6040, 0, &offsetOfIs620n_1.control_word},
	{POS1_620N,INFO_620N, 0x607A, 0, &offsetOfIs620n_1.target_position},
	{POS1_620N,INFO_620N, 0x60FF, 0, &offsetOfIs620n_1.target_velocity},
	{POS1_620N,INFO_620N, 0x6071, 0, &offsetOfIs620n_1.target_torque},
	{POS1_620N,INFO_620N, 0x6060, 0, &offsetOfIs620n_1.modes_operation},
	{POS1_620N,INFO_620N, 0x60B8, 0, &offsetOfIs620n_1.touch_probe},
	{POS1_620N,INFO_620N, 0x607F, 0, &offsetOfIs620n_1.max_profile_velocity},

	{POS1_620N,INFO_620N, 0x603F, 0, &offsetOfIs620n_1.error_code},			
	{POS1_620N,INFO_620N, 0x6041, 0, &offsetOfIs620n_1.status_word},		   
	{POS1_620N,INFO_620N, 0x6064, 0, &offsetOfIs620n_1.position_actual_value}, 
	{POS1_620N,INFO_620N, 0x6077, 0, &offsetOfIs620n_1.torque_actual_value},	
	{POS1_620N,INFO_620N, 0x6061, 0, &offsetOfIs620n_1.touch_probe_status},	
	{POS1_620N,INFO_620N, 0x60B9, 0, &offsetOfIs620n_1.touch_probe_pos1_pos_value}, 
	{POS1_620N,INFO_620N, 0x60BA, 0, &offsetOfIs620n_1.touch_probe_pos2_pos_value}, 
	{POS1_620N,INFO_620N, 0x60BC, 0, &offsetOfIs620n_1.modes_of_operation_display},	
	{POS1_620N,INFO_620N, 0x60FD, 0, &offsetOfIs620n_1.digital_inputs},	
	{}

};


ec_pdo_entry_reg_t* domain_regs[MAX_SLAVES]={
	domain0_regs,
	domain1_regs,
	NULL,
};



ec_pdo_entry_info_t slave_1_pdo_entries[] = {
    {0x6040, 0x00, 16},
    {0x607A, 0x00, 32},
    {0x60FF, 0x00, 32},
    {0x6071, 0x00, 16},
    {0x6060, 0x00, 8},
    {0x60B8, 0x00, 16},
    {0x607F, 0x00, 32},
    
    {0x603F, 0x00, 16},
    {0x6041, 0x00, 16},
    {0x6064, 0x00, 32},
    {0x6077, 0x00, 16},
    {0x6061, 0x00,  8},
    {0x60B9, 0x00, 16},
    {0x60BA, 0x00, 32},
	{0x60BC, 0x00, 32},
	{0x60FD, 0x00, 32}	
};



ec_pdo_entry_info_t slave_0_pdo_entries[] = {
    {0x6040, 0x00, 16},
    {0x607A, 0x00, 32},
    {0x60FF, 0x00, 32},
    {0x6071, 0x00, 16},
    {0x6060, 0x00, 8},
    {0x60B8, 0x00, 16},
    {0x607F, 0x00, 32},
    
    {0x603F, 0x00, 16},
    {0x6041, 0x00, 16},
    {0x6064, 0x00, 32},
    {0x6077, 0x00, 16},
    {0x6061, 0x00,  8},
    {0x60B9, 0x00, 16},
    {0x60BA, 0x00, 32},
	{0x60BC, 0x00, 32},
	{0x60FD, 0x00, 32}	
};



//注意这里的pdo映射索引
ec_pdo_info_t slave_0_pdos[] = {
    {0x1702, 7, slave_0_pdo_entries + 0},
    {0x1B02	, 9, slave_0_pdo_entries + 7},
};


ec_pdo_info_t slave_1_pdos[] = {
    {0x1702, 7, slave_1_pdo_entries + 0},
    {0x1B02, 9, slave_1_pdo_entries + 7},
};



ec_sync_info_t slave_0_syncs[] = {
    {0, EC_DIR_OUTPUT, 0, NULL, EC_WD_DISABLE},
    {1, EC_DIR_INPUT, 0, NULL, EC_WD_DISABLE},
    {2, EC_DIR_OUTPUT, 1, slave_0_pdos + 0, EC_WD_ENABLE},
    {3, EC_DIR_INPUT, 1, slave_0_pdos + 1, EC_WD_DISABLE},
    {0xff}
};

ec_sync_info_t slave_1_syncs[] = {
    {0, EC_DIR_OUTPUT, 0, NULL, EC_WD_DISABLE},
    {1, EC_DIR_INPUT, 0, NULL, EC_WD_DISABLE},
    {2, EC_DIR_OUTPUT, 1, slave_1_pdos + 0, EC_WD_ENABLE},
    {3, EC_DIR_INPUT, 1, slave_1_pdos + 1, EC_WD_DISABLE},
    {0xff}
};

ec_sync_info_t* slave_syncs[MAX_SLAVES]={
	slave_0_syncs,
	slave_1_syncs,	
	NULL,
};


//sdo配置，在激活master之前可以调用
 int configParamOfServo(ec_master_t *master, slave_info *servo_config,unsigned int slave_cnt)
{
	
	uint16_t encoder_config = 14101;
	uint32_t celeration = 200;
	uint32_t abort_code = 0;
	uint32_t deceleration = 200;
	uint32_t maxVelocity = 0x0a6aaaaa;
	uint16_t velocity_loop_gain = 401;
	int cnt = 0;
	for(cnt=0;cnt<slave_cnt;cnt++)
	{
		if( 0 > ecrt_master_sdo_download(master,servo_config[cnt].position,0x6083,0,(uint8_t*)&celeration,4,&abort_code))goto error_out;
		if( 0 > ecrt_master_sdo_download(master,servo_config[cnt].position,0x6084,0,(uint8_t*)&deceleration,4,&abort_code))goto error_out;
		if( 0 > ecrt_master_sdo_download(master,servo_config[cnt].position,0x2000,1,(uint8_t*)&encoder_config,2,&abort_code))goto error_out;
		if( 0 > ecrt_master_sdo_download(master,servo_config[cnt].position,0x607f,0,(uint8_t*)&maxVelocity,4,&abort_code))goto error_out;
 		if( 0 > ecrt_master_sdo_download(master,servo_config[cnt].position,0x2008,1,(uint8_t*)&velocity_loop_gain,2,&abort_code))goto error_out;
	}
	
	return 0;
	
error_out:
	printf("error!!,sdo config failed abort code %x\n",abort_code);
	return 1;
}

int main(void)
{
	ec_master_t * master =NULL;
	ec_domain_t*  domain = NULL;
	 uint8_t * domain_pd = NULL; /* process data */
	ec_slave_config_t* slave[MAX_SLAVES];
	ec_master_state_t state;

	memset(slave,0,sizeof(slave));


	master	  = ecrt_request_master( 0 );
	if(master == NULL) goto error_out;
	printf("master found\n");
	
	ecrt_master_state( master, &state );  //获取master信息

	domain  = ecrt_master_create_domain(master);
	if (!domain) goto error_out;
	int cnt;
	for(cnt =0;cnt<state.slaves_responding;cnt++)
	{
		slave[cnt]   = ecrt_master_slave_config(master,servo_config[cnt].alias,\
														servo_config[cnt].position,\
														servo_config[cnt].vendor_id,\
														servo_config[cnt].product_code);
    	if (!slave[cnt])  goto error_out;
	}

	printf("Configuring SDOs...\n");
	if(0!=configParamOfServo(master, servo_config,state.slaves_responding))goto error_out;
	
	printf("Configuring PDOs...\n");
	for(cnt =0;cnt<state.slaves_responding;cnt++)
	{
		if (ecrt_slave_config_pdos(slave[cnt], EC_END, slave_syncs[cnt]))  goto error_out;
	}


	for(cnt =0;cnt<state.slaves_responding;cnt++)
	{
		if (ecrt_domain_reg_pdo_entry_list(domain, domain_regs[cnt]))  goto error_out;
	}

	for(cnt =0;cnt<state.slaves_responding;cnt++)
	{
	 	ecrt_slave_config_dc(slave[cnt], 0x300, PERIOD_NS, SHIFT_NS, 0, 0)  ;
	}
	
    printf("Activating master...\n");
    if ( ecrt_master_activate(master) ) goto error_out;
	if (!(domain_pd = ecrt_domain_data(domain))) goto error_out;


	
        
    printf("Start !\n");

	cyclic_task(master,state.slaves_responding,domain,&(domain_pd));

	return 0;


error_out:
	printf("error!!start failed\n");
	return 0 ;
		
}

关于获取master的信息来获得slave个数   参考了 https://etherlab-users.etherlab.narkive.com/IkBhZEoF/how-to-get-slave-count-from-userspace 的方法（我只会down代码而已，谈不上技术程序员）

汇川伺服手册需要参考，对不同的伺服都需要一本手册在手，了解pdo映射条目，sdo索引的具体含义。

我选择的是同步位置模式,控制两个电机转一定的位置

（ps 汇川在速度模式下需要在每个任务周期对目标速度进行写操作，否则电机没有反应，这个卡了我好几天才发现）

 

echo_hello1
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
0x6040控制字
cfqq1989的博客
12-08 616
【代码】0x6040控制字。
基于ARM的Linux+Xenomai实时系统搭建及igh主站配置
09-21
基于ARM的Linux+Xenomai实时系统搭建及igh主站配置
基于SOEM的EtherCat主站程序控制汇川SV660
06-02
LAN8720,DP83848，汇川SV660,SV620，无操作系统STM32F407
ethercat linux 主站igh程序讲解
01-08
linux，ethercat 开源master igh 汇川伺服电机 igh流程讲解 英文论文Motion Control of 6-DOF Manipulator Based on EtherCAT 六轴机械臂开源控制
igh实时控制电机动起来的一个小项目，包括编译环境，及代码
12-04
IGH，xenomai控制电机，下载解压后，需要修改在mian.c里面把自己电机的ID换一下就能运行了。这里面是视频演示（ https://www.bilibili.com/video/BV1rg411A7Mm/ ）。这里面是搭建IGH的教程（ https://blog.csdn.net/qq_50808730/category_11470195.html ）
基于X86核心的Linux+Xenomai系统构建+igh主站移植
09-21
基于X86核心的Linux+Xenomai系统构建+igh主站移植
IgH详解七、ethercat实时网卡驱动
EtherCAT
09-26 8182
IgH支持两种模式的网络驱动 一、generic 通用模式的网卡驱动 这种模式下是通过TCPIP协议栈对上层提供的socket接口来实现的，这种模式下网络收发的实时性取决于TCPIP协议栈的处理效率，一般实时性都不好，优点是通用性好，板卡自带的驱动就可以使用，不需要修改。 二、实时网卡驱动 以e1000e为例来对比，在普通网卡驱动上需要实现的功能来达到好的实时性。 1、在网卡probe过程中，把网卡驱动注册到etherc...
Elmo canopen 之 控制字 0x6040
sususuqingxiao的博客
12-06 4096
状态机 状态机描述设备状态和驱动器可能的控制顺序。单个状态代表一种特殊的内部或外部行为。驱动器的状态也决定了哪些命令被接受;例如，点对点point-to-point运动只能在驱动器处于OPERATION ENABLED状态时启动。 状态可以使用控制字和/或根据内部事件改变。当前状态可以通过Statusword读取 驱动器在启动后执行转换0和1，无论是在上电或在NMT节点复位时的CAN通信。这种状态一直保持到由于接收到的主机命令而发生更改。 出现FAULT OCCURRED表示在操作过程中驱动器发生了.
1 IgH EtherCAT 主站
Queen B is Mine
11-18 8816
1 IgH EtherCAT 主站本章涵盖了有关EtherCAT主站的一些常规信息。1.1 功能摘要下面的列表给出了主要功能的简短摘要。 Linux 2.6 / 3.x的内核模块设计。 根据IEC 61158-12 [2] [3]实现。 为几个常见的以太网芯片提供支持EtherCAT的本机驱动程序，以及为 Linux内核支持的所有芯片提供通用驱动程序。 本地驱动程序在没有中断的情况下操作硬件 使
ethercat学习笔记1
08-08
代码的笔记放到第二章。1.8 松下的从站 PDO映射。6040h控制字这个控制字是用来控制伺服电机上使能的。6041状态字这个状态字读取伺服电机的状态。控制模式
ethercat-1.5.2.rar_ETHERCAT_Ethercat主站_igh_linux_主战
07-15
总的来说，这个压缩包提供的资源对于想要学习和开发基于Linux的EtherCAT主站应用的人来说是非常宝贵的。通过深入研究和实践，不仅可以掌握EtherCAT协议，还能提升Linux和网络编程能力，为从事工业自动化领域的开发...
Ubuntu 22.04下以SOEM为EtherCAT主站的驱动电机例子
hejzh123456的博客
10-17 6732
本文分享了以SOEM为EtherCAT主站的驱动电机的例子，其中述说了在调试SOEM中遇到的一些坑
（三）通用(generic)三轴（XYZ）电机使能配置文件
m0_65612642的博客
01-25 1360
---------------------@本博主，免费送专项配置文件---------------------- 2022最新linuxcnc2.8版轴运动配置文件【.hal .xml .ini】 *****************************deltaPos.hal文件对应X Y Z 轴格式如下：******************************* *******************deltaPos.xml文件对应轴关节数的各个参数的调整修改思路如下：****...
H5U PLC EtherCAT总线伺服回原(6098H=3)
RXXW_Dor的博客
06-12 1651
大部分运动控制都会对机械回原点进行大篇幅讲解，也可以看出机械回原点的重要性。常规的回原点方式大概有几十种吧，本文会给出常用回原点的注意事项，和编程推荐写法。如果原点回归速度、脉冲的加减速时间以及左限位原点位置设置的不合理，都会导致在回原点触碰到原点信号减速过程中已触碰左极限的情况，虽然软件内部已有对此类特殊情况的解决方案，但是在方案设计的时候还是尽量避免各种特殊情况的出现；回原模式3、4、5、6都没有限位的参与，这种机构的回原方式需要注意安全，可以规定必须手动移动到减速点激活状态在开启回原点功能。
＜工控＞＜PLC＞汇川Easy521系列PLC与汇川SV630N伺服进行EtherCat通讯的相关配置及指令编写
最新发布
用沸腾的热血，支付我们的人生吧！
05-24 1353
本系列是关于PLC相关的博文，包括PLC编程、PLC与上位机通讯、PLC与下位驱动、仪器仪表等通讯、PLC指令解析等相关内容。PLC品牌包括但不限于西门子、三菱等国外品牌，汇川、信捷等国内品牌。除了PLC为主要内容外，PLC相关元器件如触摸屏（HMI）、交换机等工控产品，如果有值得记录的内容，也会添加进来。
CANopen概念总结、心得体会
kuniqiw的博客
02-20 1518
NMT主机和NMT从机之间通讯的报文就称为。
IGH_Master主站配置驱动伺服电机和变频器总结
A-CAT的博客
11-22 5073
IGH_Master主站配置驱动伺服电机和变频器总结 Ethercat是倍福公司提出的一种工业现场总线协议，具有很好的实时性，IGH是一种开源的Ethercat主站实现协议，本文总结了一下使用IGH_Master驱动伺服电机和变频器的经验
CANOpen DS402伺服电机控制项目总结
gzggyg
06-13 2147
有些厂家把状态字的bit9在CANOpen控制的时候是置1的，认为CANOpen就是远程控制，而有些厂家则无此处理。上面的控制方式是周期性的发位置指令给伺服，旧的指令还未到位的时候新指令已经下发，则伺服会立即更新指令，不会等到上一条指令执行完，两条指令中间也就不会有停顿。一共使用过三个厂家的伺服电机，控制字都是一样的，但是状态字各家有自己的处理，有一点小差别。如下是其中一家的文档。PP_MODE的控制是最复杂的，除了要给定位置和速度，还要控制控制字中的bit4和bit5才能更新指令。
igh ethercat程序汇川IS620代码示例
05-09
以下是汇川IS620 EtherCAT从站的示例代码： 1. 首先，需要定义一些常量和宏。 ```c // EtherCAT从站地址 #define ECAT_SLAVE_ADDRESS 0x01 // EtherCAT从站状态 #define ECAT_STATE_INIT 0 #define ECAT_STATE_PREOP 1 #define ECAT_STATE_SAFEOP 2 #define ECAT_STATE_OP 3 // EtherCAT从站对象字典索引 #define ECAT_IDX_STATUSWORD 0x6041 #define ECAT_IDX_CONTROLWORD 0x6040 #define ECAT_IDX_POSITION_ACTUAL 0x6064 #define ECAT_IDX_POSITION_TARGET 0x607A // EtherCAT从站对象字典子索引 #define ECAT_SUBIDX_STATUSWORD 0x00 #define ECAT_SUBIDX_CONTROLWORD 0x00 #define ECAT_SUBIDX_POSITION_ACTUAL 0x00 #define ECAT_SUBIDX_POSITION_TARGET 0x00 // EtherCAT从站对象字典数据长度 #define ECAT_LEN_STATUSWORD 2 #define ECAT_LEN_CONTROLWORD 2 #define ECAT_LEN_POSITION_ACTUAL 4 #define ECAT_LEN_POSITION_TARGET 4 // EtherCAT从站对象字典数据偏移量 #define ECAT_OFF_STATUSWORD 0 #define ECAT_OFF_CONTROLWORD 0 #define ECAT_OFF_POSITION_ACTUAL 0 #define ECAT_OFF_POSITION_TARGET 0 // EtherCAT从站对象字典数据类型 #define ECAT_TYPE_STATUSWORD UNSIGNED16 #define ECAT_TYPE_CONTROLWORD UNSIGNED16 #define ECAT_TYPE_POSITION_ACTUAL INTEGER32 #define ECAT_TYPE_POSITION_TARGET INTEGER32 // EtherCAT从站对象字典数据访问权限 #define ECAT_ACCESS_STATUSWORD RO #define ECAT_ACCESS_CONTROLWORD RW #define ECAT_ACCESS_POSITION_ACTUAL RO #define ECAT_ACCESS_POSITION_TARGET RW // EtherCAT从站PDO映射索引 #define ECAT_PDO_IDX_RX 0x1600 #define ECAT_PDO_IDX_TX 0x1A00 // EtherCAT从站PDO映射子索引 #define ECAT_PDO_SUBIDX_RX 0x01 #define ECAT_PDO_SUBIDX_TX 0x01 // EtherCAT从站PDO映射数据长度 #define ECAT_PDO_LEN_RX 8 #define ECAT_PDO_LEN_TX 8 // EtherCAT从站PDO映射数据类型 #define ECAT_PDO_TYPE_RX UNSIGNED16 #define ECAT_PDO_TYPE_TX UNSIGNED16 // EtherCAT从站PDO映射数据访问权限 #define ECAT_PDO_ACCESS_RX RO #define ECAT_PDO_ACCESS_TX RO // EtherCAT从站PDO映射数据偏移量 #define ECAT_PDO_OFF_RX 0 #define ECAT_PDO_OFF_TX 0 // EtherCAT从站PDO映射方向 #define ECAT_PDO_DIR_RX INPUT #define ECAT_PDO_DIR_TX OUTPUT ``` 2. 然后，需要定义EtherCAT从站的对象字典。 ```c // EtherCAT从站对象字典 const ECAT_OBJECT_DICT ECAT_OBJ_DICT[] = { {ECAT_IDX_STATUSWORD, ECAT_SUBIDX_STATUSWORD, ECAT_LEN_STATUSWORD, ECAT_OFF_STATUSWORD, ECAT_TYPE_STATUSWORD, ECAT_ACCESS_STATUSWORD}, {ECAT_IDX_CONTROLWORD, ECAT_SUBIDX_CONTROLWORD, ECAT_LEN_CONTROLWORD, ECAT_OFF_CONTROLWORD, ECAT_TYPE_CONTROLWORD, ECAT_ACCESS_CONTROLWORD}, {ECAT_IDX_POSITION_ACTUAL, ECAT_SUBIDX_POSITION_ACTUAL, ECAT_LEN_POSITION_ACTUAL, ECAT_OFF_POSITION_ACTUAL, ECAT_TYPE_POSITION_ACTUAL, ECAT_ACCESS_POSITION_ACTUAL}, {ECAT_IDX_POSITION_TARGET, ECAT_SUBIDX_POSITION_TARGET, ECAT_LEN_POSITION_TARGET, ECAT_OFF_POSITION_TARGET, ECAT_TYPE_POSITION_TARGET, ECAT_ACCESS_POSITION_TARGET}, {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000} // 结束标志 }; ``` 3. 接下来，需要定义EtherCAT从站的PDO映射。 ```c // EtherCAT从站PDO映射 const ECAT_PDO_MAPPING ECAT_PDO_MAPPING[] = { {ECAT_PDO_IDX_RX, ECAT_PDO_SUBIDX_RX, ECAT_PDO_LEN_RX, ECAT_PDO_OFF_RX, ECAT_PDO_TYPE_RX, ECAT_PDO_ACCESS_RX, ECAT_PDO_DIR_RX}, {ECAT_PDO_IDX_TX, ECAT_PDO_SUBIDX_TX, ECAT_PDO_LEN_TX, ECAT_PDO_OFF_TX, ECAT_PDO_TYPE_TX, ECAT_PDO_ACCESS_TX, ECAT_PDO_DIR_TX}, {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000} // 结束标志 }; ``` 4. 然后，需要编写初始化函数，用于初始化EtherCAT从站。 ```c // EtherCAT从站状态 static uint8_t ecat_state = ECAT_STATE_INIT; // EtherCAT从站控制字 static uint16_t ecat_ctrlword = 0x0000; // EtherCAT从站状态字 static uint16_t ecat_statusword = 0x0000; // EtherCAT从站位置实际值 static int32_t ecat_pos_actual = 0; // EtherCAT从站位置目标值 static int32_t ecat_pos_target = 0; // EtherCAT从站初始化 void ecat_init(void) { // 初始化EtherCAT从站 ecatal_init(ECAT_SLAVE_ADDRESS, ECAT_OBJ_DICT, ECAT_PDO_MAPPING); // 设置EtherCAT从站状态为Init ecat_state = ECAT_STATE_INIT; } ``` 5. 接着，需要编写状态更新函数，用于更新EtherCAT从站的状态。 ```c // EtherCAT从站状态更新 void ecat_update(void) { // 获取EtherCAT从站状态字 ecatal_read_object(ECAT_IDX_STATUSWORD, ECAT_SUBIDX_STATUSWORD, &ecat_statusword); // 根据EtherCAT从站状态字更新状态 switch (ecat_state) { case ECAT_STATE_INIT: if (ecat_statusword == 0x0010) { // 设置EtherCAT从站状态为Pre-Operational ecat_state = ECAT_STATE_PREOP; // 使能EtherCAT从站 ecatal_enable(); } break; case ECAT_STATE_PREOP: if (ecat_statusword == 0x0028) { // 设置EtherCAT从站状态为Safe-Operational ecat_state = ECAT_STATE_SAFEOP; } break; case ECAT_STATE_SAFEOP: if (ecat_statusword == 0x0038) { // 设置EtherCAT从站状态为Operational ecat_state = ECAT_STATE_OP; } break; case ECAT_STATE_OP: if (ecat_statusword == 0x0028) { // 设置EtherCAT从站状态为Safe-Operational ecat_state = ECAT_STATE_SAFEOP; } break; } } ``` 6. 最后，需要编写主函数，用于控制EtherCAT从站。 ```c int main(void) { // 初始化EtherCAT从站 ecat_init(); while (1) { // 更新EtherCAT从站状态 ecat_update(); // 如果EtherCAT从站状态为Operational，则执行控制逻辑 if (ecat_state == ECAT_STATE_OP) { // 读取EtherCAT从站位置实际值 ecatal_read_object(ECAT_IDX_POSITION_ACTUAL, ECAT_SUBIDX_POSITION_ACTUAL, &ecat_pos_actual); // 读取EtherCAT从站位置目标值 ecatal_read_object(ECAT_IDX_POSITION_TARGET, ECAT_SUBIDX_POSITION_TARGET, &ecat_pos_target); // 如果位置实际值与位置目标值不同，则发送位置控制命令 if (ecat_pos_actual != ecat_pos_target) { // 设置EtherCAT从站控制字 ecat_ctrlword = 0x000F; // 发送位置控制命令 ecatal_write_object(ECAT_IDX_CONTROLWORD, ECAT_SUBIDX_CONTROLWORD, &ecat_ctrlword); // 发送位置目标值 ecatal_write_object(ECAT_IDX_POSITION_TARGET, ECAT_SUBIDX_POSITION_TARGET, &ecat_pos_target); } } } } ``` 以上是汇川IS620 EtherCAT从站的示例代码，供参考。由于具体的应用场景和要求不同，实际使用时需要根据自己的情况进行调整和修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值