21

    22

#ifndef __KERNEL__

    23

#  define __KERNEL__

    24

#endif

    25

#ifndef MODULE

    26

#  define MODULE

    27

#endif

    28

    29

#include <linux/config.h>

    30

#include <linux/module.h>

    31

    32

#include <linux/sched.h>

    33

#include <linux/kernel.h>

    35

#include <linux/fs.h>     /* everything... */

    36

#include <linux/proc_fs.h>

    37

#include <linux/time.h>

    38

#include <linux/timer.h>

    39

#include <linux/timex.h>  /* fuer get_cycles */

    40

#include <linux/errno.h>  /* error codes */

    41

#include <asm/msr.h> /* maschine-specific registers */

    42

#include <linux/param.h> /* fuer HZ */

    43

#include <linux/ipipe.h>

    44

    45

#include "msr_param.h"   //wird im Projektverzeichnis erwartet

    46

    47

//#include <msr_control.h>

    48

#include <msr_lists.h>

    49

#include <msr_charbuf.h>

    50

#include <msr_reg.h>

    51

#include <msr_error_reg.h>

    52

#include <msr_messages.h>

    53

#include <msr_proc.h>

    54

#include <msr_utils.h>

    55

#include <msr_main.h>

    56

    57

    58

#include <msr_float.h>

    59

    60

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

    61

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

    62

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

    63

#include "../drivers/ec_module.h"

    64

    65

#include "msr_jitter.h"

    66

    70

    71

#define HZREDUCTION (MSR_ABTASTFREQUENZ/HZ)

    72

    73

extern wait_queue_head_t msr_read_waitqueue;

    74

    75

extern struct msr_char_buf *msr_kanal_puffer;

    76

    77

extern int proc_abtastfrequenz;

    78

    83

    84

//adeos

    85

    86

static struct ipipe_domain this_domain;

    87

    88

static struct ipipe_sysinfo sys_info;

    89

    90

static EtherCAT_master_t *ecat_master = NULL;

    91

    92

static EtherCAT_slave_t ecat_slaves[] =

    93

{

    94

#if 1

    95

    // Block 1

   107

   108

    // Block 2

   125

    // Block 3

   139

#endif

   140

};

   141

   142

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

   143

   144

#define USE_MSR_LIB

   145

   146

#ifdef USE_MSR_LIB

   147

double value;

   148

int dig1;

   149

#endif

   150

   151

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

   152

 *

   153

 * Function: next2004

   154

 *

   155

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

   156

   157

static int next2004(int *wrap)

   158

{

   159

    static int i = 0;

   160

    unsigned int j = 0;

   161

   162

    *wrap = 0;

   163

   164

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

   165

    {

   166

        i++;

   167

   168

        i %= ECAT_SLAVES_COUNT;

   169

   170

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

   171

   172

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

   173

        {

   174

            return i;

   175

        }

   176

    }

   177

   178

    return -1;

   179

}

   180

   181

   182

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

   183

 *

   184

 * Function: msr_controller_run()

   185

 *

   186

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

   187

   188

static void msr_controller_run(void)

   189

