1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2007-2009  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  Using the EtherCAT technology and brand is permitted in compliance with

    23

 *  the industrial property and similar rights of Beckhoff Automation GmbH.

    24

 *

    25

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

    26

    27

#include <errno.h>

    28

#include <signal.h>

    29

#include <stdio.h>

    30

#include <string.h>

    31

#include <sys/resource.h>

    32

#include <sys/time.h>

    33

#include <sys/types.h>

    34

#include <unistd.h>

    35

    36

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

    37

    38

#include "ecrt.h"

    39

    40

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

    41

    42

// Application parameters

    43

#define FREQUENCY 100

    44

#define PRIORITY 1

    45

    46

// Optional features

    47

#define CONFIGURE_PDOS  1

    48

#define SDO_ACCESS      0

    49

    50

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

    51

    52

// EtherCAT

    53

static ec_master_t *master = NULL;

    54

static ec_master_state_t master_state = {};

    55

    56

static ec_domain_t *domain1 = NULL;

    57

static ec_domain_state_t domain1_state = {};

    58

    59

static ec_slave_config_t *sc_ana_in = NULL;

    60

static ec_slave_config_state_t sc_ana_in_state = {};

    61

    62

// Timer

    63

static unsigned int sig_alarms = 0;

    64

static unsigned int user_alarms = 0;

    65

    66

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

    67

    68

// process data

    69

static uint8_t *domain1_pd = NULL;

    70

    71

#define BusCouplerPos  0, 0

    72

#define DigOutSlavePos 0, 2

    73

#define AnaInSlavePos  0, 3

    74

#define AnaOutSlavePos 0, 4

    75

    76

#define Beckhoff_EK1100 0x00000002, 0x044c2c52

    77

#define Beckhoff_EL2004 0x00000002, 0x07d43052

    78

#define Beckhoff_EL2032 0x00000002, 0x07f03052

    79

#define Beckhoff_EL3152 0x00000002, 0x0c503052

    80

#define Beckhoff_EL3102 0x00000002, 0x0c1e3052

    81

#define Beckhoff_EL4102 0x00000002, 0x10063052

    82

    83

// offsets for PDO entries

    84

static unsigned int off_ana_in_status;

    85

static unsigned int off_ana_in_value;

    86

static unsigned int off_ana_out;

    87

static unsigned int off_dig_out;

    88

    89

const static ec_pdo_entry_reg_t domain1_regs[] = {

    90

    {AnaInSlavePos,  Beckhoff_EL3102, 0x3101, 1, &off_ana_in_status},

    91

    {AnaInSlavePos,  Beckhoff_EL3102, 0x3101, 2, &off_ana_in_value},

    92

	{AnaOutSlavePos, Beckhoff_EL4102, 0x3001, 1, &off_ana_out},

    93

	{DigOutSlavePos, Beckhoff_EL2032, 0x3001, 1, &off_dig_out},

    94

	{}

    95

};

    96

    97

static unsigned int counter = 0;

    98

static unsigned int blink = 0;

    99

   100

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

   101

   102

#if CONFIGURE_PDOS

   103

   104

// Analog in --------------------------

   105

   106

static ec_pdo_entry_info_t el3102_pdo_entries[] = {

   107

    {0x3101, 1,  8}, // channel 1 status

   108

    {0x3101, 2, 16}, // channel 1 value

   109

    {0x3102, 1,  8}, // channel 2 status

   110

    {0x3102, 2, 16}, // channel 2 value

   111

    {0x6401, 1, 16}, // channel 1 value (alt.)

   112

    {0x6401, 2, 16}  // channel 2 value (alt.)

   113

};

   114

   115

static ec_pdo_info_t el3102_pdos[] = {

   116

    {0x1A00, 2, el3102_pdo_entries},

   117

    {0x1A01, 2, el3102_pdo_entries + 2}

   118

};

   119

   120

static ec_sync_info_t el3102_syncs[] = {

   121

    {2, EC_DIR_OUTPUT},

   122

    {3, EC_DIR_INPUT, 2, el3102_pdos},

   123

    {0xff}

   124

};

   125

   126

// Analog out -------------------------

   127

   128

static ec_pdo_entry_info_t el4102_pdo_entries[] = {

   129

    {0x3001, 1, 16}, // channel 1 value

   130

    {0x3002, 1, 16}, // channel 2 value

   131

};

   132

   133

static ec_pdo_info_t el4102_pdos[] = {

   134

    {0x1600, 1, el4102_pdo_entries},

   135

    {0x1601, 1, el4102_pdo_entries + 1}

   136

};

   137

   138

static ec_sync_info_t el4102_syncs[] = {

   139

    {2, EC_DIR_OUTPUT, 2, el4102_pdos},

   140

    {3, EC_DIR_INPUT},

   141

    {0xff}

   142

};

   143

   144

// Digital out ------------------------

   145

   146

static ec_pdo_entry_info_t el2004_channels[] = {

   147

    {0x3001, 1, 1}, // Value 1

   148

    {0x3001, 2, 1}, // Value 2

   149

    {0x3001, 3, 1}, // Value 3

   150

    {0x3001, 4, 1}  // Value 4

   151

};

   152

   153

