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 <linux/module.h>

    35

#include <linux/timer.h>

    36

#include <linux/spinlock.h>

    37

#include <linux/interrupt.h>

    38

    39

#include "../../include/ecrt.h" // EtherCAT realtime interface

    40

    41

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

    42

    43

// Module parameters

    44

#define FREQUENCY 100

    45

    46

// Optional features

    47

#define CONFIGURE_PDOS  1

    48

#define EL3162_ALT_PDOS 0

    49

#define EXTERNAL_MEMORY 1

    50

#define SDO_ACCESS      0

    51

    52

#define PFX "ec_mini: "

    53

    54

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

    55

    56

// EtherCAT

    57

static ec_master_t *master = NULL;

    58

static ec_master_state_t master_state = {};

    59

spinlock_t master_lock = SPIN_LOCK_UNLOCKED;

    60

    61

static ec_domain_t *domain1 = NULL;

    62

static ec_domain_state_t domain1_state = {};

    63

    64

static ec_slave_config_t *sc_ana_in = NULL;

    65

static ec_slave_config_state_t sc_ana_in_state = {};

    66

    67

// Timer

    68

static struct timer_list timer;

    69

    70

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

    71

    72

// process data

    73

static uint8_t *domain1_pd; // process data memory

    74

    75

#define AnaInSlavePos  0, 1

    76

#define DigOutSlavePos 0, 3

    77

    78

#define Beckhoff_EL2004 0x00000002, 0x07D43052

    79

#define Beckhoff_EL3162 0x00000002, 0x0C5A3052

    80

    81

static unsigned int off_ana_in; // offsets for Pdo entries

    82

static unsigned int off_dig_out;

    83

    84

const static ec_pdo_entry_reg_t domain1_regs[] = {

    85

#if EL3162_ALT_PDOS

    86

    {AnaInSlavePos,  Beckhoff_EL3162, 0x6401, 2, &off_ana_in},

    87

#else

    88

    {AnaInSlavePos,  Beckhoff_EL3162, 0x3101, 2, &off_ana_in},

    89

#endif

    90

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

    91

    {}

    92

};

    93

    94

static unsigned int counter = 0;

    95

static unsigned int blink = 0;

    96

    97

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

    98

    99

#if CONFIGURE_PDOS

   100

   101

static ec_pdo_entry_info_t el3162_pdo_entries[] = {

   102

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

   103

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

   104

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

   105

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

   106

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

   107

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

   108

};

   109

   110

#if EL3162_ALT_PDOS

   111

static ec_pdo_info_t el3162_pdos[] = {

   112

    {0x1A10, 2, el3162_pdo_entries + 4},

   113

};

   114

   115

static ec_sync_info_t el3162_syncs[] = {

   116

    {2, EC_DIR_OUTPUT},

   117

    {3, EC_DIR_INPUT, 1, el3162_pdos},

   118

    {0xff}

   119

};

   120

#else

   121

static ec_pdo_info_t el3162_pdos[] = {

   122

    {0x1A00, 2, el3162_pdo_entries},

   123

    {0x1A01, 2, el3162_pdo_entries + 2}

   124

};

   125

   126

static ec_sync_info_t el3162_syncs[] = {

   127

    {2, EC_DIR_OUTPUT},

   128

    {3, EC_DIR_INPUT, 2, el3162_pdos},

   129

    {0xff}

   130

};

   131

#endif

   132

   133

static ec_pdo_entry_info_t el2004_channels[] = {

   134

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

   135

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

   136

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

   137

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

   138

};

   139

   140

static ec_pdo_info_t el2004_pdos[] = {

   141

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

   142

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

   143

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

   144

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

   145

};

   146

   147

static ec_sync_info_t el2004_syncs[] = {

   148

    {0, EC_DIR_OUTPUT, 4, el2004_pdos},

   149

    {1, EC_DIR_INPUT},

   150

    {0xff}

   151

};

   152

#endif

   153

   154

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

   155

   156

#if SDO_ACCESS

   157

static ec_sdo_request_t *sdo;

   158

#endif

   159

   160

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

   161

   162

void check_domain1_state(void)

   163

{

   164

    ec_domain_state_t ds;

   165

   166

    spin_lock(&master_lock);

   167

    ecrt_domain_state(domain1, &ds);

   168

    spin_unlock(&master_lock);

   169

   170

    if (ds.working_counter != domain1_state.working_counter)

   171

        printk(KERN_INFO PFX "Domain1: WC %u.\n", ds.working_counter);

   172

    if (ds.wc_state != domain1_state.wc_state)

   173

        printk(KERN_INFO PFX "Domain1: State %u.\n", ds.wc_state);

   174

   175

    domain1_state = ds;

   176

}

   177

   178

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

   179

   180

