2  *

     2  *

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

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

     4  *

     4  *

     5  *  Methoden für ein EtherCAT-Kommando.

     5  *  Methoden für ein EtherCAT-Kommando.

     6  *

     6  *

    11 

    10 

    12 #include <linux/slab.h>

    11 #include <linux/slab.h>

    13 

    12 

    14 #include "ec_command.h"

    13 #include "ec_command.h"

    15 

    14 

    17 

    16 

    18 /**

    17 /**

    19    Kommando-Konstruktor.

    18    Kommando-Konstruktor.

    20 

    19 

    21    Initialisiert alle Variablen innerhalb des Kommandos auf die

    20    Initialisiert alle Variablen innerhalb des Kommandos auf die

    32   cmd->state = ECAT_CS_READY;

    31   cmd->state = ECAT_CS_READY;

    33   cmd->index = 0;

    32   cmd->index = 0;

    34   cmd->working_counter = 0;

    33   cmd->working_counter = 0;

    35 }

    34 }

    36 

    35 

    38 

    37 

    39 /**

    38 /**

    40    Kommando-Destruktor.

    39    Kommando-Destruktor.

    41 

    40 

    42    Setzt alle Attribute auf den Anfangswert zurueck.

    41    Setzt alle Attribute auf den Anfangswert zurueck.

    47 void EtherCAT_command_clear(EtherCAT_command_t *cmd)

    46 void EtherCAT_command_clear(EtherCAT_command_t *cmd)

    48 {

    47 {

    49   EtherCAT_command_init(cmd);

    48   EtherCAT_command_init(cmd);

    50 }

    49 }

    51 

    50 

    53 

    52 

    54 #define ECAT_FUNC_HEADER \

    53 #define ECAT_FUNC_HEADER \

    55   EtherCAT_command_init(cmd)

    54   EtherCAT_command_init(cmd)

    56 

    55 

    57 #define ECAT_FUNC_WRITE_FOOTER \

    56 #define ECAT_FUNC_WRITE_FOOTER \

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

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

    60 

    59 

    61 #define ECAT_FUNC_READ_FOOTER \

    60 #define ECAT_FUNC_READ_FOOTER \

    62   cmd->data_length = length;

    61   cmd->data_length = length;

    63 

    62 

    65 

    64 

    66 /**

    65 /**

    67    Initialisiert ein EtherCAT-NPRD-Kommando.

    66    Initialisiert ein EtherCAT-NPRD-Kommando.

    68 

    67 

    69    @param cmd Zeiger auf das Kommando

    68    @param cmd Zeiger auf das Kommando

    75 void EtherCAT_command_read(EtherCAT_command_t *cmd,

    74 void EtherCAT_command_read(EtherCAT_command_t *cmd,

    76                            unsigned short node_address,

    75                            unsigned short node_address,

    77                            unsigned short offset,

    76                            unsigned short offset,

    78                            unsigned int length)

    77                            unsigned int length)

    79 {

    78 {

    82 

    81 

    83   ECAT_FUNC_HEADER;

    82   ECAT_FUNC_HEADER;

    84 

    83 

    85   cmd->type = ECAT_CMD_NPRD;

    84   cmd->type = ECAT_CMD_NPRD;

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

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

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

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

    88 

    87 

    89   ECAT_FUNC_READ_FOOTER;

    88   ECAT_FUNC_READ_FOOTER;

    90 }

    89 }

    91 

    90 

    93 

    92 

    94 /**

    93 /**

    95    Initialisiert ein EtherCAT-NPWR-Kommando.

    94    Initialisiert ein EtherCAT-NPWR-Kommando.

    96 

    95 

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

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

   108                             unsigned short node_address,

   107                             unsigned short node_address,

   109                             unsigned short offset,

   108                             unsigned short offset,

   110                             unsigned int length,

   109                             unsigned int length,

   111                             const unsigned char *data)

   110                             const unsigned char *data)

   112 {

   111 {

   115 

   114 

   116   ECAT_FUNC_HEADER;

   115   ECAT_FUNC_HEADER;

   117 

   116 

   118   cmd->type = ECAT_CMD_NPWR;

   117   cmd->type = ECAT_CMD_NPWR;

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

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

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

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

   121 

   120 

   122   ECAT_FUNC_WRITE_FOOTER;

   121   ECAT_FUNC_WRITE_FOOTER;

   123 }

   122 }

   124 

   123 

   126 

   125 

   127 /**

   126 /**

   128    Initialisiert ein EtherCAT-APRD-Kommando.

   127    Initialisiert ein EtherCAT-APRD-Kommando.

   129 

   128 

   130    Alloziert ein "autoincerement physical read"-Kommando

   129    Alloziert ein "autoincerement physical read"-Kommando

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

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

   149 

   148 

   150   ECAT_FUNC_READ_FOOTER;

   149   ECAT_FUNC_READ_FOOTER;

   151 }

   150 }

   152 

   151 

   154 

   153 

   155 /**

   154 /**

   156    Initialisiert ein EtherCAT-APWR-Kommando.

   155    Initialisiert ein EtherCAT-APWR-Kommando.

   157 

   156 

   158    Alloziert ein "autoincrement physical write"-Kommando

   157    Alloziert ein "autoincrement physical write"-Kommando

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

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

   179 

   178 

   180   ECAT_FUNC_WRITE_FOOTER;

   179   ECAT_FUNC_WRITE_FOOTER;

   181 }

   180 }

   182 

   181 

   184 

   183 

   185 /**

   184 /**

   186    Initialisiert ein EtherCAT-BRD-Kommando.

   185    Initialisiert ein EtherCAT-BRD-Kommando.

   187 

   186 

   188    Alloziert ein "broadcast read"-Kommando

   187    Alloziert ein "broadcast read"-Kommando

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

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

   205 

   204 

   206   ECAT_FUNC_READ_FOOTER;

   205   ECAT_FUNC_READ_FOOTER;

   207 }

   206 }

   208 

   207 

   210 

   209 

   211 /**

   210 /**

   212    Initialisiert ein EtherCAT-BWR-Kommando.

   211    Initialisiert ein EtherCAT-BWR-Kommando.

   213 

   212 

   214    Alloziert ein "broadcast write"-Kommando

   213    Alloziert ein "broadcast write"-Kommando

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

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

   233 

   232 

   234   ECAT_FUNC_WRITE_FOOTER;

   233   ECAT_FUNC_WRITE_FOOTER;

   235 }

   234 }

   236 

   235 

   238 

   237 

   239 /**

   238 /**

   240    Initialisiert ein EtherCAT-LRW-Kommando.

   239    Initialisiert ein EtherCAT-LRW-Kommando.

   241 

   240 

   242    Alloziert ein "logical read write"-Kommando

   241    Alloziert ein "logical read write"-Kommando

   259   cmd->address.logical = offset;

   258   cmd->address.logical = offset;

   260 

   259 

   261   ECAT_FUNC_WRITE_FOOTER;

   260   ECAT_FUNC_WRITE_FOOTER;

   262 }

   261 }

   263 

   262