1

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

     2

 *

     3

 * m i n i . c

     4

 *

     5

 * Minimalmodul für EtherCAT

     6

 *

     7

 * $Id$

     8

 *

     9

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

    10

    11

#include <linux/module.h>

    12

#include <linux/delay.h>

    13

#include <linux/timer.h>

    14

    15

#include "../include/EtherCAT_rt.h" // Echtzeitschnittstelle

    16

#include "../include/EtherCAT_si.h" // Slave-Interface-Makros

    17

    18

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

    19

    20

#define ABTASTFREQUENZ 1000

    21

    22

struct timer_list timer;

    23

    24

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

    25

    26

// EtherCAT

    27

ec_master_t *master = NULL;

    28

ec_domain_t *domain1 = NULL;

    29

    30

// Datenfelder

    31

void *r_ssi;

    32

void *r_inc;

    33

    34

// Kanäle

    35

uint32_t k_angle, k_pos;

    36

    37

ec_field_init_t domain1_fields[] = {

    38

    {&r_ssi,   "1", "Beckhoff", "EL5001", ec_ipvalue, 0, 1},

    39

    {&r_inc, "0:3", "Beckhoff", "EL5101", ec_ipvalue, 0, 1},

    40

    {}

    41

};

    42

    43

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

    44

    45

void run(unsigned long data)

    46

{

    47

    static unsigned int counter = 0;

    48

    49

    // Prozessdaten lesen und schreiben

    50

    EtherCAT_rt_domain_xio(domain1);

    51

    52

    k_angle = EC_READ_U16(r_inc);

    53

    k_pos   = EC_READ_U32(r_ssi);

    54

    55

    if (counter) {

    56

        counter--;

    57

    }

    58

    else {

    59

        counter = ABTASTFREQUENZ;

    60

        printk(KERN_INFO "k_angle = %i\n", k_angle);

    61

        printk(KERN_INFO "k_pos   = %i\n", k_pos);

    62

    }

    63

    64

    // Timer neu starten

    65

    timer.expires += HZ / ABTASTFREQUENZ;

    66

    add_timer(&timer);

    67

}

    68

    69

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

    70

    71

int __init init_mini_module(void)

    72

{

    73

    const ec_field_init_t *field;

    74

    75

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

    76

    77

    if ((master = EtherCAT_rt_request_master(0)) == NULL) {

    78

        printk(KERN_ERR "Error requesting master 0!\n");

    79

        goto out_return;

    80

    }

    81

    82

    EtherCAT_rt_master_print(master);

    83

    84

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

    85

    86

    if (!(domain1 = EtherCAT_rt_master_register_domain(master, ec_sync, 100)))

    87

    {

    88

        printk(KERN_ERR "EtherCAT: Could not register domain!\n");

    89

        goto out_release_master;

    90

    }

    91

    92

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

    93

    94

    for (field = domain1_fields; field->data; field++)

    95

    {

    96

        if (!EtherCAT_rt_register_slave_field(domain1,

    97

                                              field->address,

    98

                                              field->vendor,

    99

                                              field->product,

   100

                                              field->data,

   101

                                              field->field_type,

   102

                                              field->field_index,

   103

                                              field->field_count)) {

   104

            printk(KERN_ERR "EtherCAT: Could not register field!\n");

   105

            goto out_release_master;

   106

        }

   107

    }

   108

   109

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

   110

   111

    if (EtherCAT_rt_master_activate(master)) {

   112

        printk(KERN_ERR "EtherCAT: Could not activate master!\n");

   113

        goto out_release_master;

   114

    }

   115

   116

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

   117

   118

    init_timer(&timer);

   119

    timer.function = run;

   120

    timer.expires = jiffies + 10; // Das erste Mal sofort feuern

   121

    add_timer(&timer);

   122

   123

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

   124

   125

    return 0;

   126

   127

 out_release_master:

   128

  EtherCAT_rt_release_master(master);

   129

   130

 out_return:

   131

  return -1;

   132

}

   133

   134

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

   135

   136

void __exit cleanup_mini_module(void)

   137

{

   138

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

   139

   140

    if (master)

   141

    {

   142

        del_timer_sync(&timer);

   143

   144

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

   145

   146

        EtherCAT_rt_master_deactivate(master);

   147

        EtherCAT_rt_release_master(master);

   148

    }

   149

   150

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

   151

}

   152

   153

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

   154

   155

MODULE_LICENSE("GPL");

   156

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

   157

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   158

   159

module_init(init_mini_module);

   160

module_exit(cleanup_mini_module);

   161

   162

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

   163

   164

/* Emacs-Konfiguration

   165

;;; Local Variables: ***

   166

;;; c-basic-offset:4 ***

   167

;;; End: ***

   168

*/