1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

#include <linux/version.h>

    31

#include <linux/module.h>

    32

#include <linux/timer.h>

    33

#include <linux/interrupt.h>

    34

#include <linux/err.h>

    35

    36

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)

    37

#include <linux/semaphore.h>

    38

#else

    39

#include <asm/semaphore.h>

    40

#endif

    41

    42

#include "../../include/ecrt.h" // EtherCAT realtime interface

    43

    44

#include "serial.h"

    45

    46

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

    47

    48

// Module parameters

    49

#define FREQUENCY 100

    50

    51

// Optional features

    52

    53

#define PFX "ec_tty_example: "

    54

    55

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

    56

    57

// EtherCAT

    58

static ec_master_t *master = NULL;

    59

static ec_master_state_t master_state = {};

    60

struct semaphore master_sem;

    61

    62

static ec_domain_t *domain1 = NULL;

    63

static ec_domain_state_t domain1_state = {};

    64

    65

// Timer

    66

static struct timer_list timer;

    67

    68

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

    69

    70

// process data

    71

static uint8_t *domain1_pd; // process data memory

    72

    73

#define BusCouplerPos  0, 0

    74

    75

#define Beckhoff_EK1100 0x00000002, 0x044c2c52

    76

    77

static unsigned int counter = 0;

    78

    79

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

    80

    81

void check_domain1_state(void)

    82

{

    83

    ec_domain_state_t ds;

    84

    85

    down(&master_sem);

    86

    ecrt_domain_state(domain1, &ds);

    87

    up(&master_sem);

    88

    89

    if (ds.working_counter != domain1_state.working_counter)

    90

        printk(KERN_INFO PFX "Domain1: WC %u.\n", ds.working_counter);

    91

    if (ds.wc_state != domain1_state.wc_state)

    92

        printk(KERN_INFO PFX "Domain1: State %u.\n", ds.wc_state);

    93

    94

    domain1_state = ds;

    95

}

    96

    97

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

    98

    99

void check_master_state(void)

   100

{

   101

    ec_master_state_t ms;

   102

   103

    down(&master_sem);

   104

    ecrt_master_state(master, &ms);

   105

    up(&master_sem);

   106

   107

    if (ms.slaves_responding != master_state.slaves_responding)

   108

        printk(KERN_INFO PFX "%u slave(s).\n", ms.slaves_responding);

   109

    if (ms.al_states != master_state.al_states)

   110

        printk(KERN_INFO PFX "AL states: 0x%02X.\n", ms.al_states);

   111

    if (ms.link_up != master_state.link_up)

   112

        printk(KERN_INFO PFX "Link is %s.\n", ms.link_up ? "up" : "down");

   113

   114

    master_state = ms;

   115

}

   116

   117

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

   118

   119

void cyclic_task(unsigned long data)

   120

{

   121

    // receive process data

   122

    down(&master_sem);

   123

    ecrt_master_receive(master);

   124

    ecrt_domain_process(domain1);

   125

    up(&master_sem);

   126

   127

    // check process data state (optional)

   128

    check_domain1_state();

   129

   130

    if (counter) {

   131

        counter--;

   132

    } else { // do this at 1 Hz

   133

        counter = FREQUENCY;

   134

   135

        // check for master state (optional)

   136

        check_master_state();

   137

    }

   138

   139

    run_serial_devices(domain1_pd);

   140

   141

    // send process data

   142

    down(&master_sem);

   143

    ecrt_domain_queue(domain1);

   144

    up(&master_sem);

   145

    ecrt_master_send(master);

   146

   147

    // restart timer

   148

    timer.expires += HZ / FREQUENCY;

   149

    add_timer(&timer);

   150

}

   151

   152

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

   153

   154

void request_lock_callback(void *cb_data)

   155

{

   156

    ec_master_t *m = (ec_master_t *) cb_data;

   157

    down(&master_sem);

   158

}

   159

   160

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

   161

   162

void release_lock_callback(void *cb_data)

   163

{

   164

    ec_master_t *m = (ec_master_t *) cb_data;

   165

    up(&master_sem);

   166

}

   167

   168

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

   169

   170

int __init init_mini_module(void)

   171

{

   172

    int ret = -1;

   173

    ec_slave_config_t *sc;

   174

   175

    printk(KERN_INFO PFX "Starting...\n");

   176

   177

    master = ecrt_request_master(0);

   178

    if (!master) {

   179

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

   180

        ret = -EBUSY; 

   181

        goto out_return;

   182

    }

   183

   184

    sema_init(&master_sem, 1);

   185

    ecrt_master_callbacks(master, request_lock_callback, release_lock_callback, master);

   186

   187

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

   188

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

   189

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

   190

        goto out_release_master;

   191

    }

   192

   193

    // Create configuration for bus coupler

   194

    sc = ecrt_master_slave_config(master, BusCouplerPos, Beckhoff_EK1100);

   195

    if (!sc) {

   196

        printk(KERN_ERR PFX "Failed to create slave config.\n");

   197

        ret = -ENOMEM;

   198

        goto out_release_master;

   199

    }

   200

   201

    create_serial_devices(master, domain1);

   202

   203

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

   204

    if (ecrt_master_activate(master)) {

   205

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

   206

        goto out_free_serial;

   207

    }

   208

   209

    // Get internal process data for domain

   210

    domain1_pd = ecrt_domain_data(domain1);

   211

   212

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

   213

    init_timer(&timer);

   214

    timer.function = cyclic_task;

   215

    timer.expires = jiffies + 10;

   216

    add_timer(&timer);

   217

   218

    printk(KERN_INFO PFX "Started.\n");

   219

    return 0;

   220

   221

out_free_serial:

   222

    free_serial_devices();

   223

out_release_master:

   224

    printk(KERN_ERR PFX "Releasing master...\n");

   225

    ecrt_release_master(master);

   226

out_return:

   227

    printk(KERN_ERR PFX "Failed to load. Aborting.\n");

   228

    return ret;

   229

}

   230

   231

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

   232

   233

void __exit cleanup_mini_module(void)

   234

{

   235

    printk(KERN_INFO PFX "Stopping...\n");

   236

   237

    del_timer_sync(&timer);

   238

   239

    free_serial_devices();

   240

   241

    printk(KERN_INFO PFX "Releasing master...\n");

   242

    ecrt_release_master(master);

   243

   244

    printk(KERN_INFO PFX "Unloading.\n");

   245

}

   246

   247

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

   248

   249

MODULE_LICENSE("GPL");

   250

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

   251

MODULE_DESCRIPTION("EtherCAT minimal test environment");

   252

   253

module_init(init_mini_module);

   254

module_exit(cleanup_mini_module);

   255

   256

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