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/ecrt.h" // Echtzeitschnittstelle

    16

    18

    19

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

    20

    21

#define ABTASTFREQUENZ 100

    22

    23

struct timer_list timer;

    24

    25

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

    26

    27

// EtherCAT

    28

ec_master_t *master = NULL;

    29

ec_domain_t *domain1 = NULL;

    30

    31

// Datenfelder

    32

void *r_ssi;

    33

    34

// Kanäle

    35

uint32_t k_pos;

    36

    37

ec_field_init_t domain1_fields[] = {

    38

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

    39

    {}

    40

};

    41

    42

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

    43

    44

void run(unsigned long data)

    45

{

    46

    static unsigned int counter = 0;

    47

    48

#ifdef ASYNC

    49

    // Prozessdaten emfpangen

    50

    ecrt_master_async_receive(master);

    51

    ecrt_domain_process(domain1);

    52

    53

    // Prozessdaten verarbeiten

    54

    k_pos   = EC_READ_U32(r_ssi);

    55

    56

    // Prozessdaten senden

    57

    ecrt_domain_queue(domain1);

    58

    ecrt_master_async_send(master);

    59

#else

    60

    // Prozessdaten senden und emfpangen

    61

    ecrt_domain_queue(domain1);

    62

    ecrt_master_sync_io(master);

    63

    ecrt_domain_process(domain1);

    64

    65

    // Prozessdaten verarbeiten

    66

    k_pos   = EC_READ_U32(r_ssi);

    67

#endif

    68

    69

    if (counter) {

    70

        counter--;

    71

    }

    72

    else {

    73

        counter = ABTASTFREQUENZ;

    74

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

    75

    }

    76

    77

    // Timer neu starten

    78

    timer.expires += HZ / ABTASTFREQUENZ;

    79

    add_timer(&timer);

    80

}

    81

    82

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

    83

    84

int __init init_mini_module(void)

    85

{

    86

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

    87

    88

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

    89

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

    90

        goto out_return;

    91

    }

    92

    93

    //ecrt_master_print(master);

    94

    95

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

    96

    97

    if (!(domain1 = ecrt_master_create_domain(master)))

    98

    {

    99

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

   100

        goto out_release_master;

   101

    }

   102

   103

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

   104

   105

    if (ecrt_domain_register_field_list(domain1, domain1_fields)) {

   106

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

   107

        goto out_release_master;

   108

    }

   109

   110

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

   111

   112

    if (ecrt_master_activate(master)) {

   113

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

   114

        goto out_release_master;

   115

    }

   116

   117

#ifdef ASYNC

   120

#endif

   121

   122

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

   123

   124

    init_timer(&timer);

   125

    timer.function = run;

   126

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

   127

    add_timer(&timer);

   128

   129

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

   130

   131

    return 0;

   132

   133

 out_release_master:

   134

  ecrt_release_master(master);

   135

   136

 out_return:

   137

  return -1;

   138

}

   139

   140

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

   141

   142

void __exit cleanup_mini_module(void)

   143

{

   144

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

   145

   146

    if (master)

   147

    {

   148

        del_timer_sync(&timer);

   149

   150

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

   151

   152

        ecrt_master_deactivate(master);

   153

        ecrt_release_master(master);

   154

    }

   155

   156

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

   157

}

   158

   159

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

   160

   161

MODULE_LICENSE("GPL");

   162

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

   163

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   164

   165

module_init(init_mini_module);

   166

module_exit(cleanup_mini_module);

   167

   168

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

   169

   170

/* Emacs-Konfiguration

   171

;;; Local Variables: ***

   172

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

   173

;;; End: ***

   174

*/