etherlabmaster: comparison master/fsm.c

equal deleted inserted replaced

-:2cf6ae0a2419
+:14aeb79aa992
 fsm->master_state = ec_fsm_master_start;
 fsm->master_slaves_responding = 0;
 fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;
 fsm->master_validation = 0;
-ec_command_init(&fsm->command);
+ec_datagram_init(&fsm->datagram);
-if (ec_command_prealloc(&fsm->command, EC_MAX_DATA_SIZE)) {
+if (ec_datagram_prealloc(&fsm->datagram, EC_MAX_DATA_SIZE)) {
-EC_ERR("Failed to allocate FSM command.\n");
+EC_ERR("Failed to allocate FSM datagram.\n");
 return -1;
 }
 return 0;
 }
 Destructor.
 */
 void ec_fsm_clear(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_clear(&fsm->command);
+ec_datagram_clear(&fsm->datagram);
 }
 /*****************************************************************************/
 /**
 Starts with getting slave count and slave states.
 */
 void ec_fsm_master_start(ec_fsm_t *fsm)
 {
-ec_command_brd(&fsm->command, 0x0130, 2);
+ec_datagram_brd(&fsm->datagram, 0x0130, 2);
-ec_master_queue_command(fsm->master, &fsm->command);
+ec_master_queue_datagram(fsm->master, &fsm->datagram);
 fsm->master_state = ec_fsm_master_broadcast;
 }
 /*****************************************************************************/
 Processes the broadcast read slave count and slaves states.
 */
 void ec_fsm_master_broadcast(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 unsigned int topology_change, states_change, i;
 ec_slave_t *slave;
 ec_master_t *master = fsm->master;
-if (command->state != EC_CMD_RECEIVED) {
+if (datagram->state != EC_CMD_RECEIVED) {
 if (!master->device->link_state) {
 fsm->master_slaves_responding = 0;
 list_for_each_entry(slave, &master->slaves, list) {
 slave->online = 0;
 }
 fsm->master_state = ec_fsm_master_start;
 fsm->master_state(fsm); // execute immediately
 return;
 }
-topology_change = (command->working_counter !=
+topology_change = (datagram->working_counter !=
 fsm->master_slaves_responding);
-states_change = (EC_READ_U8(command->data) != fsm->master_slave_states);
+states_change = (EC_READ_U8(datagram->data) != fsm->master_slave_states);
-fsm->master_slave_states = EC_READ_U8(command->data);
+fsm->master_slave_states = EC_READ_U8(datagram->data);
-fsm->master_slaves_responding = command->working_counter;
+fsm->master_slaves_responding = datagram->working_counter;
 if (topology_change) {
 EC_INFO("%i slave%s responding.\n",
 fsm->master_slaves_responding,
 fsm->master_slaves_responding == 1 ? "" : "s");
 return;
 }
 // fetch state from each slave
 fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);
-ec_command_nprd(&fsm->command, fsm->slave->station_address, 0x0130, 2);
+ec_datagram_nprd(&fsm->datagram, fsm->slave->station_address, 0x0130, 2);
-ec_master_queue_command(master, &fsm->command);
+ec_master_queue_datagram(master, &fsm->datagram);
 fsm->master_state = ec_fsm_master_states;
 }
 /*****************************************************************************/
 // have all states been read?
 if (slave->list.next != &master->slaves) {
 // process next slave
 fsm->slave = list_entry(fsm->slave->list.next, ec_slave_t, list);
-ec_command_nprd(&fsm->command, fsm->slave->station_address, 0x0130, 2);
+ec_datagram_nprd(&fsm->datagram, fsm->slave->station_address,
-ec_master_queue_command(master, &fsm->command);
+0x0130, 2);
+ec_master_queue_datagram(master, &fsm->datagram);
 fsm->master_state = ec_fsm_master_states;
 return;
 }
 // all slave stated read; check, if a bus validation has to be done
 */
 void ec_fsm_master_states(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_slave_t *slave = fsm->slave;
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 uint8_t new_state;
-if (command->state != EC_CMD_RECEIVED) {
+if (datagram->state != EC_CMD_RECEIVED) {
 fsm->master_state = ec_fsm_master_start;
 fsm->master_state(fsm); // execute immediately
 return;
 }
 // did the slave not respond to its station address?
-if (command->working_counter != 1) {
+if (datagram->working_counter != 1) {
 if (slave->online) {
 slave->online = 0;
 EC_INFO("Slave %i: offline.\n", slave->ring_position);
 }
 ec_fsm_master_action_next_slave_state(fsm);
 return;
 }
 // slave responded
-new_state = EC_READ_U8(command->data);
+new_state = EC_READ_U8(datagram->data);
 if (!slave->online) { // slave was offline before
 slave->online = 1;
 slave->error_flag = 0; // clear error flag
 slave->current_state = new_state;
 EC_INFO("Slave %i: online (", slave->ring_position);
 their station address, so that they can be reconfigured later.
 */
 void ec_fsm_master_reconfigure(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 while (fsm->slave->online) {
 if (fsm->slave->list.next == &fsm->master->slaves) { // last slave?
 fsm->master_state = ec_fsm_master_start;
 fsm->master_state(fsm); // execute immediately
 }
 EC_INFO("Reinitializing slave %i.\n", fsm->slave->ring_position);
 // write station address
-ec_command_apwr(command, fsm->slave->ring_position, 0x0010, 2);
+ec_datagram_apwr(datagram, fsm->slave->ring_position, 0x0010, 2);
-EC_WRITE_U16(command->data, fsm->slave->station_address);
+EC_WRITE_U16(datagram->data, fsm->slave->station_address);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->master_state = ec_fsm_master_address;
 }
 /*****************************************************************************/
 */
 void ec_fsm_master_address(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_slave_t *slave = fsm->slave;
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 EC_ERR("Failed to write station address on slave %i.\n",
 slave->ring_position);
 }
 if (fsm->slave->list.next == &fsm->master->slaves) { // last slave?
 slave, according to its ring position.
 */
 void ec_fsm_slave_start_reading(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 // write station address
-ec_command_apwr(command, fsm->slave->ring_position, 0x0010, 2);
+ec_datagram_apwr(datagram, fsm->slave->ring_position, 0x0010, 2);
-EC_WRITE_U16(command->data, fsm->slave->station_address);
+EC_WRITE_U16(datagram->data, fsm->slave->station_address);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->slave_state = ec_fsm_slave_read_state;
 }
 /*****************************************************************************/
 Slave state: READ_STATUS.
 */
 void ec_fsm_slave_read_state(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->slave->error_flag = 1;
 fsm->slave_state = ec_fsm_slave_end;
 EC_ERR("Failed to write station address of slave %i.\n",
 fsm->slave->ring_position);
 return;
 }
 // Read AL state
-ec_command_nprd(command, fsm->slave->station_address, 0x0130, 2);
+ec_datagram_nprd(datagram, fsm->slave->station_address, 0x0130, 2);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->slave_state = ec_fsm_slave_read_base;
 }
 /*****************************************************************************/
 Slave state: READ_BASE.
 */
 void ec_fsm_slave_read_base(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->slave->error_flag = 1;
 fsm->slave_state = ec_fsm_slave_end;
 EC_ERR("Failed to read AL state of slave %i.\n",
 fsm->slave->ring_position);
 return;
 }
-slave->current_state = EC_READ_U8(command->data);
+slave->current_state = EC_READ_U8(datagram->data);
 if (slave->current_state & EC_ACK) {
 EC_WARN("Slave %i has state error bit set (0x%02X)!\n",
 slave->ring_position, slave->current_state);
 slave->current_state &= 0x0F;
 }
 // read base data
-ec_command_nprd(command, fsm->slave->station_address, 0x0000, 6);
+ec_datagram_nprd(datagram, fsm->slave->station_address, 0x0000, 6);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->slave_state = ec_fsm_slave_read_dl;
 }
 /*****************************************************************************/
 Slave state: READ_DL.
 */
 void ec_fsm_slave_read_dl(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->slave->error_flag = 1;
 fsm->slave_state = ec_fsm_slave_end;
 EC_ERR("Failed to read base data of slave %i.\n",
 slave->ring_position);
 return;
 }
-slave->base_type       = EC_READ_U8 (command->data);
+slave->base_type       = EC_READ_U8 (datagram->data);
-slave->base_revision   = EC_READ_U8 (command->data + 1);
+slave->base_revision   = EC_READ_U8 (datagram->data + 1);
-slave->base_build      = EC_READ_U16(command->data + 2);
+slave->base_build      = EC_READ_U16(datagram->data + 2);
-slave->base_fmmu_count = EC_READ_U8 (command->data + 4);
+slave->base_fmmu_count = EC_READ_U8 (datagram->data + 4);
-slave->base_sync_count = EC_READ_U8 (command->data + 5);
+slave->base_sync_count = EC_READ_U8 (datagram->data + 5);
 if (slave->base_fmmu_count > EC_MAX_FMMUS)
 slave->base_fmmu_count = EC_MAX_FMMUS;
 // read data link status
-ec_command_nprd(command, slave->station_address, 0x0110, 2);
+ec_datagram_nprd(datagram, slave->station_address, 0x0110, 2);
-ec_master_queue_command(slave->master, command);
+ec_master_queue_datagram(slave->master, datagram);
 fsm->slave_state = ec_fsm_slave_eeprom_size;
 }
 /*****************************************************************************/
 Read the actual size of the EEPROM to allocate the EEPROM image.
 */
 void ec_fsm_slave_eeprom_size(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 uint16_t dl_status;
 unsigned int i;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->slave->error_flag = 1;
 fsm->slave_state = ec_fsm_slave_end;
 EC_ERR("Failed to read DL status of slave %i.\n",
 slave->ring_position);
 return;
 }
-dl_status = EC_READ_U16(command->data);
+dl_status = EC_READ_U16(datagram->data);
 for (i = 0; i < 4; i++) {
 slave->dl_link[i] = dl_status & (1 << (4 + i)) ? 1 : 0;
 slave->dl_loop[i] = dl_status & (1 << (8 + i * 2)) ? 1 : 0;
 slave->dl_signal[i] = dl_status & (1 << (9 + i * 2)) ? 1 : 0;
 }
 void ec_fsm_slave_conf(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_slave_t *slave = fsm->slave;
 ec_master_t *master = fsm->master;
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 fsm->change_state(fsm); // execute state change state machine
 if (fsm->change_state == ec_fsm_change_error) {
 slave->error_flag = 1;
 fsm->slave_state(fsm); // execute immediately
 return;
 }
 // reset FMMUs
-ec_command_npwr(command, slave->station_address, 0x0600,
+ec_datagram_npwr(datagram, slave->station_address, 0x0600,
 EC_FMMU_SIZE * slave->base_fmmu_count);
-memset(command->data, 0x00, EC_FMMU_SIZE * slave->base_fmmu_count);
+memset(datagram->data, 0x00, EC_FMMU_SIZE * slave->base_fmmu_count);
-ec_master_queue_command(master, command);
+ec_master_queue_datagram(master, datagram);
 fsm->slave_state = ec_fsm_slave_sync;
 }
 /*****************************************************************************/
 Configure sync managers.
 */
 void ec_fsm_slave_sync(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 unsigned int j;
 const ec_sync_t *sync;
 ec_eeprom_sync_t *eeprom_sync, mbox_sync;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 slave->error_flag = 1;
 fsm->slave_state = ec_fsm_slave_end;
 EC_ERR("Failed to reset FMMUs of slave %i.\n",
 slave->ring_position);
 return;
 fsm->slave_state(fsm); // execute immediately
 return;
 }
 // configure sync managers
-ec_command_npwr(command, slave->station_address, 0x0800,
+ec_datagram_npwr(datagram, slave->station_address, 0x0800,
 EC_SYNC_SIZE * slave->base_sync_count);
-memset(command->data, 0x00, EC_SYNC_SIZE * slave->base_sync_count);
+memset(datagram->data, 0x00, EC_SYNC_SIZE * slave->base_sync_count);
 // known slave type, take type's SM information
 if (slave->type) {
 for (j = 0; slave->type->sync_managers[j] && j < EC_MAX_SYNC; j++) {
 sync = slave->type->sync_managers[j];
-ec_sync_config(sync, slave, command->data + EC_SYNC_SIZE * j);
+ec_sync_config(sync, slave, datagram->data + EC_SYNC_SIZE * j);
 }
 }
 // unknown type, but slave has mailbox
 else if (slave->sii_mailbox_protocols)
 fsm->slave_state = ec_fsm_slave_end;
 EC_ERR("Invalid sync manager configuration found!");
 return;
 }
 ec_eeprom_sync_config(eeprom_sync,
-command->data + EC_SYNC_SIZE
+datagram->data + EC_SYNC_SIZE
 * eeprom_sync->index);
 }
 }
 // no sync manager information; guess mailbox settings
 mbox_sync.physical_start_address =
 slave->sii_rx_mailbox_offset;
 mbox_sync.length = slave->sii_rx_mailbox_size;
 mbox_sync.control_register = 0x26;
 mbox_sync.enable = 1;
-ec_eeprom_sync_config(&mbox_sync, command->data);
+ec_eeprom_sync_config(&mbox_sync, datagram->data);
 mbox_sync.physical_start_address =
 slave->sii_tx_mailbox_offset;
 mbox_sync.length = slave->sii_tx_mailbox_size;
 mbox_sync.control_register = 0x22;
 mbox_sync.enable = 1;
 ec_eeprom_sync_config(&mbox_sync,
-command->data + EC_SYNC_SIZE);
+datagram->data + EC_SYNC_SIZE);
 }
 EC_INFO("Mailbox configured for unknown slave %i\n",
 slave->ring_position);
 }
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->slave_state = ec_fsm_slave_preop;
 }
 /*****************************************************************************/
 Change slave state to PREOP.
 */
 void ec_fsm_slave_preop(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 slave->error_flag = 1;
 fsm->slave_state = ec_fsm_slave_end;
 EC_ERR("Failed to set sync managers on slave %i.\n",
 slave->ring_position);
 return;
 void ec_fsm_slave_fmmu(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_slave_t *slave = fsm->slave;
 ec_master_t *master = fsm->master;
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 unsigned int j;
 fsm->change_state(fsm); // execute state change state machine
 if (fsm->change_state == ec_fsm_change_error) {
 fsm->slave_state(fsm); // execute immediately
 return;
 }
 // configure FMMUs
-ec_command_npwr(command, slave->station_address,
+ec_datagram_npwr(datagram, slave->station_address,
 0x0600, EC_FMMU_SIZE * slave->base_fmmu_count);
-memset(command->data, 0x00, EC_FMMU_SIZE * slave->base_fmmu_count);
+memset(datagram->data, 0x00, EC_FMMU_SIZE * slave->base_fmmu_count);
 for (j = 0; j < slave->fmmu_count; j++) {
 ec_fmmu_config(&slave->fmmus[j], slave,
-command->data + EC_FMMU_SIZE * j);
+datagram->data + EC_FMMU_SIZE * j);
 }
-ec_master_queue_command(master, command);
+ec_master_queue_datagram(master, datagram);
 fsm->slave_state = ec_fsm_slave_saveop;
 }
 /*****************************************************************************/
 Set slave state to SAVEOP.
 */
 void ec_fsm_slave_saveop(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
-if (fsm->slave->base_fmmu_count && (command->state != EC_CMD_RECEIVED ||
+if (fsm->slave->base_fmmu_count && (datagram->state != EC_CMD_RECEIVED ||
-command->working_counter != 1)) {
+datagram->working_counter != 1)) {
 fsm->slave->error_flag = 1;
 fsm->slave_state = ec_fsm_slave_end;
 EC_ERR("Failed to set FMMUs on slave %i.\n",
 fsm->slave->ring_position);
 return;
 Starts reading the slave information interface.
 */
 void ec_fsm_sii_start_reading(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 // initiate read operation
 if (fsm->sii_mode) {
-ec_command_npwr(command, fsm->slave->station_address, 0x502, 4);
+ec_datagram_npwr(datagram, fsm->slave->station_address, 0x502, 4);
 }
 else {
-ec_command_apwr(command, fsm->slave->ring_position, 0x502, 4);
+ec_datagram_apwr(datagram, fsm->slave->ring_position, 0x502, 4);
 }
-EC_WRITE_U8 (command->data,     0x00); // read-only access
+EC_WRITE_U8 (datagram->data,     0x00); // read-only access
-EC_WRITE_U8 (command->data + 1, 0x01); // request read operation
+EC_WRITE_U8 (datagram->data + 1, 0x01); // request read operation
-EC_WRITE_U16(command->data + 2, fsm->sii_offset);
+EC_WRITE_U16(datagram->data + 2, fsm->sii_offset);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->sii_state = ec_fsm_sii_read_check;
 }
 /*****************************************************************************/
 /**
 SII state: READ_CHECK.
-Checks, if the SII-read-command has been sent and issues a fetch command.
+Checks, if the SII-read-datagram has been sent and issues a fetch datagram.
 */
 void ec_fsm_sii_read_check(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
-EC_ERR("SII: Reception of read command failed.\n");
+EC_ERR("SII: Reception of read datagram failed.\n");
 fsm->sii_state = ec_fsm_sii_error;
 return;
 }
 fsm->sii_start = get_cycles();
-// issue check/fetch command
+// issue check/fetch datagram
 if (fsm->sii_mode) {
-ec_command_nprd(command, fsm->slave->station_address, 0x502, 10);
+ec_datagram_nprd(datagram, fsm->slave->station_address, 0x502, 10);
 }
 else {
-ec_command_aprd(command, fsm->slave->ring_position, 0x502, 10);
+ec_datagram_aprd(datagram, fsm->slave->ring_position, 0x502, 10);
 }
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->sii_state = ec_fsm_sii_read_fetch;
 }
 /*****************************************************************************/
 /**
 SII state: READ_FETCH.
-Fetches the result of an SII-read command.
+Fetches the result of an SII-read datagram.
 */
 void ec_fsm_sii_read_fetch(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
-EC_ERR("SII: Reception of check/fetch command failed.\n");
+EC_ERR("SII: Reception of check/fetch datagram failed.\n");
 fsm->sii_state = ec_fsm_sii_error;
 return;
 }
 // check "busy bit"
-if (EC_READ_U8(command->data + 1) & 0x81) {
+if (EC_READ_U8(datagram->data + 1) & 0x81) {
 // still busy... timeout?
 if (get_cycles() - fsm->sii_start >= (cycles_t) 10 * cpu_khz) {
 EC_ERR("SII: Timeout.\n");
 fsm->sii_state = ec_fsm_sii_error;
 #if 0
 EC_DBG("SII busy: %02X %02X %02X %02X\n",
-EC_READ_U8(command->data + 0),
+EC_READ_U8(datagram->data + 0),
-EC_READ_U8(command->data + 1),
+EC_READ_U8(datagram->data + 1),
-EC_READ_U8(command->data + 2),
+EC_READ_U8(datagram->data + 2),
-EC_READ_U8(command->data + 3));
+EC_READ_U8(datagram->data + 3));
 #endif
 }
-// issue check/fetch command again
+// issue check/fetch datagram again
 if (fsm->sii_mode) {
-ec_command_nprd(command, fsm->slave->station_address, 0x502, 10);
+ec_datagram_nprd(datagram, fsm->slave->station_address, 0x502, 10);
 }
 else {
-ec_command_aprd(command, fsm->slave->ring_position, 0x502, 10);
+ec_datagram_aprd(datagram, fsm->slave->ring_position, 0x502, 10);
 }
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 return;
 }
 #if 0
 EC_DBG("SII rec: %02X %02X %02X %02X - %02X %02X %02X %02X\n",
-EC_READ_U8(command->data + 0), EC_READ_U8(command->data + 1),
+EC_READ_U8(datagram->data + 0), EC_READ_U8(datagram->data + 1),
-EC_READ_U8(command->data + 2), EC_READ_U8(command->data + 3),
+EC_READ_U8(datagram->data + 2), EC_READ_U8(datagram->data + 3),
-EC_READ_U8(command->data + 6), EC_READ_U8(command->data + 7),
+EC_READ_U8(datagram->data + 6), EC_READ_U8(datagram->data + 7),
-EC_READ_U8(command->data + 8), EC_READ_U8(command->data + 9));
+EC_READ_U8(datagram->data + 8), EC_READ_U8(datagram->data + 9));
 #endif
 // SII value received.
-memcpy(fsm->sii_value, command->data + 6, 4);
+memcpy(fsm->sii_value, datagram->data + 6, 4);
 fsm->sii_state = ec_fsm_sii_end;
 }
 /*****************************************************************************/
 Starts reading the slave information interface.
 */
 void ec_fsm_sii_start_writing(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 // initiate write operation
-ec_command_npwr(command, fsm->slave->station_address, 0x502, 8);
+ec_datagram_npwr(datagram, fsm->slave->station_address, 0x502, 8);
-EC_WRITE_U8 (command->data,     0x01); // enable write access
+EC_WRITE_U8 (datagram->data,     0x01); // enable write access
-EC_WRITE_U8 (command->data + 1, 0x02); // request write operation
+EC_WRITE_U8 (datagram->data + 1, 0x02); // request write operation
-EC_WRITE_U32(command->data + 2, fsm->sii_offset);
+EC_WRITE_U32(datagram->data + 2, fsm->sii_offset);
-memcpy(command->data + 6, fsm->sii_value, 2);
+memcpy(datagram->data + 6, fsm->sii_value, 2);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->sii_state = ec_fsm_sii_write_check;
 }
 /*****************************************************************************/
 SII state: WRITE_CHECK.
 */
 void ec_fsm_sii_write_check(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
-EC_ERR("SII: Reception of write command failed.\n");
+EC_ERR("SII: Reception of write datagram failed.\n");
 fsm->sii_state = ec_fsm_sii_error;
 return;
 }
 fsm->sii_start = get_cycles();
-// issue check/fetch command
+// issue check/fetch datagram
-ec_command_nprd(command, fsm->slave->station_address, 0x502, 2);
+ec_datagram_nprd(datagram, fsm->slave->station_address, 0x502, 2);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->sii_state = ec_fsm_sii_write_check2;
 }
 /*****************************************************************************/
 SII state: WRITE_CHECK2.
 */
 void ec_fsm_sii_write_check2(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
-EC_ERR("SII: Reception of write check command failed.\n");
+EC_ERR("SII: Reception of write check datagram failed.\n");
 fsm->sii_state = ec_fsm_sii_error;
 return;
 }
