1

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

     2

 *  

     3

 *  $Id$

     4

 *  

     5

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

     6

 *  

     7

 *  This file is part of the IgH EtherCAT master userspace library.

     8

 *  

     9

 *  The IgH EtherCAT master userspace library is free software; you can

    10

 *  redistribute it and/or modify it under the terms of the GNU Lesser General

    11

 *  Public License as published by the Free Software Foundation; version 2.1

    12

 *  of the License.

    13

 *

    14

 *  The IgH EtherCAT master userspace library is distributed in the hope that

    15

 *  it will be useful, but WITHOUT ANY WARRANTY; without even the implied

    16

 *  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU Lesser General Public License for more details.

    18

 *

    19

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

    20

 *  along with the IgH EtherCAT master userspace library. If not, see

    21

 *  <http://www.gnu.org/licenses/>.

    22

 *  

    23

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

    24

 *  the industrial property and similar rights of Beckhoff Automation GmbH.

    25

 *

    26

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

    27

    28

#include <stdlib.h>

    29

#include <sys/ioctl.h>

    30

#include <stdio.h>

    31

#include <errno.h>

    32

#include <string.h>

    33

#include <sys/mman.h>

    34

    35

#include "master.h"

    36

#include "domain.h"

    37

#include "slave_config.h"

    38

#include "master/ioctl.h"

    39

    40

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

    41

    42

ec_domain_t *ecrt_master_create_domain(ec_master_t *master)

    43

{

    44

    ec_domain_t *domain;

    45

    int index;

    46

    47

    domain = malloc(sizeof(ec_domain_t));

    48

    if (!domain) {

    49

        fprintf(stderr, "Failed to allocate memory.\n");

    50

        return 0;

    51

    }

    52

    53

    index = ioctl(master->fd, EC_IOCTL_CREATE_DOMAIN, NULL);

    54

    if (index == -1) {

    55

        fprintf(stderr, "Failed to create domain: %s\n", strerror(errno));

    56

        free(domain);

    57

        return 0; 

    58

    }

    59

    60

    domain->index = (unsigned int) index;

    61

    domain->master = master;

    62

    domain->process_data = NULL;

    63

    return domain;

    64

}

    65

    66

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

    67

    68

ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,

    69

        uint16_t alias, uint16_t position, uint32_t vendor_id,

    70

        uint32_t product_code)

    71

{

    72

    ec_ioctl_config_t data;

    73

    ec_slave_config_t *sc;

    74

    int index;

    75

    76

    sc = malloc(sizeof(ec_slave_config_t));

    77

    if (!sc) {

    78

        fprintf(stderr, "Failed to allocate memory.\n");

    79

        return 0;

    80

    }

    81

    82

    data.alias = alias;

    83

    data.position = position;

    84

    data.vendor_id = vendor_id;

    85

    data.product_code = product_code;

    86

    87

    if (ioctl(master->fd, EC_IOCTL_CREATE_SLAVE_CONFIG, &data) == -1) {

    88

        fprintf(stderr, "Failed to create slave config: %s\n",

    89

                strerror(errno));

    90

        free(sc);

    91

        return 0; 

    92

    }

    93

    94

    sc->master = master;

    95

    sc->index = data.config_index;

    96

    sc->alias = alias;

    97

    sc->position = position;

    98

    return sc;

    99

}

   100

   101

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

   102

   103

int ecrt_master_slave(ec_master_t *master, uint16_t position,

   104

        ec_slave_info_t *slave_info)

   105

{

   106

    ec_ioctl_slave_t data;

   107

    int index;

   108

   109

    data.position = position;

   110

   111

    if (ioctl(master->fd, EC_IOCTL_SLAVE, &data) == -1) {

   112

        fprintf(stderr, "Failed to get slave info: %s\n",

   113

                strerror(errno));

   114

        return -1;

   115

    }

   116

   117

    slave_info->position = data.position;

   118

    slave_info->vendor_id = data.vendor_id;

   119

    slave_info->product_code = data.product_code;

   120

    slave_info->revision_number = data.revision_number;

   121

    slave_info->serial_number = data.serial_number;

   122

    slave_info->alias = data.alias;

   123

    slave_info->current_on_ebus = data.current_on_ebus;

   124

    slave_info->al_state = data.al_state;

   125

    slave_info->error_flag = data.error_flag;

   126

    slave_info->sync_count = data.sync_count;

   127

    slave_info->sdo_count = data.sdo_count;

   128

    strncpy(slave_info->name, data.name, EC_IOCTL_STRING_SIZE);

   129

   130

    return 0;

   131

}

   132

   133

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

   134

   135

int ecrt_master_activate(ec_master_t *master)

   136

{

   137

    if (ioctl(master->fd, EC_IOCTL_ACTIVATE,

   138

                &master->process_data_size) == -1) {

   139

        fprintf(stderr, "Failed to activate master: %s\n",

   140

                strerror(errno));

   141

        return -1; // FIXME

   142

    }

   143

   144

    if (master->process_data_size) {

   145

        master->process_data = mmap(0, master->process_data_size,

   146

                PROT_READ | PROT_WRITE, MAP_SHARED, master->fd, 0);

   147

        if (master->process_data == MAP_FAILED) {

   148

            fprintf(stderr, "Failed to map process data: %s", strerror(errno));

   149

            master->process_data = NULL;

   150

            master->process_data_size = 0;

   151

            return -1; // FIXME

   152

        }

   153

   154

        // Access the mapped region to cause the initial page fault

   155

        printf("pd: %x\n", master->process_data[0]);

   156

    }

   157

   158

    return 0;

   159

}

   160

   161

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

   162

   163

void ecrt_master_send(ec_master_t *master)

   164

{

   165

    if (ioctl(master->fd, EC_IOCTL_SEND, NULL) == -1) {

   166

        fprintf(stderr, "Failed to send: %s\n", strerror(errno));

   167

    }

   168

}

   169

   170

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

   171

   172

void ecrt_master_receive(ec_master_t *master)

   173

{

   174

    if (ioctl(master->fd, EC_IOCTL_RECEIVE, NULL) == -1) {

   175

        fprintf(stderr, "Failed to receive: %s\n", strerror(errno));

   176

    }

   177

}

   178

   179

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

   180

   181

void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)

   182

{

   183

    if (ioctl(master->fd, EC_IOCTL_MASTER_STATE, state) == -1) {

   184

        fprintf(stderr, "Failed to get master state: %s\n", strerror(errno));

   185

    }

   186

}

   187

   188

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