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

    16

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

    17

    18

/**

    19

   Kommando-Konstruktor.

    20

    21

   Initialisiert alle Variablen innerhalb des Kommandos auf die

    22

   Default-Werte.

    23

    24

   @param cmd Zeiger auf das zu initialisierende Kommando.

    25

*/

    26

    27

void EtherCAT_command_init(EtherCAT_command_t *cmd)

    28

{

    29

  cmd->type = ECAT_CMD_NONE;

    30

  cmd->address.logical = 0x00000000;

    31

  cmd->data_length = 0;

    32

  cmd->state = ECAT_CS_READY;

    33

  cmd->index = 0;

    34

  cmd->working_counter = 0;

    35

}

    36

    37

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

    38

    39

/**

    40

   Kommando-Destruktor.

    41

    42

   Setzt alle Attribute auf den Anfangswert zurueck.

    43

    44

   @param cmd Zeiger auf das zu initialisierende Kommando.

    45

*/

    46

    47

void EtherCAT_command_clear(EtherCAT_command_t *cmd)

    48

{

    49

  EtherCAT_command_init(cmd);

    50

}

    51

    52

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

    53

    54

#define ECAT_FUNC_HEADER \

    55

  EtherCAT_command_init(cmd)

    56

    57

#define ECAT_FUNC_WRITE_FOOTER \

    58

  cmd->data_length = length; \

    59

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

    60

    61

#define ECAT_FUNC_READ_FOOTER \

    62

  cmd->data_length = length;

    63

    64

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

    65

    66

/**

    67

   Initialisiert ein EtherCAT-NPRD-Kommando.

    68

    69

   @param cmd Zeiger auf das Kommando

    70

   @param node_address Adresse des Knotens (Slaves)

    71

   @param offset Physikalische Speicheradresse im Slave

    72

   @param length Länge der zu lesenden Daten

    73

*/

    74

    75

void EtherCAT_command_read(EtherCAT_command_t *cmd,

    76

                           unsigned short node_address,

    77

                           unsigned short offset,

    78

                           unsigned int length)

    79

{

    80

  if (node_address == 0x0000)

    81

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

    82

    83

  ECAT_FUNC_HEADER;

    84

    85

  cmd->type = ECAT_CMD_NPRD;

    86

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

    87

  cmd->address.phy.mem = offset;

    88

    89

  ECAT_FUNC_READ_FOOTER;

    90

}

    91

    92

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

    93

    94

/**

    95

   Initialisiert ein EtherCAT-NPWR-Kommando.

    96

    97

   Alloziert ein "node-adressed physical write"-Kommando

    98

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

    99

   100

   @param cmd Zeiger auf das Kommando

   101

   @param node_address Adresse des Knotens (Slaves)

   102

   @param offset Physikalische Speicheradresse im Slave

   103

   @param length Länge der zu schreibenden Daten

   104

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   105

*/

   106

   107

void EtherCAT_command_write(EtherCAT_command_t *cmd,

   108

                            unsigned short node_address,

   109

                            unsigned short offset,

   110

                            unsigned int length,

   111

                            const unsigned char *data)

   112

{

   113

  if (node_address == 0x0000)

   114

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

   115

   116

  ECAT_FUNC_HEADER;

   117

   118

  cmd->type = ECAT_CMD_NPWR;

   119

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

   120

  cmd->address.phy.mem = offset;

   121

   122

  ECAT_FUNC_WRITE_FOOTER;

   123

}

   124

   125

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

   126

   127

/**

   128

   Initialisiert ein EtherCAT-APRD-Kommando.

   129

   130

   Alloziert ein "autoincerement physical read"-Kommando

   131

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

   132

   133

   @param cmd Zeiger auf das Kommando

   134

   @param ring_position (Negative) Position des Slaves im Bus

   135

   @param offset Physikalische Speicheradresse im Slave

   136

   @param length Länge der zu lesenden Daten

   137

*/

   138

   139

