1

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

     2

 *

     3

 * ec_mini.c

     4

 *

     5

 * Minimalmodul für EtherCAT

     6

 *           

     7

 * $Id$

     8

 *

     9

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

    10

    11

#include <linux/module.h>

    12

#include <linux/tqueue.h>

    13

#include <linux/slab.h>

    14

#include <linux/delay.h>

    15

#include <linux/completion.h>

    16

    17

#include "../drivers/ec_master.h"

    18

#include "../drivers/ec_device.h"

    19

#include "../drivers/ec_types.h"

    20

#include "../drivers/ec_dbg.h"

    21

    22

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

    23

    24

#define ECAT_OPEN

    25

#define ECAT_MASTER

    26

#define ECAT_SLAVES

    27

#define ECAT_CYCLIC_DATA

    28

    29

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

    30

    31

extern EtherCAT_device_t rtl_ecat_dev;

    32

    33

#ifdef ECAT_MASTER

    34

static EtherCAT_master_t *ecat_master = NULL;

    35

#endif

    36

    37

#ifdef ECAT_SLAVES

    38

static EtherCAT_slave_t ecat_slaves[] =

    39

{

    40

#if 0

    41

  // Block 1

    42

  ECAT_INIT_SLAVE(Beckhoff_EK1100),

    43

  ECAT_INIT_SLAVE(Beckhoff_EL4102),

    44

  ECAT_INIT_SLAVE(Beckhoff_EL3162),

    45

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    46

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    47

  ECAT_INIT_SLAVE(Beckhoff_EL3102),

    48

  ECAT_INIT_SLAVE(Beckhoff_EL4102),

    49

  ECAT_INIT_SLAVE(Beckhoff_EL4102),

    50

  ECAT_INIT_SLAVE(Beckhoff_EL4102),

    51

  ECAT_INIT_SLAVE(Beckhoff_EL3162),

    52

  ECAT_INIT_SLAVE(Beckhoff_EL3162),

    53

  ECAT_INIT_SLAVE(Beckhoff_EL3162),

    54

  ECAT_INIT_SLAVE(Beckhoff_EL3102),

    55

  ECAT_INIT_SLAVE(Beckhoff_EL3102),

    56

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    57

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    58

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    59

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    60

#endif

    61

    62

  // Block 2

    63

  ECAT_INIT_SLAVE(Beckhoff_EK1100),

    64

  ECAT_INIT_SLAVE(Beckhoff_EL4102),

    65

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    66

  ECAT_INIT_SLAVE(Beckhoff_EL3162),

    67

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    68

  ECAT_INIT_SLAVE(Beckhoff_EL3102),

    69

    70

  // Block 3

    71

  ECAT_INIT_SLAVE(Beckhoff_EK1100),

    72

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    73

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    74

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    75

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    76

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    77

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    78

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    79

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    80

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    81

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    82

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    83

  ECAT_INIT_SLAVE(Beckhoff_EL1014)

    84

};

    85

    86

#define ECAT_SLAVES_COUNT (sizeof(ecat_slaves) / sizeof(EtherCAT_slave_t))

    87

#endif

    88

    89

#ifdef ECAT_CYCLIC_DATA

    90

double value;

    91

int dig1;

    92

struct tq_struct cyclic_task;

    93

struct clientdata {task_queue *queue;} cyclic_data;

    94

static DECLARE_COMPLETION(on_exit);

    95

#endif

    96

    97

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

    98

 *

    99

 * Function: next2004

   100

 *

   101

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

   102

   103

#ifdef ECAT_CYCLIC_DATA

   104

static int next2004(int *wrap)

   105

{

   106

  static int i = 0;

   107

  unsigned int j = 0;

   108

   109

  *wrap = 0;

   110

   111

  for (j = 0; j < ECAT_SLAVES_COUNT; j++)

   112

  {

   113

    i++;

   114

   115

    i %= ECAT_SLAVES_COUNT;

   116

   117

    if (i == 0) *wrap = 1;

   118

   119

    if (ecat_slaves[i].desc == Beckhoff_EL2004)

   120

    {

   121

      return i;

   122

    }

   123

  }

   124

   125

  return -1;

   126

}

   127

#endif

   128

   129

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

   130

 *

   131

 * Function: run

   132

 *

   133

 * Beschreibung: Zyklischer Prozess

   134

 *

   135

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

   136

   137

#ifdef ECAT_CYCLIC_DATA

   138

void run(void *ptr)

   139