void check_master_state(void)

   181

{

   182

    ec_master_state_t ms;

   183

   184

    spin_lock(&master_lock);

   185

    ecrt_master_state(master, &ms);

   186

    spin_unlock(&master_lock);

   187

   188

    if (ms.slaves_responding != master_state.slaves_responding)

   189

        printk(KERN_INFO PFX "%u slave(s).\n", ms.slaves_responding);

   190

    if (ms.al_states != master_state.al_states)

   191

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

   192

    if (ms.link_up != master_state.link_up)

   193

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

   194

   195

    master_state = ms;

   196

}

   197

   198

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

   199

   200

void check_slave_config_states(void)

   201

{

   202

    ec_slave_config_state_t s;

   203

   204

    spin_lock(&master_lock);

   205

    ecrt_slave_config_state(sc_ana_in, &s);

   206

    spin_unlock(&master_lock);

   207

   208

    if (s.al_state != sc_ana_in_state.al_state)

   209

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

   210

    if (s.online != sc_ana_in_state.online)

   211

        printk(KERN_INFO PFX "AnaIn: %s.\n", s.online ? "online" : "offline");

   212

    if (s.operational != sc_ana_in_state.operational)

   213

        printk(KERN_INFO PFX "AnaIn: %soperational.\n",

   214

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

   215

   216

    sc_ana_in_state = s;

   217

}

   218

   219

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

   220

   221

#if SDO_ACCESS

   222

void read_sdo(void)

   223

{

   224

    switch (ecrt_sdo_request_state(sdo)) {

   225

        case EC_SDO_REQUEST_UNUSED: // request was not used yet

   226

            ecrt_sdo_request_read(sdo); // trigger first read

   227

            break;

   228

        case EC_SDO_REQUEST_BUSY:

   229

            printk(KERN_INFO PFX "Still busy...\n");

   230

            break;

   231

        case EC_SDO_REQUEST_SUCCESS:

   232

            printk(KERN_INFO PFX "Sdo value: 0x%04X\n",

   233

                    EC_READ_U16(ecrt_sdo_request_data(sdo)));

   234

            ecrt_sdo_request_read(sdo); // trigger next read

   235

            break;

   236

        case EC_SDO_REQUEST_ERROR:

   237

            printk(KERN_INFO PFX "Failed to read Sdo!\n");

   238

            ecrt_sdo_request_read(sdo); // retry reading

   239

            break;

   240

    }

   241

}

   242

#endif

   243

   244

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

   245

   246

void cyclic_task(unsigned long data)

   247

{

   248

    // receive process data

   249

    spin_lock(&master_lock);

   250

    ecrt_master_receive(master);

   251

    ecrt_domain_process(domain1);

   252

    spin_unlock(&master_lock);

   253

   254

    // check process data state (optional)

   255

    check_domain1_state();

   256

   257

    if (counter) {

   258

        counter--;

   259

    } else { // do this at 1 Hz

   260

        counter = FREQUENCY;

   261

   262

        // calculate new process data

   263

        blink = !blink;

   264

   265

        // check for master state (optional)

   266

        check_master_state();

   267

   268

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

   269

        check_slave_config_states();

   270

   271

#if SDO_ACCESS

   272

        // read process data Sdo

   273

        read_sdo();

   274

#endif

   275

    }

   276

   277

    // write process data

   278

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

   279

   280

    // send process data

   281

    spin_lock(&master_lock);

   282

    ecrt_domain_queue(domain1);

   283

    ecrt_master_send(master);

   284

    spin_unlock(&master_lock);

   285

   286

    // restart timer

   287

    timer.expires += HZ / FREQUENCY;

   288

    add_timer(&timer);

   289

}

   290

   291

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

   292

   293

int request_lock(void *data)

   294

{

   295

    spin_lock(&master_lock);

   296

    return 0; // access allowed

   297

}

   298

   299

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

   300

   301

void release_lock(void *data)

   302

{

   303

    spin_unlock(&master_lock);

   304

}

   305

   306

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

   307

   308

int __init init_mini_module(void)

   309

{

   310

#if CONFIGURE_PDOS

   311

    ec_slave_config_t *sc;

   312

#endif

   313

#if EXTERNAL_MEMORY

   314

    unsigned int size;

   315

#endif

   316

   317

    printk(KERN_INFO PFX "Starting...\n");

   318

   319

    if (!(master = ecrt_request_master(0))) {

   320

        printk(KERN_ERR PFX "Requesting master 0 failed!\n");

   321

        goto out_return;

   322

    }

   323

   324

    ecrt_master_callbacks(master, request_lock, release_lock, NULL);

   325

   326

    printk(KERN_INFO PFX "Registering domain...\n");

   327

    if (!(domain1 = ecrt_master_create_domain(master))) {

   328

        printk(KERN_ERR PFX "Domain creation failed!\n");

   329

        goto out_release_master;

   330

    }

   331

   332

    if (!(sc_ana_in = ecrt_master_slave_config(

   333

                    master, AnaInSlavePos, Beckhoff_EL3162))) {

   334

        printk(KERN_ERR PFX "Failed to get slave configuration.\n");

   335

        goto out_release_master;

   336

    }

   337

   338

#if CONFIGURE_PDOS

   339

    printk(KERN_INFO PFX "Configuring Pdos...\n");

   340

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

   341

        printk(KERN_ERR PFX "Failed to configure Pdos.\n");

   342

        goto out_release_master;

   343

    }

   344

   345

    if (!(sc = ecrt_master_slave_config(

   346

                    master, DigOutSlavePos, Beckhoff_EL2004))) {

   347

        printk(KERN_ERR PFX "Failed to get slave configuration.\n");

   348

        goto out_release_master;

   349

    }

   350

   351

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

   352

        printk(KERN_ERR PFX "Failed to configure Pdos.\n");

   353

        goto out_release_master;

   354

    }

   355