void EtherCAT_command_position_read(EtherCAT_command_t *cmd,

   140

                                    short ring_position,

   141

                                    unsigned short offset,

   142

                                    unsigned int length)

   143

{

   144

  ECAT_FUNC_HEADER;

   145

   146

  cmd->type = ECAT_CMD_APRD;

   147

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

   148

  cmd->address.phy.mem = offset;

   149

   150

  ECAT_FUNC_READ_FOOTER;

   151

}

   152

   153

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

   154

   155

/**

   156

   Initialisiert ein EtherCAT-APWR-Kommando.

   157

   158

   Alloziert ein "autoincrement physical write"-Kommando

   159

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

   160

   161

   @param cmd Zeiger auf das Kommando

   162

   @param ring_position (Negative) Position des Slaves im Bus

   163

   @param offset Physikalische Speicheradresse im Slave

   164

   @param length Länge der zu schreibenden Daten

   165

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   166

*/

   167

   168

void EtherCAT_command_position_write(EtherCAT_command_t *cmd,

   169

                                     short ring_position,

   170

                                     unsigned short offset,

   171

                                     unsigned int length,

   172

                                     const unsigned char *data)

   173

{

   174

  ECAT_FUNC_HEADER;

   175

   176

  cmd->type = ECAT_CMD_APWR;

   177

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

   178

  cmd->address.phy.mem = offset;

   179

   180

  ECAT_FUNC_WRITE_FOOTER;

   181

}

   182

   183

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

   184

   185

/**

   186

   Initialisiert ein EtherCAT-BRD-Kommando.

   187

   188

   Alloziert ein "broadcast read"-Kommando

   189

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

   190

   191

   @param cmd Zeiger auf das Kommando

   192

   @param offset Physikalische Speicheradresse im Slave

   193

   @param length Länge der zu lesenden Daten

   194

*/

   195

   196

void EtherCAT_command_broadcast_read(EtherCAT_command_t *cmd,

   197

                                     unsigned short offset,

   198

                                     unsigned int length)

   199

{

   200

  ECAT_FUNC_HEADER;

   201

   202

  cmd->type = ECAT_CMD_BRD;

   203

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

   204

  cmd->address.phy.mem = offset;

   205

   206

  ECAT_FUNC_READ_FOOTER;

   207

}

   208

   209

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

   210

   211

/**

   212

   Initialisiert ein EtherCAT-BWR-Kommando.

   213

   214

   Alloziert ein "broadcast write"-Kommando

   215

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

   216

   217

   @param cmd Zeiger auf das Kommando

   218

   @param offset Physikalische Speicheradresse im Slave

   219

   @param length Länge der zu schreibenden Daten

   220

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   221

*/

   222

   223

void EtherCAT_command_broadcast_write(EtherCAT_command_t *cmd,

   224

                                      unsigned short offset,

   225

                                      unsigned int length,

   226

                                      const unsigned char *data)

   227

{

   228

  ECAT_FUNC_HEADER;

   229

   230

  cmd->type = ECAT_CMD_BWR;

   231

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

   232

  cmd->address.phy.mem = offset;

   233

   234

  ECAT_FUNC_WRITE_FOOTER;

   235

}

   236

   237

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

   238

   239

/**

   240

   Initialisiert ein EtherCAT-LRW-Kommando.

   241

   242

   Alloziert ein "logical read write"-Kommando

   243

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

   244

   245

   @param cmd Zeiger auf das Kommando

   246

   @param offset Logische Speicheradresse

   247

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

   248

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

   249

*/

   250

   251

void EtherCAT_command_logical_read_write(EtherCAT_command_t *cmd,

   252

                                         unsigned int offset,

   253

                                         unsigned int length,

   254

                                         unsigned char *data)

   255

{

   256

  ECAT_FUNC_HEADER;

   257

   258

  cmd->type = ECAT_CMD_LRW;

   259

  cmd->address.logical = offset;

   260

   261

  ECAT_FUNC_WRITE_FOOTER;

   262

}

   263

   264

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