Hello Thomas,
we follow a rather pragmatic way to bring those slaves to operational:
Do the configuration with TwinCat and make sure the Profibus
Slave/Master goes to work properly.
Export from TwinCat the configuration of the EtherCat slave (6731-xxxx)
to an xml-file.
Make the xml-file more readable with "xmllint --format".
Now how have to search manually (with an editor) for the configuration
SDO's of your slave.
You are looking for the objects:
0xf800: Master configuration
0x8000: Slave 1 config
0x8010: Slave 2 config
....
cut these out and put them into your C program, find below an example
for a program with a Profibus Master and a Profibus Slave talking to
each other.
Regards Wilhelm.
/*****************************************************************************
*
* $Id: main.cpp,v 55c679db2375 2010/11/10 14:05:17 fp $
*
* Copyright (C) 2010 Florian Pose, Ingenieurgemeinschaft IgH
* Modified by Wilhelm Hagemeister, Ingenieurgemeinschaft IgH
* Demo shows how to configure a Beckhoff profibus slave/master EL6731
(0010)
*
****************************************************************************/
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sched.h>
#include <unistd.h>
#include <sys/mman.h>
#include <pthread.h>
/****************************************************************************/
#include <ecrt.h>
/****************************************************************************/
/** Task period in ns. */
#define PERIOD_NS (1000000)
#define CLOCK_TO_USE CLOCK_REALTIME
#define MEASURE_TIMING
/****************************************************************************/
#define NSEC_PER_SEC (1000000000)
#define FREQUENCY (NSEC_PER_SEC / PERIOD_NS)
#define DIFF_NS(A, B) (((B).tv_sec - (A).tv_sec) * NSEC_PER_SEC + \
(B).tv_nsec - (A).tv_nsec)
/****************************************************************************/
// EtherCAT
#define CouplerPos 0, 0
#define ProfiPosSlave 0, 1
#define ProfiPosMaster 0, 2
#define Beckhoff_EK1100 0x00000002, 0x044c2c52
#define Beckhoff_EL6731 0x00000002, 0x1a4b3052
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 = NULL;
static ec_slave_config_state_t sc_state = {};
/****************************************************************************/
/** Profibus configuration.
* Stealed from TwinCAT configuration export.
*/
const char *pb_config_slave_0x8000 =
"2d00020000000000000000000000a8010000f4"
"f0000000000a02000000008801140b095f00800008d9e9";
/*----------------------*/
const char *pb_config_master_0xf800 =
"11000109e8030b0020030910647e0401280004000000000000000000";
const char *pb_config_master_0x8000 =
"2d00020001100000c0a8045a0202a8010000f4f00"
"00000001602000000008801140b095f00c000080c"
"8100000000c0a8045a0202d9e9";
// process data
static uint8_t *domain1_pd = NULL;
// offsets for PDO entries
static unsigned int off_out_slave;
static unsigned int off_in_slave;
static unsigned int off_out_master;
static unsigned int off_in_master;
const static ec_pdo_entry_reg_t domain1_regs[] = {
{ProfiPosSlave, Beckhoff_EL6731, 0x7000, 1, &off_out_slave},
{ProfiPosSlave, Beckhoff_EL6731, 0x6000, 1, &off_in_slave},
{ProfiPosMaster, Beckhoff_EL6731, 0x7000, 1, &off_out_master},
{ProfiPosMaster, Beckhoff_EL6731, 0x6000, 1, &off_in_master},
{}
};
static unsigned int counter = 0;
unsigned int run = 1;
/*****************************************************************************/
/* Master 0, Slave 1, "EL6731-0010"
* Vendor ID: 0x00000002
* Product code: 0x1a4b3052
* Revision number: 0x0011000a
*/
ec_pdo_entry_info_t slave_1_pdo_entries[] = {
{0x7000, 0x01, 160},
{0x6000, 0x01, 160},
{0xa000, 0x01, 8},
{0xf100, 0x02, 1},
{0xa000, 0x02, 1},
{0x0000, 0x00, 6},
};
ec_pdo_info_t slave_1_pdos[] = {
{0x1600, 1, slave_1_pdo_entries + 0}, /* DPS RxPDO-Map Slave */
{0x1a00, 1, slave_1_pdo_entries + 1}, /* DPS TxPDO-Map Slave */
{0x1a80, 4, slave_1_pdo_entries + 2},
};
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_DISABLE},
{3, EC_DIR_INPUT, 2, slave_1_pdos + 1, EC_WD_DISABLE},
{0xff}
};
/* Master 0, Slave 2, "EL6731"
* Vendor ID: 0x00000002
* Product code: 0x1a4b3052
* Revision number: 0x0011000a
*/
ec_pdo_entry_info_t slave_2_pdo_entries[] = {
{ 0x7000, 1, 160 }, /* 0 */
{ 0x6000, 1, 160 }, /* 1 */
{ 0xA000, 1, 8 }, /* 2 */
{ 0xF100, 1, 8 }, /* 3 */
{ 0xF100, 3, 8 }, /* 4 */
{ 0xF100, 2, 1 }, /* 5 */
{ 0xA000, 2, 1 }, /* 6 */
{ 0x0000, 0, 6 },
};
ec_pdo_info_t slave_2_pdos[] = {
{0x1600, 1, slave_2_pdo_entries + 0}, /* DPS RxPDO-Map Slave */
{0x1a00, 1, slave_2_pdo_entries + 1}, /* DPS TxPDO-Map Slave */
{0x1a80, 6, slave_2_pdo_entries + 2},
};
ec_sync_info_t slave_2_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_2_pdos + 0, EC_WD_DISABLE},
{3, EC_DIR_INPUT, 2, slave_2_pdos + 1, EC_WD_DISABLE},
{0xff}
};
/*****************************************************************************/
/* Helper funktion, buffer has be allocated and big enough */
unsigned int strToCharArray(const char *str,unsigned char *buffer)
{
unsigned int i;
unsigned char byteVal;
// const char *str = pb_config;
// unsigned char cf_data[256];
size_t size = strlen(str);
for (i = 0; i < size; i++) {
sscanf(str, "%2X", &byteVal);
str += 2;
buffer[i] = (uint8_t) byteVal;
}
return (size / 2);
}
/*****************************************************************************/
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;
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("Link is %s.\n", ms.link_up ? "up" : "down");
master_state = ms;
}
/*****************************************************************************/
void check_slave_config_states(void)
{
ec_slave_config_state_t s;
ecrt_slave_config_state(sc, &s);
if (s.al_state != sc_state.al_state)
printf("AnaIn: State 0x%02X.\n", s.al_state);
if (s.online != sc_state.online)
printf("AnaIn: %s.\n", s.online ? "online" : "offline");
if (s.operational != sc_state.operational)
printf("AnaIn: %soperational.\n",
s.operational ? "" : "Not ");
sc_state = s;
}
/*****************************************************************************/
void cyclic_task()
{
int i;
uint8_t x, reset = 0;
static uint8_t pcounter = 0;
// receive process data
ecrt_master_receive(master);
ecrt_domain_process(domain1);
// check process data state (optional)
check_domain1_state();
if (counter) {
counter--;
} else { // do this at 1 Hz
counter = FREQUENCY;
// check for master state (optional)
check_master_state();
// check for islave configuration state(s) (optional)
check_slave_config_states();
//write a byte to the master
pcounter++;
EC_WRITE_U8(domain1_pd + off_out_master + 1,pcounter);
// read some bytes from the slave
printf("\nSlave input data: ");
for (i=0;i<16;i++)
printf(" %d",EC_READ_U8(domain1_pd + off_in_slave +i));
printf("\n");
}
// send process data
ecrt_domain_queue(domain1);
ecrt_master_send(master);
}
/****************************************************************************/
void signal_handler(int signum)
{
switch (signum) {
case SIGINT:
case SIGTERM:
run = 0;
break;
}
}
/****************************************************************************/
#define MAX_SAFE_STACK (8*1024)
void stack_prefault(void)
{
unsigned char dummy[MAX_SAFE_STACK];
memset(&dummy, 0, MAX_SAFE_STACK);
}
/****************************************************************************/
void *rt_thread_func(void *data)
{
struct timespec wakeupTime;
int ret;
#ifdef MEASURE_TIMING
struct timespec startTime, endTime, lastStartTime = {}, lastOutputTime;
uint32_t period_ns = 0, exec_ns = 0, latency_ns = 0,
latency_min_ns = 0, latency_max_ns = 0,
period_min_ns = 0, period_max_ns = 0,
exec_min_ns = 0, exec_max_ns = 0;
#endif
printf("rt_thread running.\n");
// get current time
clock_gettime(CLOCK_TO_USE, &wakeupTime);
lastStartTime = wakeupTime;
while (run) {
wakeupTime.tv_nsec += PERIOD_NS;
while (wakeupTime.tv_nsec >= NSEC_PER_SEC) {
wakeupTime.tv_nsec -= NSEC_PER_SEC;
wakeupTime.tv_sec++;
}
ret = clock_nanosleep(CLOCK_TO_USE, TIMER_ABSTIME, &wakeupTime,
NULL);
if (ret) {
printf("clock_nanosleep(): %s\n", strerror(ret));
}
#ifdef MEASURE_TIMING
clock_gettime(CLOCK_TO_USE, &startTime);
latency_ns = DIFF_NS(wakeupTime, startTime);
period_ns = DIFF_NS(lastStartTime, startTime);
exec_ns = DIFF_NS(lastStartTime, endTime);
lastStartTime = startTime;
//printf("period_ns=%10u exec_ns=%5u\n", period_ns, exec_ns);
if (latency_ns > latency_max_ns) {
latency_max_ns = latency_ns;
}
if (latency_ns < latency_min_ns) {
latency_min_ns = latency_ns;
}
if (period_ns > period_max_ns) {
period_max_ns = period_ns;
}
if (period_ns < period_min_ns) {
period_min_ns = period_ns;
}
if (exec_ns > exec_max_ns) {
exec_max_ns = exec_ns;
}
if (exec_ns < exec_min_ns) {
exec_min_ns = exec_ns;
}
#endif
cyclic_task();
#ifdef MEASURE_TIMING
if (DIFF_NS(lastOutputTime, startTime) >= NSEC_PER_SEC) {
// output timing stats
printf("period %10u ... %10u\n",
period_min_ns, period_max_ns);
printf("exec %10u ... %10u\n",
exec_min_ns, exec_max_ns);
printf("latency %10u ... %10u\n\n",
latency_min_ns, latency_max_ns);
period_max_ns = 0;
period_min_ns = 0xffffffff;
exec_max_ns = 0;
exec_min_ns = 0xffffffff;
latency_max_ns = 0;
latency_min_ns = 0xffffffff;
lastOutputTime = startTime;
}
clock_gettime(CLOCK_TO_USE, &endTime);
#endif
}
pthread_exit(NULL);
}
/****************************************************************************/
int main(int argc, char **argv)
{
struct sigaction sa;
struct sched_param param;
pthread_t rt_thread;
int ret;
int cnt;
unsigned char pb_config_buf[256];
sa.sa_handler = signal_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if (sigaction(SIGTERM, &sa, 0)) {
fprintf(stderr, "Failed to install signal handler!\n");
return -1;
}
if (sigaction(SIGINT, &sa, 0)) {
fprintf(stderr, "Failed to install signal handler!\n");
return -1;
}
master = ecrt_request_master(0);
if (!master)
return -1;
domain1 = ecrt_master_create_domain(master);
if (!domain1)
return -1;
printf("Configuring PDOs...\n");
/* EK1100 */
if (!(sc = ecrt_master_slave_config(master, CouplerPos,
Beckhoff_EK1100))) {
fprintf(stderr, "Failed to get slave configuration.\n");
return -1;
}
/* EL6731 Slave*/
if (!(sc = ecrt_master_slave_config(master, ProfiPosSlave,
Beckhoff_EL6731))) {
fprintf(stderr, "Failed to get slave configuration.\n");
return -1;
}
cnt = strToCharArray(pb_config_slave_0x8000,pb_config_buf);
ecrt_slave_config_complete_sdo(sc, 0x8000, pb_config_buf, cnt);
if (ecrt_slave_config_pdos(sc, EC_END, slave_1_syncs)) {
fprintf(stderr, "Failed to configure PDOs.\n");
return -1;
}
/* EL6731 Master*/
if (!(sc = ecrt_master_slave_config(master, ProfiPosMaster,
Beckhoff_EL6731))) {
fprintf(stderr, "Failed to get slave configuration.\n");
return -1;
}
cnt = strToCharArray(pb_config_master_0xf800,pb_config_buf);
ecrt_slave_config_complete_sdo(sc, 0xf800, pb_config_buf, cnt);
cnt = strToCharArray(pb_config_master_0x8000,pb_config_buf);
ecrt_slave_config_complete_sdo(sc, 0x8000, pb_config_buf, cnt);
if (ecrt_slave_config_pdos(sc, EC_END, slave_2_syncs)) {
fprintf(stderr, "Failed to configure PDOs (PB-Master).\n");
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;
}
param.sched_priority = 80;
if (sched_setscheduler(0, SCHED_FIFO, ¶m) == -1) {
perror("sched_setscheduler failed");
exit(-1);
}
if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
perror("mlockall failed");
exit(-2);
}
stack_prefault();
printf("Starting timer...\n");
ret = pthread_create(&rt_thread, NULL, rt_thread_func, NULL);
if (ret < 0) {
fprintf(stderr, "Failed to create realtime thread: %i.\n", ret);
return ret;
}
while (run) {
sleep(1);
}
return ret;
}
/****************************************************************************/
Am 15.09.2012 08:46, schrieb Thomas Paoloni:
> Hi all,
>
> I'm fighting with a Beckhoff 6731-0010 (Profibus slave to ethercat
> bridge) which I'm not able to bring in OP state.
> Nobody from Beckhoff is able to help me, they only seems to know their
> twincat software, and nobody can explain how the same operations made by
> twincat can be made trought SDO and C programming.
> Even sniffing traffic with wireshark and trying to reproduce the same
> with my code works because I can see some ADS packets which I can't
> reproduce with Linux master.
> Does anybody know more than me about this node, or maybe some other
> network masters/slaves like CanOpen, Profibus, etc. that I think should
> basically work in the same way ?
>
> Thanks in advance,
> Thomas.
> _______________________________________________
> etherlab-users mailing list
> etherlab-users@etherlab.org
> http://lists.etherlab.org/mailman/listinfo/etherlab-users
_______________________________________________
etherlab-users mailing list
etherlab-users@etherlab.org
http://lists.etherlab.org/mailman/listinfo/etherlab-users
