1

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

     2

 *

     3

 *  c o m m a n d . c

     4

 *

     5

 *  Methoden für ein EtherCAT-Kommando.

     6

 *

     7

 *  $Id$

     8

 *

     9

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

    10

    11

#include <linux/slab.h>

    12

#include <linux/delay.h>

    13

    14

#include "command.h"

    15

#include "master.h"

    16

    17

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

    18

    19

#define EC_FUNC_HEADER \

    20

    command->index = 0; \

    21

    command->working_counter = 0; \

    22

    command->state = EC_CMD_INIT;

    23

    24

#define EC_FUNC_WRITE_FOOTER \

    25

    command->data_size = data_size; \

    26

    memcpy(command->data, data, data_size);

    27

    28

#define EC_FUNC_READ_FOOTER \

    29

    command->data_size = data_size; \

    30

    memset(command->data, 0x00, data_size);

    31

    32

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

    33

    34

/**

    35

   Initialisiert ein EtherCAT-NPRD-Kommando.

    36

    37

   Node-adressed physical read.

    38

*/

    39

    40

void ec_command_init_nprd(ec_command_t *command,

    41

                          /**< EtherCAT-Rahmen */

    42

                          uint16_t node_address,

    43

                          /**< Adresse des Knotens (Slaves) */

    44

                          uint16_t offset,

    45

                          /**< Physikalische Speicheradresse im Slave */

    46

                          size_t data_size

    47

                          /**< Länge der zu lesenden Daten */

    48

                          )

    49

{

    50

    if (unlikely(node_address == 0x0000))

    51

        EC_WARN("Using node address 0x0000!\n");

    52

    53

    EC_FUNC_HEADER;

    54

    55

    command->type = EC_CMD_NPRD;

    56

    command->address.physical.slave = node_address;

    57

    command->address.physical.mem = offset;

    58

    59

    EC_FUNC_READ_FOOTER;

    60

}

    61

    62

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

    63

    64

/**

    65

   Initialisiert ein EtherCAT-NPWR-Kommando.

    66

    67

   Node-adressed physical write.

    68

*/

    69

    70

void ec_command_init_npwr(ec_command_t *command,

    71

                          /**< EtherCAT-Rahmen */

    72

                          uint16_t node_address,

    73

                          /**< Adresse des Knotens (Slaves) */

    74

                          uint16_t offset,

    75

                          /**< Physikalische Speicheradresse im Slave */

    76

                          size_t data_size,

    77

                          /**< Länge der zu schreibenden Daten */

    78

                          const uint8_t *data

    79

                          /**< Zeiger auf Speicher mit zu schreibenden Daten */

    80

                          )

    81

{

    82

    if (unlikely(node_address == 0x0000))

    83

        EC_WARN("Using node address 0x0000!\n");

    84

    85

    EC_FUNC_HEADER;

    86

    87

    command->type = EC_CMD_NPWR;

    88

    command->address.physical.slave = node_address;

    89

    command->address.physical.mem = offset;

    90

    91

    EC_FUNC_WRITE_FOOTER;

    92

}

    93

    94

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

    95

    96

/**

    97

   Initialisiert ein EtherCAT-APRD-Kommando.

    98

    99

   Autoincrement physical read.

   100

*/

   101

   102

void ec_command_init_aprd(ec_command_t *command,

   103

                          /**< EtherCAT-Rahmen */

   104

                          uint16_t ring_position,

   105

                          /**< Position des Slaves im Bus */

   106

                          uint16_t offset,

   107

                          /**< Physikalische Speicheradresse im Slave */

   108

                          size_t data_size

   109

                          /**< Länge der zu lesenden Daten */

   110

                          )

   111

{

   112

    EC_FUNC_HEADER;

   113

   114

    command->type = EC_CMD_APRD;

   115

    command->address.physical.slave = (int16_t) ring_position * (-1);

   116

    command->address.physical.mem = offset;

   117

   118

    EC_FUNC_READ_FOOTER;

   119

}

   120

   121

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

   122

   123

