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

    32

//void *r_ssi_input, *r_ssi_status, *r_4102[3];

    33

    34

// Kanäle

    35

uint32_t k_pos;

    36

uint8_t k_stat;

    37

    38

ec_field_init_t domain1_fields[] = {

    39

    {NULL, "1", "Beckhoff", "EL1014", "InputValue",  0},

    40

    {NULL, "2", "Beckhoff", "EL2004", "OutputValue", 0},

    41

    //{NULL, "3", "Beckhoff", "EL3162", "InputValue",  0},

    42

    {NULL, "4", "Beckhoff", "EL4132", "OutputValue",  0},

    43

    {NULL, "6", "Beckhoff", "EL5001", "InputValue", 0},

    44

    {}

    45

};

    46

    47

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

    48

    49

void run(unsigned long data)

    50

{

    51

    static unsigned int counter = 0;

    52

    53

#ifdef ASYNC

    54

    // Prozessdaten empfangen

    55

    ecrt_master_async_receive(master);

    56

    ecrt_domain_process(domain1);

    57

    58

    // Prozessdaten verarbeiten

    59

    //k_pos   = EC_READ_U32(r_ssi_input);

    60

    //k_stat  = EC_READ_U8(r_ssi_status);

    61

    62

    // Prozessdaten senden

    63

    ecrt_domain_queue(domain1);

    64

    ecrt_master_async_send(master);

    65

#else

    66

    // Prozessdaten senden und empfangen

    67

    ecrt_domain_queue(domain1);

    68

    ecrt_master_sync_io(master);

    69

    ecrt_domain_process(domain1);

    70

    71

    // Prozessdaten verarbeiten

    72

    //k_pos   = EC_READ_U32(r_ssi_input);

    73

    //k_stat  = EC_READ_U8(r_ssi_status);

    74

#endif

    75

    76

    if (counter) {

    77

        counter--;

    78

    }

    79

    else {

    80

        counter = ABTASTFREQUENZ;

    81

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

    82

        //printk(KERN_INFO "k_stat   = 0x%02X\n", k_stat);

    83

    }

    84

    85

    // Timer neu starten

    86

    timer.expires += HZ / ABTASTFREQUENZ;

    87

    add_timer(&timer);

    88

}

    89

    90

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

    91

    92

int __init init_mini_module(void)

    93

{

    94

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

    95

    96

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

    97

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

    98

        goto out_return;

    99

    }

   100

   101

    ecrt_master_print(master);

   102

   103

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

   104

   105

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

   106

    {

   107

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

   108

        goto out_release_master;

   109

    }

   110

   111

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

   112

   113

    if (ecrt_domain_register_field_list(domain1, domain1_fields)) {

   114

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

   115

        goto out_release_master;

   116

    }

   117

   118

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

   119

   120

    if (ecrt_master_activate(master)) {

   121

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

   122

        goto out_release_master;

   123

    }

   124

   125

    //ecrt_master_debug(master, 2);

   126

   127

#if 0

   128

    if (ecrt_master_sdo_write(master, "1", 0x4061, 1,  0, 1) ||

   129

        ecrt_master_sdo_write(master, "1", 0x4061, 2,  1, 1) ||

   130

        ecrt_master_sdo_write(master, "1", 0x4061, 3,  1, 1) ||

   131

        ecrt_master_sdo_write(master, "1", 0x4066, 0,  0, 1) ||

   132

        ecrt_master_sdo_write(master, "1", 0x4067, 0,  4, 1) ||

   133

        ecrt_master_sdo_write(master, "1", 0x4068, 0,  0, 1) ||

   134

        ecrt_master_sdo_write(master, "1", 0x4069, 0, 25, 1) ||

   135

        ecrt_master_sdo_write(master, "1", 0x406A, 0, 25, 1) ||

   136

        ecrt_master_sdo_write(master, "1", 0x406B, 0, 50, 1)) {

   137

        printk(KERN_ERR "EtherCAT: Failed to configure SSI!\n");

   138

        goto out_deactivate;

   139

    }

   140

#endif

   141

   142

    //ecrt_master_debug(master, 0);

   143

   144

#if 0

   145

    printk(KERN_INFO "Writing alias...\n");

   146

    if (ecrt_master_write_slave_alias(master, "0", 0xBEEF)) {

   147

        printk(KERN_ERR "EtherCAT: Failed to write alias!\n");

   148

        goto out_deactivate;

   149

    }

   150

#endif

   151

   152

#ifdef ASYNC

   153

    // Einmal senden und warten...

   154

    ecrt_master_prepare_async_io(master);

   155

#endif

   156

   157

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

   158

   159

    init_timer(&timer);

   160

    timer.function = run;

   161

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

   162

    add_timer(&timer);

   163

   164

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

   165

   166

    return 0;

   167

   168

#if 0

   169

 out_deactivate:

   170

    ecrt_master_deactivate(master);

   171

#endif

   172

   173

 out_release_master:

   174

    ecrt_release_master(master);

   175

   176

 out_return:

   177

    return -1;

   178

}

   179

   180

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

   181

   182

void __exit cleanup_mini_module(void)

   183

{

   184

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

   185

   186

    if (master)

   187

    {

   188

        del_timer_sync(&timer);

   189

   190

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

   191

   192

        ecrt_master_deactivate(master);

   193

        ecrt_release_master(master);

   194

    }

   195

   196

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

   197

}

   198

   199

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

   200

   201

MODULE_LICENSE("GPL");

   202

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

   203

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   204

   205

module_init(init_mini_module);

   206

module_exit(cleanup_mini_module);

   207

   208

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

   209

   210

/* Emacs-Konfiguration

   211

;;; Local Variables: ***

   212

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

   213

;;; End: ***

   214

*/