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

    49

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

    50

    51

// EtherCAT

    52

static ec_master_t *master = NULL;

    53

static ec_master_state_t master_state = {};

    54

    55

static ec_domain_t *domain1 = NULL;

    56

static ec_domain_state_t domain1_state = {};

    57

    58

static ec_slave_config_t *sc_ana_in = NULL;

    59

static ec_slave_config_state_t sc_ana_in_state = {};

    60

    61

// Timer

    62

static unsigned int sig_alarms = 0;

    63

static unsigned int user_alarms = 0;

    64

    65

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

    66

    67

// process data

    68

static uint8_t *domain1_pd = NULL;

    69

    70

#define BusCouplerPos  0, 0

    71

#define AnaOutSlavePos 0, 1

    72

#define AnaInSlavePos  0, 2

    73

#define DigOutSlavePos 0, 3

    74

    75

#define Beckhoff_EK1100 0x00000002, 0x044c2c52

    76

#define Beckhoff_EL2004 0x00000002, 0x07d43052

    77

#define Beckhoff_EL2032 0x00000002, 0x07f03052

    78

#define Beckhoff_EL3152 0x00000002, 0x0c503052

    79

#define Beckhoff_EL4102 0x00000002, 0x10063052

    80

    81

// offsets for PDO entries

    82

static unsigned int off_ana_in_status;

    83

static unsigned int off_ana_in_value;

    84

static unsigned int off_ana_out;

    85

static unsigned int off_dig_out;

    86

    87

const static ec_pdo_entry_reg_t domain1_regs[] = {

    88

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

    89

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

    90

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

    91

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

    92

	{}

    93

};

    94

    95

static unsigned int counter = 0;

    96

static unsigned int blink = 0;

    97

    98

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

    99

   100

#if CONFIGURE_PDOS

   101

   102

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

   103

   104

static ec_pdo_entry_info_t el3152_pdo_entries[] = {

   105

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

   106

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

   107

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

   108

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

   109

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

   110

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

   111

};

   112

   113

static ec_pdo_info_t el3152_pdos[] = {

   114

    {0x1A00, 2, el3152_pdo_entries},

   115

    {0x1A01, 2, el3152_pdo_entries + 2}

   116

};

   117

   118

static ec_sync_info_t el3152_syncs[] = {

   119

    {2, EC_DIR_OUTPUT},

   120

    {3, EC_DIR_INPUT, 2, el3152_pdos},

   121

    {0xff}

   122

};

   123

   124

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

   125

   126

static ec_pdo_entry_info_t el4102_pdo_entries[] = {

   127

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

   128

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

   129

};

   130

   131

static ec_pdo_info_t el4102_pdos[] = {

   132

    {0x1600, 1, el4102_pdo_entries},

   133

    {0x1601, 1, el4102_pdo_entries + 1}

   134

};

   135

   136

static ec_sync_info_t el4102_syncs[] = {

   137

    {2, EC_DIR_OUTPUT, 2, el4102_pdos},

   138

    {3, EC_DIR_INPUT},

   139

    {0xff}

   140

};

   141

   142

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

   143

   144

static ec_pdo_entry_info_t el2004_channels[] = {

   145

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

   146

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

   147

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

   148

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

   149

};

   150

   151

static ec_pdo_info_t el2004_pdos[] = {

   152

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

   153

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

   154

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

   155

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

   156

};

   157

   158

static ec_sync_info_t el2004_syncs[] = {

   159

    {0, EC_DIR_OUTPUT, 4, el2004_pdos},

   160

    {1, EC_DIR_INPUT},

   161

    {0xff}

   162

};

   163

#endif

   164

   165

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

   166

   167

void check_domain1_state(void)

   168

{

   169

    ec_domain_state_t ds;

   170

   171

    ecrt_domain_state(domain1, &ds);

   172

   173

    if (ds.working_counter != domain1_state.working_counter)

   174

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

   175

    if (ds.wc_state != domain1_state.wc_state)

   176

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

   177

   178

    domain1_state = ds;

   179

}

   180

   181

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

   182

   183

void check_master_state(void)

   184

{

   185

    ec_master_state_t ms;

   186

   187

    ecrt_master_state(master, &ms);

   188

   189

    if (ms.slaves_responding != master_state.slaves_responding)

   190

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

   191

    if (ms.al_states != master_state.al_states)

   192

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

   193

    if (ms.link_up != master_state.link_up)

   194

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

   195

   196

    master_state = ms;

   197

}

   198

   199

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

   200

   201

void check_slave_config_states(void)

   202

