[etherlab-users] Beginner: Modifying the example code "user"
Gavin Lambert
gavinl at compacsort.com
Wed Apr 5 09:00:25 CEST 2017
Unless your slave device is a Beckhoff EL3102, that name is going to confuse you later. You should use a more accurate name, or just specify the values directly instead of using a #define.
Similarly, you haven’t changed AnaInSlavePos from its previous value of 0,2 which specifies that the slave is the third device in the network, which is probably not correct for your network.
You should probably spend some time reading the documentation for the library and understand what all of these tables and values actually mean, based on the documentation for the APIs they are passed to and EtherCAT networks in general.
(Also note that while it’s ok to call printf from your real-time loop while you’re experimenting, you’ll have to remove it for a real application. printf is blocking and too slow to maintain a stable real-time loop; you have to be very careful what code you put in there.)
From: Justin Hunt [mailto:jphunt3 at asu.edu]
Sent: Wednesday, 5 April 2017 13:32
To: Gavin Lambert <gavin.lambert at compacsort.com>
Cc: etherlab-users at etherlab.org
Subject: Re: [etherlab-users] Beginner: Modifying the example code "user"
Hi Gavin,
Thank you for the reply, I really appreciate your time. I worked today to implement your instructions. Here is what I did:
1) I changed the original definition "#define Beckhoff_EL3102 0x00000002, 0x0c1e3052" to include the vendor ID and product code of my sensor, which I got from using Konsole command "ethercat slaves -v." So now it reads "#define Beckhoff_EL3102 0x00000732, 0x26483052"
2) I updated the domain1_regs to include only analog input from the index and sub index of the sensor force value I wish to read, like so:
const static ec_pdo_entry_reg_t domain1_regs[] = {
{AnaInSlavePos, Beckhoff_EL3102, 0x6000, 2, &off_ana_in_value},
{}
I am not sure if these two changes address your instructions correctly. I can however compile and run the code now. I tried to add the following line under cyclic_task() to see if I could stream the data to the Konsole, but it does not see to work:
printf("AnaIn: value %u\n", EC_READ_U32(domain1_pd + off_ana_in_value));
included below is the complete code in case it is needed.
****************************************************************************/
#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 "ecrt.h"
/****************************************************************************/
// Application parameters
#define FREQUENCY 100
#define PRIORITY 1
// Optional features
#define CONFIGURE_PDOS 1
#define SDO_ACCESS 0
/****************************************************************************/
// EtherCAT
static ec_master_t *master = NULL;
static ec_master_state_t master_state = {};
static ec_domain_t *domain1 = NULL;
static ec_domain_state_t domain1_state = {};
static ec_slave_config_t *sc_ana_in = NULL;
static ec_slave_config_state_t sc_ana_in_state = {};
// Timer
static unsigned int sig_alarms = 0;
static unsigned int user_alarms = 0;
/****************************************************************************/
// process data
static uint8_t *domain1_pd = NULL;
#define BusCouplerPos 0, 0 //#define assigns 0, 0 to the name BusCouplerPos
#define DigOutSlavePos 0, 2
#define AnaInSlavePos 0, 3
#define AnaOutSlavePos 0, 4
#define Beckhoff_EK1100 0x00000002, 0x044c2c52
//#define Beckhoff_EL2004 0x00000002, 0x07d43052
#define Beckhoff_EL2032 0x00000002, 0x07f03052
#define Beckhoff_EL3152 0x00000002, 0x0c503052
//#define Beckhoff_EL3102 0x00000002, 0x0c1e3052
#define Beckhoff_EL3102 0x00000732, 0x26483052
#define Beckhoff_EL4102 0x00000002, 0x10063052
//test
// offsets for PDO entries
static unsigned int off_ana_in_status;
static unsigned int off_ana_in_value;
//static unsigned int off_ana_out;
//static unsigned int off_dig_out;
const static ec_pdo_entry_reg_t domain1_regs[] = {
{AnaInSlavePos, Beckhoff_EL3102, 0x6000, 2, &off_ana_in_value},
{}
};
static unsigned int counter = 0;
static unsigned int blink = 0;
/*****************************************************************************/
#if CONFIGURE_PDOS
static ec_pdo_entry_info_t el3102_pdo_entries[] = {
{0x7010, 1, 32}, /* Control 1 */
{0x7010, 2, 32}, /* Control 2 */
{0x6000, 1, 32}, /* Fx/Gage0 */
{0x6000, 2, 32}, /* Fy/Gage1 */
{0x6000, 3, 32}, /* Fz/Gage2 */
{0x6000, 4, 32}, /* Tx/Gage3 */
{0x6000, 5, 32}, /* Ty/Gage3 */
{0x6000, 6, 32}, /* Tz/Gage3 */
{0x6010, 0, 32}, /* SubIndex 000 */
{0x6020, 0, 32}, /* SubIndex 000 */
};
static ec_pdo_info_t el3102_pdos[] = {
{0x1601, 2, el3102_pdo_entries + 0}, /* DO RxPDO-Map */
{0x1a00, 8, el3102_pdo_entries + 2}, /* DI TxPDO-Map */
};
ec_sync_info_t el3102_syncs[] = {
{0, EC_DIR_OUTPUT, 0, NULL, EC_WD_DISABLE},
{1, EC_DIR_INPUT, 0, NULL, EC_WD_DISABLE},
{2, EC_DIR_OUTPUT, 1, el3102_pdos + 0, EC_WD_ENABLE},
{3, EC_DIR_INPUT, 1, el3102_pdos + 1, EC_WD_DISABLE},
{0xff}
};
#endif
/*****************************************************************************/
#if SDO_ACCESS
static ec_sdo_request_t *sdo;
#endif
/*****************************************************************************/
void check_domain1_state(void)
{
ec_domain_state_t ds;
ecrt_domain_state(domain1, &ds);
if (ds.working_counter != domain1_state.working_counter)
printf("Domain1: WC %u.\n", ds.working_counter);
if (ds.wc_state != domain1_state.wc_state)
printf("Domain1: State %u.\n", ds.wc_state);
domain1_state = ds;
}
/*****************************************************************************/
void check_master_state(void)
{
ec_master_state_t ms;
//printf("test");
ecrt_master_state(master, &ms);
if (ms.slaves_responding != master_state.slaves_responding)
printf("%u slave(s).\n", ms.slaves_responding);
if (ms.al_states != master_state.al_states)
printf("AL states: 0x%02X.\n", ms.al_states);
if (ms.link_up != master_state.link_up)
//printf("test");
printf("Link is %s.\n", ms.link_up ? "up" : "down");
master_state = ms;
}
/*****************************************************************************/
//printf("enter");
void check_slave_config_states(void)
{
ec_slave_config_state_t s;
ecrt_slave_config_state(sc_ana_in, &s);
//printf("test");
if (s.al_state != sc_ana_in_state.al_state)
printf("AnaIn: State 0x%02X.\n", s.al_state);
if (s.online != sc_ana_in_state.online)
printf("AnaIn: %s.\n", s.online ? "online" : "offline");
if (s.operational != sc_ana_in_state.operational)
printf("AnaIn: %soperational.\n",
s.operational ? "" : "Not ");
sc_ana_in_state = s;
}
/*****************************************************************************/
#if SDO_ACCESS
void read_sdo(void)
{
switch (ecrt_sdo_request_state(sdo)) {
case EC_REQUEST_UNUSED: // request was not used yet
ecrt_sdo_request_read(sdo); // trigger first read
break;
case EC_REQUEST_BUSY:
fprintf(stderr, "Still busy...\n");
break;
case EC_REQUEST_SUCCESS:
fprintf(stderr, "SDO value: 0x%04X\n",
EC_READ_U32(ecrt_sdo_request_data(sdo)));
ecrt_sdo_request_read(sdo); // trigger next read
break;
case EC_REQUEST_ERROR:
fprintf(stderr, "Failed to read SDO!\n");
ecrt_sdo_request_read(sdo); // retry reading
break;
}
}
#endif
/****************************************************************************/
void cyclic_task()
{
// receive process data
ecrt_master_receive(master);
ecrt_domain_process(domain1);
// check process data state (optional)
check_domain1_state();
printf("AnaIn: value %u\n", EC_READ_U32(domain1_pd + off_ana_in_value));
if (counter) {
counter--;
} else { // do this at 1 Hz
counter = FREQUENCY;
// calculate new process data
blink = !blink;
//printf("test");
// check for master state (optional)
//check_master_state();
//printf("test1");
// check for islave configuration state(s) (optional)
check_slave_config_states();
#if SDO_ACCESS
// read process data SDO
read_sdo();
#endif
}
#if 0
// read process data
// printf("test2");
printf("AnaIn: state %u value %u\n",
EC_READ_U8(domain1_pd + off_ana_in_status),
EC_READ_U32(domain1_pd + off_ana_in_value));
#endif
// #if 1
// // write process data
// EC_WRITE_U8(domain1_pd + off_dig_out, blink ? 0x06 : 0x09);
// #endif
// send process data
ecrt_domain_queue(domain1);
ecrt_master_send(master);
}
/****************************************************************************/
void signal_handler(int signum) {
switch (signum) {
case SIGALRM:
sig_alarms++;
break;
}
}
/****************************************************************************/
int main(int argc, char **argv)
{
ec_slave_config_t *sc;
struct sigaction sa;
struct itimerval tv;
master = ecrt_request_master(0);
if (!master)
return -1;
domain1 = ecrt_master_create_domain(master);
if (!domain1)
return -1;
if (!(sc_ana_in = ecrt_master_slave_config(
master, AnaInSlavePos, Beckhoff_EL3102))) {
fprintf(stderr, "Failed to get slave configuration.\n");
return -1;
}
#if SDO_ACCESS
fprintf(stderr, "Creating SDO requests...\n");
if (!(sdo = ecrt_slave_config_create_sdo_request(sc_ana_in, 0x6000, 2, 2))) {
fprintf(stderr, "Failed to create SDO request.\n");
return -1;
}
ecrt_sdo_request_timeout(sdo, 500); // ms
#endif
#if CONFIGURE_PDOS
printf("Configuring PDOs...\n");
if (ecrt_slave_config_pdos(sc_ana_in, EC_END, el3102_syncs)) {
fprintf(stderr, "Failed to configure PDOs.\n");
return -1;
}
// if (!(sc = ecrt_master_slave_config(
// master, AnaOutSlavePos, Beckhoff_EL4102))) {
// fprintf(stderr, "Failed to get slave configuration.\n");
// return -1;
// }
//
// if (ecrt_slave_config_pdos(sc, EC_END, el4102_syncs)) {
// fprintf(stderr, "Failed to configure PDOs.\n");
// return -1;
// }
//
// if (!(sc = ecrt_master_slave_config(
// master, DigOutSlavePos, Beckhoff_EL2032))) {
// fprintf(stderr, "Failed to get slave configuration.\n");
// return -1;
// }
// if (ecrt_slave_config_pdos(sc, EC_END, el2004_syncs)) {
// fprintf(stderr, "Failed to configure PDOs.\n");
// return -1;
// }
#endif
// Create configuration for bus coupler
sc = ecrt_master_slave_config(master, BusCouplerPos, Beckhoff_EL3102);
if (!sc)
return -1;
if (ecrt_domain_reg_pdo_entry_list(domain1, domain1_regs)) {
fprintf(stderr, "PDO entry registration failed!\n");
return -1;
}
printf("Activating master...\n");
if (ecrt_master_activate(master))
return -1;
if (!(domain1_pd = ecrt_domain_data(domain1))) {
return -1;
}
#if PRIORITY
pid_t pid = getpid();
if (setpriority(PRIO_PROCESS, pid, -19))
fprintf(stderr, "Warning: Failed to set priority: %s\n",
strerror(errno));
#endif
sa.sa_handler = signal_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if (sigaction(SIGALRM, &sa, 0)) {
fprintf(stderr, "Failed to install signal handler!\n");
return -1;
}
printf("Starting timer...\n");
tv.it_interval.tv_sec = 0;
tv.it_interval.tv_usec = 100000 / FREQUENCY;
tv.it_value.tv_sec = 0;
tv.it_value.tv_usec = 1000;
if (setitimer(ITIMER_REAL, &tv, NULL)) {
fprintf(stderr, "Failed to start timer: %s\n", strerror(errno));
return 1;
}
printf("Started.\n");
while (1) {
//printf("test");
pause();
#if 0
struct timeval t;
gettimeofday(&t, NULL);
printf("%u.%06u\n", t.tv_sec, t.tv_usec);
#endif
while (sig_alarms != user_alarms) {
cyclic_task();
//fprintf("t");
user_alarms++;
}
}
return 0;
}
/****************************************************************************/
On Mon, Apr 3, 2017 at 7:10 PM, Gavin Lambert <gavinl at compacsort.com <mailto:gavinl at compacsort.com> > wrote:
You’re halfway there. You also need to update the domain1_regs to reflect the layout of your network (type and position of all slave devices) and to define variables to receive the offsets into domain memory to use for transferring the corresponding PDOs.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.etherlab.org/pipermail/etherlab-users/attachments/20170405/fd681747/attachment-0003.htm>
More information about the Etherlab-users
mailing list