1

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

     2

 *

     3

 *  e c _ c o m m a n d . c

     4

 *

     5

 *  Methoden für ein EtherCAT-Kommando.

     6

 *

     7

 *  $Date$

     8

 *  $Author$

     9

 *

    10

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

    11

    12

#include <linux/slab.h>

    13

    14

#include "ec_command.h"

    15

#include "ec_dbg.h"

    16

    17

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

    18

    19

/**

    20

   Kommando-Konstruktor.

    21

    22

   Initialisiert alle Variablen innerhalb des Kommandos auf die

    23

   Default-Werte.

    24

    25

   @param cmd Zeiger auf das zu initialisierende Kommando.

    26

*/

    27

    28

void EtherCAT_command_init(EtherCAT_command_t *cmd)

    29

{

    30

  cmd->type = ECAT_CMD_NONE;

    31

  cmd->address.logical = 0x00000000;

    32

  cmd->data_length = 0;

    33

  cmd->state = ECAT_CS_READY;

    34

  cmd->index = 0;

    35

  cmd->working_counter = 0;

    36

}

    37

    38

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

    39

    40

/**

    41

   Kommando-Destruktor.

    42

    43

   Setzt alle Attribute auf den Anfangswert zurueck.

    44

    45

   @param cmd Zeiger auf das zu initialisierende Kommando.

    46

*/

    47

    48

void EtherCAT_command_clear(EtherCAT_command_t *cmd)

    49

{

    50

  EtherCAT_command_init(cmd);

    51

}

    52

    53

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

    54

    55

#define ECAT_FUNC_HEADER \

    56

  EtherCAT_command_init(cmd)

    57

    58

#define ECAT_FUNC_WRITE_FOOTER \

    59

  cmd->data_length = length; \

    60

  memcpy(cmd->data, data, length);

    61

    62

#define ECAT_FUNC_READ_FOOTER \

    63

  cmd->data_length = length;

    64

    65

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

    66

    67

/**

    68

   Initialisiert ein EtherCAT-NPRD-Kommando.

    69

    70

   @param cmd Zeiger auf das Kommando

    71

   @param node_address Adresse des Knotens (Slaves)

    72

   @param offset Physikalische Speicheradresse im Slave

    73

   @param length Länge der zu lesenden Daten

    74

*/

    75

    76

void EtherCAT_command_read(EtherCAT_command_t *cmd,

    77

                           unsigned short node_address,

    78

                           unsigned short offset,

    79

                           unsigned int length)

    80

{

    81

  if (node_address == 0x0000)

    82

    EC_DBG(KERN_WARNING "EtherCAT: Using node address 0x0000!\n");

    83

    84

  ECAT_FUNC_HEADER;

    85

    86

  cmd->type = ECAT_CMD_NPRD;

    87

  cmd->address.phy.dev.node = node_address;

    88

  cmd->address.phy.mem = offset;

    89

    90

  ECAT_FUNC_READ_FOOTER;

    91

}

    92

    93

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

    94

    95

/**

    96

   Initialisiert ein EtherCAT-NPWR-Kommando.

    97

    98

   Alloziert ein "node-adressed physical write"-Kommando

    99

   und fügt es in die Liste des Masters ein.

   100

   101

   @param cmd Zeiger auf das Kommando

   102

   @param node_address Adresse des Knotens (Slaves)

   103

   @param offset Physikalische Speicheradresse im Slave

   104

   @param length Länge der zu schreibenden Daten

   105

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   106

*/

   107

   108

void EtherCAT_command_write(EtherCAT_command_t *cmd,

   109

                            unsigned short node_address,

   110

                            unsigned short offset,

   111

                            unsigned int length,

   112

                            const unsigned char *data)

   113

{

   114

  if (node_address == 0x0000)

   115

    EC_DBG(KERN_WARNING "EtherCAT: Using node address 0x0000!\n");

   116

   117

  ECAT_FUNC_HEADER;

   118

   119

  cmd->type = ECAT_CMD_NPWR;

   120

  cmd->address.phy.dev.node = node_address;

   121

  cmd->address.phy.mem = offset;

   122

   123

  ECAT_FUNC_WRITE_FOOTER;

   124

}

   125

   126

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

   127

   128

/**

   129

   Initialisiert ein EtherCAT-APRD-Kommando.

   130

   131

   Alloziert ein "autoincerement physical read"-Kommando

   132

   und fügt es in die Liste des Masters ein.

   133

   134

   @param cmd Zeiger auf das Kommando

   135

   @param ring_position (Negative) Position des Slaves im Bus

   136

   @param offset Physikalische Speicheradresse im Slave

   137

   @param length Länge der zu lesenden Daten

   138

*/

   139

   140

