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

// Prozessdaten

    31

uint8_t *dig_out1;

    32

uint16_t *ssi_value;

    33

uint16_t *inc_value;

    34

    35

uint32_t angle0;

    36

    37

ec_field_init_t domain1_fields[] = {

    38

    {(void **) &dig_out1,    "2", "Beckhoff", "EL2004", ec_opvalue, 0, 1},

    39

    {(void **) &ssi_value,   "3", "Beckhoff", "EL5001", ec_ipvalue, 0, 1},

    40

    {(void **) &inc_value, "0:4", "Beckhoff", "EL5101", ec_ipvalue, 0, 1},

    41

    {}

    42

};

    43

    44

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

    45

    46

void run(unsigned long data)

    47

{

    48

    static unsigned int counter = 0;

    49

    50

    // Prozessdaten lesen und schreiben

    51

    EtherCAT_rt_domain_xio(domain1);

    52

    53

    angle0 = (uint32_t) *inc_value;

    54

    55

    if (counter) {

    56

        counter--;

    57

    }

    58

    else {

    59

        counter = ABTASTFREQUENZ;

    60

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

    61

    }

    62

    63

    // Timer neu starten

    64

    timer.expires += HZ / ABTASTFREQUENZ;

    65

    add_timer(&timer);

    66

}

    67

    68

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

    69

    70

int __init init_mini_module(void)

    71

{

    72

    const ec_field_init_t *field;

    73

    74

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

    75

    76

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

    77

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

    78

        goto out_return;

    79

    }

    80

    81

    EtherCAT_rt_master_print(master);

    82

    83

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

    84

    85

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

    86

    {

    87

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

    88

        goto out_release_master;

    89

    }

    90

    91

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

    92

    93

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

    94

    {

    95

        if (!EtherCAT_rt_register_slave_field(domain1,

    96

                                              field->address,

    97

                                              field->vendor,

    98

                                              field->product,

    99

                                              field->data,

   100

                                              field->field_type,

   101

                                              field->field_index,

   102

                                              field->field_count)) {

   103

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

   104

            goto out_release_master;

   105

        }

   106

    }

   107

   108

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

   109

   110

    if (EtherCAT_rt_master_activate(master)) {

   111

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

   112

        goto out_release_master;

   113

    }

   114

   115

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

   116

   117

    init_timer(&timer);

   118

    timer.function = run;

   119

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

   120

    add_timer(&timer);

   121

   122

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

   123

   124

    return 0;

   125

   126

 out_release_master:

   127

  EtherCAT_rt_release_master(master);

   128

   129

 out_return:

   130

  return -1;

   131

}

   132

   133

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

   134

   135

void __exit cleanup_mini_module(void)

   136

{

   137

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

   138

   139

    if (master)

   140

    {

   141

        del_timer_sync(&timer);

   142

   143

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

   144

   145

        EtherCAT_rt_master_deactivate(master);

   146

        EtherCAT_rt_release_master(master);

   147

    }

   148

   149

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

   150

}

   151

   152

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

   153

   154

MODULE_LICENSE("GPL");

   155

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

   156

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   157

   158

module_init(init_mini_module);

   159

module_exit(cleanup_mini_module);

   160

   161

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

   162

   163

/* Emacs-Konfiguration

   164

;;; Local Variables: ***

   165

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

   166

;;; End: ***

   167

*/