/**

   124

   Initialisiert ein EtherCAT-APWR-Kommando.

   125

   126

   Autoincrement physical write.

   127

*/

   128

   129

void ec_command_init_apwr(ec_command_t *command,

   130

                          /**< EtherCAT-Rahmen */

   131

                          uint16_t ring_position,

   132

                          /**< Position des Slaves im Bus */

   133

                          uint16_t offset,

   134

                          /**< Physikalische Speicheradresse im Slave */

   135

                          size_t data_size,

   136

                          /**< Länge der zu schreibenden Daten */

   137

                          const uint8_t *data

   138

                          /**< Zeiger auf Speicher mit zu schreibenden Daten */

   139

                          )

   140

{

   141

    EC_FUNC_HEADER;

   142

   143

    command->type = EC_CMD_APWR;

   144

    command->address.physical.slave = (int16_t) ring_position * (-1);

   145

    command->address.physical.mem = offset;

   146

   147

    EC_FUNC_WRITE_FOOTER;

   148

}

   149

   150

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

   151

   152

/**

   153

   Initialisiert ein EtherCAT-BRD-Kommando.

   154

   155

   Broadcast read.

   156

*/

   157

   158

void ec_command_init_brd(ec_command_t *command,

   159

                         /**< EtherCAT-Rahmen */

   160

                         uint16_t offset,

   161

                         /**< Physikalische Speicheradresse im Slave */

   162

                         size_t data_size

   163

                         /**< Länge der zu lesenden Daten */

   164

                         )

   165

{

   166

    EC_FUNC_HEADER;

   167

   168

    command->type = EC_CMD_BRD;

   169

    command->address.physical.slave = 0x0000;

   170

    command->address.physical.mem = offset;

   171

   172

    EC_FUNC_READ_FOOTER;

   173

}

   174

   175

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

   176

   177

/**

   178

   Initialisiert ein EtherCAT-BWR-Kommando.

   179

   180

   Broadcast write.

   181

*/

   182

   183

void ec_command_init_bwr(ec_command_t *command,

   184

                         /**< EtherCAT-Rahmen */

   185

                         uint16_t offset,

   186

                         /**< Physikalische Speicheradresse im Slave */

   187

                         size_t data_size,

   188

                         /**< Länge der zu schreibenden Daten */

   189

                         const uint8_t *data

   190

                         /**< Zeiger auf Speicher mit zu schreibenden Daten */

   191

                         )

   192

{

   193

    EC_FUNC_HEADER;

   194

   195

    command->type = EC_CMD_BWR;

   196

    command->address.physical.slave = 0x0000;

   197

    command->address.physical.mem = offset;

   198

   199

    EC_FUNC_WRITE_FOOTER;

   200

}

   201

   202

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

   203

   204

/**

   205

   Initialisiert ein EtherCAT-LRW-Kommando.

   206

   207

   Logical read write.

   208

*/

   209

   210

void ec_command_init_lrw(ec_command_t *command,

   211

                         /**< EtherCAT-Rahmen */

   212

                         uint32_t offset,

   213

                         /**< Logische Startadresse */

   214

                         size_t data_size,

   215

                         /**< Länge der zu lesenden/schreibenden Daten */

   216

                         uint8_t *data

   217

                         /**< Zeiger auf die Daten */

   218

                         )

   219

{

   220

    EC_FUNC_HEADER;

   221

   222

    command->type = EC_CMD_LRW;

   223

    command->address.logical = offset;

   224

   225

    EC_FUNC_WRITE_FOOTER;

   226

}

   227

   228

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

   229

   230

/* Emacs-Konfiguration

   231

;;; Local Variables: ***

   232

;;; c-basic-offset:4 ***

   233

;;; End: ***

   234

*/