static ec_pdo_info_t el2004_pdos[] = {

   154

    {0x1600, 1, &el2004_channels[0]},

   155

    {0x1601, 1, &el2004_channels[1]},

   156

    {0x1602, 1, &el2004_channels[2]},

   157

    {0x1603, 1, &el2004_channels[3]}

   158

};

   159

   160

static ec_sync_info_t el2004_syncs[] = {

   161

    {0, EC_DIR_OUTPUT, 4, el2004_pdos},

   162

    {1, EC_DIR_INPUT},

   163

    {0xff}

   164

};

   165

#endif

   166

   167

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

   168

   169

#if SDO_ACCESS

   170

static ec_sdo_request_t *sdo;

   171

#endif

   172

   173

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

   174

   175

void check_domain1_state(void)

   176

{

   177

    ec_domain_state_t ds;

   178

   179

    ecrt_domain_state(domain1, &ds);

   180

   181

    if (ds.working_counter != domain1_state.working_counter)

   182

        printf("Domain1: WC %u.\n", ds.working_counter);

   183

    if (ds.wc_state != domain1_state.wc_state)

   184

        printf("Domain1: State %u.\n", ds.wc_state);

   185

   186

    domain1_state = ds;

   187

}

   188

   189

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

   190

   191

void check_master_state(void)

   192

{

   193

    ec_master_state_t ms;

   194

   195

    ecrt_master_state(master, &ms);

   196

   197

    if (ms.slaves_responding != master_state.slaves_responding)

   198

        printf("%u slave(s).\n", ms.slaves_responding);

   199

    if (ms.al_states != master_state.al_states)

   200

        printf("AL states: 0x%02X.\n", ms.al_states);

   201

    if (ms.link_up != master_state.link_up)

   202

        printf("Link is %s.\n", ms.link_up ? "up" : "down");

   203

   204

    master_state = ms;

   205

}

   206

   207

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

   208

   209

void check_slave_config_states(void)

   210

{

   211

    ec_slave_config_state_t s;

   212

   213

    ecrt_slave_config_state(sc_ana_in, &s);

   214

   215

    if (s.al_state != sc_ana_in_state.al_state)

   216

        printf("AnaIn: State 0x%02X.\n", s.al_state);

   217

    if (s.online != sc_ana_in_state.online)

   218

        printf("AnaIn: %s.\n", s.online ? "online" : "offline");

   219

    if (s.operational != sc_ana_in_state.operational)

   220

        printf("AnaIn: %soperational.\n",

   221

                s.operational ? "" : "Not ");

   222

   223

    sc_ana_in_state = s;

   224

}

   225

   226

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

   227

   228

#if SDO_ACCESS

   229

void read_sdo(void)

   230

{

   231

    switch (ecrt_sdo_request_state(sdo)) {

   232

        case EC_REQUEST_UNUSED: // request was not used yet

   233

            ecrt_sdo_request_read(sdo); // trigger first read

   234

            break;

   235

        case EC_REQUEST_BUSY:

   236

            fprintf(stderr, "Still busy...\n");

   237

            break;

   238

        case EC_REQUEST_SUCCESS:

   239

            fprintf(stderr, "SDO value: 0x%04X\n",

   240

                    EC_READ_U16(ecrt_sdo_request_data(sdo)));

   241

            ecrt_sdo_request_read(sdo); // trigger next read

   242

            break;

   243

        case EC_REQUEST_ERROR:

   244

            fprintf(stderr, "Failed to read SDO!\n");

   245

            ecrt_sdo_request_read(sdo); // retry reading

   246

            break;

   247

    }

   248

}

   249

#endif

   250

   251

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

   252

   253

void cyclic_task()

   254

{

   255

    int i;

   256

   257

    // receive process data

   258

    ecrt_master_receive(master);

   259

    ecrt_domain_process(domain1);

   260

   261

    // check process data state (optional)

   262

    check_domain1_state();

   263

   264

    if (counter) {

   265

        counter--;

   266

    } else { // do this at 1 Hz

   267

        counter = FREQUENCY;

   268

   269

        // calculate new process data

   270

        blink = !blink;

   271

   272

        // check for master state (optional)

   273

        check_master_state();

   274

   275

        // check for islave configuration state(s) (optional)

   276

        check_slave_config_states();

   277

   278

#if SDO_ACCESS

   279

        // read process data SDO

   280

        read_sdo();

   281

#endif

   282

   283

    }

   284

   285

#if 0

   286

    // read process data

   287

    printf("AnaIn: state %u value %u\n",

   288

            EC_READ_U8(domain1_pd + off_ana_in_status),

   289

            EC_READ_U16(domain1_pd + off_ana_in_value));

   290

#endif

   291

   292

#if 1

   293

    // write process data

   294

    EC_WRITE_U8(domain1_pd + off_dig_out, blink ? 0x06 : 0x09);

   295

#endif

   296

   297

    // send process data

   298

    ecrt_domain_queue(domain1);

   299

    ecrt_master_send(master);

   300

}

   301

   302

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

   303

   304

