etherlabmaster: comparison master/fsm

equal deleted inserted replaced

-:9114b3a5f9d3
+:d5d04c868e0e
 {
 return fsm->state != ec_fsm_master_state_end
 && fsm->state != ec_fsm_master_state_error;
 }
-/*****************************************************************************/
-/**
-\return true, if the master state machine terminated gracefully
-*/
-int ec_fsm_master_success(ec_fsm_master_t *fsm /**< master state machine */)
-{
-return fsm->state == ec_fsm_master_state_end;
-}
 /******************************************************************************
-*  operation/idle state machine
+*  master state machine
 *****************************************************************************/
 /**
 Master state: START.
 Starts with getting slave count and slave states.
 */
 void ec_fsm_master_state_start(ec_fsm_master_t *fsm)
 {
 ec_datagram_brd(fsm->datagram, 0x0130, 2);
-ec_master_queue_datagram(fsm->master, fsm->datagram);
 fsm->state = ec_fsm_master_state_broadcast;
 }
 /*****************************************************************************/
 ec_datagram_t *datagram = fsm->datagram;
 unsigned int i;
 ec_slave_t *slave;
 ec_master_t *master = fsm->master;
-if (datagram->state == EC_DATAGRAM_TIMED_OUT) {
+if (datagram->state == EC_DATAGRAM_TIMED_OUT)
-// always retry
+return; // always retry
-ec_master_queue_datagram(fsm->master, fsm->datagram);
-return;
-}
 if (datagram->state != EC_DATAGRAM_RECEIVED) { // EC_DATAGRAM_ERROR
 // link is down
 fsm->slaves_responding = 0;
 list_for_each_entry(slave, &master->slaves, list) {
 EC_INFO("Scanning bus.\n");
 // begin scanning of slaves
 fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);
+fsm->state = ec_fsm_master_state_scan_slaves;
 ec_fsm_slave_start_scan(&fsm->fsm_slave, fsm->slave);
 ec_fsm_slave_exec(&fsm->fsm_slave); // execute immediately
-fsm->state = ec_fsm_master_state_scan_slaves;
 return;
 }
 // fetch state from each slave
 fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);
 ec_datagram_nprd(fsm->datagram, fsm->slave->station_address, 0x0130, 2);
-ec_master_queue_datagram(master, fsm->datagram);
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_master_state_read_states;
 }
 /*****************************************************************************/
 slave->ring_position, old_state);
 }
 }
 fsm->slave = slave;
+fsm->state = ec_fsm_master_state_configure_slave;
 ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);
 ec_fsm_slave_exec(&fsm->fsm_slave); // execute immediately
