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

    56

ec_domain_t *ecrt_master_create_domain(ec_master_t *master)

    57

{

    58

    ec_domain_t *domain;

    59

    int index;

    60

    61

    domain = malloc(sizeof(ec_domain_t));

    62

    if (!domain) {

    63

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

    64

        return 0;

    65

    }

    66

    67

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

    68

    if (index == -1) {

    69

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

    70

        free(domain);

    71

        return 0; 

    72

    }

    73

    74

    domain->index = (unsigned int) index;

    75

    domain->master = master;

    76

    domain->process_data = NULL;

    77

    return domain;

    78

}

    79

    80

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

    81

    82

ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,

    83

        uint16_t alias, uint16_t position, uint32_t vendor_id,

    84

        uint32_t product_code)

    85

{

    86

    ec_ioctl_config_t data;

    87

    ec_slave_config_t *sc;

    88

    int index;

    89

    90

    sc = malloc(sizeof(ec_slave_config_t));

    91

    if (!sc) {

    92

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

    93

        return 0;

    94

    }

    95

    96

    data.alias = alias;

    97

    data.position = position;

    98

    data.vendor_id = vendor_id;

    99

    data.product_code = product_code;

   100

   101

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

   102

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

   103

                strerror(errno));

   104

        free(sc);

   105

        return 0; 

   106

    }

   107

   108

    sc->master = master;

   109

    sc->index = data.config_index;

   110

    sc->alias = alias;

   111

    sc->position = position;

   112

    return sc;

   113

}

   114

   134

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

   135

   136

int ecrt_master_slave(ec_master_t *master, uint16_t position,

   137

        ec_slave_info_t *slave_info)

   138

{

   139

    ec_ioctl_slave_t data;

   140

    int index;

   141

   142

    data.position = position;

   143

   144

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

   145

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

   146

                strerror(errno));

   147

        return -1;

   148

    }

   149

   150

    slave_info->position = data.position;

   151

    slave_info->vendor_id = data.vendor_id;

   152

    slave_info->product_code = data.product_code;

   153

    slave_info->revision_number = data.revision_number;

   154

    slave_info->serial_number = data.serial_number;

   155

    slave_info->alias = data.alias;

   156

    slave_info->current_on_ebus = data.current_on_ebus;

   157

    slave_info->al_state = data.al_state;

   158

    slave_info->error_flag = data.error_flag;

   159

    slave_info->sync_count = data.sync_count;

   160

    slave_info->sdo_count = data.sdo_count;

   161

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

   162

   163

    return 0;

   164

}

   165

   166

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

   167

   168

int ecrt_master_activate(ec_master_t *master)

   169

{

   170

    if (ioctl(master->fd, EC_IOCTL_ACTIVATE,

   171

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

   172

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

   173

                strerror(errno));

   174

        return -1; // FIXME

   175

    }

   176

   177

    if (master->process_data_size) {

   178

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

   179

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

   180

        if (master->process_data == MAP_FAILED) {

   181

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

   182

            master->process_data = NULL;

   183

            master->process_data_size = 0;

   184

            return -1; // FIXME

   185

        }

   186

   187

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

   188

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

   189

    }

   190

   191

    return 0;

   192

}

   193

   194

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

   195

   196

void ecrt_master_send(ec_master_t *master)

   197

{

   198

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

   199

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

   200

    }

   201

}

   202

   203

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

   204

   205

void ecrt_master_receive(ec_master_t *master)

   206

{

   207

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

   208

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

   209

    }

   210

}

   211

   212

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

   213

   214

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

   215

{

   216

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

   217

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

   218

    }

   219

}

   220

   221

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

   222

   223

void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)

   224

{

   225

    ec_ioctl_app_time_t data;

   226

   227

    data.app_time = app_time;

   228

   229

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

   230

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

   231

                strerror(errno));

   232

    }

   233

}

   234

   235

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

   236

   237

void ecrt_master_sync_reference_clock(ec_master_t *master)

   238

{

   239

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

   240

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

   241

                strerror(errno));

   242

    }

   243

}

   244

   245

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

   246

   247

void ecrt_master_sync_slave_clocks(ec_master_t *master)

   248

{

   249

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

   250

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

   251

    }

   252

}

   253

   254

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

   255

   256

int ecrt_slave_sdo_download(ec_master_t* master, uint16_t slave_position,

   257

        uint16_t index, uint8_t subindex, uint8_t *data,

   258

        size_t data_size, uint32_t *abort_code)

   259

{

   260

    ec_ioctl_slave_sdo_download_t download;

   261

   262

    download.slave_position = slave_position;

   263

    download.sdo_index = index;

   264

    download.sdo_entry_subindex = subindex;

   265

    download.data_size = data_size;

   266

    download.data = data;

   267

   268

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

   269

        if (errno == -EIO) {

   270

            if (abort_code) {

   271

                *abort_code = download.abort_code;

   272

            }

   273

        }

   274

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

   275

            strerror(errno));

   276

        return -1;

   277

    }

   278

   279

    return 0;

   280

}

   281

   282

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

   283

   284

int ecrt_slave_sdo_upload(ec_master_t* master, uint16_t slave_position,

   285

        uint16_t index, uint8_t subindex, uint8_t *target,

   286

        size_t target_size, size_t *result_size, uint32_t *abort_code)

   287

{

   288

    ec_ioctl_slave_sdo_upload_t upload;

   289

   290

    upload.slave_position = slave_position;

   291

    upload.sdo_index = index;

   292

    upload.sdo_entry_subindex = subindex;

   293

    upload.target_size = target_size;

   294

    upload.target = target;

   295

   296

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

   297

        if (errno == -EIO) {

   298

            if (abort_code) {

   299

                *abort_code = upload.abort_code;

   300

            }

   301

        }

   302

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

   303

                strerror(errno));

   304

        return -1;

   305

    }

   306

   307

    *result_size = upload.data_size;

   308

    return 0;

   309

}

   310

   311

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