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

ec_master_t *master = NULL;

    21

ec_slave_t *s_in, *s_out, *s_ssi;

    22

    23

struct timer_list timer;

    24

    25

ec_slave_init_t slaves[] = {

    26

    // Zeiger, Index, Herstellername, Produktname, Domäne

    27

    {  &s_in,  "1",   "Beckhoff",     "EL3102",    1      },

    28

    {  &s_out, "2",   "Beckhoff",     "EL2004",    1      },

    29

    {  &s_ssi, "3",   "Beckhoff",     "EL5001",    1      }

    30

};

    31

    32

#define SLAVE_COUNT (sizeof(slaves) / sizeof(ec_slave_init_t))

    33

    34

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

    35

    36

void run(unsigned long data)

    37

{

    38

    static unsigned int counter;

    39

    40

    // Klemmen-IO

    41

    EC_WRITE_EL20XX(s_out, 3, EC_READ_EL31XX(s_in, 0) < 0);

    42

    43

    if (!counter) {

    44

        EtherCAT_rt_debug_level(master, 2);

    45

    }

    46

    47

    // Prozessdaten lesen und schreiben

    48

    EtherCAT_rt_domain_xio(master, 1, 100);

    49

    50

    if (counter) {

    51

        counter--;

    52

    }

    53

    else {

    54

        EtherCAT_rt_debug_level(master, 0);

    55

        printk("SSI status=%X value=%u\n",

    56

               EC_READ_EL5001_STATE(s_ssi), EC_READ_EL5001_VALUE(s_ssi));

    57

        counter = 1000;

    58

    }

    59

    60

    // Timer neu starten

    61

    timer.expires += HZ / 1000;

    62

    add_timer(&timer);

    63

}

    64

    65

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

    66

    67

int __init init_mini_module(void)

    68

{

    69

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

    70

    71

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

    72

        printk(KERN_ERR "EtherCAT master 0 not available!\n");

    73

        goto out_return;

    74

    }

    75

    76

    if (EtherCAT_rt_register_slave_list(master, slaves, SLAVE_COUNT)) {

    77

        printk(KERN_ERR "Could not register slaves!\n");

    78

        goto out_release_master;

    79

    }

    80

    81

    printk("Activating all EtherCAT slaves.\n");

    82

    83

    if (EtherCAT_rt_activate_slaves(master)) {

    84

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

    85

        goto out_release_master;

    86

    }

    87

    88

    printk("Configuring EtherCAT slaves.\n");

    89

    90

    if (EtherCAT_rt_canopen_sdo_write(master, s_ssi, 0x4067, 0, 2, 2)) {

    91

        printk(KERN_ERR "EtherCAT: Could not set SSI baud rate!\n");

    92

        goto out_release_master;

    93

    }

    94

    95

    if (EtherCAT_rt_canopen_sdo_write(master, s_ssi, 0x4061, 4, 1, 1)) {

    96

        printk(KERN_ERR "EtherCAT: Could not set SSI feature bit!\n");

    97

        goto out_release_master;

    98

    }

    99

   100

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

   101

   102

    init_timer(&timer);

   103

   104

    timer.function = run;

   105

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

   106

    add_timer(&timer);

   107

   108

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

   109

   110

    return 0;

   111

   112

 out_release_master:

   113

  EtherCAT_rt_release_master(master);

   114

   115

 out_return:

   116

  return -1;

   117

}

   118

   119

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

   120

   121

void __exit cleanup_mini_module(void)

   122

{

   123

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

   124

   125

    if (master)

   126

    {

   127

        del_timer_sync(&timer);

   128

   129

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

   130

   131

        EtherCAT_rt_deactivate_slaves(master);

   132

        EtherCAT_rt_release_master(master);

   133

    }

   134

   135

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

   136

}

   137

   138

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

   139

   140

MODULE_LICENSE("GPL");

   141

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

   142

MODULE_DESCRIPTION ("Minimal EtherCAT environment");

   143

   144

module_init(init_mini_module);

   145

module_exit(cleanup_mini_module);

   146

   147

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

   148

   149

/* Emacs-Konfiguration

   150

;;; Local Variables: ***

   151

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

   152

;;; End: ***

   153

*/