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 100

    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_queue(domain1);

    51

    EtherCAT_rt_master_xio(master);

    52

    EtherCAT_rt_domain_process(domain1);

    53

    54

    k_angle = EC_READ_U16(r_inc);

    55

    k_pos   = EC_READ_U32(r_ssi);

    56

    57

    if (counter) {

    58

        counter--;

    59

    }

    60

    else {

    61

        counter = ABTASTFREQUENZ;

    62

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

    63

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

    64

    }

    65

    66

    // Timer neu starten

    67

    timer.expires += HZ / ABTASTFREQUENZ;

    68

    add_timer(&timer);

    69

}

    70

    71

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

    72

    73

int __init init_mini_module(void)

    74

{

    75

    const ec_field_init_t *field;

    76

    77

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

    78

    79

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

    80

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

    81

        goto out_return;

    82

    }

    83

    84

    EtherCAT_rt_master_print(master);

    85

    86

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

    87

    88

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

    89

    {

    90

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

    91

        goto out_release_master;

    92

    }

    93

    94

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

    95

    96

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

    97

    {

    98

        if (!EtherCAT_rt_register_slave_field(domain1,

    99

                                              field->address,

   100

                                              field->vendor,

   101

                                              field->product,

   102

                                              field->data,

   103

                                              field->field_type,

   104

                                              field->field_index,

   105

                                              field->field_count)) {

   106

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

   107

            goto out_release_master;

   108

        }

   109

    }

   110

   111

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

   112

   113

    if (EtherCAT_rt_master_activate(master)) {

   114

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

   115

        goto out_release_master;

   116

    }

   117

   118

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

   119

   120

    init_timer(&timer);

   121

    timer.function = run;

   122

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

   123

    add_timer(&timer);

   124

   125

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

   126

   127

    return 0;

   128

   129

 out_release_master:

   130

  EtherCAT_rt_release_master(master);

   131

   132

 out_return:

   133

  return -1;

   134

}

   135

   136

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

   137

   138

void __exit cleanup_mini_module(void)

   139

{

   140

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

   141

   142

    if (master)

   143

    {

   144

        del_timer_sync(&timer);

   145

   146

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

   147

   148

        EtherCAT_rt_master_deactivate(master);

   149

        EtherCAT_rt_release_master(master);

   150

    }

   151

   152

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

   153

}

   154

   155

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

   156

   157

MODULE_LICENSE("GPL");

   158

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

   159

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   160

   161

module_init(init_mini_module);

   162

module_exit(cleanup_mini_module);

   163

   164

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

   165

   166

/* Emacs-Konfiguration

   167

;;; Local Variables: ***

   168

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

   169

;;; End: ***

   170

*/