void EtherCAT_command_position_read(EtherCAT_command_t *cmd,

   141

                                    short ring_position,

   142

                                    unsigned short offset,

   143

                                    unsigned int length)

   144

{

   145

  ECAT_FUNC_HEADER;

   146

   147

  cmd->type = ECAT_CMD_APRD;

   148

  cmd->address.phy.dev.pos = ring_position;

   149

  cmd->address.phy.mem = offset;

   150

   151

  ECAT_FUNC_READ_FOOTER;

   152

}

   153

   154

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

   155

   156

/**

   157

   Initialisiert ein EtherCAT-APWR-Kommando.

   158

   159

   Alloziert ein "autoincrement physical write"-Kommando

   160

   und fügt es in die Liste des Masters ein.

   161

   162

   @param cmd Zeiger auf das Kommando

   163

   @param ring_position (Negative) Position des Slaves im Bus

   164

   @param offset Physikalische Speicheradresse im Slave

   165

   @param length Länge der zu schreibenden Daten

   166

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   167

*/

   168

   169

void EtherCAT_command_position_write(EtherCAT_command_t *cmd,

   170

                                     short ring_position,

   171

                                     unsigned short offset,

   172

                                     unsigned int length,

   173

                                     const unsigned char *data)

   174

{

   175

  ECAT_FUNC_HEADER;

   176

   177

  cmd->type = ECAT_CMD_APWR;

   178

  cmd->address.phy.dev.pos = ring_position;

   179

  cmd->address.phy.mem = offset;

   180

   181

  ECAT_FUNC_WRITE_FOOTER;

   182

}

   183

   184

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

   185

   186

/**

   187

   Initialisiert ein EtherCAT-BRD-Kommando.

   188

   189

   Alloziert ein "broadcast read"-Kommando

   190

   und fügt es in die Liste des Masters ein.

   191

   192

   @param cmd Zeiger auf das Kommando

   193

   @param offset Physikalische Speicheradresse im Slave

   194

   @param length Länge der zu lesenden Daten

   195

*/

   196

   197

void EtherCAT_command_broadcast_read(EtherCAT_command_t *cmd,

   198

                                     unsigned short offset,

   199

                                     unsigned int length)

   200

{

   201

  ECAT_FUNC_HEADER;

   202

   203

  cmd->type = ECAT_CMD_BRD;

   204

  cmd->address.phy.dev.node = 0x0000;

   205

  cmd->address.phy.mem = offset;

   206

   207

  ECAT_FUNC_READ_FOOTER;

   208

}

   209

   210

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

   211

   212

/**

   213

   Initialisiert ein EtherCAT-BWR-Kommando.

   214

   215

   Alloziert ein "broadcast write"-Kommando

   216

   und fügt es in die Liste des Masters ein.

   217

   218

   @param cmd Zeiger auf das Kommando

   219

   @param offset Physikalische Speicheradresse im Slave

   220

   @param length Länge der zu schreibenden Daten

   221

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   222

*/

   223

   224

void EtherCAT_command_broadcast_write(EtherCAT_command_t *cmd,

   225

                                      unsigned short offset,

   226

                                      unsigned int length,

   227

                                      const unsigned char *data)

   228

{

   229

  ECAT_FUNC_HEADER;

   230

   231

  cmd->type = ECAT_CMD_BWR;

   232

  cmd->address.phy.dev.node = 0x0000;

   233

  cmd->address.phy.mem = offset;

   234

   235

  ECAT_FUNC_WRITE_FOOTER;

   236

}

   237

   238

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

   239

   240

/**

   241

   Initialisiert ein EtherCAT-LRW-Kommando.

   242

   243

   Alloziert ein "logical read write"-Kommando

   244

   und fügt es in die Liste des Masters ein.

   245

   246

   @param cmd Zeiger auf das Kommando

   247

   @param offset Logische Speicheradresse

   248

   @param length Länge der zu lesenden/schreibenden Daten

   249

   @param data Zeiger auf Speicher mit zu lesenden/schreibenden Daten

   250

*/

   251

   252

void EtherCAT_command_logical_read_write(EtherCAT_command_t *cmd,

   253

                                         unsigned int offset,

   254

                                         unsigned int length,

   255

                                         unsigned char *data)

   256

{

   257

  ECAT_FUNC_HEADER;

   258

   259

  cmd->type = ECAT_CMD_LRW;

   260

  cmd->address.logical = offset;

   261

   262

  ECAT_FUNC_WRITE_FOOTER;

   263

}

   264

   265

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