{

   203

    ec_slave_config_state_t s;

   204

   205

    ecrt_slave_config_state(sc_ana_in, &s);

   206

   207

    if (s.al_state != sc_ana_in_state.al_state)

   208

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

   209

    if (s.online != sc_ana_in_state.online)

   210

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

   211

    if (s.operational != sc_ana_in_state.operational)

   212

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

   213

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

   214

   215

    sc_ana_in_state = s;

   216

}

   217

   218

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

   219

   220

void cyclic_task()

   221

{

   222

    int i;

   223

   224

    // receive process data

   225

    ecrt_master_receive(master);

   226

    ecrt_domain_process(domain1);

   227

   228

    // check process data state (optional)

   229

    check_domain1_state();

   230

   231

    if (counter) {

   232

        counter--;

   233

    } else { // do this at 1 Hz

   234

        counter = FREQUENCY;

   235

   236

        // calculate new process data

   237

        blink = !blink;

   238

   239

        // check for master state (optional)

   240

        check_master_state();

   241

   242

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

   243

        check_slave_config_states();

   244

    }

   245

   246

#if 0

   247

    // read process data

   248

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

   249

            EC_READ_U8(domain1_pd + off_ana_in_status),

   250

            EC_READ_U16(domain1_pd + off_ana_in_value));

   251

#endif

   252

   253

#if 1

   254

    // write process data

   255

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

   256

#endif

   257

   258

    // send process data

   259

    ecrt_domain_queue(domain1);

   260

    ecrt_master_send(master);

   261

}

   262

   263

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

   264

   265

void signal_handler(int signum) {

   266

    switch (signum) {

   267

        case SIGALRM:

   268

            sig_alarms++;

   269

            break;

   270

    }

   271

}

   272

   273

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

   274

   275

int main(int argc, char **argv)

   276

{

   277

	ec_slave_config_t *sc;

   278

    struct sigaction sa;

   279

    struct itimerval tv;

   280

   281

    master = ecrt_request_master(0);

   282

	if (!master)

   283

		return -1;

   284

   285

    domain1 = ecrt_master_create_domain(master);

   286

    if (!domain1)

   287

        return -1;

   288

   289

    if (!(sc_ana_in = ecrt_master_slave_config(

   290

                    master, AnaInSlavePos, Beckhoff_EL3152))) {

   291

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

   292

        return -1;

   293

    }

   294

   295

#if CONFIGURE_PDOS

   296

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

   297

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

   298

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

   299

        return -1;

   300

    }

   301

   302

    if (!(sc = ecrt_master_slave_config(

   303

                    master, AnaOutSlavePos, Beckhoff_EL4102))) {

   304

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

   305

        return -1;

   306

    }

   307

   308

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

   309

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

   310

        return -1;

   311

    }

   312

   313

    if (!(sc = ecrt_master_slave_config(

   314

                    master, DigOutSlavePos, Beckhoff_EL2032))) {

   315

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

   316

        return -1;

   317

    }

   318

   319

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

   320

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

   321

        return -1;

   322

    }

   323

#endif

   324

   325

    // Create configuration for bus coupler

   326

    sc = ecrt_master_slave_config(master, BusCouplerPos, Beckhoff_EK1100);

   327

    if (!sc)

   328

        return -1;

   329

   330

    if (ecrt_domain_reg_pdo_entry_list(domain1, domain1_regs)) {

   331

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

   332

		return -1;

   333

    }

   334

   335

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

   336

    if (ecrt_master_activate(master))

   337

        return -1;

   338

   339

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

   340

        return -1;

   341

    }

   342

   343

#if PRIORITY

   344

    pid_t pid = getpid();

   345

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

   346

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

   347

                strerror(errno));

   348

#endif

   349

   350

    sa.sa_handler = signal_handler;

   351

    sigemptyset(&sa.sa_mask);

   352

    sa.sa_flags = 0;

   353

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

   354

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

   355

        return -1;

   356

    }

   357

   358

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

   359

    tv.it_interval.tv_sec = 0;

   360

    tv.it_interval.tv_usec = 1000000 / FREQUENCY;

   361

    tv.it_value.tv_sec = 0;

   362

    tv.it_value.tv_usec = 1000;

   363

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

   364

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

   365

        return 1;

   366

    }

   367

   368

    printf("Started.\n");

   369

	while (1) {

   370

        pause();

   371

   372

#if 0

   373

        struct timeval t;

   374

        gettimeofday(&t, NULL);

   375

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

   376

#endif

   377

   378

        while (sig_alarms != user_alarms) {

   379

            cyclic_task();

   380

            user_alarms++;

   381

        }

   382

	}

   383

   384

	return 0;

   385

}

   386

   387

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