#endif

   356

   357

#if SDO_ACCESS

   358

    printk(KERN_INFO PFX "Creating Sdo requests...\n");

   359

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

   360

        printk(KERN_ERR PFX "Failed to create Sdo request.\n");

   361

        goto out_release_master;

   362

    }

   363

    ecrt_sdo_request_timeout(sdo, 500); // ms

   364

#endif

   365

   366

    printk(KERN_INFO PFX "Registering Pdo entries...\n");

   367

    if (ecrt_domain_reg_pdo_entry_list(domain1, domain1_regs)) {

   368

        printk(KERN_ERR PFX "Pdo entry registration failed!\n");

   369

        goto out_release_master;

   370

    }

   371

   372

#if EXTERNAL_MEMORY

   373

    if ((size = ecrt_domain_size(domain1))) {

   374

        if (!(domain1_pd = (uint8_t *) kmalloc(size, GFP_KERNEL))) {

   375

            printk(KERN_ERR PFX "Failed to allocate %u bytes of process data"

   376

                    " memory!\n", size);

   377

            goto out_release_master;

   378

        }

   379

        ecrt_domain_external_memory(domain1, domain1_pd);

   380

    }

   381

#endif

   382

   383

    printk(KERN_INFO PFX "Activating master...\n");

   384

    if (ecrt_master_activate(master)) {

   385

        printk(KERN_ERR PFX "Failed to activate master!\n");

   386

#if EXTERNAL_MEMORY

   387

        goto out_free_process_data;

   388

#else

   389

        goto out_release_master;

   390

#endif

   391

    }

   392

   393

#if !EXTERNAL_MEMORY

   394

    // Get internal process data for domain

   395

    domain1_pd = ecrt_domain_data(domain1);

   396

#endif

   397

   398

    printk(KERN_INFO PFX "Starting cyclic sample thread.\n");

   399

    init_timer(&timer);

   400

    timer.function = cyclic_task;

   401

    timer.expires = jiffies + 10;

   402

    add_timer(&timer);

   403

   404

    printk(KERN_INFO PFX "Started.\n");

   405

    return 0;

   406

   407

#if EXTERNAL_MEMORY

   408

out_free_process_data:

   409

    kfree(domain1_pd);

   410

#endif

   411

out_release_master:

   412

    printk(KERN_ERR PFX "Releasing master...\n");

   413

    ecrt_release_master(master);

   414

out_return:

   415

    printk(KERN_ERR PFX "Failed to load. Aborting.\n");

   416

    return -1;

   417

}

   418

   419

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

   420

   421

void __exit cleanup_mini_module(void)

   422

{

   423

    printk(KERN_INFO PFX "Stopping...\n");

   424

   425

    del_timer_sync(&timer);

   426

   427

#if EXTERNAL_MEMORY

   428

    kfree(domain1_pd);

   429

#endif

   430

   431

    printk(KERN_INFO PFX "Releasing master...\n");

   432

    ecrt_release_master(master);

   433

   434

    printk(KERN_INFO PFX "Unloading.\n");

   435

}

   436

   437

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

   438

   439

MODULE_LICENSE("GPL");

   440

MODULE_AUTHOR("Florian Pose <fp@igh-essen.com>");

   441

MODULE_DESCRIPTION("EtherCAT minimal test environment");

   442

   443

module_init(init_mini_module);

   444

module_exit(cleanup_mini_module);

   445

   446

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