{

   140

  struct clientdata *data = (struct clientdata *) ptr;

   141

   142

#if 1

   143

  static int ms = 0;

   144

  static int cnt = 0;

   145

  static unsigned long int k = 0;

   146

  static int firstrun = 1;

   147

   148

  static int klemme = 12;

   149

  static int kanal = 0;

   150

  static int up_down = 0;

   151

  int wrap = 0;

   152

   153

  ms++;

   154

  ms %= 1000;

   155

   156

#if 0

   157

  ecat_tx_delay = ((unsigned int) (100000 / HZ) * (ecat_master->dev->tx_time-k))

   158

    / (current_cpu_data.loops_per_jiffy / 10);

   159

  ecat_rx_delay = ((unsigned int) (100000 / HZ) * (ecat_master->dev->rx_time-k))

   160

    / (current_cpu_data.loops_per_jiffy / 10);

   161

   162

  rx_intr = ecat_master->dev->rx_intr_cnt;

   163

  tx_intr = ecat_master->dev->tx_intr_cnt;

   164

  total_intr = ecat_master->dev->intr_cnt;

   165

#endif

   166

   167

  // Prozessdaten lesen

   168

  if (!firstrun)

   169

  {

   170

    klemme = next2004(&wrap);

   171

   172

    EtherCAT_read_process_data(ecat_master);

   173

   174

    // Daten lesen und skalieren

   175

    value = EtherCAT_read_value(&ecat_master->slaves[5], 0) / 3276.7;

   176

    dig1 = EtherCAT_read_value(&ecat_master->slaves[3], 0);

   177

  }

   178

   179

#if 0

   180

  // Daten schreiben

   181

  EtherCAT_write_value(&ecat_master->slaves[4], 0, ms > 500 ? 1 : 0);

   182

  EtherCAT_write_value(&ecat_master->slaves[4], 1, ms > 500 ? 0 : 1);

   183

  EtherCAT_write_value(&ecat_master->slaves[4], 2, ms > 500 ? 0 : 1);

   184

  EtherCAT_write_value(&ecat_master->slaves[4], 3, ms > 500 ? 1 : 0);

   185

#endif

   186

   187

  if (cnt++ > 20)

   188

  {

   189

    cnt = 0;

   190

   191

    if (++kanal > 3)

   192

    {

   193

      kanal = 0;

   194

      klemme = next2004(&wrap);

   195

   196

      if (wrap == 1)

   197

      {

   198

        if (up_down == 1) up_down = 0;

   199

        else up_down = 1;

   200

      }

   201

    }

   202

  }

   203

   204

  if (klemme >= 0)

   205

    EtherCAT_write_value(&ecat_master->slaves[klemme], kanal,up_down);

   206

   207

#if 0

   208

  EtherCAT_write_value(&ecat_master->slaves[13], 1, ms > 500 ? 0 : 1);

   209

  EtherCAT_write_value(&ecat_master->slaves[14], 2, ms > 500 ? 0 : 1);

   210

  EtherCAT_write_value(&ecat_master->slaves[15], 3, ms > 500 ? 1 : 0);

   211

#endif

   212

   213

  // Prozessdaten schreiben

   214

  rdtscl(k);

   215

  EtherCAT_write_process_data(ecat_master);

   216

  firstrun = 0;

   217

#endif

   218

   219

  if (data->queue)

   220

  {

   221

    // Neu in die Taskqueue eintragen

   222

    queue_task(&cyclic_task, data->queue);

   223

  }

   224

  else

   225

  {

   226

    //last_queue_finished = 0;

   227

    complete(&on_exit);

   228

  }

   229

}

   230

#endif

   231

   232

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

   233

*

   234

* Function: init

   235

*

   236

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

   237

   238

int init()

   239

