Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/fsm_master.c
changeset 849 4b712ec8929d
parent 834 0791aac03180
child 853 726326d0aef4
equal deleted inserted replaced
848:ae0829882a72 849:4b712ec8929d 
    42 #include "master.h"
 
    42 #include "master.h"
 
    43 #include "mailbox.h"
 
    43 #include "mailbox.h"
 
    44 #ifdef EC_EOE
 
    44 #ifdef EC_EOE
 
    45 #include "ethernet.h"
 
    45 #include "ethernet.h"
 
    46 #endif
 
    46 #endif
 
       
    47 
    47 #include "fsm_master.h"
 
    48 #include "fsm_master.h"
 
    48 
    49 
    49 /*****************************************************************************/
 
    50 /*****************************************************************************/
 
    50 
    51 
    51 void ec_fsm_master_state_start(ec_fsm_master_t *);
 
    52 void ec_fsm_master_state_start(ec_fsm_master_t *);
 
   368 int ec_fsm_master_action_process_sdo(
 
   369 int ec_fsm_master_action_process_sdo(
 
   369         ec_fsm_master_t *fsm /**< master state machine */
 
   370         ec_fsm_master_t *fsm /**< master state machine */
 
   370         )
 
   371         )
 
   371 {
 
   372 {
 
   372     ec_master_t *master = fsm->master;
 
   373     ec_master_t *master = fsm->master;
 
   373     ec_sdo_request_t *request;
 
   374     ec_master_sdo_request_t *request;
 
   374     ec_slave_t *slave;
 
   375     ec_slave_t *slave;
 
   375 
   376 
   376     // search the first request to be processed
 
   377     // search the first request to be processed
 
   377     while (1) {
 
   378     while (1) {
 
   378         down(&master->sdo_sem);
 
   379         down(&master->sdo_sem);
 
   379         if (list_empty(&master->sdo_requests)) {
 
   380         if (list_empty(&master->slave_sdo_requests)) {
 
   380             up(&master->sdo_sem);
 
   381             up(&master->sdo_sem);
 
   381             break;
 
   382             break;
 
   382         }
 
   383         }
 
   383         // get first request
 
   384         // get first request
 
   384         request =
 
   385         request = list_entry(master->slave_sdo_requests.next,
 
   385             list_entry(master->sdo_requests.next, ec_sdo_request_t, list);
 
   386                 ec_master_sdo_request_t, list);
 
   386         list_del_init(&request->list); // dequeue
 
   387         list_del_init(&request->list); // dequeue
 
   387         request->state = EC_REQUEST_IN_PROGRESS;
 
   388         request->req.state = EC_REQUEST_IN_PROGRESS;
 
   388         up(&master->sdo_sem);
 
   389         up(&master->sdo_sem);
 
   389 
   390 
   390         slave = request->slave;
 
   391         slave = request->slave;
 
   391         if (slave->current_state == EC_SLAVE_STATE_INIT ||
 
   392         if (slave->current_state == EC_SLAVE_STATE_INIT ||
 
   392                 slave->online_state == EC_SLAVE_OFFLINE ||
 
   393                 slave->online_state == EC_SLAVE_OFFLINE ||
 
   393                 slave->error_flag) {
 
   394                 slave->error_flag) {
 
   394             EC_ERR("Discarding Sdo request, slave %i not ready.\n",
 
   395             EC_ERR("Discarding Sdo request, slave %u not ready.\n",
 
   395                     slave->ring_position);
 
   396                     slave->ring_position);
 
   396             request->state = EC_REQUEST_FAILURE;
 
   397             request->req.state = EC_REQUEST_FAILURE;
 
   397             wake_up(&master->sdo_queue);
 
   398             wake_up(&master->sdo_queue);
 
   398             continue;
 
   399             continue;
 
   399         }
 
   400         }
 
   400 
   401 
   401         // found pending Sdo request. execute it!
 
   402         // Found pending Sdo request. Execute it!
 
   402         if (master->debug_level)
 
   403         if (master->debug_level)
 
   403             EC_DBG("Processing Sdo request for slave %i...\n",
 
   404             EC_DBG("Processing Sdo request for slave %i...\n",
 
   404                     slave->ring_position);
 
   405                     slave->ring_position);
 
   405 
   406 
   406         // start uploading Sdo
 
   407         // Start uploading Sdo
 
   407         fsm->idle = 0;
 
   408         fsm->idle = 0;
 
   408         fsm->slave = slave;
 
       
   409         fsm->sdo_request = request;
 
   409         fsm->sdo_request = request;
 
   410         fsm->state = ec_fsm_master_state_sdo_request;
 
   410         fsm->state = ec_fsm_master_state_sdo_request;
 
   411         ec_fsm_coe_upload(&fsm->fsm_coe, slave, fsm->sdo_request);
 
   411         ec_fsm_coe_upload(&fsm->fsm_coe, slave, &request->req);
 
   412         ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately
 
   412         ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately
 
   413         return 1;
 
   413         return 1;
 
   414     }
 
   414     }
 
   415 
   415 
   416     return 0;
 
   416     return 0;
 
  1020 */
 
  1020 */
 
  1021 
  1021 
  1022 void ec_fsm_master_state_sdo_request(ec_fsm_master_t *fsm /**< master state machine */)
 
  1022 void ec_fsm_master_state_sdo_request(ec_fsm_master_t *fsm /**< master state machine */)
 
  1023 {
 
  1023 {
 
  1024     ec_master_t *master = fsm->master;
 
  1024     ec_master_t *master = fsm->master;
 
  1025     ec_sdo_request_t *request = fsm->sdo_request;
 
  1025     ec_master_sdo_request_t *request = fsm->sdo_request;
 
  1026 
  1026 
  1027     if (ec_fsm_coe_exec(&fsm->fsm_coe)) return;
 
  1027     if (ec_fsm_coe_exec(&fsm->fsm_coe)) return;
 
  1028 
  1028 
  1029     if (!ec_fsm_coe_success(&fsm->fsm_coe)) {
 
  1029     if (!ec_fsm_coe_success(&fsm->fsm_coe)) {
 
  1030         EC_DBG("Failed to process Sdo request for slave %i.\n",
 
  1030         EC_DBG("Failed to process Sdo request for slave %i.\n",
 
  1031                 fsm->slave->ring_position);
 
  1031                 fsm->slave->ring_position);
 
  1032         request->state = EC_REQUEST_FAILURE;
 
  1032         request->req.state = EC_REQUEST_FAILURE;
 
  1033         wake_up(&master->sdo_queue);
 
  1033         wake_up(&master->sdo_queue);
 
  1034         fsm->state = ec_fsm_master_state_error;
 
  1034         fsm->state = ec_fsm_master_state_error;
 
  1035         return;
 
  1035         return;
 
  1036     }
 
  1036     }
 
  1037 
  1037 
  1038     // Sdo request finished 
  1038     // Sdo request finished 
  1039     request->state = EC_REQUEST_COMPLETE;
 
  1039     request->req.state = EC_REQUEST_COMPLETE;
 
  1040     wake_up(&master->sdo_queue);
 
  1040     wake_up(&master->sdo_queue);
 
  1041 
  1041 
  1042     if (master->debug_level)
 
  1042     if (master->debug_level)
 
  1043         EC_DBG("Finished Sdo request for slave %i.\n",
 
  1043         EC_DBG("Finished Sdo request for slave %i.\n",
 
  1044                 fsm->slave->ring_position);
 
  1044                 fsm->slave->ring_position);
etherlabmaster