1

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

     2

 *

     3

 *  msr_module.c

     4

 *

     5

 *  Kernelmodul f�ür 2.6 Kernel zur Me�ßdatenerfassung, Steuerung und Regelung.

     6

 *

     7

 *  Autor: Wilhelm Hagemeister, Florian Pose

     8

 *

     9

 *  (C) Copyright IgH 2002

    10

 *  Ingenieurgemeinschaft IgH

    11

 *  Heinz-B�äcker Str. 34

    12

 *  D-45356 Essen

    13

 *  Tel.: +49 201/61 99 31

    14

 *  Fax.: +49 201/61 98 36

    15

 *  E-mail: hm@igh-essen.com

    16

 *

    17

 *  $Id$

    18

 *

    19

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

    20

    21

// Linux

    22

#include <linux/module.h>

    23

#include <linux/ipipe.h>

    24

    25

// RT_lib

    26

#include <msr_main.h>

    27

#include <msr_utils.h>

    28

#include <msr_messages.h>

    29

#include <msr_float.h>

    30

#include <msr_reg.h>

    31

#include "msr_param.h"

    32

#include "msr_jitter.h"

    33

    34

// EtherCAT

    35

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

    36

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

    37

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

    38

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

    39

    40

// Defines/Makros

    41

#define TSC2US(T1, T2) ((T2 - T1) * 1000UL / cpu_khz)

    42

#define HZREDUCTION (MSR_ABTASTFREQUENZ / HZ)

    43

    44

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

    45

/* Globale Variablen */

    46

    47

// RT_lib

    48

extern struct timeval process_time;

    49

struct timeval msr_time_increment; // Increment per Interrupt

    50

    51

// Adeos

    52

static struct ipipe_domain this_domain;

    53

static struct ipipe_sysinfo sys_info;

    54

    55

// EtherCAT

    56

    57

static EtherCAT_master_t *ecat_master = NULL;

    58

static unsigned int ecat_bus_time = 0;

    59

static unsigned int ecat_timeouts = 0;

    60

    61

static EtherCAT_slave_t ecat_slaves[] =

    62

{

    63

    // Block 1

    64

    ECAT_INIT_SLAVE(Beckhoff_EK1100, 0),

    65

    ECAT_INIT_SLAVE(Beckhoff_EL3102, 0)

    66

};

    67

    68

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

    69

    70

#define USE_MSR_LIB

    71

    72

#ifdef USE_MSR_LIB

    73

double value;

    74

int dig1;

    75

#endif

    76

    77

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

    78

 *

    79

 * Function: msr_controller_run()

    80

 *

    81

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

    82

    83

static void msr_controller_run(void)

    84

{

    85

    static unsigned int debug_counter = 0;

    86

    87

    // Prozessdaten lesen

    88

    msr_jitter_run(MSR_ABTASTFREQUENZ);

    89

    90

    if (debug_counter == 0) {

    91

        ecat_master->debug_level = 2;

    92

    }

    93

    94

    // Prozessdaten schreiben

    95

    96

    if (EtherCAT_process_data_cycle(ecat_master, 0, 40) < 0)

    97

        ecat_timeouts++;

    98

    99

    if (debug_counter == 0) {

   100

        ecat_master->debug_level = 0;

   101

    }

   102

   103

    value = EtherCAT_read_value(&ecat_slaves[1], 0);

   104

   105

    debug_counter++;

   106

    if (debug_counter >= MSR_ABTASTFREQUENZ * 5) debug_counter = 0;

   107

}

   108

   109

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

   110

 *

   111

 *  Function: msr_run(_interrupt)

   112

 *

   113

 *  Beschreibung: Routine wird zyklisch im Timerinterrupt ausgef�ührt

   114

 *                (hier mu�ß alles rein, was Echtzeit ist ...)

   115

 *

   116

 *  Parameter: Zeiger auf msr_data

   117

 *

   118

 *  R�ückgabe:

   119

 *

   120

 *  Status: exp

   121

 *

   122

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

   123

   124

void msr_run(unsigned irq)

   125

{

   126

    static int counter = 0;

   127

   128

#ifdef USE_MSR_LIB

   129

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

   130

    MSR_ADEOS_INTERRUPT_CODE(msr_controller_run(); msr_write_kanal_list(););

   131

#else

   132

    msr_controller_run();

   133

#endif

   134

   135

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

   136

    if (counter++ > HZREDUCTION) {

   137

	ipipe_propagate_irq(irq);  //und weiterreichen

   138

	counter = 0;

   139

    }

   140

}

   141

   142

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

   143

   144

