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

    33

void *r_field[9];

    34

void *r_4102[3];

    35

    36

// Kanäle

    37

uint32_t k_pos;

    39

    40

ec_field_init_t domain1_fields[] = {

    43

    {&r_field[1],   "2", "Beckhoff", "EL4132", "OutputValue", 0, 1},

    48

    {&r_field[6],   "7", "Beckhoff", "EL2004", "OutputValue", 0, 1},

    49

    {&r_field[7],   "8", "Beckhoff", "EL4132", "OutputValue", 0, 1},

    50

    {&r_field[8],   "9", "Beckhoff", "EL4132", "OutputValue", 0, 1},

    51

    {}

    52

};

    53

    54

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

    55

    56

void run(unsigned long data)

    57

{

    58

    static unsigned int counter = 0;

    59

    60

#ifdef ASYNC

    61

    // Prozessdaten emfpangen

    62

    ecrt_master_async_receive(master);

    63

    ecrt_domain_process(domain1);

    64

    65

    // Prozessdaten verarbeiten

    68

    69

    // Prozessdaten senden

    70

    ecrt_domain_queue(domain1);

    71

    ecrt_master_async_send(master);

    72

#else

    73

    // Prozessdaten senden und emfpangen

    74

    ecrt_domain_queue(domain1);

    75

    ecrt_master_sync_io(master);

    76

    ecrt_domain_process(domain1);

    77

    78

    // Prozessdaten verarbeiten

    79

    k_pos   = EC_READ_U32(r_ssi);

    80

#endif

    81

    82

    if (counter) {

    83

        counter--;

    84

    }

    85

    else {

    86

        counter = ABTASTFREQUENZ;

    89

    }

    90

    91

    // Timer neu starten

    92

    timer.expires += HZ / ABTASTFREQUENZ;

    93

    add_timer(&timer);

    94

}

    95

    96

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

    97

    98

int __init init_mini_module(void)

    99

{

   100

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

   101

   102

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

   103

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

   104

        goto out_return;

   105

    }

   106

   107

    ecrt_master_print(master);

   108

   109

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

   110

   111

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

   112

    {

   113

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

   114

        goto out_release_master;

   115

    }

   116

   117

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

   118

   119

    if (ecrt_domain_register_field_list(domain1, domain1_fields)) {

   120

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

   121

        goto out_release_master;

   122

    }

   123

   124

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

   125

   126

    if (ecrt_master_activate(master)) {

   127

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

   128

        goto out_release_master;

   129

    }

   130

   148

#ifdef ASYNC

   149

    // Einmal senden und warten...

   150

    ecrt_master_prepare_async_io(master);

   151

#endif

   152

   153

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

   154

   155

    init_timer(&timer);

   156

    timer.function = run;

   157

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

   158

    add_timer(&timer);

   159

   160

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

   161

   162

    return 0;

   163

   167

 out_release_master:

   169

   170

 out_return:

   172

}

   173

   174

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

   175

   176

void __exit cleanup_mini_module(void)

   177

{

   178

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

   179

   180

    if (master)

   181

    {

   182

        del_timer_sync(&timer);

   183

   184

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

   185

   186

        ecrt_master_deactivate(master);

   187

        ecrt_release_master(master);

   188

    }

   189

   190

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

   191

}

   192

   193

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

   194

   195

MODULE_LICENSE("GPL");

   196

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

   197

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   198

   199

module_init(init_mini_module);

   200

module_exit(cleanup_mini_module);

   201

   202

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

   203

   204

/* Emacs-Konfiguration

   205

;;; Local Variables: ***

   206

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

   207

;;; End: ***

   208

*/