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

 *  ---

    24

 *  

    25

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

    26

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

    27

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    28

 *

    29

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

    30

    31

#include <stdlib.h>

    32

#include <sys/ioctl.h>

    33

#include <stdio.h>

    34

#include <errno.h>

    35

#include <string.h>

    36

#include <sys/mman.h>

    37

    38

#include "master.h"

    39

#include "domain.h"

    40

#include "slave_config.h"

    41

#include "master/ioctl.h"

    42

    43

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

    44

    45

ec_domain_t *ecrt_master_create_domain(ec_master_t *master)

    46

{

    47

    ec_domain_t *domain;

    48

    int index;

    49

    50

    domain = malloc(sizeof(ec_domain_t));

    51

    if (!domain) {

    52

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

    53

        return 0;

    54

    }

    55

    56

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

    57

    if (index == -1) {

    58

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

    59

        free(domain);

    60

        return 0; 

    61

    }

    62

    63

    domain->index = (unsigned int) index;

    64

    domain->master = master;

    65

    domain->process_data = NULL;

    66

    return domain;

    67

}

    68

    69

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

    70

    71

ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,

    72

        uint16_t alias, uint16_t position, uint32_t vendor_id,

    73

        uint32_t product_code)

    74

{

    75

    ec_ioctl_config_t data;

    76

    ec_slave_config_t *sc;

    77

    int index;

    78

    79

    sc = malloc(sizeof(ec_slave_config_t));

    80

    if (!sc) {

    81

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

    82

        return 0;

    83

    }

    84

    85

    data.alias = alias;

    86

    data.position = position;

    87

    data.vendor_id = vendor_id;

    88

    data.product_code = product_code;

    89

    90

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

    91

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

    92

                strerror(errno));

    93

        free(sc);

    94

        return 0; 

    95

    }

    96

    97

    sc->master = master;

    98

    sc->index = data.config_index;

    99

    sc->alias = alias;

   100

    sc->position = position;

   101

    return sc;

   102

}

   103

   104

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

   105

   106

int ecrt_master_slave(ec_master_t *master, uint16_t position,

   107

        ec_slave_info_t *slave_info)

   108

{

   109

    ec_ioctl_slave_t data;

   110

    int index;

   111

   112

    data.position = position;

   113

   114

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

   115

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

   116

                strerror(errno));

   117

        return -1;

   118

    }

   119

   120

    slave_info->position = data.position;

   121

    slave_info->vendor_id = data.vendor_id;

   122

    slave_info->product_code = data.product_code;

   123

    slave_info->revision_number = data.revision_number;

   124

    slave_info->serial_number = data.serial_number;

   125

    slave_info->alias = data.alias;

   126

    slave_info->current_on_ebus = data.current_on_ebus;

   127

    slave_info->al_state = data.al_state;

   128

    slave_info->error_flag = data.error_flag;

   129

    slave_info->sync_count = data.sync_count;

   130

    slave_info->sdo_count = data.sdo_count;

   131

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

   132

   133

    return 0;

   134

}

   135

   136

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

   137

   138

int ecrt_master_activate(ec_master_t *master)

   139

{

   140

    if (ioctl(master->fd, EC_IOCTL_ACTIVATE,

   141

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

   142

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

   143

                strerror(errno));

   144

        return -1; // FIXME

   145

    }

   146

   147

    if (master->process_data_size) {

   148

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

   149

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

   150

        if (master->process_data == MAP_FAILED) {

   151

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

   152

            master->process_data = NULL;

   153

            master->process_data_size = 0;

   154

            return -1; // FIXME

   155

        }

   156

   157

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

   158

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

   159

    }

   160

   161

    return 0;

   162

}

   163

   164

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

   165

   166

void ecrt_master_send(ec_master_t *master)

   167

{

   168

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

   169

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

   170

    }

   171

}

   172

   173

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

   174

   175

void ecrt_master_receive(ec_master_t *master)

   176

{

   177

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

   178

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

   179

    }

   180

}

   181

   182

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

   183

   184

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

   185

{

   186

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

   187

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

   188

    }

   189

}

   190

   191

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

   192

   193

void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)

   194

{

   195

    ec_ioctl_app_time_t data;

   196

   197

    data.app_time = app_time;

   198

   199

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

   200

        fprintf(stderr, "Failed to set application time: %s\n",

   201

                strerror(errno));

   202

    }

   203

}

   204

   205

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

   206

   207

void ecrt_master_sync_reference_clock(ec_master_t *master)

   208

{

   209

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

   210

        fprintf(stderr, "Failed to sync reference clock: %s\n",

   211

                strerror(errno));

   212

    }

   213

}

   214

   215

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

   216

   217

void ecrt_master_sync_slave_clocks(ec_master_t *master)

   218

{

   219

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

   220

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

   221

    }

   222

}

   223

   224

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

   225

   226

int ecrt_slave_sdo_download(ec_master_t* master, uint16_t slave_position,

   227

        uint16_t index, uint8_t subindex, uint8_t *data,

   228

        size_t data_size, uint32_t *abort_code)

   229

{

   230

    ec_ioctl_slave_sdo_download_t download;

   231

   232

    download.slave_position = slave_position;

   233

    download.sdo_index = index;

   234

    download.sdo_entry_subindex = subindex;

   235

    download.data_size = data_size;

   236

    download.data = data;

   237

   238

    if (ioctl(master->fd, EC_IOCTL_SLAVE_SDO_DOWNLOAD, &download) == -1) {

   239

        if (errno == -EIO) {

   240

            if (abort_code) {

   241

                *abort_code = download.abort_code;

   242

            }

   243

        }

   244

        fprintf(stderr, "Failed to execute SDO download: %s\n",

   245

            strerror(errno));

   246

        return -1;

   247

    }

   248

   249

    return 0;

   250

}

   251

   252

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

   253

   254

int ecrt_slave_sdo_upload(ec_master_t* master, uint16_t slave_position,

   255

        uint16_t index, uint8_t subindex, uint8_t *target,

   256

        size_t target_size, size_t *result_size, uint32_t *abort_code)

   257

{

   258

    ec_ioctl_slave_sdo_upload_t upload;

   259

   260

    upload.slave_position = slave_position;

   261

    upload.sdo_index = index;

   262

    upload.sdo_entry_subindex = subindex;

   263

    upload.target_size = target_size;

   264

    upload.target = target;

   265

   266

    if (ioctl(master->fd, EC_IOCTL_SLAVE_SDO_UPLOAD, &upload) == -1) {

   267

        if (errno == -EIO) {

   268

            if (abort_code) {

   269

                *abort_code = upload.abort_code;

   270

            }

   271

        }

   272

        fprintf(stderr, "Failed to execute SDO upload: %s\n",

   273

                strerror(errno));

   274

        return -1;

   275

    }

   276

   277

    *result_size = upload.data_size;

   278

    return 0;

   279

}

   280

   281

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