diff -r 2cf6ae0a2419 -r 14aeb79aa992 master/master.c --- a/master/master.c Tue Jun 27 20:24:32 2006 +0000 +++ b/master/master.c Thu Jul 06 08:23:24 2006 +0000 @@ -50,7 +50,7 @@ #include "slave.h" #include "types.h" #include "device.h" -#include "command.h" +#include "datagram.h" #include "ethernet.h" /*****************************************************************************/ @@ -110,10 +110,10 @@ master->device = NULL; master->reserved = 0; INIT_LIST_HEAD(&master->slaves); - INIT_LIST_HEAD(&master->command_queue); + INIT_LIST_HEAD(&master->datagram_queue); INIT_LIST_HEAD(&master->domains); INIT_LIST_HEAD(&master->eoe_handlers); - ec_command_init(&master->simple_command); + ec_datagram_init(&master->simple_datagram); INIT_WORK(&master->freerun_work, ec_master_freerun, (void *) master); init_timer(&master->eoe_timer); master->eoe_timer.function = ec_master_eoe_run; @@ -171,7 +171,7 @@ /** Master destructor. - Removes all pending commands, clears the slave list, clears all domains + Removes all pending datagrams, clears the slave list, clears all domains and frees the device. */ @@ -184,7 +184,7 @@ ec_master_reset(master); ec_fsm_clear(&master->fsm); - ec_command_clear(&master->simple_command); + ec_datagram_clear(&master->simple_datagram); destroy_workqueue(master->workqueue); // clear EoE objects @@ -212,17 +212,18 @@ void ec_master_reset(ec_master_t *master /**< EtherCAT master */) { - ec_command_t *command, *next_c; + ec_datagram_t *datagram, *next_c; ec_domain_t *domain, *next_d; ec_master_eoe_stop(master); ec_master_freerun_stop(master); ec_master_clear_slaves(master); - // empty command queue - list_for_each_entry_safe(command, next_c, &master->command_queue, queue) { - list_del_init(&command->queue); - command->state = EC_CMD_ERROR; + // empty datagram queue + list_for_each_entry_safe(datagram, next_c, + &master->datagram_queue, queue) { + list_del_init(&datagram->queue); + datagram->state = EC_CMD_ERROR; } // clear domains @@ -232,7 +233,7 @@ kobject_put(&domain->kobj); } - master->command_index = 0; + master->datagram_index = 0; master->debug_level = 0; master->timeout = 500; // 500us @@ -274,97 +275,97 @@ /*****************************************************************************/ /** - Places a command in the command queue. -*/ - -void ec_master_queue_command(ec_master_t *master, /**< EtherCAT master */ - ec_command_t *command /**< command */ - ) -{ - ec_command_t *queued_command; - - // check, if the command is already queued - list_for_each_entry(queued_command, &master->command_queue, queue) { - if (queued_command == command) { - command->state = EC_CMD_QUEUED; + Places a datagram in the datagram queue. +*/ + +void ec_master_queue_datagram(ec_master_t *master, /**< EtherCAT master */ + ec_datagram_t *datagram /**< datagram */ + ) +{ + ec_datagram_t *queued_datagram; + + // check, if the datagram is already queued + list_for_each_entry(queued_datagram, &master->datagram_queue, queue) { + if (queued_datagram == datagram) { + datagram->state = EC_CMD_QUEUED; if (unlikely(master->debug_level)) - EC_WARN("command already queued.\n"); + EC_WARN("datagram already queued.\n"); return; } } - list_add_tail(&command->queue, &master->command_queue); - command->state = EC_CMD_QUEUED; -} - -/*****************************************************************************/ - -/** - Sends the commands in the queue. + list_add_tail(&datagram->queue, &master->datagram_queue); + datagram->state = EC_CMD_QUEUED; +} + +/*****************************************************************************/ + +/** + Sends the datagrams in the queue. \return 0 in case of success, else < 0 */ -void ec_master_send_commands(ec_master_t *master /**< EtherCAT master */) -{ - ec_command_t *command; - size_t command_size; +void ec_master_send_datagrams(ec_master_t *master /**< EtherCAT master */) +{ + ec_datagram_t *datagram; + size_t datagram_size; uint8_t *frame_data, *cur_data; void *follows_word; cycles_t t_start, t_end; - unsigned int frame_count, more_commands_waiting; + unsigned int frame_count, more_datagrams_waiting; frame_count = 0; t_start = get_cycles(); if (unlikely(master->debug_level > 0)) - EC_DBG("ec_master_send_commands\n"); + EC_DBG("ec_master_send_datagrams\n"); do { // fetch pointer to transmit socket buffer frame_data = ec_device_tx_data(master->device); cur_data = frame_data + EC_FRAME_HEADER_SIZE; follows_word = NULL; - more_commands_waiting = 0; - - // fill current frame with commands - list_for_each_entry(command, &master->command_queue, queue) { - if (command->state != EC_CMD_QUEUED) continue; - - // does the current command fit in the frame? - command_size = EC_COMMAND_HEADER_SIZE + command->data_size - + EC_COMMAND_FOOTER_SIZE; - if (cur_data - frame_data + command_size > ETH_DATA_LEN) { - more_commands_waiting = 1; + more_datagrams_waiting = 0; + + // fill current frame with datagrams + list_for_each_entry(datagram, &master->datagram_queue, queue) { + if (datagram->state != EC_CMD_QUEUED) continue; + + // does the current datagram fit in the frame? + datagram_size = EC_DATAGRAM_HEADER_SIZE + datagram->data_size + + EC_DATAGRAM_FOOTER_SIZE; + if (cur_data - frame_data + datagram_size > ETH_DATA_LEN) { + more_datagrams_waiting = 1; break; } - command->state = EC_CMD_SENT; - command->t_sent = t_start; - command->index = master->command_index++; + datagram->state = EC_CMD_SENT; + datagram->t_sent = t_start; + datagram->index = master->datagram_index++; if (unlikely(master->debug_level > 0)) - EC_DBG("adding command 0x%02X\n", command->index); - - // set "command following" flag in previous frame + EC_DBG("adding datagram 0x%02X\n", datagram->index); + + // set "datagram following" flag in previous frame if (follows_word) EC_WRITE_U16(follows_word, EC_READ_U16(follows_word) | 0x8000); - // EtherCAT command header - EC_WRITE_U8 (cur_data, command->type); - EC_WRITE_U8 (cur_data + 1, command->index); - EC_WRITE_U32(cur_data + 2, command->address.logical); - EC_WRITE_U16(cur_data + 6, command->data_size & 0x7FF); + // EtherCAT datagram header + EC_WRITE_U8 (cur_data, datagram->type); + EC_WRITE_U8 (cur_data + 1, datagram->index); + EC_WRITE_U32(cur_data + 2, datagram->address.logical); + EC_WRITE_U16(cur_data + 6, datagram->data_size & 0x7FF); EC_WRITE_U16(cur_data + 8, 0x0000); follows_word = cur_data + 6; - cur_data += EC_COMMAND_HEADER_SIZE; - - // EtherCAT command data - memcpy(cur_data, command->data, command->data_size); - cur_data += command->data_size; - - // EtherCAT command footer + cur_data += EC_DATAGRAM_HEADER_SIZE; + + // EtherCAT datagram data + memcpy(cur_data, datagram->data, datagram->data_size); + cur_data += datagram->data_size; + + // EtherCAT datagram footer EC_WRITE_U16(cur_data, 0x0000); // reset working counter - cur_data += EC_COMMAND_FOOTER_SIZE; + cur_data += EC_DATAGRAM_FOOTER_SIZE; } if (cur_data - frame_data == EC_FRAME_HEADER_SIZE) { @@ -388,11 +389,11 @@ ec_device_send(master->device, cur_data - frame_data); frame_count++; } - while (more_commands_waiting); + while (more_datagrams_waiting); if (unlikely(master->debug_level > 0)) { t_end = get_cycles(); - EC_DBG("ec_master_send_commands sent %i frames in %ius.\n", + EC_DBG("ec_master_send_datagrams sent %i frames in %ius.\n", frame_count, (u32) (t_end - t_start) * 1000 / cpu_khz); } } @@ -411,10 +412,10 @@ ) { size_t frame_size, data_size; - uint8_t command_type, command_index; + uint8_t datagram_type, datagram_index; unsigned int cmd_follows, matched; const uint8_t *cur_data; - ec_command_t *command; + ec_datagram_t *datagram; if (unlikely(size < EC_FRAME_HEADER_SIZE)) { master->stats.corrupted++; @@ -436,64 +437,64 @@ cmd_follows = 1; while (cmd_follows) { - // process command header - command_type = EC_READ_U8 (cur_data); - command_index = EC_READ_U8 (cur_data + 1); - data_size = EC_READ_U16(cur_data + 6) & 0x07FF; - cmd_follows = EC_READ_U16(cur_data + 6) & 0x8000; - cur_data += EC_COMMAND_HEADER_SIZE; + // process datagram header + datagram_type = EC_READ_U8 (cur_data); + datagram_index = EC_READ_U8 (cur_data + 1); + data_size = EC_READ_U16(cur_data + 6) & 0x07FF; + cmd_follows = EC_READ_U16(cur_data + 6) & 0x8000; + cur_data += EC_DATAGRAM_HEADER_SIZE; if (unlikely(cur_data - frame_data - + data_size + EC_COMMAND_FOOTER_SIZE > size)) { + + data_size + EC_DATAGRAM_FOOTER_SIZE > size)) { master->stats.corrupted++; ec_master_output_stats(master); return; } - // search for matching command in the queue + // search for matching datagram in the queue matched = 0; - list_for_each_entry(command, &master->command_queue, queue) { - if (command->state == EC_CMD_SENT - && command->type == command_type - && command->index == command_index - && command->data_size == data_size) { + list_for_each_entry(datagram, &master->datagram_queue, queue) { + if (datagram->state == EC_CMD_SENT + && datagram->type == datagram_type + && datagram->index == datagram_index + && datagram->data_size == data_size) { matched = 1; break; } } - // no matching command was found + // no matching datagram was found if (!matched) { master->stats.unmatched++; ec_master_output_stats(master); - cur_data += data_size + EC_COMMAND_FOOTER_SIZE; + cur_data += data_size + EC_DATAGRAM_FOOTER_SIZE; continue; } - // copy received data in the command memory - memcpy(command->data, cur_data, data_size); + // copy received data in the datagram memory + memcpy(datagram->data, cur_data, data_size); cur_data += data_size; - // set the command's working counter - command->working_counter = EC_READ_U16(cur_data); - cur_data += EC_COMMAND_FOOTER_SIZE; - - // dequeue the received command - command->state = EC_CMD_RECEIVED; - list_del_init(&command->queue); - } -} - -/*****************************************************************************/ - -/** - Sends a single command and waits for its reception. - If the slave doesn't respond, the command is sent again. + // set the datagram's working counter + datagram->working_counter = EC_READ_U16(cur_data); + cur_data += EC_DATAGRAM_FOOTER_SIZE; + + // dequeue the received datagram + datagram->state = EC_CMD_RECEIVED; + list_del_init(&datagram->queue); + } +} + +/*****************************************************************************/ + +/** + Sends a single datagram and waits for its reception. + If the slave doesn't respond, the datagram is sent again. \return 0 in case of success, else < 0 */ int ec_master_simple_io(ec_master_t *master, /**< EtherCAT master */ - ec_command_t *command /**< command */ + ec_datagram_t *datagram /**< datagram */ ) { unsigned int response_tries_left; @@ -502,19 +503,19 @@ while (1) { - ec_master_queue_command(master, command); + ec_master_queue_datagram(master, datagram); ecrt_master_sync_io(master); - if (command->state == EC_CMD_RECEIVED) { - if (likely(command->working_counter)) + if (datagram->state == EC_CMD_RECEIVED) { + if (likely(datagram->working_counter)) return 0; } - else if (command->state == EC_CMD_TIMEOUT) { + else if (datagram->state == EC_CMD_TIMEOUT) { EC_ERR("Simple-IO TIMEOUT!\n"); return -1; } - else if (command->state == EC_CMD_ERROR) { - EC_ERR("Simple-IO command error!\n"); + else if (datagram->state == EC_CMD_ERROR) { + EC_ERR("Simple-IO datagram error!\n"); return -1; } @@ -540,7 +541,7 @@ { ec_slave_t *slave; ec_slave_ident_t *ident; - ec_command_t *command; + ec_datagram_t *datagram; unsigned int i; uint16_t coupler_index, coupler_subindex; uint16_t reverse_coupler_index, current_coupler_index; @@ -550,12 +551,12 @@ return -1; } - command = &master->simple_command; + datagram = &master->simple_datagram; // determine number of slaves on bus - if (ec_command_brd(command, 0x0000, 4)) return -1; - if (unlikely(ec_master_simple_io(master, command))) return -1; - master->slave_count = command->working_counter; + if (ec_datagram_brd(datagram, 0x0000, 4)) return -1; + if (unlikely(ec_master_simple_io(master, datagram))) return -1; + master->slave_count = datagram->working_counter; EC_INFO("Found %i slaves on bus.\n", master->slave_count); if (!master->slave_count) return 0; @@ -588,10 +589,10 @@ list_for_each_entry(slave, &master->slaves, list) { // write station address - if (ec_command_apwr(command, slave->ring_position, 0x0010, + if (ec_datagram_apwr(datagram, slave->ring_position, 0x0010, sizeof(uint16_t))) goto out_free; - EC_WRITE_U16(command->data, slave->station_address); - if (unlikely(ec_master_simple_io(master, command))) { + EC_WRITE_U16(datagram->data, slave->station_address); + if (unlikely(ec_master_simple_io(master, datagram))) { EC_ERR("Writing station address failed on slave %i!\n", slave->ring_position); goto out_free; @@ -650,7 +651,7 @@ if (unlikely((u32) (t_now - master->stats.t_last) / cpu_khz > 1000)) { if (master->stats.timeouts) { - EC_WARN("%i commands TIMED OUT!\n", master->stats.timeouts); + EC_WARN("%i datagrams TIMED OUT!\n", master->stats.timeouts); master->stats.timeouts = 0; } if (master->stats.delayed) { @@ -662,7 +663,7 @@ master->stats.corrupted = 0; } if (master->stats.unmatched) { - EC_WARN("%i command(s) UNMATCHED!\n", master->stats.unmatched); + EC_WARN("%i datagram(s) UNMATCHED!\n", master->stats.unmatched); master->stats.unmatched = 0; } master->stats.t_last = t_now; @@ -1075,7 +1076,7 @@ { unsigned int j; ec_slave_t *slave; - ec_command_t *command; + ec_datagram_t *datagram; const ec_sync_t *sync; const ec_slave_type_t *type; const ec_fmmu_t *fmmu; @@ -1083,7 +1084,7 @@ ec_domain_t *domain; ec_eeprom_sync_t *eeprom_sync, mbox_sync; - command = &master->simple_command; + datagram = &master->simple_datagram; // allocate all domains domain_offset = 0; @@ -1112,11 +1113,12 @@ // reset FMMUs if (slave->base_fmmu_count) { - if (ec_command_npwr(command, slave->station_address, 0x0600, - EC_FMMU_SIZE * slave->base_fmmu_count)) + if (ec_datagram_npwr(datagram, slave->station_address, 0x0600, + EC_FMMU_SIZE * slave->base_fmmu_count)) return -1; - memset(command->data, 0x00, EC_FMMU_SIZE * slave->base_fmmu_count); - if (unlikely(ec_master_simple_io(master, command))) { + memset(datagram->data, 0x00, + EC_FMMU_SIZE * slave->base_fmmu_count); + if (unlikely(ec_master_simple_io(master, datagram))) { EC_ERR("Resetting FMMUs failed on slave %i!\n", slave->ring_position); return -1; @@ -1125,11 +1127,11 @@ // reset sync managers if (slave->base_sync_count) { - if (ec_command_npwr(command, slave->station_address, 0x0800, + if (ec_datagram_npwr(datagram, slave->station_address, 0x0800, EC_SYNC_SIZE * slave->base_sync_count)) return -1; - memset(command->data, 0x00, EC_SYNC_SIZE * slave->base_sync_count); - if (unlikely(ec_master_simple_io(master, command))) { + memset(datagram->data, 0x00, EC_SYNC_SIZE * slave->base_sync_count); + if (unlikely(ec_master_simple_io(master, datagram))) { EC_ERR("Resetting sync managers failed on slave %i!\n", slave->ring_position); return -1; @@ -1140,11 +1142,11 @@ if (type) { // known slave type, take type's SM information for (j = 0; type->sync_managers[j] && j < EC_MAX_SYNC; j++) { sync = type->sync_managers[j]; - if (ec_command_npwr(command, slave->station_address, + if (ec_datagram_npwr(datagram, slave->station_address, 0x0800 + j * EC_SYNC_SIZE, EC_SYNC_SIZE)) return -1; - ec_sync_config(sync, slave, command->data); - if (unlikely(ec_master_simple_io(master, command))) { + ec_sync_config(sync, slave, datagram->data); + if (unlikely(ec_master_simple_io(master, datagram))) { EC_ERR("Setting sync manager %i failed on slave %i!\n", j, slave->ring_position); return -1; @@ -1156,12 +1158,12 @@ if (!list_empty(&slave->eeprom_syncs)) { list_for_each_entry(eeprom_sync, &slave->eeprom_syncs, list) { EC_INFO("Sync manager %i...\n", eeprom_sync->index); - if (ec_command_npwr(command, slave->station_address, - 0x800 + eeprom_sync->index * - EC_SYNC_SIZE, - EC_SYNC_SIZE)) return -1; - ec_eeprom_sync_config(eeprom_sync, command->data); - if (unlikely(ec_master_simple_io(master, command))) { + if (ec_datagram_npwr(datagram, slave->station_address, + 0x800 + eeprom_sync->index * + EC_SYNC_SIZE, + EC_SYNC_SIZE)) return -1; + ec_eeprom_sync_config(eeprom_sync, datagram->data); + if (unlikely(ec_master_simple_io(master, datagram))) { EC_ERR("Setting sync manager %i failed on slave %i!\n", eeprom_sync->index, slave->ring_position); return -1; @@ -1174,10 +1176,10 @@ mbox_sync.length = slave->sii_rx_mailbox_size; mbox_sync.control_register = 0x26; mbox_sync.enable = 1; - if (ec_command_npwr(command, slave->station_address, - 0x800,EC_SYNC_SIZE)) return -1; - ec_eeprom_sync_config(&mbox_sync, command->data); - if (unlikely(ec_master_simple_io(master, command))) { + if (ec_datagram_npwr(datagram, slave->station_address, + 0x800,EC_SYNC_SIZE)) return -1; + ec_eeprom_sync_config(&mbox_sync, datagram->data); + if (unlikely(ec_master_simple_io(master, datagram))) { EC_ERR("Setting sync manager 0 failed on slave %i!\n", slave->ring_position); return -1; @@ -1188,10 +1190,10 @@ mbox_sync.length = slave->sii_tx_mailbox_size; mbox_sync.control_register = 0x22; mbox_sync.enable = 1; - if (ec_command_npwr(command, slave->station_address, - 0x808, EC_SYNC_SIZE)) return -1; - ec_eeprom_sync_config(&mbox_sync, command->data); - if (unlikely(ec_master_simple_io(master, command))) { + if (ec_datagram_npwr(datagram, slave->station_address, + 0x808, EC_SYNC_SIZE)) return -1; + ec_eeprom_sync_config(&mbox_sync, datagram->data); + if (unlikely(ec_master_simple_io(master, datagram))) { EC_ERR("Setting sync manager 1 failed on slave %i!\n", slave->ring_position); return -1; @@ -1218,11 +1220,11 @@ // configure FMMUs for (j = 0; j < slave->fmmu_count; j++) { fmmu = &slave->fmmus[j]; - if (ec_command_npwr(command, slave->station_address, - 0x0600 + j * EC_FMMU_SIZE, EC_FMMU_SIZE)) + if (ec_datagram_npwr(datagram, slave->station_address, + 0x0600 + j * EC_FMMU_SIZE, EC_FMMU_SIZE)) return -1; - ec_fmmu_config(fmmu, slave, command->data); - if (unlikely(ec_master_simple_io(master, command))) { + ec_fmmu_config(fmmu, slave, datagram->data); + if (unlikely(ec_master_simple_io(master, datagram))) { EC_ERR("Setting FMMU %i failed on slave %i!\n", j, slave->ring_position); return -1; @@ -1288,17 +1290,17 @@ /*****************************************************************************/ /** - Sends queued commands and waits for their reception. + Sends queued datagrams and waits for their reception. \ingroup RealtimeInterface */ void ecrt_master_sync_io(ec_master_t *master /**< EtherCAT master */) { - ec_command_t *command, *n; - unsigned int commands_sent; + ec_datagram_t *datagram, *n; + unsigned int datagrams_sent; cycles_t t_start, t_end, t_timeout; - // send commands + // send datagrams ecrt_master_async_send(master); t_start = get_cycles(); // measure io time @@ -1310,23 +1312,23 @@ t_end = get_cycles(); // take current time if (t_end - t_start >= t_timeout) break; // timeout! - commands_sent = 0; - list_for_each_entry_safe(command, n, &master->command_queue, queue) { - if (command->state == EC_CMD_RECEIVED) - list_del_init(&command->queue); - else if (command->state == EC_CMD_SENT) - commands_sent++; - } - - if (!commands_sent) break; - } - - // timeout; dequeue all commands - list_for_each_entry_safe(command, n, &master->command_queue, queue) { - switch (command->state) { + datagrams_sent = 0; + list_for_each_entry_safe(datagram, n, &master->datagram_queue, queue) { + if (datagram->state == EC_CMD_RECEIVED) + list_del_init(&datagram->queue); + else if (datagram->state == EC_CMD_SENT) + datagrams_sent++; + } + + if (!datagrams_sent) break; + } + + // timeout; dequeue all datagrams + list_for_each_entry_safe(datagram, n, &master->datagram_queue, queue) { + switch (datagram->state) { case EC_CMD_SENT: case EC_CMD_QUEUED: - command->state = EC_CMD_TIMEOUT; + datagram->state = EC_CMD_TIMEOUT; master->stats.timeouts++; ec_master_output_stats(master); break; @@ -1337,26 +1339,26 @@ default: break; } - list_del_init(&command->queue); - } -} - -/*****************************************************************************/ - -/** - Asynchronous sending of commands. + list_del_init(&datagram->queue); + } +} + +/*****************************************************************************/ + +/** + Asynchronous sending of datagrams. \ingroup RealtimeInterface */ void ecrt_master_async_send(ec_master_t *master /**< EtherCAT master */) { - ec_command_t *command, *n; + ec_datagram_t *datagram, *n; if (unlikely(!master->device->link_state)) { - // link is down, no command can be sent - list_for_each_entry_safe(command, n, &master->command_queue, queue) { - command->state = EC_CMD_ERROR; - list_del_init(&command->queue); + // link is down, no datagram can be sent + list_for_each_entry_safe(datagram, n, &master->datagram_queue, queue) { + datagram->state = EC_CMD_ERROR; + list_del_init(&datagram->queue); } // query link state @@ -1365,19 +1367,19 @@ } // send frames - ec_master_send_commands(master); -} - -/*****************************************************************************/ - -/** - Asynchronous receiving of commands. + ec_master_send_datagrams(master); +} + +/*****************************************************************************/ + +/** + Asynchronous receiving of datagrams. \ingroup RealtimeInterface */ void ecrt_master_async_receive(ec_master_t *master /**< EtherCAT master */) { - ec_command_t *command, *next; + ec_datagram_t *datagram, *next; cycles_t t_received, t_timeout; ec_device_call_isr(master->device); @@ -1385,18 +1387,19 @@ t_received = get_cycles(); t_timeout = (cycles_t) master->timeout * (cpu_khz / 1000); - // dequeue all received commands - list_for_each_entry_safe(command, next, &master->command_queue, queue) - if (command->state == EC_CMD_RECEIVED) list_del_init(&command->queue); - - // dequeue all commands that timed out - list_for_each_entry_safe(command, next, &master->command_queue, queue) { - switch (command->state) { + // dequeue all received datagrams + list_for_each_entry_safe(datagram, next, &master->datagram_queue, queue) + if (datagram->state == EC_CMD_RECEIVED) + list_del_init(&datagram->queue); + + // dequeue all datagrams that timed out + list_for_each_entry_safe(datagram, next, &master->datagram_queue, queue) { + switch (datagram->state) { case EC_CMD_SENT: case EC_CMD_QUEUED: - if (t_received - command->t_sent > t_timeout) { - list_del_init(&command->queue); - command->state = EC_CMD_TIMEOUT; + if (t_received - datagram->t_sent > t_timeout) { + list_del_init(&datagram->queue); + datagram->state = EC_CMD_TIMEOUT; master->stats.timeouts++; ec_master_output_stats(master); } @@ -1411,7 +1414,7 @@ /** Prepares synchronous IO. - Queues all domain commands and sends them. Then waits a certain time, so + Queues all domain datagrams and sends them. Then waits a certain time, so that ecrt_master_sasync_receive() can be called securely. \ingroup RealtimeInterface */ @@ -1421,7 +1424,7 @@ ec_domain_t *domain; cycles_t t_start, t_end, t_timeout; - // queue commands of all domains + // queue datagrams of all domains list_for_each_entry(domain, &master->domains, list) ecrt_domain_queue(domain);