{

   240

#ifdef ECAT_OPEN

   241

  int rv = -1;

   242

#endif

   243

   244

  EC_DBG(KERN_INFO "=== Starting Minimal EtherCAT environment... ===\n");

   245

   246

  EtherCAT_device_debug(&rtl_ecat_dev);

   247

  //mdelay(5000);

   248

   249

#ifdef ECAT_OPEN

   250

  EC_DBG("Opening EtherCAT device.\n");

   251

   252

  // HIER PASSIERT DER FEHLER:

   253

  if (EtherCAT_device_open(&rtl_ecat_dev) < 0)

   254

  {

   255

    EC_DBG(KERN_ERR "msr_modul: Could not initialize EtherCAT NIC.\n");

   256

    goto out_nothing;

   257

  }

   258

   259

  if (!rtl_ecat_dev.dev) // Es gibt kein EtherCAT-Device

   260

  {

   261

    EC_DBG(KERN_ERR "msr_modul: No EtherCAT device!\n");

   262

    goto out_close;

   263

  }

   264

#endif

   265

   266

#ifdef ECAT_MASTER

   267

  EC_DBG("Initialising EtherCAT master\n");

   268

   269

  if ((ecat_master = (EtherCAT_master_t *) kmalloc(sizeof(EtherCAT_master_t), GFP_KERNEL)) == 0)

   270

  {

   271

    EC_DBG(KERN_ERR "msr_modul: Could not alloc memory for EtherCAT master!\n");

   272

    goto out_close;

   273

  }

   274

   275

  if (EtherCAT_master_init(ecat_master, &rtl_ecat_dev) < 0)

   276

  {

   277

    EC_DBG(KERN_ERR "EtherCAT could not init master!\n");

   278

    goto out_master;

   279

  }

   280

   281

  ecat_master->debug_level = 1;

   282

#endif

   283

   284

#ifdef ECAT_SLAVES

   285

  EC_DBG("Checking EtherCAT slaves.\n");

   286

   287

  if (EtherCAT_check_slaves(ecat_master, ecat_slaves, ECAT_SLAVES_COUNT) != 0)

   288

  {

   289

    EC_DBG(KERN_ERR "EtherCAT: Could not init slaves!\n");

   290

    goto out_masterclear;

   291

  }

   292

   293

  EC_DBG("Activating all EtherCAT slaves.\n");

   294

   295

  if (EtherCAT_activate_all_slaves(ecat_master) != 0)

   296

  {

   297

    EC_DBG(KERN_ERR "EtherCAT: Could not activate slaves!\n");

   298

    goto out_masterclear;

   299

  }

   300

#endif

   301

   302

#ifdef ECAT_CYCLIC_DATA

   303

  EC_DBG("Starting cyclic sample thread.\n");

   304

   305

  cyclic_task.routine = run;

   306

  cyclic_task.data = (void *) &cyclic_data;

   307

  cyclic_data.queue = &tq_timer;

   308

  queue_task(&cyclic_task, &tq_timer);

   309

   310

  EC_DBG("Initialised sample thread.\n");

   311

#endif

   312

   313

  EC_DBG(KERN_INFO "=== Minimal EtherCAT environment started. ===\n");

   314

   315

  return 0;

   316

   317

#ifdef ECAT_SLAVES

   318

 out_masterclear:

   319

  EC_DBG(KERN_INFO "Clearing EtherCAT master.\n");

   320

  EtherCAT_master_clear(ecat_master);

   321

#endif

   322

   323

#ifdef ECAT_MASTER

   324

 out_master:

   325

  EC_DBG(KERN_INFO "Freeing EtherCAT master.\n");

   326

  kfree(ecat_master);

   327

#endif

   328

   329

#ifdef ECAT_OPEN

   330

 out_close:

   331

  EC_DBG(KERN_INFO "Closing device.\n");

   332

  EtherCAT_device_close(&rtl_ecat_dev);

   333

   334

 out_nothing:

   335

  return rv;

   336

#endif

   337

}

   338

   339

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

   340

*

   341

* Function: cleanup

   342

*

   343

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

   344

   345

void cleanup()

   346

{

   347

  EC_DBG(KERN_INFO "=== Stopping Minimal EtherCAT environment... ===\n");

   348

   349

#ifdef ECAT_MASTER

   350

  if (ecat_master)

   351

  {

   352

    //ecat_master->debug_level = 1;

   353

   354

#ifdef ECAT_CYCLIC_DATA

   355

    cyclic_data.queue = NULL;

   356

    wait_for_completion(&on_exit);

   357

    EtherCAT_clear_process_data(ecat_master);

   358

#endif

   359

   360

#ifdef ECAT_SLAVES

   361

    EC_DBG(KERN_INFO "Deactivating slaves.\n");

   362

    EtherCAT_deactivate_all_slaves(ecat_master);

   363

#endif

   364

   365

    EC_DBG(KERN_INFO "Clearing EtherCAT master.\n");

   366

    EtherCAT_master_clear(ecat_master);

   367

   368

    EC_DBG(KERN_INFO "Freeing EtherCAT master.\n");

   369

    kfree(ecat_master);

   370

    ecat_master = NULL;

   371

  }

   372

#endif

   373

   374

#ifdef ECAT_OPEN

   375

  EC_DBG(KERN_INFO "Closing device.\n");

   376

  EtherCAT_device_close(&rtl_ecat_dev);

   377

#endif

   378

   379

  EC_DBG(KERN_INFO "=== Minimal EtherCAT environment stopped. ===\n");

   380

}

   381

   382

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

   383

   384

MODULE_LICENSE("GPL");

   385

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

   386

MODULE_DESCRIPTION ("Minimal EtherCAT environment");

   387

   388

module_init(init);

   389

module_exit(cleanup);

   390

   391

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