15 #include "ec_dbg.h"

    55 

    56 #define ECAT_FUNC_HEADER \

    57   EtherCAT_command_init(cmd)

    58 

    59 #define ECAT_FUNC_WRITE_FOOTER \

    60   cmd->data_length = length; \

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

    62 

    63 #define ECAT_FUNC_READ_FOOTER \

    64   cmd->data_length = length;

    65 

    66 /***************************************************************/

    67 

    68 /**

    69    Initialisiert ein EtherCAT-NPRD-Kommando.

    70 

    71    @param cmd Zeiger auf das Kommando

    72    @param node_address Adresse des Knotens (Slaves)

    73    @param offset Physikalische Speicheradresse im Slave

    74    @param length Länge der zu lesenden Daten

    75 */

    76 

    77 void EtherCAT_command_read(EtherCAT_command_t *cmd,

    78                            unsigned short node_address,

    79                            unsigned short offset,

    80                            unsigned int length)

    81 {

    82   if (node_address == 0x0000)

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

    84 

    85   ECAT_FUNC_HEADER;

    86 

    87   cmd->type = ECAT_CMD_NPRD;

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

    89   cmd->address.phy.mem = offset;

    90 

    91   ECAT_FUNC_READ_FOOTER;

    92 }

    93 

    94 /***************************************************************/

    95 

    96 /**

    97    Initialisiert ein EtherCAT-NPWR-Kommando.

    98 

    99    Alloziert ein "node-adressed physical write"-Kommando

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

   101 

   102    @param cmd Zeiger auf das Kommando

   103    @param node_address Adresse des Knotens (Slaves)

   104    @param offset Physikalische Speicheradresse im Slave

   105    @param length Länge der zu schreibenden Daten

   106    @param data Zeiger auf Speicher mit zu schreibenden Daten

   107 */

   108 

   109 void EtherCAT_command_write(EtherCAT_command_t *cmd,

   110                             unsigned short node_address,

   111                             unsigned short offset,

   112                             unsigned int length,

   113                             const unsigned char *data)

   114 {

   115   if (node_address == 0x0000)

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

   117 

   118   ECAT_FUNC_HEADER;

   119 

   120   cmd->type = ECAT_CMD_NPWR;

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

   122   cmd->address.phy.mem = offset;

   123 

   124   ECAT_FUNC_WRITE_FOOTER;

   125 }

   126 

   127 /***************************************************************/

   128 

   129 /**

   130    Initialisiert ein EtherCAT-APRD-Kommando.

   131 

   132    Alloziert ein "autoincerement physical read"-Kommando

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

   134 

   135    @param cmd Zeiger auf das Kommando

   136    @param ring_position (Negative) Position des Slaves im Bus

   137    @param offset Physikalische Speicheradresse im Slave

   138    @param length Länge der zu lesenden Daten

   139 */

   140 

   141 void EtherCAT_command_position_read(EtherCAT_command_t *cmd,

   142                                     short ring_position,

   143                                     unsigned short offset,

   144                                     unsigned int length)

   145 {

   146   ECAT_FUNC_HEADER;

   147 

   148   cmd->type = ECAT_CMD_APRD;

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

   150   cmd->address.phy.mem = offset;

   151 

   152   ECAT_FUNC_READ_FOOTER;

   153 }

   154 

   155 /***************************************************************/

   156 

   157 /**

   158    Initialisiert ein EtherCAT-APWR-Kommando.

   159 

   160    Alloziert ein "autoincrement physical write"-Kommando

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

   162 

   163    @param cmd Zeiger auf das Kommando

   164    @param ring_position (Negative) Position des Slaves im Bus

   165    @param offset Physikalische Speicheradresse im Slave

   166    @param length Länge der zu schreibenden Daten

   167    @param data Zeiger auf Speicher mit zu schreibenden Daten

   168 */

   169 

   170 void EtherCAT_command_position_write(EtherCAT_command_t *cmd,

   171                                      short ring_position,

   172                                      unsigned short offset,

   173                                      unsigned int length,

   174                                      const unsigned char *data)

   175 {

   176   ECAT_FUNC_HEADER;

   177 

   178   cmd->type = ECAT_CMD_APWR;

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

   180   cmd->address.phy.mem = offset;

   181 

   182   ECAT_FUNC_WRITE_FOOTER;

   183 }

   184 

   185 /***************************************************************/

   186 

   187 /**

   188    Initialisiert ein EtherCAT-BRD-Kommando.

   189 

   190    Alloziert ein "broadcast read"-Kommando

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

   192 

   193    @param cmd Zeiger auf das Kommando

   194    @param offset Physikalische Speicheradresse im Slave

   195    @param length Länge der zu lesenden Daten

   196 */

   197 

   198 void EtherCAT_command_broadcast_read(EtherCAT_command_t *cmd,

   199                                      unsigned short offset,

   200                                      unsigned int length)

   201 {

   202   ECAT_FUNC_HEADER;

   203 

   204   cmd->type = ECAT_CMD_BRD;

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

   206   cmd->address.phy.mem = offset;

   207 

   208   ECAT_FUNC_READ_FOOTER;

   209 }

   210 

   211 /***************************************************************/

   212 

   213 /**

   214    Initialisiert ein EtherCAT-BWR-Kommando.

   215 

   216    Alloziert ein "broadcast write"-Kommando

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

   218 

   219    @param cmd Zeiger auf das Kommando

   220    @param offset Physikalische Speicheradresse im Slave

   221    @param length Länge der zu schreibenden Daten

   222    @param data Zeiger auf Speicher mit zu schreibenden Daten

   223 */

   224 

   225 void EtherCAT_command_broadcast_write(EtherCAT_command_t *cmd,

   226                                       unsigned short offset,

   227                                       unsigned int length,

   228                                       const unsigned char *data)

   229 {

   230   ECAT_FUNC_HEADER;

   231 

   232   cmd->type = ECAT_CMD_BWR;

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

   234   cmd->address.phy.mem = offset;

   235 

   236   ECAT_FUNC_WRITE_FOOTER;

   237 }

   238 

   239 /***************************************************************/

   240 

   241 /**

   242    Initialisiert ein EtherCAT-LRW-Kommando.

   243 

   244    Alloziert ein "logical read write"-Kommando

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

   246 

   247    @param cmd Zeiger auf das Kommando

   248    @param offset Logische Speicheradresse

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

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

   251 */

   252 

   253 void EtherCAT_command_logical_read_write(EtherCAT_command_t *cmd,

   254                                          unsigned int offset,

   255                                          unsigned int length,

   256                                          unsigned char *data)

   257 {

   258   ECAT_FUNC_HEADER;

   259 

   260   cmd->type = ECAT_CMD_LRW;

   261   cmd->address.logical = offset;

   262 

   263   ECAT_FUNC_WRITE_FOOTER;

   264 }

   265 

   266 /***************************************************************/