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

    ecrt_master_send(master);

   145

    up(&master_sem);

   146

   147

    // restart timer

   148

    timer.expires += HZ / FREQUENCY;

   149

    add_timer(&timer);

   150

}

   151

   152

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

   153

   154

void send_callback(void *cb_data)

   155

{

   156

    ec_master_t *m = (ec_master_t *) cb_data;

   157

    down(&master_sem);

   158

    ecrt_master_send_ext(m);

   159

    up(&master_sem);

   160

}

   161

   162

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

   163

   164

void receive_callback(void *cb_data)

   165

{

   166

    ec_master_t *m = (ec_master_t *) cb_data;

   167

    down(&master_sem);

   168

    ecrt_master_receive(m);

   169

    up(&master_sem);

   170

}

   171

   172

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

   173

   174

int __init init_mini_module(void)

   175

{

   176

    int ret = -1;

   177

    ec_slave_config_t *sc;

   178

   179

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

   180

   181

    master = ecrt_request_master(0);

   182

    if (!master) {

   183

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

   184

        ret = -EBUSY;

   185

        goto out_return;

   186

    }

   187

   188

    sema_init(&master_sem, 1);

   189

    ecrt_master_callbacks(master, send_callback, receive_callback, master);

   190

   191

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

   192

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

   193

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

   194

        goto out_release_master;

   195

    }

   196

   197

    // Create configuration for bus coupler

   198

    sc = ecrt_master_slave_config(master, BusCouplerPos, Beckhoff_EK1100);

   199

    if (!sc) {

   200

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

   201

        ret = -ENOMEM;

   202

        goto out_release_master;

   203

    }

   204

   205

    create_serial_devices(master, domain1);

   206

   207

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

   208

    if (ecrt_master_activate(master)) {

   209

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

   210

        goto out_free_serial;

   211

    }

   212

   213

    // Get internal process data for domain

   214

    domain1_pd = ecrt_domain_data(domain1);

   215

   216

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

   217

    init_timer(&timer);

   218

    timer.function = cyclic_task;

   219

    timer.expires = jiffies + 10;

   220

    add_timer(&timer);

   221

   222

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

   223

    return 0;

   224

   225

out_free_serial:

   226

    free_serial_devices();

   227

out_release_master:

   228

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

   229

    ecrt_release_master(master);

   230

out_return:

   231

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

   232

    return ret;

   233

}

   234

   235

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

   236

   237

void __exit cleanup_mini_module(void)

   238

{

   239

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

   240

   241

    del_timer_sync(&timer);

   242

   243

    free_serial_devices();

   244

   245

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

   246

    ecrt_release_master(master);

   247

   248

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

   249

}

   250

   251

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

   252

   253

MODULE_LICENSE("GPL");

   254

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

   255

MODULE_DESCRIPTION("EtherCAT minimal test environment");

   256

   257

module_init(init_mini_module);

   258

module_exit(cleanup_mini_module);

   259

   260

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