79 /** |
79 /** |
80 * Bus status. |
80 * Bus status. |
81 */ |
81 */ |
82 |
82 |
83 typedef enum { |
83 typedef enum { |
84 EC_BUS_FAILURE, // some slaves offline |
84 EC_BUS_FAILURE = -1, /**< At least one slave with process data exchange |
85 EC_BUS_OK, // all slaves online |
85 is offline. */ |
86 EC_BUS_REDUNDANCY // bus interrupted, but redundancy active |
86 EC_BUS_OK /**< All slaves with process data exchange are |
|
87 online. */ |
87 } |
88 } |
88 ec_bus_status_t; |
89 ec_bus_status_t; |
89 |
90 |
90 /** |
91 /** |
91 * Master status. |
92 * Master status. |
92 * This is used for the output parameter of ecrt_master_get_status(). |
93 * This is used for the output parameter of ecrt_master_get_status(). |
93 */ |
94 */ |
94 |
95 |
95 typedef struct { |
96 typedef struct { |
96 ec_bus_status_t bus_status; |
97 ec_bus_status_t bus_status; /**< \see ec_bus_status_t */ |
97 unsigned int bus_tainted; |
98 unsigned int bus_tainted; /**< non-zero, if the bus topology is invalid */ |
98 unsigned int slaves_responding; |
99 unsigned int slaves_responding; /**< number of responging slaves */ |
99 } |
100 } |
100 ec_master_status_t; |
101 ec_master_status_t; |
101 |
102 |
102 /** |
103 /** |
103 Initialization type for PDO registrations. |
104 * List entry for domain PDO registrations. |
104 This type is used as a parameter for the ecrt_domain_register_pdo_list() |
105 * This type is used as a parameter for the ecrt_domain_register_pdo_list() |
105 function. |
106 * convenience function. |
106 */ |
107 */ |
107 |
108 |
108 typedef struct |
109 typedef struct { |
109 { |
110 const char *slave_address; /**< slave address string |
110 const char *slave_address; /**< slave address string (see |
111 \see ec_master_parse_slave_address() */ |
111 ecrt_master_get_slave()) */ |
|
112 uint32_t vendor_id; /**< vendor ID */ |
112 uint32_t vendor_id; /**< vendor ID */ |
113 uint32_t product_code; /**< product code */ |
113 uint32_t product_code; /**< product code */ |
114 uint16_t pdo_entry_index; /**< PDO entry index */ |
114 uint16_t pdo_entry_index; /**< PDO entry index */ |
115 uint8_t pdo_entry_subindex; /**< PDO entry subindex */ |
115 uint8_t pdo_entry_subindex; /**< PDO entry subindex */ |
116 void **data_ptr; /**< address of the process data pointer */ |
116 void **data_ptr; /**< address of the process data pointer */ |
117 } |
117 } |
118 ec_pdo_reg_t; |
118 ec_pdo_reg_t; |
119 |
119 |
120 /** |
120 /** |
121 Direction type for ecrt_domain_register_pdo_range() |
121 * Direction type for PDO mapping and range registration functions. |
122 */ |
122 */ |
123 |
123 |
124 typedef enum { |
124 typedef enum { |
125 EC_DIR_OUTPUT, |
125 EC_DIR_OUTPUT, /**< values written by master */ |
126 EC_DIR_INPUT |
126 EC_DIR_INPUT /**< values read by master */ |
127 } |
127 } |
128 ec_direction_t; |
128 ec_direction_t; |
129 |
129 |
130 /****************************************************************************** |
130 /****************************************************************************** |
131 * Master request functions |
131 * Global functions |
132 *****************************************************************************/ |
132 *****************************************************************************/ |
133 |
133 |
134 ec_master_t *ecrt_request_master(unsigned int master_index); |
134 ec_master_t *ecrt_request_master(unsigned int master_index); |
135 void ecrt_release_master(ec_master_t *master); |
135 void ecrt_release_master(ec_master_t *master); |
136 |
136 |
143 void ecrt_master_callbacks(ec_master_t *master, int (*request_cb)(void *), |
143 void ecrt_master_callbacks(ec_master_t *master, int (*request_cb)(void *), |
144 void (*release_cb)(void *), void *cb_data); |
144 void (*release_cb)(void *), void *cb_data); |
145 |
145 |
146 ec_domain_t *ecrt_master_create_domain(ec_master_t *master); |
146 ec_domain_t *ecrt_master_create_domain(ec_master_t *master); |
147 |
147 |
|
148 ec_slave_t *ecrt_master_get_slave(const ec_master_t *, const char *, |
|
149 uint32_t vendor_id, uint32_t product_code); |
|
150 |
148 int ecrt_master_activate(ec_master_t *master); |
151 int ecrt_master_activate(ec_master_t *master); |
149 |
152 |
150 void ecrt_master_send(ec_master_t *master); |
153 void ecrt_master_send(ec_master_t *master); |
151 void ecrt_master_receive(ec_master_t *master); |
154 void ecrt_master_receive(ec_master_t *master); |
152 |
155 |
153 ec_slave_t *ecrt_master_get_slave(const ec_master_t *, const char *); |
|
154 |
|
155 void ecrt_master_get_status(const ec_master_t *master, ec_master_status_t *); |
156 void ecrt_master_get_status(const ec_master_t *master, ec_master_status_t *); |
156 |
157 |
157 /****************************************************************************** |
158 /****************************************************************************** |
158 * Domain Methods |
159 * Domain Methods |
159 *****************************************************************************/ |
160 *****************************************************************************/ |
160 |
161 |
161 ec_slave_t *ecrt_domain_register_pdo(ec_domain_t *domain, |
162 int ecrt_domain_register_pdo(ec_domain_t *domain, ec_slave_t *slave, |
162 const char *address, |
163 uint16_t pdo_index, uint8_t pdo_subindex, void **data_ptr); |
163 uint32_t vendor_id, |
164 |
164 uint32_t product_code, |
165 int ecrt_domain_register_pdo_range(ec_domain_t *domain, ec_slave_t *slave, |
165 uint16_t pdo_index, |
166 ec_direction_t direction, uint16_t offset, uint16_t length, |
166 uint8_t pdo_subindex, |
167 void **data_ptr); |
167 void **data_ptr); |
|
168 |
168 |
169 int ecrt_domain_register_pdo_list(ec_domain_t *domain, |
169 int ecrt_domain_register_pdo_list(ec_domain_t *domain, |
170 const ec_pdo_reg_t *pdos); |
170 const ec_pdo_reg_t *pdos); |
171 |
|
172 ec_slave_t *ecrt_domain_register_pdo_range(ec_domain_t *domain, |
|
173 const char *address, |
|
174 uint32_t vendor_id, |
|
175 uint32_t product_code, |
|
176 ec_direction_t direction, |
|
177 uint16_t offset, |
|
178 uint16_t length, |
|
179 void **data_ptr); |
|
180 |
171 |
181 void ecrt_domain_process(ec_domain_t *domain); |
172 void ecrt_domain_process(ec_domain_t *domain); |
182 void ecrt_domain_queue(ec_domain_t *domain); |
173 void ecrt_domain_queue(ec_domain_t *domain); |
|
174 |
183 int ecrt_domain_state(const ec_domain_t *domain); |
175 int ecrt_domain_state(const ec_domain_t *domain); |
184 |
176 |
185 /****************************************************************************** |
177 /****************************************************************************** |
186 * Slave Methods |
178 * Slave Methods |
187 *****************************************************************************/ |
179 *****************************************************************************/ |
200 /****************************************************************************** |
192 /****************************************************************************** |
201 * Bitwise read/write macros |
193 * Bitwise read/write macros |
202 *****************************************************************************/ |
194 *****************************************************************************/ |
203 |
195 |
204 /** |
196 /** |
205 Read a certain bit of an EtherCAT data byte. |
197 * Read a certain bit of an EtherCAT data byte. |
206 \param DATA EtherCAT data pointer |
198 * \param DATA EtherCAT data pointer |
207 \param POS bit position |
199 * \param POS bit position |
208 */ |
200 */ |
209 |
201 |
210 #define EC_READ_BIT(DATA, POS) ((*((uint8_t *) (DATA)) >> (POS)) & 0x01) |
202 #define EC_READ_BIT(DATA, POS) ((*((uint8_t *) (DATA)) >> (POS)) & 0x01) |
211 |
203 |
212 /** |
204 /** |
213 Write a certain bit of an EtherCAT data byte. |
205 * Write a certain bit of an EtherCAT data byte. |
214 \param DATA EtherCAT data pointer |
206 * \param DATA EtherCAT data pointer |
215 \param POS bit position |
207 * \param POS bit position |
216 \param VAL new bit value |
208 * \param VAL new bit value |
217 */ |
209 */ |
218 |
210 |
219 #define EC_WRITE_BIT(DATA, POS, VAL) \ |
211 #define EC_WRITE_BIT(DATA, POS, VAL) \ |
220 do { \ |
212 do { \ |
221 if (VAL) *((uint8_t *) (DATA)) |= (1 << (POS)); \ |
213 if (VAL) *((uint8_t *) (DATA)) |= (1 << (POS)); \ |
222 else *((uint8_t *) (DATA)) &= ~(1 << (POS)); \ |
214 else *((uint8_t *) (DATA)) &= ~(1 << (POS)); \ |
225 /****************************************************************************** |
217 /****************************************************************************** |
226 * Read macros |
218 * Read macros |
227 *****************************************************************************/ |
219 *****************************************************************************/ |
228 |
220 |
229 /** |
221 /** |
230 Read an 8-bit unsigned value from EtherCAT data. |
222 * Read an 8-bit unsigned value from EtherCAT data. |
231 \return EtherCAT data value |
223 * \return EtherCAT data value |
232 */ |
224 */ |
233 |
225 |
234 #define EC_READ_U8(DATA) \ |
226 #define EC_READ_U8(DATA) \ |
235 ((uint8_t) *((uint8_t *) (DATA))) |
227 ((uint8_t) *((uint8_t *) (DATA))) |
236 |
228 |
237 /** |
229 /** |
238 Read an 8-bit signed value from EtherCAT data. |
230 * Read an 8-bit signed value from EtherCAT data. |
239 \param DATA EtherCAT data pointer |
231 * \param DATA EtherCAT data pointer |
240 \return EtherCAT data value |
232 * \return EtherCAT data value |
241 */ |
233 */ |
242 |
234 |
243 #define EC_READ_S8(DATA) \ |
235 #define EC_READ_S8(DATA) \ |
244 ((int8_t) *((uint8_t *) (DATA))) |
236 ((int8_t) *((uint8_t *) (DATA))) |
245 |
237 |
246 /** |
238 /** |
247 Read a 16-bit unsigned value from EtherCAT data. |
239 * Read a 16-bit unsigned value from EtherCAT data. |
248 \param DATA EtherCAT data pointer |
240 * \param DATA EtherCAT data pointer |
249 \return EtherCAT data value |
241 * \return EtherCAT data value |
250 */ |
242 */ |
251 |
243 |
252 #define EC_READ_U16(DATA) \ |
244 #define EC_READ_U16(DATA) \ |
253 ((uint16_t) le16_to_cpup((void *) (DATA))) |
245 ((uint16_t) le16_to_cpup((void *) (DATA))) |
254 |
246 |
255 /** |
247 /** |
256 Read a 16-bit signed value from EtherCAT data. |
248 * Read a 16-bit signed value from EtherCAT data. |
257 \param DATA EtherCAT data pointer |
249 * \param DATA EtherCAT data pointer |
258 \return EtherCAT data value |
250 * \return EtherCAT data value |
259 */ |
251 */ |
260 |
252 |
261 #define EC_READ_S16(DATA) \ |
253 #define EC_READ_S16(DATA) \ |
262 ((int16_t) le16_to_cpup((void *) (DATA))) |
254 ((int16_t) le16_to_cpup((void *) (DATA))) |
263 |
255 |
264 /** |
256 /** |
265 Read a 32-bit unsigned value from EtherCAT data. |
257 * Read a 32-bit unsigned value from EtherCAT data. |
266 \param DATA EtherCAT data pointer |
258 * \param DATA EtherCAT data pointer |
267 \return EtherCAT data value |
259 * \return EtherCAT data value |
268 */ |
260 */ |
269 |
261 |
270 #define EC_READ_U32(DATA) \ |
262 #define EC_READ_U32(DATA) \ |
271 ((uint32_t) le32_to_cpup((void *) (DATA))) |
263 ((uint32_t) le32_to_cpup((void *) (DATA))) |
272 |
264 |
273 /** |
265 /** |
274 Read a 32-bit signed value from EtherCAT data. |
266 * Read a 32-bit signed value from EtherCAT data. |
275 \param DATA EtherCAT data pointer |
267 * \param DATA EtherCAT data pointer |
276 \return EtherCAT data value |
268 * \return EtherCAT data value |
277 */ |
269 */ |
278 |
270 |
279 #define EC_READ_S32(DATA) \ |
271 #define EC_READ_S32(DATA) \ |
280 ((int32_t) le32_to_cpup((void *) (DATA))) |
272 ((int32_t) le32_to_cpup((void *) (DATA))) |
281 |
273 |
282 |
|
283 /****************************************************************************** |
274 /****************************************************************************** |
284 * Write macros |
275 * Write macros |
285 *****************************************************************************/ |
276 *****************************************************************************/ |
286 |
277 |
287 /** |
278 /** |
288 Write an 8-bit unsigned value to EtherCAT data. |
279 * Write an 8-bit unsigned value to EtherCAT data. |
289 \param DATA EtherCAT data pointer |
280 * \param DATA EtherCAT data pointer |
290 \param VAL new value |
281 * \param VAL new value |
291 */ |
282 */ |
292 |
283 |
293 #define EC_WRITE_U8(DATA, VAL) \ |
284 #define EC_WRITE_U8(DATA, VAL) \ |
294 do { \ |
285 do { \ |
295 *((uint8_t *)(DATA)) = ((uint8_t) (VAL)); \ |
286 *((uint8_t *)(DATA)) = ((uint8_t) (VAL)); \ |
296 } while (0) |
287 } while (0) |
297 |
288 |
298 /** |
289 /** |
299 Write an 8-bit signed value to EtherCAT data. |
290 * Write an 8-bit signed value to EtherCAT data. |
300 \param DATA EtherCAT data pointer |
291 * \param DATA EtherCAT data pointer |
301 \param VAL new value |
292 * \param VAL new value |
302 */ |
293 */ |
303 |
294 |
304 #define EC_WRITE_S8(DATA, VAL) EC_WRITE_U8(DATA, VAL) |
295 #define EC_WRITE_S8(DATA, VAL) EC_WRITE_U8(DATA, VAL) |
305 |
296 |
306 /** |
297 /** |
307 Write a 16-bit unsigned value to EtherCAT data. |
298 * Write a 16-bit unsigned value to EtherCAT data. |
308 \param DATA EtherCAT data pointer |
299 * \param DATA EtherCAT data pointer |
309 \param VAL new value |
300 * \param VAL new value |
310 */ |
301 */ |
311 |
302 |
312 #define EC_WRITE_U16(DATA, VAL) \ |
303 #define EC_WRITE_U16(DATA, VAL) \ |
313 do { \ |
304 do { \ |
314 *((uint16_t *) (DATA)) = (uint16_t) (VAL); \ |
305 *((uint16_t *) (DATA)) = (uint16_t) (VAL); \ |
315 cpu_to_le16s(DATA); \ |
306 cpu_to_le16s(DATA); \ |
316 } while (0) |
307 } while (0) |
317 |
308 |
318 /** |
309 /** |
319 Write a 16-bit signed value to EtherCAT data. |
310 * Write a 16-bit signed value to EtherCAT data. |
320 \param DATA EtherCAT data pointer |
311 * \param DATA EtherCAT data pointer |
321 \param VAL new value |
312 * \param VAL new value |
322 */ |
313 */ |
323 |
314 |
324 #define EC_WRITE_S16(DATA, VAL) EC_WRITE_U16(DATA, VAL) |
315 #define EC_WRITE_S16(DATA, VAL) EC_WRITE_U16(DATA, VAL) |
325 |
316 |
326 /** |
317 /** |
327 Write a 32-bit unsigned value to EtherCAT data. |
318 * Write a 32-bit unsigned value to EtherCAT data. |
328 \param DATA EtherCAT data pointer |
319 * \param DATA EtherCAT data pointer |
329 \param VAL new value |
320 * \param VAL new value |
330 */ |
321 */ |
331 |
322 |
332 #define EC_WRITE_U32(DATA, VAL) \ |
323 #define EC_WRITE_U32(DATA, VAL) \ |
333 do { \ |
324 do { \ |
334 *((uint32_t *) (DATA)) = (uint32_t) (VAL); \ |
325 *((uint32_t *) (DATA)) = (uint32_t) (VAL); \ |
335 cpu_to_le16s(DATA); \ |
326 cpu_to_le16s(DATA); \ |
336 } while (0) |
327 } while (0) |
337 |
328 |
338 /** |
329 /** |
339 Write a 32-bit signed value to EtherCAT data. |
330 * Write a 32-bit signed value to EtherCAT data. |
340 \param DATA EtherCAT data pointer |
331 * \param DATA EtherCAT data pointer |
341 \param VAL new value |
332 * \param VAL new value |
342 */ |
333 */ |
343 |
334 |
344 #define EC_WRITE_S32(DATA, VAL) EC_WRITE_U32(DATA, VAL) |
335 #define EC_WRITE_S32(DATA, VAL) EC_WRITE_U32(DATA, VAL) |
345 |
336 |
346 /*****************************************************************************/ |
337 /*****************************************************************************/ |
347 |
338 |