-if (EC_READ_U8(command->data + 1) & 0x82) {
+if (EC_READ_U8(datagram->data + 1) & 0x82) {
 // still busy... timeout?
 if (get_cycles() - fsm->sii_start >= (cycles_t) 10 * cpu_khz) {
 EC_ERR("SII: Write timeout.\n");
 fsm->sii_state = ec_fsm_sii_error;
 }
-// issue check/fetch command again
+// issue check/fetch datagram again
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 }
-else if (EC_READ_U8(command->data + 1) & 0x40) {
+else if (EC_READ_U8(datagram->data + 1) & 0x40) {
 EC_ERR("SII: Write operation failed!\n");
 fsm->sii_state = ec_fsm_sii_error;
 }
 else { // success
 fsm->sii_state = ec_fsm_sii_end;
 Change state: START.
 */
 void ec_fsm_change_start(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 // write new state to slave
-ec_command_npwr(command, slave->station_address, 0x0120, 2);
+ec_datagram_npwr(datagram, slave->station_address, 0x0120, 2);
-EC_WRITE_U16(command->data, fsm->change_new);
+EC_WRITE_U16(datagram->data, fsm->change_new);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->change_state = ec_fsm_change_check;
 }
 /*****************************************************************************/
 Change state: CHECK.
 */
 void ec_fsm_change_check(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
-if (command->state != EC_CMD_RECEIVED) {
+if (datagram->state != EC_CMD_RECEIVED) {
 fsm->change_state = ec_fsm_change_error;
-EC_ERR("Failed to send state command to slave %i!\n",
+EC_ERR("Failed to send state datagram to slave %i!\n",
 fsm->slave->ring_position);
 return;
 }
-if (command->working_counter != 1) {
+if (datagram->working_counter != 1) {
 fsm->change_state = ec_fsm_change_error;
 EC_ERR("Failed to set state 0x%02X on slave %i: Slave did not"
 " respond.\n", fsm->change_new, fsm->slave->ring_position);
 return;
 }
 fsm->change_start = get_cycles();
 // read AL status from slave
-ec_command_nprd(command, slave->station_address, 0x0130, 2);
+ec_datagram_nprd(datagram, slave->station_address, 0x0130, 2);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->change_state = ec_fsm_change_status;
 }
 /*****************************************************************************/
 Change state: STATUS.
 */
 void ec_fsm_change_status(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->change_state = ec_fsm_change_error;
 EC_ERR("Failed to check state 0x%02X on slave %i.\n",
 fsm->change_new, slave->ring_position);
 return;
 }
-slave->current_state = EC_READ_U8(command->data);
+slave->current_state = EC_READ_U8(datagram->data);
 if (slave->current_state == fsm->change_new) {
 // state has been set successfully
 fsm->change_state = ec_fsm_change_end;
 return;
 fsm->change_new = slave->current_state & 0x0F;
 EC_ERR("Failed to set state 0x%02X - Slave %i refused state change"
 " (code 0x%02X)!\n", fsm->change_new, slave->ring_position,
 slave->current_state);
 // fetch AL status error code
-ec_command_nprd(command, slave->station_address, 0x0134, 2);
+ec_datagram_nprd(datagram, slave->station_address, 0x0134, 2);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->change_state = ec_fsm_change_code;
 return;
 }
 if (get_cycles() - fsm->change_start >= (cycles_t) 10 * cpu_khz) {
 fsm->change_new, slave->ring_position);
 return;
 }
 // still old state: check again
-ec_command_nprd(command, slave->station_address, 0x0130, 2);
+ec_datagram_nprd(datagram, slave->station_address, 0x0130, 2);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 }
 /*****************************************************************************/
 /**
 Change state: CODE.
 */
 void ec_fsm_change_code(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 uint32_t code;
 const ec_code_msg_t *al_msg;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->change_state = ec_fsm_change_error;
-EC_ERR("Reception of AL status code command failed.\n");
+EC_ERR("Reception of AL status code datagram failed.\n");
 return;
 }
-if ((code = EC_READ_U16(command->data))) {
+if ((code = EC_READ_U16(datagram->data))) {
 for (al_msg = al_status_messages; al_msg->code; al_msg++) {
 if (al_msg->code != code) continue;
 EC_ERR("AL status message 0x%04X: \"%s\".\n",
 al_msg->code, al_msg->message);
 break;
 if (!al_msg->code)
 EC_ERR("Unknown AL status code 0x%04X.\n", code);
 }
 // acknowledge "old" slave state
-ec_command_npwr(command, slave->station_address, 0x0120, 2);
+ec_datagram_npwr(datagram, slave->station_address, 0x0120, 2);
-EC_WRITE_U16(command->data, slave->current_state);
+EC_WRITE_U16(datagram->data, slave->current_state);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->change_state = ec_fsm_change_ack;
 }
 /*****************************************************************************/
 Change state: ACK.
 */
 void ec_fsm_change_ack(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->change_state = ec_fsm_change_error;
-EC_ERR("Reception of state ack command failed.\n");
+EC_ERR("Reception of state ack datagram failed.\n");
 return;
 }
 // read new AL status
-ec_command_nprd(command, slave->station_address, 0x0130, 2);
+ec_datagram_nprd(datagram, slave->station_address, 0x0130, 2);
-ec_master_queue_command(fsm->master, command);
+ec_master_queue_datagram(fsm->master, datagram);
 fsm->change_state = ec_fsm_change_ack2;
 }
 /*****************************************************************************/
 Acknowledge 2.
 */
 void ec_fsm_change_ack2(ec_fsm_t *fsm /**< finite state machine */)
 {
-ec_command_t *command = &fsm->command;
+ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
-if (command->state != EC_CMD_RECEIVED || command->working_counter != 1) {
+if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->change_state = ec_fsm_change_error;
-EC_ERR("Reception of state ack check command failed.\n");
+EC_ERR("Reception of state ack check datagram failed.\n");
 return;
 }
-slave->current_state = EC_READ_U8(command->data);
+slave->current_state = EC_READ_U8(datagram->data);
 if (slave->current_state == fsm->change_new) {
 fsm->change_state = ec_fsm_change_error;
 EC_INFO("Acknowleged state 0x%02X on slave %i.\n",
 slave->current_state, slave->ring_position);

changeset 293	14aeb79aa992
parent 292	2cf6ae0a2419
child 297	ac2a057a8ef2
child 1715	e675450f2174