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", "EL5001", "InputValue", 0},

    40

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

    41

    {}

    42

};

    43

    44

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

    45

    46

void run(unsigned long data)

    47

{

    48

    static unsigned int counter = 0;

    49

    50

#ifdef ASYNC

    51

    // Prozessdaten empfangen

    52

    ecrt_master_async_receive(master);

    53

    ecrt_domain_process(domain1);

    54

    55

    // Prozessdaten verarbeiten

    56

    //k_pos   = EC_READ_U32(r_ssi_input);

    57

    //k_stat  = EC_READ_U8(r_ssi_status);

    58

    59

    // Prozessdaten senden

    60

    ecrt_domain_queue(domain1);

    61

    ecrt_master_run(master);

    62

    ecrt_master_async_send(master);

    63

#else

    64

    // Prozessdaten senden und empfangen

    65

    ecrt_domain_queue(domain1);

    66

    ecrt_master_run(master);

    67

    ecrt_master_sync_io(master);

    68

    ecrt_domain_process(domain1);

    69

    70

    // Prozessdaten verarbeiten

    71

    //k_pos   = EC_READ_U32(r_ssi_input);

    72

    //k_stat  = EC_READ_U8(r_ssi_status);

    73

#endif

    74

    75

    if (counter) {

    76

        counter--;

    77

    }

    78

    else {

    79

        counter = ABTASTFREQUENZ;

    80

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

    81

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

    82

    }

    83

    84

    // Timer neu starten

    85

    timer.expires += HZ / ABTASTFREQUENZ;

    86

    add_timer(&timer);

    87

}

    88

    89

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

    90

    91

int __init init_mini_module(void)

    92

{

    93

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

    94

    95

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

    96

        printk(KERN_ERR "Requesting master 0 failed!\n");

    97

        goto out_return;

    98

    }

    99

   100

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

   101

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

   102

    {

   103

        printk(KERN_ERR "Domain creation failed!\n");

   104

        goto out_release_master;

   105

    }

   106

   107

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

   108

    if (ecrt_domain_register_field_list(domain1, domain1_fields)) {

   109

        printk(KERN_ERR "Field registration failed!\n");

   110

        goto out_release_master;

   111

    }

   112

   113

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

   114

    if (ecrt_master_activate(master)) {

   115

        printk(KERN_ERR "Failed to activate master!\n");

   116

        goto out_release_master;

   117

    }

   118

   119

#if 0

   120

    if (ecrt_master_fetch_sdo_lists(master)) {

   121

        printk(KERN_ERR "Failed to fetch SDO lists!\n");

   122

        goto out_deactivate;

   123

    }

   124

    ecrt_master_print(master, 2);

   125

#else

   126

    ecrt_master_print(master, 0);

   127

#endif

   128

   129

   130

#if 0

   131

    if (!(slave = ecrt_master_get_slave(master, "5"))) {

   132

        printk(KERN_ERR "Failed to get slave 5!\n");

   133

        goto out_deactivate;

   134

    }

   135

   136

    if (ecrt_slave_sdo_write_exp8(slave, 0x4061, 1,  0) ||

   137

        ecrt_slave_sdo_write_exp8(slave, 0x4061, 2,  1) ||

   138

        ecrt_slave_sdo_write_exp8(slave, 0x4061, 3,  1) ||

   139

        ecrt_slave_sdo_write_exp8(slave, 0x4066, 0,  0) ||

   140

        ecrt_slave_sdo_write_exp8(slave, 0x4067, 0,  4) ||

   141

        ecrt_slave_sdo_write_exp8(slave, 0x4068, 0,  0) ||

   142

        ecrt_slave_sdo_write_exp8(slave, 0x4069, 0, 25) ||

   143

        ecrt_slave_sdo_write_exp8(slave, 0x406A, 0, 25) ||

   144

        ecrt_slave_sdo_write_exp8(slave, 0x406B, 0, 50)) {

   145

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

   146

        goto out_deactivate;

   147

    }

   148

#endif

   149

   150

#if 0

   151

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

   152

    if (ecrt_slave_sdo_write_exp16(slave, 0xBEEF)) {

   153

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

   154

        goto out_deactivate;

   155

    }

   156

#endif

   157

   158

#ifdef ASYNC

   159

    // Einmal senden und warten...

   160

    ecrt_master_prepare_async_io(master);

   161

#endif

   162

   163

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

   164

    init_timer(&timer);

   165

    timer.function = run;

   166

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

   167

    add_timer(&timer);

   168

   169

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

   170

    return 0;

   171

   172

#if 0

   173

 out_deactivate:

   174

    ecrt_master_deactivate(master);

   175

#endif

   176

 out_release_master:

   177

    ecrt_release_master(master);

   178

 out_return:

   179

    return -1;

   180

}

   181

   182

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

   183

   184

void __exit cleanup_mini_module(void)

   185

{

   186

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

   187

   188

    if (master) {

   189

        del_timer_sync(&timer);

   190

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

   191

        ecrt_master_deactivate(master);

   192

        ecrt_release_master(master);

   193

    }

   194

   195

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

   196

}

   197

   198

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

   199

   200

MODULE_LICENSE("GPL");

   201

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

   202

MODULE_DESCRIPTION ("EtherCAT minimal test environment");

   203

   204

module_init(init_mini_module);

   205

module_exit(cleanup_mini_module);

   206

   207

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

   208

   209

/* Emacs-Konfiguration

   210

;;; Local Variables: ***

   211

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

   212

;;; End: ***

   213

*/