void domain_entry(void)

   145

{

   146

    printk("Domain %s started.\n", ipipe_current_domain->name);

   147

   148

    ipipe_get_sysinfo(&sys_info);

   149

    ipipe_virtualize_irq(ipipe_current_domain,sys_info.archdep.tmirq,

   150

			 &msr_run, NULL, IPIPE_HANDLE_MASK);

   151

   152

    ipipe_tune_timer(1000000000UL/MSR_ABTASTFREQUENZ,0);

   153

}

   154

   155

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

   156

 *

   157

 *  Function: msr_register_channels

   158

 *

   159

 *  Beschreibung: KanŽäle registrieren

   160

 *

   161

 *  Parameter:

   162

 *

   163

 *  RŽückgabe:

   164

 *

   165

 *  Status: exp

   166

 *

   167

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

   168

   169

int msr_globals_register(void)

   170

{

   171

#ifdef USE_MSR_LIB

   172

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

   173

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

   174

#endif

   175

   176

    msr_reg_kanal("/Taskinfo/EtherCAT/BusTime", "us", &ecat_bus_time, TUINT);

   177

    msr_reg_kanal("/Taskinfo/EtherCAT/Timeouts", "", &ecat_timeouts, TUINT);

   178

   179

    return 0;

   180

}

   181

   182

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

   183

 * the init/clean material

   184

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

   185

   186

int __init init_module()

   187

{

   188

    unsigned int i;

   189

    struct ipipe_domain_attr attr; //ipipe

   190

   191

    // Als allererstes die RT-lib initialisieren

   192

#ifdef USE_MSR_LIB

   193

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

   194

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

   195

        goto out_return;

   196

    }

   197

#endif

   198

   199

    msr_jitter_init();

   200

   201

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

   202

   203

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

   204

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

   205

        goto out_msr_cleanup;

   206

    }

   207

   208

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

   209

   210

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

   211

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

   212

        goto out_release_master;

   213

    }

   214

   215

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

   216

   217

    for (i = 0; i < ECAT_SLAVES_COUNT; i++) {

   218

        if (EtherCAT_activate_slave(ecat_master, ecat_slaves + i) < 0) {

   219

            printk(KERN_ERR "EtherCAT: Could not activate slave %i!\n", i);

   220

            goto out_release_master;

   221

        }

   222

    }

   223

   224

    do_gettimeofday(&process_time);

   225

    msr_time_increment.tv_sec=0;

   226

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

   227

   228

    ipipe_init_attr (&attr);

   229

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

   230

    attr.priority = IPIPE_ROOT_PRIO + 1;

   231

    attr.entry    = &domain_entry;

   232

    ipipe_register_domain(&this_domain,&attr);

   233

   234

    return 0;

   235

   236

 out_release_master:

   237

    EtherCAT_release(ecat_master);

   238

   239

 out_msr_cleanup:

   240

    msr_rtlib_cleanup();

   241

   242

 out_return:

   243

    return -1;

   244

}

   245

   246

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

   247

   248

void __exit cleanup_module()

   249

{

   250

    unsigned int i;

   251

   252

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

   253

   254

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

   255

    ipipe_unregister_domain(&this_domain);

   256

   257

    if (ecat_master)

   258

    {

   259

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

   260

   261

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

   262

   263

        for (i = 0; i < ECAT_SLAVES_COUNT; i++) {

   264

            if (EtherCAT_deactivate_slave(ecat_master, ecat_slaves + i) < 0) {

   265

                printk(KERN_WARNING "Warning - Could not deactivate slave!\n");

   266

            }

   267

        }

   268

   269

        EtherCAT_release(ecat_master);

   270

   271

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

   272

    }

   273

   274

#ifdef USE_MSR_LIB

   275

    msr_rtlib_cleanup();

   276

#endif

   277

}

   278

   279

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

   280

   281

MODULE_LICENSE("GPL");

   282

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

   283

MODULE_DESCRIPTION ("EtherCAT test environment");

   284

   285

module_init(init_module);

   286

module_exit(cleanup_module);

   287

   288

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