 |
IgH EtherCAT Master
1.6.1
|
|
IgH EtherCAT Master
1.6.1
|
EtherCAT interface for realtime applications. More...
Data Structures | |
| struct | ec_master_state_t |
| Master state. More... | |
| struct | ec_master_link_state_t |
| Redundant link state. More... | |
| struct | ec_slave_config_state_t |
| Slave configuration state. More... | |
| struct | ec_master_info_t |
| Master information. More... | |
| struct | ec_master_scan_progress_t |
| Master scan progress information. More... | |
| struct | ec_slave_port_link_t |
| EtherCAT slave port information. More... | |
| struct | ec_slave_info_t |
| Slave information. More... | |
| struct | ec_domain_state_t |
| Domain state. More... | |
| struct | ec_pdo_entry_info_t |
| PDO entry configuration information. More... | |
| struct | ec_pdo_info_t |
| PDO configuration information. More... | |
| struct | ec_sync_info_t |
| Sync manager configuration information. More... | |
| struct | ec_pdo_entry_reg_t |
| List record type for PDO entry mass-registration. More... | |
Macros | |
| #define | ECRT_VER_MAJOR 1 |
| EtherCAT realtime interface major version number. | |
| #define | ECRT_VER_MINOR 6 |
| EtherCAT realtime interface minor version number. | |
| #define | ECRT_VERSION(a, b) (((a) << 8) + (b)) |
| EtherCAT realtime interface version word generator. | |
| #define | ECRT_VERSION_MAGIC ECRT_VERSION(ECRT_VER_MAJOR, ECRT_VER_MINOR) |
| EtherCAT realtime interface version word. | |
| #define | EC_HAVE_REDUNDANCY |
| Defined, if the redundancy features are available. More... | |
| #define | EC_HAVE_EMERGENCY |
| Defined, if the CoE emergency ring feature is available. More... | |
| #define | EC_HAVE_REG_ACCESS |
| Defined, if the register access interface is available. More... | |
| #define | EC_HAVE_SELECT_REF_CLOCK |
| Defined if the method ecrt_master_select_reference_clock() is available. | |
| #define | EC_HAVE_REF_CLOCK_TIME |
| Defined if the method ecrt_master_reference_clock_time() is available. | |
| #define | EC_HAVE_REG_BY_POS |
| Defined if the method ecrt_slave_config_reg_pdo_entry_pos() is available. | |
| #define | EC_HAVE_SYNC_TO |
| Defined if the method ecrt_master_sync_reference_clock_to() is available. | |
| #define | EC_HAVE_FLAGS |
| Defined if the method ecrt_slave_config_flag() is available. | |
| #define | EC_HAVE_SOE_REQUESTS |
| Defined if the methods ecrt_slave_config_create_soe_request(), ecrt_soe_request_object(), ecrt_soe_request_timeout(), ecrt_soe_request_data(), ecrt_soe_request_data_size(), ecrt_soe_request_state(), ecrt_soe_request_write() and ecrt_soe_request_read() and the datatype ec_soe_request_t are available. | |
| #define | EC_HAVE_SCAN_PROGRESS |
| Defined, if the method ecrt_master_scan_progress() and the ec_master_scan_progress_t structure are available. | |
| #define | EC_HAVE_SET_IP |
| Defined, if the methods ecrt_slave_config_eoe_mac_address(), ecrt_slave_config_eoe_ip_address(), ecrt_slave_config_eoe_subnet_mask(), ecrt_slave_config_eoe_default_gateway(), ecrt_slave_config_eoe_dns_address(), ecrt_slave_config_eoe_hostname() are available. | |
| #define | EC_HAVE_STATE_TIMEOUT |
| Defined, if the method ecrt_slave_config_state_timeout() is available. | |
| #define | EC_PUBLIC_API |
| Symbol visibility control macro. | |
| #define | EC_END ~0U |
| End of list marker. More... | |
| #define | EC_MAX_SYNC_MANAGERS 16 |
| Maximum number of sync managers per slave. | |
| #define | EC_MAX_STRING_LENGTH 64 |
| Maximum string length. More... | |
| #define | EC_MAX_PORTS 4 |
| Maximum number of slave ports. More... | |
| #define | EC_TIMEVAL2NANO(TV) (((TV).tv_sec - 946684800ULL) * 1000000000ULL + (TV).tv_usec * 1000ULL) |
| Timeval to nanoseconds conversion. More... | |
| #define | EC_COE_EMERGENCY_MSG_SIZE 8 |
| Size of a CoE emergency message in byte. More... | |
| #define | EC_READ_BIT(DATA, POS) ((*((uint8_t *) (DATA)) >> (POS)) & 0x01) |
| Read a certain bit of an EtherCAT data byte. More... | |
| #define | EC_WRITE_BIT(DATA, POS, VAL) |
| Write a certain bit of an EtherCAT data byte. More... | |
| #define | EC_READ_U8(DATA) ((uint8_t) *((uint8_t *) (DATA))) |
| Read an 8-bit unsigned value from EtherCAT data. More... | |
| #define | EC_READ_S8(DATA) ((int8_t) *((uint8_t *) (DATA))) |
| Read an 8-bit signed value from EtherCAT data. More... | |
| #define | EC_READ_U16(DATA) ((uint16_t) le16_to_cpup((void *) (DATA))) |
| Read a 16-bit unsigned value from EtherCAT data. More... | |
| #define | EC_READ_S16(DATA) ((int16_t) le16_to_cpup((void *) (DATA))) |
| Read a 16-bit signed value from EtherCAT data. More... | |
| #define | EC_READ_U32(DATA) ((uint32_t) le32_to_cpup((void *) (DATA))) |
| Read a 32-bit unsigned value from EtherCAT data. More... | |
| #define | EC_READ_S32(DATA) ((int32_t) le32_to_cpup((void *) (DATA))) |
| Read a 32-bit signed value from EtherCAT data. More... | |
| #define | EC_READ_U64(DATA) ((uint64_t) le64_to_cpup((void *) (DATA))) |
| Read a 64-bit unsigned value from EtherCAT data. More... | |
| #define | EC_READ_S64(DATA) ((int64_t) le64_to_cpup((void *) (DATA))) |
| Read a 64-bit signed value from EtherCAT data. More... | |
| #define | EC_WRITE_U8(DATA, VAL) |
| Write an 8-bit unsigned value to EtherCAT data. More... | |
| #define | EC_WRITE_S8(DATA, VAL) EC_WRITE_U8(DATA, VAL) |
| Write an 8-bit signed value to EtherCAT data. More... | |
| #define | EC_WRITE_U16(DATA, VAL) |
| Write a 16-bit unsigned value to EtherCAT data. More... | |
| #define | EC_WRITE_S16(DATA, VAL) EC_WRITE_U16(DATA, VAL) |
| Write a 16-bit signed value to EtherCAT data. More... | |
| #define | EC_WRITE_U32(DATA, VAL) |
| Write a 32-bit unsigned value to EtherCAT data. More... | |
| #define | EC_WRITE_S32(DATA, VAL) EC_WRITE_U32(DATA, VAL) |
| Write a 32-bit signed value to EtherCAT data. More... | |
| #define | EC_WRITE_U64(DATA, VAL) |
| Write a 64-bit unsigned value to EtherCAT data. More... | |
| #define | EC_WRITE_S64(DATA, VAL) EC_WRITE_U64(DATA, VAL) |
| Write a 64-bit signed value to EtherCAT data. More... | |
Typedefs | |
| typedef struct ec_master | ec_master_t |
| typedef struct ec_slave_config | ec_slave_config_t |
| typedef struct ec_domain | ec_domain_t |
| typedef struct ec_sdo_request | ec_sdo_request_t |
| typedef struct ec_soe_request | ec_soe_request_t |
| typedef struct ec_voe_handler | ec_voe_handler_t |
| typedef struct ec_reg_request | ec_reg_request_t |
Enumerations | |
| enum | ec_slave_port_desc_t { EC_PORT_NOT_IMPLEMENTED, EC_PORT_NOT_CONFIGURED, EC_PORT_EBUS, EC_PORT_MII } |
| EtherCAT slave port descriptor. More... | |
| enum | ec_wc_state_t { EC_WC_ZERO = 0, EC_WC_INCOMPLETE, EC_WC_COMPLETE } |
| Domain working counter interpretation. More... | |
| enum | ec_direction_t { EC_DIR_INVALID, EC_DIR_OUTPUT, EC_DIR_INPUT, EC_DIR_COUNT } |
| Direction type for PDO assignment functions. More... | |
| enum | ec_watchdog_mode_t { EC_WD_DEFAULT, EC_WD_ENABLE, EC_WD_DISABLE } |
| Watchdog mode for sync manager configuration. More... | |
| enum | ec_request_state_t { EC_REQUEST_UNUSED, EC_REQUEST_BUSY, EC_REQUEST_SUCCESS, EC_REQUEST_ERROR } |
| Request state. More... | |
| enum | ec_al_state_t { EC_AL_STATE_INIT = 1, EC_AL_STATE_PREOP = 2, EC_AL_STATE_SAFEOP = 4, EC_AL_STATE_OP = 8 } |
| Application-layer state. More... | |
Functions | |
| EC_PUBLIC_API unsigned int | ecrt_version_magic (void) |
| Returns the version magic of the realtime interface. More... | |
| EC_PUBLIC_API ec_master_t * | ecrt_request_master (unsigned int master_index) |
| Requests an EtherCAT master for realtime operation. More... | |
| EC_PUBLIC_API void | ecrt_release_master (ec_master_t *master) |
| Releases a requested EtherCAT master. More... | |
| void | ecrt_master_callbacks (ec_master_t *master, void(*send_cb)(void *), void(*receive_cb)(void *), void *cb_data) |
| Sets the locking callbacks. More... | |
| EC_PUBLIC_API ec_domain_t * | ecrt_master_create_domain (ec_master_t *master) |
| Creates a new process data domain. More... | |
| EC_PUBLIC_API ec_slave_config_t * | ecrt_master_slave_config (ec_master_t *master, uint16_t alias, uint16_t position, uint32_t vendor_id, uint32_t product_code) |
| Obtains a slave configuration. More... | |
| EC_PUBLIC_API int | ecrt_master_select_reference_clock (ec_master_t *master, ec_slave_config_t *sc) |
| Selects the reference clock for distributed clocks. More... | |
| EC_PUBLIC_API int | ecrt_master (ec_master_t *master, ec_master_info_t *master_info) |
| Obtains master information. More... | |
| EC_PUBLIC_API int | ecrt_master_scan_progress (ec_master_t *master, ec_master_scan_progress_t *progress) |
| Obtains network scan progress information. More... | |
| EC_PUBLIC_API int | ecrt_master_get_slave (ec_master_t *master, uint16_t slave_position, ec_slave_info_t *slave_info) |
| Obtains slave information. More... | |
| EC_PUBLIC_API int | ecrt_master_sdo_download (ec_master_t *master, uint16_t slave_position, uint16_t index, uint8_t subindex, const uint8_t *data, size_t data_size, uint32_t *abort_code) |
| Executes an SDO download request to write data to a slave. More... | |
| EC_PUBLIC_API int | ecrt_master_sdo_download_complete (ec_master_t *master, uint16_t slave_position, uint16_t index, const uint8_t *data, size_t data_size, uint32_t *abort_code) |
| Executes an SDO download request to write data to a slave via complete access. More... | |
| EC_PUBLIC_API int | ecrt_master_sdo_upload (ec_master_t *master, uint16_t slave_position, uint16_t index, uint8_t subindex, uint8_t *target, size_t target_size, size_t *result_size, uint32_t *abort_code) |
| Executes an SDO upload request to read data from a slave. More... | |
| EC_PUBLIC_API int | ecrt_master_write_idn (ec_master_t *master, uint16_t slave_position, uint8_t drive_no, uint16_t idn, const uint8_t *data, size_t data_size, uint16_t *error_code) |
| Executes an SoE write request. More... | |
| EC_PUBLIC_API int | ecrt_master_read_idn (ec_master_t *master, uint16_t slave_position, uint8_t drive_no, uint16_t idn, uint8_t *target, size_t target_size, size_t *result_size, uint16_t *error_code) |
| Executes an SoE read request. More... | |
| EC_PUBLIC_API int | ecrt_master_activate (ec_master_t *master) |
| Finishes the configuration phase and prepares for cyclic operation. More... | |
| EC_PUBLIC_API int | ecrt_master_deactivate (ec_master_t *master) |
| Deactivates the master. More... | |
| EC_PUBLIC_API int | ecrt_master_set_send_interval (ec_master_t *master, size_t send_interval) |
| Set interval between calls to ecrt_master_send(). More... | |
| EC_PUBLIC_API int | ecrt_master_send (ec_master_t *master) |
| Sends all datagrams in the queue. More... | |
| EC_PUBLIC_API int | ecrt_master_receive (ec_master_t *master) |
| Fetches received frames from the hardware and processes the datagrams. More... | |
| int | ecrt_master_send_ext (ec_master_t *master) |
| Sends non-application datagrams. More... | |
| EC_PUBLIC_API int | ecrt_master_state (const ec_master_t *master, ec_master_state_t *state) |
| Reads the current master state. More... | |
| EC_PUBLIC_API int | ecrt_master_link_state (const ec_master_t *master, unsigned int dev_idx, ec_master_link_state_t *state) |
| Reads the current state of a redundant link. More... | |
| EC_PUBLIC_API int | ecrt_master_application_time (ec_master_t *master, uint64_t app_time) |
| Sets the application time. More... | |
| EC_PUBLIC_API int | ecrt_master_sync_reference_clock (ec_master_t *master) |
| Queues the DC reference clock drift compensation datagram for sending. More... | |
| EC_PUBLIC_API int | ecrt_master_sync_reference_clock_to (ec_master_t *master, uint64_t sync_time) |
| Queues the DC reference clock drift compensation datagram for sending. More... | |
| EC_PUBLIC_API int | ecrt_master_sync_slave_clocks (ec_master_t *master) |
| Queues the DC clock drift compensation datagram for sending. More... | |
| EC_PUBLIC_API int | ecrt_master_reference_clock_time (const ec_master_t *master, uint32_t *time) |
| Get the lower 32 bit of the reference clock system time. More... | |
| EC_PUBLIC_API int | ecrt_master_sync_monitor_queue (ec_master_t *master) |
| Queues the DC synchrony monitoring datagram for sending. More... | |
| EC_PUBLIC_API uint32_t | ecrt_master_sync_monitor_process (const ec_master_t *master) |
| Processes the DC synchrony monitoring datagram. More... | |
| EC_PUBLIC_API int | ecrt_master_reset (ec_master_t *master) |
| Retry configuring slaves. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_sync_manager (ec_slave_config_t *sc, uint8_t sync_index, ec_direction_t direction, ec_watchdog_mode_t watchdog_mode) |
| Configure a sync manager. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_watchdog (ec_slave_config_t *sc, uint16_t watchdog_divider, uint16_t watchdog_intervals) |
| Configure a slave's watchdog times. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_pdo_assign_add (ec_slave_config_t *sc, uint8_t sync_index, uint16_t index) |
| Add a PDO to a sync manager's PDO assignment. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_pdo_assign_clear (ec_slave_config_t *sc, uint8_t sync_index) |
| Clear a sync manager's PDO assignment. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_pdo_mapping_add (ec_slave_config_t *sc, uint16_t pdo_index, uint16_t entry_index, uint8_t entry_subindex, uint8_t entry_bit_length) |
| Add a PDO entry to the given PDO's mapping. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_pdo_mapping_clear (ec_slave_config_t *sc, uint16_t pdo_index) |
| Clear the mapping of a given PDO. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_pdos (ec_slave_config_t *sc, unsigned int n_syncs, const ec_sync_info_t syncs[]) |
| Specify a complete PDO configuration. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_reg_pdo_entry (ec_slave_config_t *sc, uint16_t entry_index, uint8_t entry_subindex, ec_domain_t *domain, unsigned int *bit_position) |
| Registers a PDO entry for process data exchange in a domain. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_reg_pdo_entry_pos (ec_slave_config_t *sc, uint8_t sync_index, unsigned int pdo_pos, unsigned int entry_pos, ec_domain_t *domain, unsigned int *bit_position) |
| Registers a PDO entry using its position. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_dc (ec_slave_config_t *sc, uint16_t assign_activate, uint32_t sync0_cycle, int32_t sync0_shift, uint32_t sync1_cycle, int32_t sync1_shift) |
| Configure distributed clocks. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_sdo (ec_slave_config_t *sc, uint16_t index, uint8_t subindex, const uint8_t *data, size_t size) |
| Add an SDO configuration. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_sdo8 (ec_slave_config_t *sc, uint16_t sdo_index, uint8_t sdo_subindex, uint8_t value) |
| Add a configuration value for an 8-bit SDO. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_sdo16 (ec_slave_config_t *sc, uint16_t sdo_index, uint8_t sdo_subindex, uint16_t value) |
| Add a configuration value for a 16-bit SDO. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_sdo32 (ec_slave_config_t *sc, uint16_t sdo_index, uint8_t sdo_subindex, uint32_t value) |
| Add a configuration value for a 32-bit SDO. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_complete_sdo (ec_slave_config_t *sc, uint16_t index, const uint8_t *data, size_t size) |
| Add configuration data for a complete SDO. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_emerg_size (ec_slave_config_t *sc, size_t elements) |
| Set the size of the CoE emergency ring buffer. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_emerg_pop (ec_slave_config_t *sc, uint8_t *target) |
| Read and remove one record from the CoE emergency ring buffer. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_emerg_clear (ec_slave_config_t *sc) |
| Clears CoE emergency ring buffer and the overrun counter. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_emerg_overruns (const ec_slave_config_t *sc) |
| Read the number of CoE emergency overruns. More... | |
| EC_PUBLIC_API ec_sdo_request_t * | ecrt_slave_config_create_sdo_request (ec_slave_config_t *sc, uint16_t index, uint8_t subindex, size_t size) |
| Create an SDO request to exchange SDOs during realtime operation. More... | |
| EC_PUBLIC_API ec_soe_request_t * | ecrt_slave_config_create_soe_request (ec_slave_config_t *sc, uint8_t drive_no, uint16_t idn, size_t size) |
| Create an SoE request to exchange SoE IDNs during realtime operation. More... | |
| EC_PUBLIC_API ec_voe_handler_t * | ecrt_slave_config_create_voe_handler (ec_slave_config_t *sc, size_t size) |
| Create an VoE handler to exchange vendor-specific data during realtime operation. More... | |
| EC_PUBLIC_API ec_reg_request_t * | ecrt_slave_config_create_reg_request (ec_slave_config_t *sc, size_t size) |
| Create a register request to exchange EtherCAT register contents during realtime operation. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_state (const ec_slave_config_t *sc, ec_slave_config_state_t *state) |
| Outputs the state of the slave configuration. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_idn (ec_slave_config_t *sc, uint8_t drive_no, uint16_t idn, ec_al_state_t state, const uint8_t *data, size_t size) |
| Add an SoE IDN configuration. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_flag (ec_slave_config_t *sc, const char *key, int32_t value) |
| Adds a feature flag to a slave configuration. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_eoe_mac_address (ec_slave_config_t *sc, const unsigned char *mac_address) |
| Sets the link/MAC address for Ethernet-over-EtherCAT (EoE) operation. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_eoe_ip_address (ec_slave_config_t *sc, struct in_addr ip_address) |
| Sets the IP address for Ethernet-over-EtherCAT (EoE) operation. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_eoe_subnet_mask (ec_slave_config_t *sc, struct in_addr subnet_mask) |
| Sets the subnet mask for Ethernet-over-EtherCAT (EoE) operation. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_eoe_default_gateway (ec_slave_config_t *sc, struct in_addr gateway_address) |
| Sets the gateway address for Ethernet-over-EtherCAT (EoE) operation. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_eoe_dns_address (ec_slave_config_t *sc, struct in_addr dns_address) |
| Sets the IPv4 address of the DNS server for Ethernet-over-EtherCAT (EoE) operation. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_eoe_hostname (ec_slave_config_t *sc, const char *name) |
| Sets the host name for Ethernet-over-EtherCAT (EoE) operation. More... | |
| EC_PUBLIC_API int | ecrt_slave_config_state_timeout (ec_slave_config_t *sc, ec_al_state_t from_state, ec_al_state_t to_state, unsigned int timeout_ms) |
| Sets the application-layer state transition timeout in ms. More... | |
| EC_PUBLIC_API int | ecrt_domain_reg_pdo_entry_list (ec_domain_t *domain, const ec_pdo_entry_reg_t *pdo_entry_regs) |
| Registers a bunch of PDO entries for a domain. More... | |
| EC_PUBLIC_API size_t | ecrt_domain_size (const ec_domain_t *domain) |
| Returns the current size of the domain's process data. More... | |
| void | ecrt_domain_external_memory (ec_domain_t *domain, uint8_t *memory) |
| Provide external memory to store the domain's process data. More... | |
| EC_PUBLIC_API uint8_t * | ecrt_domain_data (const ec_domain_t *domain) |
| Returns the domain's process data. More... | |
| EC_PUBLIC_API int | ecrt_domain_process (ec_domain_t *domain) |
| Determines the states of the domain's datagrams. More... | |
| EC_PUBLIC_API int | ecrt_domain_queue (ec_domain_t *domain) |
| (Re-)queues all domain datagrams in the master's datagram queue. More... | |
| EC_PUBLIC_API int | ecrt_domain_state (const ec_domain_t *domain, ec_domain_state_t *state) |
| Reads the state of a domain. More... | |
| EC_PUBLIC_API int | ecrt_sdo_request_index (ec_sdo_request_t *req, uint16_t index, uint8_t subindex) |
| Set the SDO index and subindex. More... | |
| EC_PUBLIC_API int | ecrt_sdo_request_timeout (ec_sdo_request_t *req, uint32_t timeout) |
| Set the timeout for an SDO request. More... | |
| EC_PUBLIC_API uint8_t * | ecrt_sdo_request_data (const ec_sdo_request_t *req) |
| Access to the SDO request's data. More... | |
| EC_PUBLIC_API size_t | ecrt_sdo_request_data_size (const ec_sdo_request_t *req) |
| Returns the current SDO data size. More... | |
| EC_PUBLIC_API ec_request_state_t | ecrt_sdo_request_state (const ec_sdo_request_t *req) |
| Get the current state of the SDO request. More... | |
| EC_PUBLIC_API int | ecrt_sdo_request_write (ec_sdo_request_t *req) |
| Schedule an SDO write operation. More... | |
| EC_PUBLIC_API int | ecrt_sdo_request_read (ec_sdo_request_t *req) |
| Schedule an SDO read operation. More... | |
| EC_PUBLIC_API int | ecrt_soe_request_idn (ec_soe_request_t *req, uint8_t drive_no, uint16_t idn) |
| Set the request's drive and Sercos ID numbers. More... | |
| EC_PUBLIC_API int | ecrt_soe_request_timeout (ec_soe_request_t *req, uint32_t timeout) |
| Set the timeout for an SoE request. More... | |
| EC_PUBLIC_API uint8_t * | ecrt_soe_request_data (const ec_soe_request_t *req) |
| Access to the SoE request's data. More... | |
| EC_PUBLIC_API size_t | ecrt_soe_request_data_size (const ec_soe_request_t *req) |
| Returns the current IDN data size. More... | |
| EC_PUBLIC_API ec_request_state_t | ecrt_soe_request_state (const ec_soe_request_t *req) |
| Get the current state of the SoE request. More... | |
| EC_PUBLIC_API int | ecrt_soe_request_write (ec_soe_request_t *req) |
| Schedule an SoE IDN write operation. More... | |
| EC_PUBLIC_API int | ecrt_soe_request_read (ec_soe_request_t *req) |
| Schedule an SoE IDN read operation. More... | |
| EC_PUBLIC_API int | ecrt_voe_handler_send_header (ec_voe_handler_t *voe, uint32_t vendor_id, uint16_t vendor_type) |
| Sets the VoE header for future send operations. More... | |
| EC_PUBLIC_API int | ecrt_voe_handler_received_header (const ec_voe_handler_t *voe, uint32_t *vendor_id, uint16_t *vendor_type) |
| Reads the header data of a received VoE message. More... | |
| EC_PUBLIC_API uint8_t * | ecrt_voe_handler_data (const ec_voe_handler_t *voe) |
| Access to the VoE handler's data. More... | |
| EC_PUBLIC_API size_t | ecrt_voe_handler_data_size (const ec_voe_handler_t *voe) |
| Returns the current data size. More... | |
| EC_PUBLIC_API int | ecrt_voe_handler_write (ec_voe_handler_t *voe, size_t size) |
| Start a VoE write operation. More... | |
| EC_PUBLIC_API int | ecrt_voe_handler_read (ec_voe_handler_t *voe) |
| Start a VoE read operation. More... | |
| EC_PUBLIC_API int | ecrt_voe_handler_read_nosync (ec_voe_handler_t *voe) |
| Start a VoE read operation without querying the sync manager status. More... | |
| EC_PUBLIC_API ec_request_state_t | ecrt_voe_handler_execute (ec_voe_handler_t *voe) |
| Execute the handler. More... | |
| EC_PUBLIC_API uint8_t * | ecrt_reg_request_data (const ec_reg_request_t *req) |
| Access to the register request's data. More... | |
| EC_PUBLIC_API ec_request_state_t | ecrt_reg_request_state (const ec_reg_request_t *req) |
| Get the current state of the register request. More... | |
| EC_PUBLIC_API int | ecrt_reg_request_write (ec_reg_request_t *req, uint16_t address, size_t size) |
| Schedule an register write operation. More... | |
| EC_PUBLIC_API int | ecrt_reg_request_read (ec_reg_request_t *req, uint16_t address, size_t size) |
| Schedule a register read operation. More... | |
EtherCAT interface for realtime applications.
This interface is designed for realtime modules that want to use EtherCAT. There are functions to request a master, to map process data, to communicate with slaves via CoE and to configure and activate the bus.
Changes in version 1.6.0:
Changes since version 1.5.2:
Changes in version 1.5.2:
Changes in version 1.5:
| #define EC_HAVE_REDUNDANCY |
Defined, if the redundancy features are available.
I. e. if the redundancy_active flag in ec_domain_state_t and the ecrt_master_link_state() method are available.
| #define EC_HAVE_EMERGENCY |
| #define EC_HAVE_REG_ACCESS |
Defined, if the register access interface is available.
I. e. if the methods ecrt_slave_config_create_reg_request(), ecrt_reg_request_data(), ecrt_reg_request_state(), ecrt_reg_request_write() and ecrt_reg_request_read() are available.
| #define EC_END ~0U |
End of list marker.
This can be used with ecrt_slave_config_pdos().
| #define EC_MAX_STRING_LENGTH 64 |
| #define EC_TIMEVAL2NANO | ( | TV | ) | (((TV).tv_sec - 946684800ULL) * 1000000000ULL + (TV).tv_usec * 1000ULL) |
Timeval to nanoseconds conversion.
This macro converts a Unix epoch time to EtherCAT DC time.
| TV | struct timeval containing epoch time. |
| #define EC_COE_EMERGENCY_MSG_SIZE 8 |
Size of a CoE emergency message in byte.
| #define EC_READ_BIT | ( | DATA, | |
| POS | |||
| ) | ((*((uint8_t *) (DATA)) >> (POS)) & 0x01) |
| #define EC_WRITE_BIT | ( | DATA, | |
| POS, | |||
| VAL | |||
| ) |
| #define EC_READ_U8 | ( | DATA | ) | ((uint8_t) *((uint8_t *) (DATA))) |
| #define EC_READ_S8 | ( | DATA | ) | ((int8_t) *((uint8_t *) (DATA))) |
| #define EC_READ_U16 | ( | DATA | ) | ((uint16_t) le16_to_cpup((void *) (DATA))) |
| #define EC_READ_S16 | ( | DATA | ) | ((int16_t) le16_to_cpup((void *) (DATA))) |
| #define EC_READ_U32 | ( | DATA | ) | ((uint32_t) le32_to_cpup((void *) (DATA))) |
| #define EC_READ_S32 | ( | DATA | ) | ((int32_t) le32_to_cpup((void *) (DATA))) |
| #define EC_READ_U64 | ( | DATA | ) | ((uint64_t) le64_to_cpup((void *) (DATA))) |
| #define EC_READ_S64 | ( | DATA | ) | ((int64_t) le64_to_cpup((void *) (DATA))) |
| #define EC_WRITE_U8 | ( | DATA, | |
| VAL | |||
| ) |
| #define EC_WRITE_S8 | ( | DATA, | |
| VAL | |||
| ) | EC_WRITE_U8(DATA, VAL) |
| #define EC_WRITE_U16 | ( | DATA, | |
| VAL | |||
| ) |
| #define EC_WRITE_S16 | ( | DATA, | |
| VAL | |||
| ) | EC_WRITE_U16(DATA, VAL) |
| #define EC_WRITE_U32 | ( | DATA, | |
| VAL | |||
| ) |
| #define EC_WRITE_S32 | ( | DATA, | |
| VAL | |||
| ) | EC_WRITE_U32(DATA, VAL) |
| #define EC_WRITE_U64 | ( | DATA, | |
| VAL | |||
| ) |
| #define EC_WRITE_S64 | ( | DATA, | |
| VAL | |||
| ) | EC_WRITE_U64(DATA, VAL) |
| typedef struct ec_master ec_master_t |
| typedef struct ec_slave_config ec_slave_config_t |
| typedef struct ec_domain ec_domain_t |
| typedef struct ec_sdo_request ec_sdo_request_t |
| typedef struct ec_soe_request ec_soe_request_t |
| typedef struct ec_voe_handler ec_voe_handler_t |
| typedef struct ec_reg_request ec_reg_request_t |
| enum ec_slave_port_desc_t |
| enum ec_wc_state_t |
Domain working counter interpretation.
This is used in ec_domain_state_t.
| Enumerator | |
|---|---|
| EC_WC_ZERO | No registered process data were exchanged. |
| EC_WC_INCOMPLETE | Some of the registered process data were exchanged. |
| EC_WC_COMPLETE | All registered process data were exchanged. |
| enum ec_direction_t |
| enum ec_watchdog_mode_t |
| enum ec_request_state_t |
Request state.
This is used as return type for ecrt_sdo_request_state() and ecrt_voe_handler_state().
| Enumerator | |
|---|---|
| EC_REQUEST_UNUSED | Not requested. |
| EC_REQUEST_BUSY | Request is being processed. |
| EC_REQUEST_SUCCESS | Request was processed successfully. |
| EC_REQUEST_ERROR | Request processing failed. |
| enum ec_al_state_t |
| EC_PUBLIC_API unsigned int ecrt_version_magic | ( | void | ) |
Returns the version magic of the realtime interface.
| EC_PUBLIC_API ec_master_t* ecrt_request_master | ( | unsigned int | master_index | ) |
Requests an EtherCAT master for realtime operation.
Before an application can access an EtherCAT master, it has to reserve one for exclusive use.
In userspace, this is a convenience function for ecrt_open_master() and ecrt_master_reserve().
This function has to be the first function an application has to call to use EtherCAT. The function takes the index of the master as its argument. The first master has index 0, the n-th master has index n - 1. The number of masters has to be specified when loading the master module.
| master_index | Index of the master to request. |
| EC_PUBLIC_API void ecrt_release_master | ( | ec_master_t * | master | ) |
Releases a requested EtherCAT master.
After use, a master it has to be released to make it available for other applications.
This method frees all created data structures. It should not be called in realtime context.
If the master was activated, ecrt_master_deactivate() is called internally.
| master | EtherCAT master |
| void ecrt_master_callbacks | ( | ec_master_t * | master, |
| void(*)(void *) | send_cb, | ||
| void(*)(void *) | receive_cb, | ||
| void * | cb_data | ||
| ) |
Sets the locking callbacks.
For concurrent master access, i. e. if other instances than the application want to send and receive datagrams on the network, the application has to provide a callback mechanism. This method takes two function pointers as its parameters. Asynchronous master access (like EoE processing) is only possible if the callbacks have been set.
The task of the send callback (send_cb) is to decide, if the network hardware is currently accessible and whether or not to call the ecrt_master_send_ext() method.
The task of the receive callback (receive_cb) is to decide, if a call to ecrt_master_receive() is allowed and to execute it respectively.
| master | EtherCAT master |
| send_cb | Datagram sending callback. |
| receive_cb | Receive callback. |
| cb_data | Arbitrary pointer passed to the callback functions. |
| EC_PUBLIC_API ec_domain_t* ecrt_master_create_domain | ( | ec_master_t * | master | ) |
Creates a new process data domain.
For process data exchange, at least one process data domain is needed. This method creates a new process data domain and returns a pointer to the new domain object. This object can be used for registering PDOs and exchanging them in cyclic operation.
This method allocates memory and should be called in non-realtime context before ecrt_master_activate().
| master | EtherCAT master. |
| EC_PUBLIC_API ec_slave_config_t* ecrt_master_slave_config | ( | ec_master_t * | master, |
| uint16_t | alias, | ||
| uint16_t | position, | ||
| uint32_t | vendor_id, | ||
| uint32_t | product_code | ||
| ) |
Obtains a slave configuration.
Creates a slave configuration object for the given alias and position tuple and returns it. If a configuration with the same alias and position already exists, it will be re-used. In the latter case, the given vendor ID and product code are compared to the stored ones. On mismatch, an error message is raised and the function returns NULL.
Slaves are addressed with the alias and position parameters.
If the slave with the given address is found during the configuration, its vendor ID and product code are matched against the given value. On mismatch, the slave is not configured and an error message is raised.
If different slave configurations are pointing to the same slave during configuration, a warning is raised and only the first configuration is applied.
This method allocates memory and should be called in non-realtime context before ecrt_master_activate().
| >0 | Pointer to the slave configuration structure. |
| NULL | in the error case. |
| master | EtherCAT master |
| alias | Slave alias. |
| position | Slave position. |
| vendor_id | Expected vendor ID. |
| product_code | Expected product code. |
| EC_PUBLIC_API int ecrt_master_select_reference_clock | ( | ec_master_t * | master, |
| ec_slave_config_t * | sc | ||
| ) |
Selects the reference clock for distributed clocks.
If this method is not called for a certain master, or if the slave configuration pointer is NULL, then the first slave with DC functionality will provide the reference clock.
| master | EtherCAT master. |
| sc | Slave config of the slave to use as the reference slave (or NULL). |
| EC_PUBLIC_API int ecrt_master | ( | ec_master_t * | master, |
| ec_master_info_t * | master_info | ||
| ) |
Obtains master information.
No memory is allocated on the heap in this function.
| master | EtherCAT master |
| master_info | Structure that will output the information |
| EC_PUBLIC_API int ecrt_master_scan_progress | ( | ec_master_t * | master, |
| ec_master_scan_progress_t * | progress | ||
| ) |
Obtains network scan progress information.
No memory is allocated on the heap in this function.
| master | EtherCAT master |
| progress | Structure that will output the progress information. |
| EC_PUBLIC_API int ecrt_master_get_slave | ( | ec_master_t * | master, |
| uint16_t | slave_position, | ||
| ec_slave_info_t * | slave_info | ||
| ) |
Obtains slave information.
Tries to find the slave with the given ring position. The obtained information is stored in a structure. No memory is allocated on the heap in this function.
| master | EtherCAT master |
| slave_position | Slave position. |
| slave_info | Structure that will output the information |
| EC_PUBLIC_API int ecrt_master_sdo_download | ( | ec_master_t * | master, |
| uint16_t | slave_position, | ||
| uint16_t | index, | ||
| uint8_t | subindex, | ||
| const uint8_t * | data, | ||
| size_t | data_size, | ||
| uint32_t * | abort_code | ||
| ) |
Executes an SDO download request to write data to a slave.
This request is processed by the master state machine. This method blocks, until the request has been processed and may not be called in realtime context.
| 0 | Success. |
| <0 | Error code. |
| master | EtherCAT master. |
| slave_position | Slave position. |
| index | Index of the SDO. |
| subindex | Subindex of the SDO. |
| data | Data buffer to download. |
| data_size | Size of the data buffer. |
| abort_code | Abort code of the SDO download. |
| EC_PUBLIC_API int ecrt_master_sdo_download_complete | ( | ec_master_t * | master, |
| uint16_t | slave_position, | ||
| uint16_t | index, | ||
| const uint8_t * | data, | ||
| size_t | data_size, | ||
| uint32_t * | abort_code | ||
| ) |
Executes an SDO download request to write data to a slave via complete access.
This request is processed by the master state machine. This method blocks, until the request has been processed and may not be called in realtime context.
| 0 | Success. |
| <0 | Error code. |
| master | EtherCAT master. |
| slave_position | Slave position. |
| index | Index of the SDO. |
| data | Data buffer to download. |
| data_size | Size of the data buffer. |
| abort_code | Abort code of the SDO download. |
| EC_PUBLIC_API int ecrt_master_sdo_upload | ( | ec_master_t * | master, |
| uint16_t | slave_position, | ||
| uint16_t | index, | ||
| uint8_t | subindex, | ||
| uint8_t * | target, | ||
| size_t | target_size, | ||
| size_t * | result_size, | ||
| uint32_t * | abort_code | ||
| ) |
Executes an SDO upload request to read data from a slave.
This request is processed by the master state machine. This method blocks, until the request has been processed and may not be called in realtime context.
| 0 | Success. |
| <0 | Error code. |
| master | EtherCAT master. |
| slave_position | Slave position. |
| index | Index of the SDO. |
| subindex | Subindex of the SDO. |
| target | Target buffer for the upload. |
| target_size | Size of the target buffer. |
| result_size | Uploaded data size. |
| abort_code | Abort code of the SDO upload. |
| EC_PUBLIC_API int ecrt_master_write_idn | ( | ec_master_t * | master, |
| uint16_t | slave_position, | ||
| uint8_t | drive_no, | ||
| uint16_t | idn, | ||
| const uint8_t * | data, | ||
| size_t | data_size, | ||
| uint16_t * | error_code | ||
| ) |
Executes an SoE write request.
Starts writing an IDN and blocks until the request was processed, or an error occurred.
| 0 | Success. |
| <0 | Error code. |
| master | EtherCAT master. |
| slave_position | Slave position. |
| drive_no | Drive number. |
| idn | SoE IDN (see ecrt_slave_config_idn()). |
| data | Pointer to data to write. |
| data_size | Size of data to write. |
| error_code | Pointer to variable, where an SoE error code can be stored. |
| EC_PUBLIC_API int ecrt_master_read_idn | ( | ec_master_t * | master, |
| uint16_t | slave_position, | ||
| uint8_t | drive_no, | ||
| uint16_t | idn, | ||
| uint8_t * | target, | ||
| size_t | target_size, | ||
| size_t * | result_size, | ||
| uint16_t * | error_code | ||
| ) |
Executes an SoE read request.
Starts reading an IDN and blocks until the request was processed, or an error occurred.
| 0 | Success. |
| <0 | Error code. |
| master | EtherCAT master. |
| slave_position | Slave position. |
| drive_no | Drive number. |
| idn | SoE IDN (see ecrt_slave_config_idn()). |
| target | Pointer to memory where the read data can be stored. |
| target_size | Size of the memory target points to. |
| result_size | Actual size of the received data. |
| error_code | Pointer to variable, where an SoE error code can be stored. |
| EC_PUBLIC_API int ecrt_master_activate | ( | ec_master_t * | master | ) |
Finishes the configuration phase and prepares for cyclic operation.
This function tells the master that the configuration phase is finished and the realtime operation will begin. The function allocates internal memory for the domains and calculates the logical FMMU addresses for domain members. It tells the master state machine that the configuration is now to be applied to the network.
| master | EtherCAT master. |
| EC_PUBLIC_API int ecrt_master_deactivate | ( | ec_master_t * | master | ) |
Deactivates the master.
Removes the master configuration. All objects created by ecrt_master_create_domain(), ecrt_master_slave_config(), ecrt_domain_data() ecrt_slave_config_create_sdo_request() and ecrt_slave_config_create_voe_handler() are freed, so pointers to them become invalid.
This method should not be called in realtime context.
| 0 | Success. |
| -EINVAL | Master has not been activated before. |
| master | EtherCAT master. |
| EC_PUBLIC_API int ecrt_master_set_send_interval | ( | ec_master_t * | master, |
| size_t | send_interval | ||
| ) |
Set interval between calls to ecrt_master_send().
This information helps the master to decide, how much data can be appended to a frame by the master state machine. When the master is configured with –enable-hrtimers, this is used to calculate the scheduling of the master thread.
| 0 | on success. |
| <0 | Error code. |
| master | EtherCAT master. |
| send_interval | Send interval in us |
| EC_PUBLIC_API int ecrt_master_send | ( | ec_master_t * | master | ) |
Sends all datagrams in the queue.
This method takes all datagrams, that have been queued for transmission, puts them into frames, and passes them to the Ethernet device for sending.
Has to be called cyclically by the application after ecrt_master_activate() has returned.
| master | EtherCAT master. |
| EC_PUBLIC_API int ecrt_master_receive | ( | ec_master_t * | master | ) |
Fetches received frames from the hardware and processes the datagrams.
Queries the network device for received frames by calling the interrupt service routine. Extracts received datagrams and dispatches the results to the datagram objects in the queue. Received datagrams, and the ones that timed out, will be marked, and dequeued.
Has to be called cyclically by the realtime application after ecrt_master_activate() has returned.
| master | EtherCAT master. |
| int ecrt_master_send_ext | ( | ec_master_t * | master | ) |
Sends non-application datagrams.
This method has to be called in the send callback function passed via ecrt_master_callbacks() to allow the sending of non-application datagrams.
| -EAGAIN | Lock could not be acquired, try again later. |
| master | EtherCAT master. |
| EC_PUBLIC_API int ecrt_master_state | ( | const ec_master_t * | master, |
| ec_master_state_t * | state | ||
| ) |
Reads the current master state.
Stores the master state information in the given state structure.
This method returns a global state. For the link-specific states in a redundant network topology, use the ecrt_master_link_state() method.
| master | EtherCAT master. |
| state | Structure to store the information. |
| EC_PUBLIC_API int ecrt_master_link_state | ( | const ec_master_t * | master, |
| unsigned int | dev_idx, | ||
| ec_master_link_state_t * | state | ||
| ) |
Reads the current state of a redundant link.
Stores the link state information in the given state structure.
| master | EtherCAT master. |
| dev_idx | Index of the device (0 = main device, 1 = first backup device, ...). |
| state | Structure to store the information. |
| EC_PUBLIC_API int ecrt_master_application_time | ( | ec_master_t * | master, |
| uint64_t | app_time | ||
| ) |
Sets the application time.
The master has to know the application's time when operating slaves with distributed clocks. The time is not incremented by the master itself, so this method has to be called cyclically.
The time is used when setting the slaves' System Time Offset and Cyclic Operation Start Time registers and when synchronizing the DC reference clock to the application time via ecrt_master_sync_reference_clock().
The time is defined as nanoseconds from 2000-01-01 00:00. Converting an epoch time can be done with the EC_TIMEVAL2NANO() macro, but is not necessary, since the absolute value is not of any interest.
| master | EtherCAT master. |
| app_time | Application time. |
| EC_PUBLIC_API int ecrt_master_sync_reference_clock | ( | ec_master_t * | master | ) |
Queues the DC reference clock drift compensation datagram for sending.
The reference clock will by synchronized to the application time provided by the last call off ecrt_master_application_time().
| 0 | Success. |
| -ENXIO | No reference clock found. |
| master | EtherCAT master. |
| EC_PUBLIC_API int ecrt_master_sync_reference_clock_to | ( | ec_master_t * | master, |
| uint64_t | sync_time | ||
| ) |
Queues the DC reference clock drift compensation datagram for sending.
The reference clock will by synchronized to the time passed in the sync_time parameter.
Has to be called by the application after ecrt_master_activate() has returned.
| 0 | Success. |
| -ENXIO | No reference clock found. |
| master | EtherCAT master. |
| sync_time | Sync reference clock to this time. |
| EC_PUBLIC_API int ecrt_master_sync_slave_clocks | ( | ec_master_t * | master | ) |
Queues the DC clock drift compensation datagram for sending.
All slave clocks synchronized to the reference clock.
Has to be called by the application after ecrt_master_activate() has returned.
| 0 | Success. |
| -ENXIO | No reference clock found. |
| master | EtherCAT master. |
| EC_PUBLIC_API int ecrt_master_reference_clock_time | ( | const ec_master_t * | master, |
| uint32_t * | time | ||
| ) |
Get the lower 32 bit of the reference clock system time.
This method can be used to synchronize the master to the reference clock.
The reference clock system time is queried via the ecrt_master_sync_slave_clocks() method, that reads the system time of the reference clock and writes it to the slave clocks (so be sure to call it cyclically to get valid data).
Calling this method makes only sense in realtime context (after master activation), when the ecrt_master_sync_slave_clocks() method is called cyclically.
| 0 | success, system time was written into time. |
| -ENXIO | No reference clock found. |
| -EIO | Slave synchronization datagram was not received. |
| master | EtherCAT master. |
| time | Pointer to store the queried system time. |
| EC_PUBLIC_API int ecrt_master_sync_monitor_queue | ( | ec_master_t * | master | ) |
Queues the DC synchrony monitoring datagram for sending.
The datagram broadcast-reads all "System time difference" registers (0x092c) to get an upper estimation of the DC synchrony. The result can be checked with the ecrt_master_sync_monitor_process() method.
| master | EtherCAT master. |
| EC_PUBLIC_API uint32_t ecrt_master_sync_monitor_process | ( | const ec_master_t * | master | ) |
Processes the DC synchrony monitoring datagram.
If the sync monitoring datagram was sent before with ecrt_master_sync_monitor_queue(), the result can be queried with this method.
| (uint32_t)-1 | Error. |
| master | EtherCAT master. |
| EC_PUBLIC_API int ecrt_master_reset | ( | ec_master_t * | master | ) |
Retry configuring slaves.
Via this method, the application can tell the master to bring all slaves to OP state. In general, this is not necessary, because it is automatically done by the master. But with special slaves, that can be reconfigured by the vendor during runtime, it can be useful.
Calling this method only makes sense in realtime context (after activation), because slaves will not be configured before.
| master | EtherCAT master. |
| EC_PUBLIC_API int ecrt_slave_config_sync_manager | ( | ec_slave_config_t * | sc, |
| uint8_t | sync_index, | ||
| ec_direction_t | direction, | ||
| ec_watchdog_mode_t | watchdog_mode | ||
| ) |
Configure a sync manager.
Sets the direction of a sync manager. This overrides the direction bits from the default control register from SII.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| sync_index | Sync manager index. Must be less than EC_MAX_SYNC_MANAGERS. |
| direction | Input/Output. |
| watchdog_mode | Watchdog mode. |
Definition at line 679 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_watchdog | ( | ec_slave_config_t * | sc, |
| uint16_t | watchdog_divider, | ||
| uint16_t | watchdog_intervals | ||
| ) |
Configure a slave's watchdog times.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| watchdog_divider | Number of 40 ns intervals (register 0x0400). Used as a base unit for all slave watchdogs^. If set to zero, the value is not written, so the default is used. |
| watchdog_intervals | Number of base intervals for sync manager watchdog (register 0x0420). If set to zero, the value is not written, so the default is used. |
Definition at line 706 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_pdo_assign_add | ( | ec_slave_config_t * | sc, |
| uint8_t | sync_index, | ||
| uint16_t | index | ||
| ) |
Add a PDO to a sync manager's PDO assignment.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| sync_index | Sync manager index. Must be less than EC_MAX_SYNC_MANAGERS. |
| index | Index of the PDO to assign. |
Definition at line 719 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_pdo_assign_clear | ( | ec_slave_config_t * | sc, |
| uint8_t | sync_index | ||
| ) |
Clear a sync manager's PDO assignment.
This can be called before assigning PDOs via ecrt_slave_config_pdo_assign_add(), to clear the default assignment of a sync manager.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| sync_index | Sync manager index. Must be less than EC_MAX_SYNC_MANAGERS. |
Definition at line 749 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_pdo_mapping_add | ( | ec_slave_config_t * | sc, |
| uint16_t | pdo_index, | ||
| uint16_t | entry_index, | ||
| uint8_t | entry_subindex, | ||
| uint8_t | entry_bit_length | ||
| ) |
Add a PDO entry to the given PDO's mapping.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| pdo_index | Index of the PDO. |
| entry_index | Index of the PDO entry to add to the PDO's mapping. |
| entry_subindex | Subindex of the PDO entry to add to the PDO's mapping. |
| entry_bit_length | Size of the PDO entry in bit. |
Definition at line 768 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_pdo_mapping_clear | ( | ec_slave_config_t * | sc, |
| uint16_t | pdo_index | ||
| ) |
Clear the mapping of a given PDO.
This can be called before mapping PDO entries via ecrt_slave_config_pdo_mapping_add(), to clear the default mapping.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| pdo_index | Index of the PDO. |
Definition at line 805 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_pdos | ( | ec_slave_config_t * | sc, |
| unsigned int | n_syncs, | ||
| const ec_sync_info_t | syncs[] | ||
| ) |
Specify a complete PDO configuration.
This function is a convenience wrapper for the functions ecrt_slave_config_sync_manager(), ecrt_slave_config_pdo_assign_clear(), ecrt_slave_config_pdo_assign_add(), ecrt_slave_config_pdo_mapping_clear() and ecrt_slave_config_pdo_mapping_add(), that are better suitable for automatic code generation.
The following example shows, how to specify a complete configuration, including the PDO mappings. With this information, the master is able to reserve the complete process data, even if the slave is not present at configuration time:
The next example shows, how to configure the PDO assignment only. The entries for each assigned PDO are taken from the PDO's default mapping. Please note, that PDO entry registration will fail, if the PDO configuration is left empty and the slave is offline.
Processing of syncs will stop, if
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| n_syncs | Number of sync manager configurations in syncs. |
| syncs | Array of sync manager configurations. |
Definition at line 831 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_reg_pdo_entry | ( | ec_slave_config_t * | sc, |
| uint16_t | entry_index, | ||
| uint8_t | entry_subindex, | ||
| ec_domain_t * | domain, | ||
| unsigned int * | bit_position | ||
| ) |
Registers a PDO entry for process data exchange in a domain.
Searches the assigned PDOs for the given PDO entry. An error is raised, if the given entry is not mapped. Otherwise, the corresponding sync manager and FMMU configurations are provided for slave configuration and the respective sync manager's assigned PDOs are appended to the given domain, if not already done. The offset of the requested PDO entry's data inside the domain's process data is returned. Optionally, the PDO entry bit position (0-7) can be retrieved via the bit_position output parameter. This pointer may be NULL, in this case an error is raised if the PDO entry does not byte-align.
This method has to be called in non-realtime context before ecrt_master_activate().
| >=0 | Success: Offset of the PDO entry's process data. |
| <0 | Error code. |
| sc | Slave configuration. |
| entry_index | Index of the PDO entry to register. |
| entry_subindex | Subindex of the PDO entry to register. |
| domain | Domain. |
| bit_position | Optional address if bit addressing is desired |
Definition at line 898 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_reg_pdo_entry_pos | ( | ec_slave_config_t * | sc, |
| uint8_t | sync_index, | ||
| unsigned int | pdo_pos, | ||
| unsigned int | entry_pos, | ||
| ec_domain_t * | domain, | ||
| unsigned int * | bit_position | ||
| ) |
Registers a PDO entry using its position.
Similar to ecrt_slave_config_reg_pdo_entry(), but not using PDO indices but offsets in the PDO mapping, because PDO entry indices may not be unique inside a slave's PDO mapping. An error is raised, if one of the given positions is out of range.
This method has to be called in non-realtime context before ecrt_master_activate().
| >=0 | Success: Offset of the PDO entry's process data. |
| <0 | Error code. |
| sc | Slave configuration. |
| sync_index | Sync manager index. |
| pdo_pos | Position of the PDO inside the SM. |
| entry_pos | Position of the entry inside the PDO. |
| domain | Domain. |
| bit_position | Optional address if bit addressing is desired |
Definition at line 953 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_dc | ( | ec_slave_config_t * | sc, |
| uint16_t | assign_activate, | ||
| uint32_t | sync0_cycle, | ||
| int32_t | sync0_shift, | ||
| uint32_t | sync1_cycle, | ||
| int32_t | sync1_shift | ||
| ) |
Configure distributed clocks.
Sets the AssignActivate word and the cycle and shift times for the sync signals.
The AssignActivate word is vendor-specific and can be taken from the XML device description file (Device -> Dc -> AssignActivate). Set this to zero, if the slave shall be operated without distributed clocks (default).
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| assign_activate | AssignActivate word. |
| sync0_cycle | SYNC0 cycle time [ns]. |
| sync0_shift | SYNC0 shift time [ns]. |
| sync1_cycle | SYNC1 cycle time [ns]. |
| sync1_shift | SYNC1 shift time [ns]. |
Definition at line 1018 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_sdo | ( | ec_slave_config_t * | sc, |
| uint16_t | index, | ||
| uint8_t | subindex, | ||
| const uint8_t * | data, | ||
| size_t | size | ||
| ) |
Add an SDO configuration.
An SDO configuration is stored in the slave configuration object and is downloaded to the slave whenever the slave is being configured by the master. This usually happens once on master activation, but can be repeated subsequently, for example after the slave's power supply failed.
0x1C10 - 0x1C2F) and PDO mapping (0x1600 - 0x17FF and 0x1A00 - 0x1BFF) should not be configured with this function, because they are part of the slave configuration done by the master. Please use ecrt_slave_config_pdos() and friends instead.This is the generic function for adding an SDO configuration. Please note that the this function does not do any endianness correction. If datatype-specific functions are needed (that automatically correct the endianness), have a look at ecrt_slave_config_sdo8(), ecrt_slave_config_sdo16() and ecrt_slave_config_sdo32().
This method has to be called in non-realtime context before ecrt_master_activate().
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| index | Index of the SDO to configure. |
| subindex | Subindex of the SDO to configure. |
| data | Pointer to the data. |
| size | Size of the data. |
Definition at line 1038 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_sdo8 | ( | ec_slave_config_t * | sc, |
| uint16_t | sdo_index, | ||
| uint8_t | sdo_subindex, | ||
| uint8_t | value | ||
| ) |
Add a configuration value for an 8-bit SDO.
This method has to be called in non-realtime context before ecrt_master_activate().
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration |
| sdo_index | Index of the SDO to configure. |
| sdo_subindex | Subindex of the SDO to configure. |
| value | Value to set. |
Definition at line 1078 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_sdo16 | ( | ec_slave_config_t * | sc, |
| uint16_t | sdo_index, | ||
| uint8_t | sdo_subindex, | ||
| uint16_t | value | ||
| ) |
Add a configuration value for a 16-bit SDO.
This method has to be called in non-realtime context before ecrt_master_activate().
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration |
| sdo_index | Index of the SDO to configure. |
| sdo_subindex | Subindex of the SDO to configure. |
| value | Value to set. |
Definition at line 1093 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_sdo32 | ( | ec_slave_config_t * | sc, |
| uint16_t | sdo_index, | ||
| uint8_t | sdo_subindex, | ||
| uint32_t | value | ||
| ) |
Add a configuration value for a 32-bit SDO.
This method has to be called in non-realtime context before ecrt_master_activate().
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration |
| sdo_index | Index of the SDO to configure. |
| sdo_subindex | Subindex of the SDO to configure. |
| value | Value to set. |
Definition at line 1108 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_complete_sdo | ( | ec_slave_config_t * | sc, |
| uint16_t | index, | ||
| const uint8_t * | data, | ||
| size_t | size | ||
| ) |
Add configuration data for a complete SDO.
The SDO data are transferred via CompleteAccess. Data for the first subindex (0) have to be included.
This method has to be called in non-realtime context before ecrt_master_activate().
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| index | Index of the SDO to configure. |
| data | Pointer to the data. |
| size | Size of the data. |
Definition at line 1123 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_emerg_size | ( | ec_slave_config_t * | sc, |
| size_t | elements | ||
| ) |
Set the size of the CoE emergency ring buffer.
The initial size is zero, so all messages will be dropped. This method can be called even after master activation, but it will clear the ring buffer!
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| elements | Number of records of the CoE emergency ring. |
Definition at line 1163 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_emerg_pop | ( | ec_slave_config_t * | sc, |
| uint8_t * | target | ||
| ) |
Read and remove one record from the CoE emergency ring buffer.
A record consists of 8 bytes:
Byte 0-1: Error code (little endian) Byte 2: Error register Byte 3-7: Data
Calling this method makes only sense in realtime context (after master activation).
| sc | Slave configuration. |
| target | Pointer to target memory (at least EC_COE_EMERGENCY_MSG_SIZE bytes). |
Definition at line 1170 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_emerg_clear | ( | ec_slave_config_t * | sc | ) |
Clears CoE emergency ring buffer and the overrun counter.
Calling this method makes only sense in realtime context (after master activation).
| sc | Slave configuration. |
Definition at line 1177 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_emerg_overruns | ( | const ec_slave_config_t * | sc | ) |
Read the number of CoE emergency overruns.
The overrun counter will be incremented when a CoE emergency message could not be stored in the ring buffer and had to be dropped. Call ecrt_slave_config_emerg_clear() to reset the counter.
Calling this method makes only sense in realtime context (after master activation).
| sc | Slave configuration. |
Definition at line 1184 of file slave_config.c.
| EC_PUBLIC_API ec_sdo_request_t* ecrt_slave_config_create_sdo_request | ( | ec_slave_config_t * | sc, |
| uint16_t | index, | ||
| uint8_t | subindex, | ||
| size_t | size | ||
| ) |
Create an SDO request to exchange SDOs during realtime operation.
The created SDO request object is freed automatically when the master is released.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| index | SDO index. |
| subindex | SDO subindex. |
| size | Data size to reserve. |
Definition at line 1233 of file slave_config.c.
| EC_PUBLIC_API ec_soe_request_t* ecrt_slave_config_create_soe_request | ( | ec_slave_config_t * | sc, |
| uint8_t | drive_no, | ||
| uint16_t | idn, | ||
| size_t | size | ||
| ) |
Create an SoE request to exchange SoE IDNs during realtime operation.
The created SoE request object is freed automatically when the master is released.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| drive_no | Drive number. |
| idn | Sercos ID-Number. |
| size | Data size to reserve. |
Definition at line 1285 of file slave_config.c.
| EC_PUBLIC_API ec_voe_handler_t* ecrt_slave_config_create_voe_handler | ( | ec_slave_config_t * | sc, |
| size_t | size | ||
| ) |
Create an VoE handler to exchange vendor-specific data during realtime operation.
The number of VoE handlers per slave configuration is not limited, but usually it is enough to create one for sending and one for receiving, if both can be done simultaneously.
The created VoE handler object is freed automatically when the master is released.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| size | Data size to reserve. |
Definition at line 1370 of file slave_config.c.
| EC_PUBLIC_API ec_reg_request_t* ecrt_slave_config_create_reg_request | ( | ec_slave_config_t * | sc, |
| size_t | size | ||
| ) |
Create a register request to exchange EtherCAT register contents during realtime operation.
This interface should not be used to take over master functionality, instead it is intended for debugging and monitoring reasons.
The created register request object is freed automatically when the master is released.
This method has to be called in non-realtime context before ecrt_master_activate().
| sc | Slave configuration. |
| size | Data size to reserve. |
Definition at line 1328 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_state | ( | const ec_slave_config_t * | sc, |
| ec_slave_config_state_t * | state | ||
| ) |
Outputs the state of the slave configuration.
Stores the state information in the given state structure. The state information is updated by the master state machine, so it may take a few cycles, until it changes.
This method is meant to be called in realtime context (after master activation).
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration |
| state | State object to write to. |
Definition at line 1380 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_idn | ( | ec_slave_config_t * | sc, |
| uint8_t | drive_no, | ||
| uint16_t | idn, | ||
| ec_al_state_t | state, | ||
| const uint8_t * | data, | ||
| size_t | size | ||
| ) |
Add an SoE IDN configuration.
A configuration for a Sercos-over-EtherCAT IDN is stored in the slave configuration object and is written to the slave whenever the slave is being configured by the master. This usually happens once on master activation, but can be repeated subsequently, for example after the slave's power supply failed.
The idn parameter can be separated into several sections:
Please note that the this function does not do any endianness correction. Multi-byte data have to be passed in EtherCAT endianness (little-endian).
This method has to be called in non-realtime context before ecrt_master_activate().
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| drive_no | Drive number. |
| idn | SoE IDN. |
| state | AL state in which to write the IDN (PREOP or SAFEOP). |
| data | Pointer to the data. |
| size | Size of the data. |
Definition at line 1399 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_flag | ( | ec_slave_config_t * | sc, |
| const char * | key, | ||
| int32_t | value | ||
| ) |
Adds a feature flag to a slave configuration.
Feature flags are a generic way to configure slave-specific behavior.
Multiple calls with the same slave configuration and key will overwrite the configuration.
The following flags may be available:
This method has to be called in non-realtime context before ecrt_master_activate().
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| key | Key as null-terminated ASCII string. |
| value | Value to store. |
Definition at line 1454 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_eoe_mac_address | ( | ec_slave_config_t * | sc, |
| const unsigned char * | mac_address | ||
| ) |
Sets the link/MAC address for Ethernet-over-EtherCAT (EoE) operation.
This method has to be called in non-realtime context before ecrt_master_activate().
The MAC address is stored in the slave configuration object and will be written to the slave during the configuration process.
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| mac_address | MAC address. |
Definition at line 1492 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_eoe_ip_address | ( | ec_slave_config_t * | sc, |
| struct in_addr | ip_address | ||
| ) |
Sets the IP address for Ethernet-over-EtherCAT (EoE) operation.
This method has to be called in non-realtime context before ecrt_master_activate().
The IP address is stored in the slave configuration object and will be written to the slave during the configuration process.
The IP address is passed by-value as a struct in_addr. This structure contains the 32-bit IPv4 address in network byte order (big endian).
A string-represented IPv4 address can be converted to a struct in_addr for example via the POSIX function inet_pton() (see man 3 inet_pton):
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| ip_address | IPv4 address. |
Definition at line 1502 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_eoe_subnet_mask | ( | ec_slave_config_t * | sc, |
| struct in_addr | subnet_mask | ||
| ) |
Sets the subnet mask for Ethernet-over-EtherCAT (EoE) operation.
This method has to be called in non-realtime context before ecrt_master_activate().
The subnet mask is stored in the slave configuration object and will be written to the slave during the configuration process.
The subnet mask is passed by-value as a struct in_addr. This structure contains the 32-bit mask in network byte order (big endian).
See ecrt_slave_config_eoe_ip_address() on how to convert string-coded masks to struct in_addr.
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| subnet_mask | IPv4 subnet mask. |
Definition at line 1512 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_eoe_default_gateway | ( | ec_slave_config_t * | sc, |
| struct in_addr | gateway_address | ||
| ) |
Sets the gateway address for Ethernet-over-EtherCAT (EoE) operation.
This method has to be called in non-realtime context before ecrt_master_activate().
The gateway address is stored in the slave configuration object and will be written to the slave during the configuration process.
The address is passed by-value as a struct in_addr. This structure contains the 32-bit IPv4 address in network byte order (big endian).
See ecrt_slave_config_eoe_ip_address() on how to convert string-coded IPv4 addresses to struct in_addr.
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| gateway_address | Gateway's IPv4 address. |
Definition at line 1522 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_eoe_dns_address | ( | ec_slave_config_t * | sc, |
| struct in_addr | dns_address | ||
| ) |
Sets the IPv4 address of the DNS server for Ethernet-over-EtherCAT (EoE) operation.
This method has to be called in non-realtime context before ecrt_master_activate().
The DNS server address is stored in the slave configuration object and will be written to the slave during the configuration process.
The address is passed by-value as a struct in_addr. This structure contains the 32-bit IPv4 address in network byte order (big endian).
See ecrt_slave_config_eoe_ip_address() on how to convert string-coded IPv4 addresses to struct in_addr.
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| dns_address | IPv4 address of the DNS server. |
Definition at line 1532 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_eoe_hostname | ( | ec_slave_config_t * | sc, |
| const char * | name | ||
| ) |
Sets the host name for Ethernet-over-EtherCAT (EoE) operation.
This method has to be called in non-realtime context before ecrt_master_activate().
The host name is stored in the slave configuration object and will be written to the slave during the configuration process.
The maximum size of the host name is 32 bytes (including the zero terminator).
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| name | Zero-terminated host name. |
Definition at line 1542 of file slave_config.c.
| EC_PUBLIC_API int ecrt_slave_config_state_timeout | ( | ec_slave_config_t * | sc, |
| ec_al_state_t | from_state, | ||
| ec_al_state_t | to_state, | ||
| unsigned int | timeout_ms | ||
| ) |
Sets the application-layer state transition timeout in ms.
Change the maximum allowed time for a slave to make an application-layer state transition for the given state transition (for example from PREOP to SAFEOP). The default values are defined in ETG.2000.
A timeout value of zero ms will restore the default value.
This method has to be called in non-realtime context before ecrt_master_activate().
| 0 | Success. |
| <0 | Error code. |
| sc | Slave configuration. |
| from_state | Initial state. |
| to_state | Target state. |
| timeout_ms | Timeout in [ms]. |
Definition at line 1554 of file slave_config.c.
| EC_PUBLIC_API int ecrt_domain_reg_pdo_entry_list | ( | ec_domain_t * | domain, |
| const ec_pdo_entry_reg_t * | pdo_entry_regs | ||
| ) |
Registers a bunch of PDO entries for a domain.
This method has to be called in non-realtime context before ecrt_master_activate().
| domain | Domain. |
| pdo_entry_regs | Array of PDO registrations. |
| EC_PUBLIC_API size_t ecrt_domain_size | ( | const ec_domain_t * | domain | ) |
Returns the current size of the domain's process data.
The domain size is calculated after master activation.
| domain | Domain. |
| void ecrt_domain_external_memory | ( | ec_domain_t * | domain, |
| uint8_t * | memory | ||
| ) |
Provide external memory to store the domain's process data.
Call this after all PDO entries have been registered and before activating the master.
The size of the allocated memory must be at least ecrt_domain_size(), after all PDO entries have been registered.
This method has to be called in non-realtime context before ecrt_master_activate().
| domain | Domain. |
| memory | Address of the memory to store the process data in. |
| EC_PUBLIC_API uint8_t* ecrt_domain_data | ( | const ec_domain_t * | domain | ) |
Returns the domain's process data.
| domain | Domain. |
| EC_PUBLIC_API int ecrt_domain_process | ( | ec_domain_t * | domain | ) |
Determines the states of the domain's datagrams.
Evaluates the working counters of the received datagrams and outputs statistics, if necessary. This must be called after ecrt_master_receive() is expected to receive the domain datagrams in order to make ecrt_domain_state() return the result of the last process data exchange.
| domain | Domain. |
| EC_PUBLIC_API int ecrt_domain_queue | ( | ec_domain_t * | domain | ) |
(Re-)queues all domain datagrams in the master's datagram queue.
Call this function to mark the domain's datagrams for exchanging at the next call of ecrt_master_send().
| domain | Domain. |
| EC_PUBLIC_API int ecrt_domain_state | ( | const ec_domain_t * | domain, |
| ec_domain_state_t * | state | ||
| ) |
Reads the state of a domain.
Stores the domain state in the given state structure.
Using this method, the process data exchange can be monitored in realtime.
| domain | Domain. |
| state | Pointer to a state object to store the information. |
| EC_PUBLIC_API int ecrt_sdo_request_index | ( | ec_sdo_request_t * | req, |
| uint16_t | index, | ||
| uint8_t | subindex | ||
| ) |
Set the SDO index and subindex.
This method is meant to be called in realtime context (after master activation). To initialize the SDO request, the index and subindex can be set via ecrt_slave_config_create_sdo_request().
| req | SDO request. |
| index | SDO index. |
| subindex | SDO subindex. |
Definition at line 181 of file sdo_request.c.
| EC_PUBLIC_API int ecrt_sdo_request_timeout | ( | ec_sdo_request_t * | req, |
| uint32_t | timeout | ||
| ) |
Set the timeout for an SDO request.
If the request cannot be processed in the specified time, if will be marked as failed.
The timeout is permanently stored in the request object and is valid until the next call of this method.
The timeout should be defined in non-realtime context, but can also be changed afterwards.
| req | SDO request. |
| timeout | Timeout in milliseconds. Zero means no timeout. |
Definition at line 191 of file sdo_request.c.
| EC_PUBLIC_API uint8_t* ecrt_sdo_request_data | ( | const ec_sdo_request_t * | req | ) |
Access to the SDO request's data.
This function returns a pointer to the request's internal SDO data memory.
This method is meant to be called in realtime context (after master activation), but can also be used to initialize data before.
| req | SDO request. |
Definition at line 199 of file sdo_request.c.
| EC_PUBLIC_API size_t ecrt_sdo_request_data_size | ( | const ec_sdo_request_t * | req | ) |
Returns the current SDO data size.
When the SDO request is created, the data size is set to the size of the reserved memory. After a read operation the size is set to the size of the read data. The size is not modified in any other situation.
This method is meant to be called in realtime context (after master activation).
| req | SDO request. |
Definition at line 206 of file sdo_request.c.
| EC_PUBLIC_API ec_request_state_t ecrt_sdo_request_state | ( | const ec_sdo_request_t * | req | ) |
Get the current state of the SDO request.
The user-space implementation fetches incoming data and stores the received data size in the request object, so the request is not const.
This method is meant to be called in realtime context (after master activation).
| req | SDO request. |
Definition at line 213 of file sdo_request.c.
| EC_PUBLIC_API int ecrt_sdo_request_write | ( | ec_sdo_request_t * | req | ) |
Schedule an SDO write operation.
This method is meant to be called in realtime context (after master activation).
| -EINVAL | Invalid input data, e.g. data size == 0. |
| -ENOBUFS | Reserved memory in ecrt_slave_config_create_sdo_request() too small. |
| req | SDO request. |
Definition at line 232 of file sdo_request.c.
| EC_PUBLIC_API int ecrt_sdo_request_read | ( | ec_sdo_request_t * | req | ) |
Schedule an SDO read operation.
This method is meant to be called in realtime context (after master activation).
| req | SDO request. |
Definition at line 220 of file sdo_request.c.
| EC_PUBLIC_API int ecrt_soe_request_idn | ( | ec_soe_request_t * | req, |
| uint8_t | drive_no, | ||
| uint16_t | idn | ||
| ) |
Set the request's drive and Sercos ID numbers.
This method is meant to be called in realtime context (after master activation). To initialize the SoE request, the drive_no and IDN can be set via ecrt_slave_config_create_soe_request().
| req | IDN request. |
| drive_no | SDO index. |
| idn | SoE IDN. |
Definition at line 268 of file soe_request.c.
| EC_PUBLIC_API int ecrt_soe_request_timeout | ( | ec_soe_request_t * | req, |
| uint32_t | timeout | ||
| ) |
Set the timeout for an SoE request.
If the request cannot be processed in the specified time, if will be marked as failed.
The timeout is permanently stored in the request object and is valid until the next call of this method.
The timeout should be defined in non-realtime context, but can also be changed afterwards.
| req | SoE request. |
| timeout | Timeout in milliseconds. Zero means no timeout. |
Definition at line 278 of file soe_request.c.
| EC_PUBLIC_API uint8_t* ecrt_soe_request_data | ( | const ec_soe_request_t * | req | ) |
Access to the SoE request's data.
This function returns a pointer to the request's internal IDN data memory.
This method is meant to be called in realtime context (after master activation), but can also be used to initialize data before.
| req | SoE request. |
Definition at line 286 of file soe_request.c.
| EC_PUBLIC_API size_t ecrt_soe_request_data_size | ( | const ec_soe_request_t * | req | ) |
Returns the current IDN data size.
When the SoE request is created, the data size is set to the size of the reserved memory. After a read operation the size is set to the size of the read data. The size is not modified in any other situation.
| req | SoE request. |
Definition at line 293 of file soe_request.c.
| EC_PUBLIC_API ec_request_state_t ecrt_soe_request_state | ( | const ec_soe_request_t * | req | ) |
Get the current state of the SoE request.
This method is meant to be called in realtime context (after master activation).
In the user-space implementation, the method fetches the size of the incoming data, so the request object is not const.
| req | SoE request. |
Definition at line 300 of file soe_request.c.
| EC_PUBLIC_API int ecrt_soe_request_write | ( | ec_soe_request_t * | req | ) |
Schedule an SoE IDN write operation.
This method is meant to be called in realtime context (after master activation).
| -EINVAL | Invalid input data, e.g. data size == 0. |
| -ENOBUFS | Reserved memory in ecrt_slave_config_create_soe_request() too small. |
| req | SoE request. |
Definition at line 314 of file soe_request.c.
| EC_PUBLIC_API int ecrt_soe_request_read | ( | ec_soe_request_t * | req | ) |
Schedule an SoE IDN read operation.
This method is meant to be called in realtime context (after master activation).
| req | SoE request. |
Definition at line 307 of file soe_request.c.
| EC_PUBLIC_API int ecrt_voe_handler_send_header | ( | ec_voe_handler_t * | voe, |
| uint32_t | vendor_id, | ||
| uint16_t | vendor_type | ||
| ) |
Sets the VoE header for future send operations.
A VoE message shall contain a 4-byte vendor ID, followed by a 2-byte vendor type at as header. These numbers can be set with this function. The values are valid and will be used for future send operations until the next call of this method.
This method is meant to be called in non-realtime context (before master activation) to initialize the header data, but it is also safe to change the header later on in realtime context.
| voe | VoE handler. |
| vendor_id | Vendor ID. |
| vendor_type | Vendor-specific type. |
Definition at line 115 of file voe_handler.c.
| EC_PUBLIC_API int ecrt_voe_handler_received_header | ( | const ec_voe_handler_t * | voe, |
| uint32_t * | vendor_id, | ||
| uint16_t * | vendor_type | ||
| ) |
Reads the header data of a received VoE message.
This method can be used to get the received VoE header information after a read operation has succeeded.
The header information is stored at the memory given by the pointer parameters.
This method is meant to be called in realtime context (after master activation).
| voe | VoE handler. |
| vendor_id | Vendor ID. |
| vendor_type | Vendor-specific type. |
Definition at line 125 of file voe_handler.c.
| EC_PUBLIC_API uint8_t* ecrt_voe_handler_data | ( | const ec_voe_handler_t * | voe | ) |
Access to the VoE handler's data.
This function returns a pointer to the VoE handler's internal memory, that points to the actual VoE data right after the VoE header (see ecrt_voe_handler_send_header()).
| voe | VoE handler. |
Definition at line 139 of file voe_handler.c.
| EC_PUBLIC_API size_t ecrt_voe_handler_data_size | ( | const ec_voe_handler_t * | voe | ) |
Returns the current data size.
The data size is the size of the VoE data without the header (see ecrt_voe_handler_send_header()).
When the VoE handler is created, the data size is set to the size of the reserved memory. At a write operation, the data size is set to the number of bytes to write. After a read operation the size is set to the size of the read data. The size is not modified in any other situation.
| voe | VoE handler. |
Definition at line 146 of file voe_handler.c.
| EC_PUBLIC_API int ecrt_voe_handler_write | ( | ec_voe_handler_t * | voe, |
| size_t | size | ||
| ) |
Start a VoE write operation.
After this function has been called, the ecrt_voe_handler_execute() method must be called in every realtime cycle as long as it returns EC_REQUEST_BUSY. No other operation may be started while the handler is busy.
This method is meant to be called in realtime context (after master activation).
| -ENOBUFS | Reserved memory in ecrt_slave_config_create_voe_handler too small. |
| voe | VoE handler. |
| size | Number of bytes to write (without the VoE header). |
Definition at line 173 of file voe_handler.c.
| EC_PUBLIC_API int ecrt_voe_handler_read | ( | ec_voe_handler_t * | voe | ) |
Start a VoE read operation.
After this function has been called, the ecrt_voe_handler_execute() method must be called in every realtime cycle as long as it returns EC_REQUEST_BUSY. No other operation may be started while the handler is busy.
The state machine queries the slave's send mailbox for new data to be send to the master. If no data appear within the EC_VOE_RESPONSE_TIMEOUT (defined in master/voe_handler.c), the operation fails.
On success, the size of the read data can be determined via ecrt_voe_handler_data_size(), while the VoE header of the received data can be retrieved with ecrt_voe_handler_received_header().
This method is meant to be called in realtime context (after master activation).
| voe | VoE handler. |
Definition at line 153 of file voe_handler.c.
| EC_PUBLIC_API int ecrt_voe_handler_read_nosync | ( | ec_voe_handler_t * | voe | ) |
Start a VoE read operation without querying the sync manager status.
After this function has been called, the ecrt_voe_handler_execute() method must be called in every realtime cycle as long as it returns EC_REQUEST_BUSY. No other operation may be started while the handler is busy.
The state machine queries the slave by sending an empty mailbox. The slave fills its data to the master in this mailbox. If no data appear within the EC_VOE_RESPONSE_TIMEOUT (defined in master/voe_handler.c), the operation fails.
On success, the size of the read data can be determined via ecrt_voe_handler_data_size(), while the VoE header of the received data can be retrieved with ecrt_voe_handler_received_header().
This method is meant to be called in realtime context (after master activation).
| voe | VoE handler. |
Definition at line 163 of file voe_handler.c.
| EC_PUBLIC_API ec_request_state_t ecrt_voe_handler_execute | ( | ec_voe_handler_t * | voe | ) |
Execute the handler.
This method executes the VoE handler. It has to be called in every realtime cycle as long as it returns EC_REQUEST_BUSY.
This method is meant to be called in realtime context (after master activation).
| voe | VoE handler. |
Definition at line 184 of file voe_handler.c.
| EC_PUBLIC_API uint8_t* ecrt_reg_request_data | ( | const ec_reg_request_t * | req | ) |
Access to the register request's data.
This function returns a pointer to the request's internal memory.
This method is meant to be called in realtime context (after master activation), but can also be used to initialize data before.
| req | Register request. |
Definition at line 78 of file reg_request.c.
| EC_PUBLIC_API ec_request_state_t ecrt_reg_request_state | ( | const ec_reg_request_t * | req | ) |
Get the current state of the register request.
This method is meant to be called in realtime context (after master activation).
| req | Register request. |
Definition at line 85 of file reg_request.c.
| EC_PUBLIC_API int ecrt_reg_request_write | ( | ec_reg_request_t * | req, |
| uint16_t | address, | ||
| size_t | size | ||
| ) |
Schedule an register write operation.
This method is meant to be called in realtime context (after master activation).
| -ENOBUFS | Reserved memory in ecrt_slave_config_create_reg_request too small. |
| req | Register request. |
| address | Register address. |
| size | Size to write. |
Definition at line 92 of file reg_request.c.
| EC_PUBLIC_API int ecrt_reg_request_read | ( | ec_reg_request_t * | req, |
| uint16_t | address, | ||
| size_t | size | ||
| ) |
Schedule a register read operation.
This method is meant to be called in realtime context (after master activation).
| -ENOBUFS | Reserved memory in ecrt_slave_config_create_reg_request too small. |
| req | Register request. |
| address | Register address. |
| size | Size to write. |
Definition at line 104 of file reg_request.c.
. -
IgH EtherCAT Master developed by
Ingenieurgemeinschaft IgH GmbH
.
All rights reserved.