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

    17

#define ASYNC

    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

    34

    35

// Kanäle

    36

uint32_t k_pos;

    37

    38

ec_field_init_t domain1_fields[] = {

    48

    {}

    49

};

    50

    51

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

    52

    53

void run(unsigned long data)

    54

{

    55

    static unsigned int counter = 0;

    56

    57

#ifdef ASYNC

    58

    // Prozessdaten emfpangen

    59

    ecrt_master_async_receive(master);

    60

    ecrt_domain_process(domain1);

    61

    62

    // Prozessdaten verarbeiten

    64

    65

    // Prozessdaten senden

    66

    ecrt_domain_queue(domain1);

    67

    ecrt_master_async_send(master);

    68

#else

    69

    // Prozessdaten senden und emfpangen

    70

    ecrt_domain_queue(domain1);

    71

    ecrt_master_sync_io(master);

    72

    ecrt_domain_process(domain1);

    73

    74

    // Prozessdaten verarbeiten

    75

    k_pos   = EC_READ_U32(r_ssi);

    76

#endif

    77

    78

    if (counter) {

    79

        counter--;

    80

    }

    81

    else {

    82

        counter = ABTASTFREQUENZ;

    83

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

    84

    }

    85

    86

    // Timer neu starten

    87

    timer.expires += HZ / ABTASTFREQUENZ;

    88

    add_timer(&timer);

    89

}

    90

    91

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

    92

    93

int __init init_mini_module(void)

    94

{

    95

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

    96

    97

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

    98

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

    99

        goto out_return;

   100

    }

   101

   103

   104

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

   105

   106

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

   107

    {

   108

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

   109

        goto out_release_master;

   110

    }

   111

   112

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

   113

   114

    if (ecrt_domain_register_field_list(domain1, domain1_fields)) {

   115

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

   116

        goto out_release_master;

   117

    }

   118

   119

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

   120

   121

    if (ecrt_master_activate(master)) {

   122

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

   123

        goto out_release_master;

   124

    }

   125

   126

#ifdef ASYNC

   127

    // Einmal senden und warten...

   128

    ecrt_master_prepare_async_io(master);

   129

#endif

   130

   131

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

   132

   133

    init_timer(&timer);

   134

    timer.function = run;

   135

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

   136

    add_timer(&timer);

   137

   138

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

   139

   140

    return 0;

   141

   142

 out_release_master:

   143

  ecrt_release_master(master);

   144

   145

 out_return:

   146

  return -1;

   147

}

   148

   149

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

   150

   151

void __exit cleanup_mini_module(void)

   152

{

   153

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

   154

   155

    if (master)

   156

    {

   157

        del_timer_sync(&timer);

   158

   159

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

   160

   161

        ecrt_master_deactivate(master);

   162

        ecrt_release_master(master);

   163

    }

   164

   165

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

   166

}

   167

   168

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

   169

   170

MODULE_LICENSE("GPL");

   171

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

   172

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   173

   174

module_init(init_mini_module);

   175

module_exit(cleanup_mini_module);

   176

   177

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

   178

   179

/* Emacs-Konfiguration

   180

;;; Local Variables: ***

   181

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

   182

;;; End: ***

   183

*/