-fsm->state = ec_fsm_master_state_configure_slave;
 return;
 }
 // Check, if EoE processing has to be started
 ec_master_eoe_start(master);
 master->sdo_seq_master++;
 }
 else {
 // start uploading SDO
 fsm->slave = slave;
+fsm->sdo_request = master->sdo_request;
 fsm->state = ec_fsm_master_state_sdo_request;
-fsm->sdo_request = master->sdo_request;
 ec_fsm_coe_upload(&fsm->fsm_coe, slave, fsm->sdo_request);
 ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately
 return;
 }
 }
 ec_slave_t *slave = fsm->slave;
 // is there another slave to query?
 if (slave->list.next != &master->slaves) {
 // process next slave
-fsm->slave = list_entry(fsm->slave->list.next, ec_slave_t, list);
+fsm->slave = list_entry(slave->list.next, ec_slave_t, list);
 ec_datagram_nprd(fsm->datagram, fsm->slave->station_address,
 0x0130, 2);
-ec_master_queue_datagram(master, fsm->datagram);
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_master_state_read_states;
 return;
 }
 void ec_fsm_master_state_read_states(ec_fsm_master_t *fsm /**< master state machine */)
 {
 ec_slave_t *slave = fsm->slave;
 ec_datagram_t *datagram = fsm->datagram;
-if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {
+if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
-ec_master_queue_datagram(fsm->master, fsm->datagram);
+return;
-return;
-}
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 EC_ERR("Failed to receive AL state datagram for slave %i"
 " (datagram state %i)\n", slave->ring_position, datagram->state);
 fsm->state = ec_fsm_master_state_error;
 ec_slave_set_state(slave, EC_READ_U8(datagram->data)); // set app state first
 ec_slave_set_online_state(slave, EC_SLAVE_ONLINE);
 // check, if new slave state has to be acknowledged
 if (slave->current_state & EC_SLAVE_STATE_ACK_ERR && !slave->error_flag) {
+fsm->state = ec_fsm_master_state_acknowledge;
 ec_fsm_change_ack(&fsm->fsm_change, slave);
 ec_fsm_change_exec(&fsm->fsm_change);
-fsm->state = ec_fsm_master_state_acknowledge;
 return;
 }
 ec_fsm_master_action_next_slave_state(fsm);
 }
 {
 ec_datagram_t *datagram = fsm->datagram;
 while (fsm->slave->online_state == EC_SLAVE_ONLINE) {
 if (fsm->slave->list.next == &fsm->master->slaves) { // last slave?
-fsm->state = ec_fsm_master_state_start;
+fsm->state = ec_fsm_master_state_end;
-fsm->state(fsm); // execute immediately
 return;
 }
 // check next slave
 fsm->slave = list_entry(fsm->slave->list.next, ec_slave_t, list);
 }
 EC_DBG("Reinitializing slave %i.\n", fsm->slave->ring_position);
 // write station address
 ec_datagram_apwr(datagram, fsm->slave->ring_position, 0x0010, 2);
 EC_WRITE_U16(datagram->data, fsm->slave->station_address);
-ec_master_queue_datagram(fsm->master, datagram);
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_master_state_rewrite_addresses;
 }
 /*****************************************************************************/
 )
 {
 ec_slave_t *slave = fsm->slave;
 ec_datagram_t *datagram = fsm->datagram;
-if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {
+if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
-ec_master_queue_datagram(fsm->master, fsm->datagram);
+return;
-return;
-}
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 EC_ERR("Failed to receive address datagram for slave %i"
 " (datagram state %i).\n",
 slave->ring_position, datagram->state);
 fsm->state = ec_fsm_master_state_error;
 return;
 }
 if (fsm->slave->list.next == &fsm->master->slaves) { // last slave?
-fsm->state = ec_fsm_master_state_start;
+fsm->state = ec_fsm_master_state_end;
-fsm->state(fsm); // execute immediately
 return;
 }
 // check next slave
 fsm->slave = list_entry(fsm->slave->list.next, ec_slave_t, list);
 */
 void ec_fsm_master_state_scan_slaves(ec_fsm_master_t *fsm /**< master state machine */)
 {
 ec_master_t *master = fsm->master;
-ec_slave_t *slave;
+ec_slave_t *slave = fsm->slave;
 if (ec_fsm_slave_exec(&fsm->fsm_slave)) // execute slave state machine
 return;
 // another slave to fetch?
-if (fsm->slave->list.next != &master->slaves) {
+if (slave->list.next != &master->slaves) {
-fsm->slave = list_entry(fsm->slave->list.next, ec_slave_t, list);
+fsm->slave = list_entry(slave->list.next, ec_slave_t, list);
 ec_fsm_slave_start_scan(&fsm->fsm_slave, fsm->slave);
 ec_fsm_slave_exec(&fsm->fsm_slave); // execute immediately
 return;
 }
 // check for another EEPROM write request
 if (ec_fsm_master_action_process_eeprom(fsm))
 return; // processing another request
-// restart master state machine.
+fsm->state = ec_fsm_master_state_end;
-fsm->state = ec_fsm_master_state_start;
-fsm->state(fsm); // execute immediately
 }
 /*****************************************************************************/
 /**
 ec_slave_sdo_dict_info(slave, &sdo_count, &entry_count);
 EC_DBG("Fetched %i SDOs and %i entries from slave %i.\n",
 sdo_count, entry_count, slave->ring_position);
 }
-// restart master state machine.
+fsm->state = ec_fsm_master_state_end;
-fsm->state = ec_fsm_master_state_start;
-fsm->state(fsm); // execute immediately
 }
 /*****************************************************************************/
 /**
 // SDO dictionary fetching finished
 request->return_code = 1;
 master->sdo_seq_master++;
-// restart master state machine.
+fsm->state = ec_fsm_master_state_end;
-fsm->state = ec_fsm_master_state_start;
-fsm->state(fsm); // execute immediately
 }
 /*****************************************************************************/
 /**

changeset 637	d5d04c868e0e
parent 612	aede068f9a74
child 642	3ed80c8ed616