1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006  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

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

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

    15

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

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

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

    20

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

    21

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

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

#include <errno.h>

    35

#include <signal.h>

    36

#include <stdio.h>

    37

#include <string.h>

    38

#include <sys/resource.h>

    39

#include <sys/time.h>

    40

#include <sys/types.h>

    41

#include <unistd.h>

    42

    43

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

    44

    45

#include "ecrt.h"

    46

    47

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

    48

    49

// Application parameters

    50

#define FREQUENCY 100

    51

#define PRIORITY 1

    52

    53

// Optional features

    54

#define CONFIGURE_PDOS  1

    55

    56

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

    57

    58

// EtherCAT

    59

static ec_master_t *master = NULL;

    60

static ec_master_state_t master_state = {};

    61

    62

static ec_domain_t *domain1 = NULL;

    63

static ec_domain_state_t domain1_state = {};

    64

    65

static ec_slave_config_t *sc_ana_in = NULL;

    66

static ec_slave_config_state_t sc_ana_in_state = {};

    67

    68

// Timer

    69

static unsigned int sig_alarms = 0;

    70

static unsigned int user_alarms = 0;

    71

    72

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

    73

    74

// process data

    75

static uint8_t *domain1_pd = NULL;

    76

    77

#define BusCouplerPos  0, 0

    78

#define AnaOutSlavePos 0, 1

    79

#define AnaInSlavePos  0, 2

    80

#define DigOutSlavePos 0, 3

    81

    82

#define Beckhoff_EK1100 0x00000002, 0x044c2c52

    83

#define Beckhoff_EL2004 0x00000002, 0x07d43052

    84

#define Beckhoff_EL2032 0x00000002, 0x07f03052

    85

#define Beckhoff_EL3152 0x00000002, 0x0c503052

    86

#define Beckhoff_EL4102 0x00000002, 0x10063052

    87

    88

// offsets for Pdo entries

    89

static unsigned int off_ana_in_status;

    90

static unsigned int off_ana_in_value;

    91

static unsigned int off_ana_out;

    92

static unsigned int off_dig_out;

    93

    94

const static ec_pdo_entry_reg_t domain1_regs[] = {

    95

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

    96

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

    97

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

    98

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

    99

	{}

   100

};

   101

   102

static unsigned int counter = 0;

   103

static unsigned int blink = 0;

   104

   105

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

   106

   107

#if CONFIGURE_PDOS

   108

   109

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

   110

   111

static ec_pdo_entry_info_t el3152_pdo_entries[] = {

   112

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

   113

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

   114

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

   115

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

   116

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

   117

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

   118

};

   119

   120

static ec_pdo_info_t el3152_pdos[] = {

   121

    {0x1A00, 2, el3152_pdo_entries},

   122

    {0x1A01, 2, el3152_pdo_entries + 2}

   123

};

   124

   125

static ec_sync_info_t el3152_syncs[] = {

   126

    {2, EC_DIR_OUTPUT},

   127

    {3, EC_DIR_INPUT, 2, el3152_pdos},

   128

    {0xff}

   129

};

   130

   131

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

   132

   133

static ec_pdo_entry_info_t el4102_pdo_entries[] = {

   134

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

   135

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

   136

};

   137

   138

static ec_pdo_info_t el4102_pdos[] = {

   139

    {0x1600, 1, el4102_pdo_entries},

   140

    {0x1601, 1, el4102_pdo_entries + 1}

   141

};

   142

   143

static ec_sync_info_t el4102_syncs[] = {

   144

    {2, EC_DIR_OUTPUT, 2, el4102_pdos},

   145

    {3, EC_DIR_INPUT},

   146

    {0xff}

   147

};

   148

   149

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

   150

   151

static ec_pdo_entry_info_t el2004_channels[] = {

   152

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

   153

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

   154

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

   155

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

   156

};

   157

   158

static ec_pdo_info_t el2004_pdos[] = {

   159

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

   160

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

   161

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

   162

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

   163

};

   164

   165

static ec_sync_info_t el2004_syncs[] = {

   166

    {0, EC_DIR_OUTPUT, 4, el2004_pdos},

   167

    {1, EC_DIR_INPUT},

   168

    {0xff}

   169

};

   170

#endif

   171

   172

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

   173

   174

void check_domain1_state(void)

   175

{

   176

    ec_domain_state_t ds;

   177

   178

    ecrt_domain_state(domain1, &ds);

   179

   180

    if (ds.working_counter != domain1_state.working_counter)

   181

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

   182

    if (ds.wc_state != domain1_state.wc_state)

   183

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

   184

   185

    domain1_state = ds;

   186

}

   187

   188

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

   189

   190

void check_master_state(void)

   191

{

   192

    ec_master_state_t ms;

   193

   194

    ecrt_master_state(master, &ms);

   195

   196

    if (ms.slaves_responding != master_state.slaves_responding)

   197

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

   198

    if (ms.al_states != master_state.al_states)

   199

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

   200

    if (ms.link_up != master_state.link_up)

   201

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

   202

   203

    master_state = ms;

   204

}

   205

   206

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

   207

   208