void signal_handler(int signum) {

   305

    switch (signum) {

   306

        case SIGALRM:

   307

            sig_alarms++;

   308

            break;

   309

    }

   310

}

   311

   312

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

   313

   314

int main(int argc, char **argv)

   315

{

   316

	ec_slave_config_t *sc;

   317

    struct sigaction sa;

   318

    struct itimerval tv;

   319

   320

    master = ecrt_request_master(0);

   321

	if (!master)

   322

		return -1;

   323

   324

    domain1 = ecrt_master_create_domain(master);

   325

    if (!domain1)

   326

        return -1;

   327

   328

    if (!(sc_ana_in = ecrt_master_slave_config(

   329

                    master, AnaInSlavePos, Beckhoff_EL3102))) {

   330

        fprintf(stderr, "Failed to get slave configuration.\n");

   331

        return -1;

   332

    }

   333

   334

#if SDO_ACCESS

   335

    fprintf(stderr, "Creating SDO requests...\n");

   336

    if (!(sdo = ecrt_slave_config_create_sdo_request(sc_ana_in, 0x3102, 2, 2))) {

   337

        fprintf(stderr, "Failed to create SDO request.\n");

   338

        return -1;

   339

    }

   340

    ecrt_sdo_request_timeout(sdo, 500); // ms

   341

#endif

   342

   343

#if CONFIGURE_PDOS

   344

    printf("Configuring PDOs...\n");

   345

    if (ecrt_slave_config_pdos(sc_ana_in, EC_END, el3102_syncs)) {

   346

        fprintf(stderr, "Failed to configure PDOs.\n");

   347

        return -1;

   348

    }

   349

   350

    if (!(sc = ecrt_master_slave_config(

   351

                    master, AnaOutSlavePos, Beckhoff_EL4102))) {

   352

        fprintf(stderr, "Failed to get slave configuration.\n");

   353

        return -1;

   354

    }

   355

   356

    if (ecrt_slave_config_pdos(sc, EC_END, el4102_syncs)) {

   357

        fprintf(stderr, "Failed to configure PDOs.\n");

   358

        return -1;

   359

    }

   360

   361

    if (!(sc = ecrt_master_slave_config(

   362

                    master, DigOutSlavePos, Beckhoff_EL2032))) {

   363

        fprintf(stderr, "Failed to get slave configuration.\n");

   364

        return -1;

   365

    }

   366

   367

    if (ecrt_slave_config_pdos(sc, EC_END, el2004_syncs)) {

   368

        fprintf(stderr, "Failed to configure PDOs.\n");

   369

        return -1;

   370

    }

   371

#endif

   372

   373

    // Create configuration for bus coupler

   374

    sc = ecrt_master_slave_config(master, BusCouplerPos, Beckhoff_EK1100);

   375

    if (!sc)

   376

        return -1;

   377

   378

    if (ecrt_domain_reg_pdo_entry_list(domain1, domain1_regs)) {

   379

        fprintf(stderr, "PDO entry registration failed!\n");

   380

		return -1;

   381

    }

   382

   383

    printf("Activating master...\n");

   384

    if (ecrt_master_activate(master))

   385

        return -1;

   386

   387

    if (!(domain1_pd = ecrt_domain_data(domain1))) {

   388

        return -1;

   389

    }

   390

   391

#if PRIORITY

   392

    pid_t pid = getpid();

   393

    if (setpriority(PRIO_PROCESS, pid, -19))

   394

        fprintf(stderr, "Warning: Failed to set priority: %s\n",

   395

                strerror(errno));

   396

#endif

   397

   398

    sa.sa_handler = signal_handler;

   399

    sigemptyset(&sa.sa_mask);

   400

    sa.sa_flags = 0;

   401

    if (sigaction(SIGALRM, &sa, 0)) {

   402

        fprintf(stderr, "Failed to install signal handler!\n");

   403

        return -1;

   404

    }

   405

   406

    printf("Starting timer...\n");

   407

    tv.it_interval.tv_sec = 0;

   408

    tv.it_interval.tv_usec = 1000000 / FREQUENCY;

   409

    tv.it_value.tv_sec = 0;

   410

    tv.it_value.tv_usec = 1000;

   411

    if (setitimer(ITIMER_REAL, &tv, NULL)) {

   412

        fprintf(stderr, "Failed to start timer: %s\n", strerror(errno));

   413

        return 1;

   414

    }

   415

   416

    printf("Started.\n");

   417

	while (1) {

   418

        pause();

   419

   420

#if 0

   421

        struct timeval t;

   422

        gettimeofday(&t, NULL);

   423

        printf("%u.%06u\n", t.tv_sec, t.tv_usec);

   424

#endif

   425

   426

        while (sig_alarms != user_alarms) {

   427

            cyclic_task();

   428

            user_alarms++;

   429

        }

   430

	}

   431

   432

	return 0;

   433

}

   434

   435

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