{

   190

    static int ms = 0;

   191

    static int cnt = 0;

   192

    static unsigned long int k = 0;

   193

    static int firstrun = 1;

   194

   195

    static int klemme = 0;

   196

    static int kanal = 0;

   197

    static int up_down = 0;

   198

    int wrap = 0;

   199

   206

   207

    // Prozessdaten lesen

   208

    msr_jitter_run(MSR_ABTASTFREQUENZ);

   209

   211

   212

    ms++;

   213

    ms %= 1000;

   214

    if (cnt++ > 200)

   215

    {

   216

        cnt = 0;

   217

   218

        if (++kanal > 3)

   219

        {

   220

            kanal = 0;

   221

            klemme = next2004(&wrap);

   222

   223

            if (wrap == 1)

   224

            {

   225

                if (up_down == 1) up_down = 0;

   226

                else up_down = 1;

   227

            }

   228

        }

   229

    }

   230

   231

    if (klemme >= 0) {

   233

    }

   234

   235

#if 0

   236

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

   237

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

   238

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

   239

#endif

   240

   241

    // Prozessdaten schreiben

   242

    rdtscl(k);

   279

    firstrun = 0;

   297

   298

void msr_run(unsigned irq)

   299

{

   300

  static int counter = 0;

   301

#ifdef USE_MSR_LIB

   302

   303

    timeval_add(&process_time,&process_time,&msr_time_increment);

   304

   305

    MSR_ADEOS_INTERRUPT_CODE(

   306

	msr_controller_run();

   307

	msr_write_kanal_list();

   308

	);

   309

#else

   310

    msr_controller_run();

   311

#endif

   312

    /* und wieder in die Timerliste eintragen */

   313

    /* und neu in die Taskqueue eintragen */

   316

   317

    ipipe_control_irq(irq,0,IPIPE_ENABLE_MASK);  //Interrupt bestŽätigen

   318

    if(counter++ > HZREDUCTION) {

   319

	ipipe_propagate_irq(irq);  //und weiterreichen

   320

	counter = 0;

   321

    }

   327

   328

    ipipe_get_sysinfo(&sys_info);

   329

    ipipe_virtualize_irq(ipipe_current_domain,sys_info.archdep.tmirq,

   330

			 &msr_run, NULL, IPIPE_HANDLE_MASK);

   331

   348

   349

int msr_globals_register(void)

   350

{

   351

#ifdef USE_MSR_LIB

   352

    msr_reg_kanal("/value", "V", &value, TDBL);

   353

    msr_reg_kanal("/dig1", "", &dig1, TINT);

   354

#endif

   362

  return 0;

   363

}

   364

   366

 * the init/clean material

   368

   369

int __init init_module()

   370

{

   372

    struct ipipe_domain_attr attr; //ipipe

   373

   374

    // Als allererstes die RT-lib initialisieren

   375

#ifdef USE_MSR_LIB

   376

    if (msr_rtlib_init(1,MSR_ABTASTFREQUENZ,10,&msr_globals_register) < 0) {

   377

        msr_print_warn("msr_modul: can't initialize rtlib!");

   378

        goto out_return;

   379

    }

   380

#endif

   381

   382

    msr_jitter_init();

   383

   384

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

   385

   386

    if ((ecat_master = EtherCAT_request(0)) == NULL) {

   387

        printk(KERN_ERR "EtherCAT master 0 not available!\n");

   388

        goto out_msr_cleanup;

   389

    }

   390

   391

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

   392

   393

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

   394

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

   395

        goto out_release_master;

   396

    }

   397

   398

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

   399

   404

    }

   405

   406

    do_gettimeofday(&process_time);

   407

    msr_time_increment.tv_sec=0;

   408

    msr_time_increment.tv_usec=(unsigned int)(1000000/MSR_ABTASTFREQUENZ);

   409

   410

    ipipe_init_attr (&attr);

   411

    attr.name     = "IPIPE-MSR-MODULE";

   412

    attr.priority = IPIPE_ROOT_PRIO + 1;

   413

    attr.entry    = &domain_entry;

   414

    ipipe_register_domain(&this_domain,&attr);

   415

   416

    return 0;

   417

   418

 out_release_master:

   419

    EtherCAT_release(ecat_master);

   420

   421

 out_msr_cleanup:

   422

    msr_rtlib_cleanup();

   423

   424

 out_return:

   425

    return -1;

   426

}

   427

   430

void __exit cleanup_module()

   434

    msr_print_info("msk_modul: unloading...");

   435

   436

    ipipe_tune_timer(1000000000UL/HZ,0); //alten Timertakt wieder herstellen

   437

    ipipe_unregister_domain(&this_domain);

   438

   439

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

   440

   441

    if (ecat_master)

   442

    {

   443

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

   451

        EtherCAT_release(ecat_master);

   452

    }

   453

   454

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

   455

   456

#ifdef USE_MSR_LIB

   457

    msr_rtlib_cleanup();

   458

#endif

   459

}

   460

   463

MODULE_LICENSE("GPL");

   464

MODULE_AUTHOR ("Wilhelm Hagemeister <hm@igh-essen.com>");

   465

MODULE_DESCRIPTION ("EtherCAT test environment");

   466

   467

module_init(init_module);

   468

module_exit(cleanup_module);

   469