void check_slave_config_states(void)

   209

{

   210

    ec_slave_config_state_t s;

   211

   212

    ecrt_slave_config_state(sc_ana_in, &s);

   213

   214

    if (s.al_state != sc_ana_in_state.al_state)

   215

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

   216

    if (s.online != sc_ana_in_state.online)

   217

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

   218

    if (s.operational != sc_ana_in_state.operational)

   219

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

   220

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

   221

   222

    sc_ana_in_state = s;

   223

}

   224

   225

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

   226

   227

void cyclic_task()

   228

{

   229

    int i;

   230

   231

    // receive process data

   232

    ecrt_master_receive(master);

   233

    ecrt_domain_process(domain1);

   234

   235

    // check process data state (optional)

   236

    check_domain1_state();

   237

   238

    if (counter) {

   239

        counter--;

   240

    } else { // do this at 1 Hz

   241

        counter = FREQUENCY;

   242

   243

        // calculate new process data

   244

        blink = !blink;

   245

   246

        // check for master state (optional)

   247

        check_master_state();

   248

   249

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

   250

        check_slave_config_states();

   251

    }

   252

   253

#if 0

   254

    // read process data

   255

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

   256

            EC_READ_U8(domain1_pd + off_ana_in_status),

   257

            EC_READ_U16(domain1_pd + off_ana_in_value));

   258

#endif

   259

   260

#if 1

   261

    // write process data

   262

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

   263

#endif

   264

   265

    // send process data

   266

    ecrt_domain_queue(domain1);

   267

    ecrt_master_send(master);

   268

}

   269

   270

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

   271

   272

void signal_handler(int signum) {

   273

    switch (signum) {

   274

        case SIGALRM:

   275

            sig_alarms++;

   276

            break;

   277

    }

   278

}

   279

   280

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

   281

   282

int main(int argc, char **argv)

   283

{

   284

	ec_slave_config_t *sc;

   285

    struct sigaction sa;

   286

    struct itimerval tv;

   287

   288

    master = ecrt_request_master(0);

   289

	if (!master)

   290

		return -1;

   291

   292

    domain1 = ecrt_master_create_domain(master);

   293

    if (!domain1)

   294

        return -1;

   295

   296

    if (!(sc_ana_in = ecrt_master_slave_config(

   297

                    master, AnaInSlavePos, Beckhoff_EL3152))) {

   298

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

   299

        return -1;

   300

    }

   301

   302

#if CONFIGURE_PDOS

   303

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

   304

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

   305

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

   306

        return -1;

   307

    }

   308

   309

    if (!(sc = ecrt_master_slave_config(

   310

                    master, AnaOutSlavePos, Beckhoff_EL4102))) {

   311

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

   312

        return -1;

   313

    }

   314

   315

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

   316

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

   317

        return -1;

   318

    }

   319

   320

    if (!(sc = ecrt_master_slave_config(

   321

                    master, DigOutSlavePos, Beckhoff_EL2032))) {

   322

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

   323

        return -1;

   324

    }

   325

   326

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

   327

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

   328

        return -1;

   329

    }

   330

#endif

   331

   332

    // Create configuration for bus coupler

   333

    sc = ecrt_master_slave_config(master, BusCouplerPos, Beckhoff_EK1100);

   334

    if (!sc)

   335

        return -1;

   336

   337

    if (ecrt_domain_reg_pdo_entry_list(domain1, domain1_regs)) {

   338

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

   339

		return -1;

   340

    }

   341

   342

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

   343

    if (ecrt_master_activate(master))

   344

        return -1;

   345

   346

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

   347

        return -1;

   348

    }

   349

   350

#if PRIORITY

   351

    pid_t pid = getpid();

   352

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

   353

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

   354

                strerror(errno));

   355

#endif

   356

   357

    sa.sa_handler = signal_handler;

   358

    sigemptyset(&sa.sa_mask);

   359

    sa.sa_flags = 0;

   360

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

   361

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

   362

        return -1;

   363

    }

   364

   365

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

   366

    tv.it_interval.tv_sec = 0;

   367

    tv.it_interval.tv_usec = 1000000 / FREQUENCY;

   368

    tv.it_value.tv_sec = 0;

   369

    tv.it_value.tv_usec = 1000;

   370

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

   371

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

   372

        return 1;

   373

    }

   374

   375

    printf("Started.\n");

   376

	while (1) {

   377

        pause();

   378

   379

#if 0

   380

        struct timeval t;

   381

        gettimeofday(&t, NULL);

   382

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

   383

#endif

   384

   385

        while (sig_alarms != user_alarms) {

   386

            cyclic_task();

   387

            user_alarms++;

   388

        }

   389

	}

   390

   391

	return 0;

   392

}

   393

   394

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