master/master.c
changeset 456 dea14706efc2
parent 449 3caf8ff4d8a2
child 459 f0da52cf6b5b
equal deleted inserted replaced
455:204c435fddf9 456:dea14706efc2
   371         while (get_cycles() - datagram->cycles_sent
   371         while (get_cycles() - datagram->cycles_sent
   372                < (cycles_t) EC_IO_TIMEOUT /* us */ * (cpu_khz / 1000)) {}
   372                < (cycles_t) EC_IO_TIMEOUT /* us */ * (cpu_khz / 1000)) {}
   373         ecrt_master_receive(master);
   373         ecrt_master_receive(master);
   374     }
   374     }
   375 
   375 
   376     // finish running FSM
   376     // finish running master FSM
   377     while (ec_fsm_exec(&master->fsm)) {
   377     if (ec_fsm_running(&master->fsm)) {
   378         ec_master_sync_io(master);
   378         while (ec_fsm_exec(&master->fsm)) {
   379     }
   379             ec_master_sync_io(master);
   380 
   380         }
   381     if (!ec_fsm_success(&master->fsm)) {
       
   382         EC_ERR("Master state machine failure!\n");
       
   383         goto out_idle;
       
   384     }
   381     }
   385 
   382 
   386     if (master->debug_level) {
   383     if (master->debug_level) {
   387         if (ec_master_measure_bus_time(master)) {
   384         if (ec_master_measure_bus_time(master)) {
   388             EC_ERR("Bus time measuring failed!\n");
   385             EC_ERR("Bus time measuring failed!\n");
   425         while (get_cycles() - datagram->cycles_sent
   422         while (get_cycles() - datagram->cycles_sent
   426                < (cycles_t) EC_IO_TIMEOUT /* us */ * (cpu_khz / 1000)) {}
   423                < (cycles_t) EC_IO_TIMEOUT /* us */ * (cpu_khz / 1000)) {}
   427         ecrt_master_receive(master);
   424         ecrt_master_receive(master);
   428     }
   425     }
   429 
   426 
       
   427     // finish running master FSM
       
   428     if (ec_fsm_running(fsm)) {
       
   429         while (ec_fsm_exec(fsm)) {
       
   430             ec_master_sync_io(master);
       
   431         }
       
   432     }
       
   433 
   430     // set states for all slaves
   434     // set states for all slaves
   431     list_for_each_entry(slave, &master->slaves, list) {
   435     list_for_each_entry(slave, &master->slaves, list) {
   432         ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);
   436         ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);
   433     }
   437 
   434 
   438         fsm->slave = slave;
   435     // execute master FSM to deactivate slaves
   439         fsm->slave_state = ec_fsm_slaveconf_start;
   436     while (ec_fsm_exec(fsm)) {
   440 
   437         ec_master_sync_io(master);
   441         do {
       
   442             fsm->slave_state(fsm);
       
   443             ec_master_sync_io(master);
       
   444         }
       
   445         while (fsm->slave_state != ec_fsm_slave_end
       
   446                && fsm->slave_state != ec_fsm_slave_error);
   438     }
   447     }
   439 
   448 
   440     ec_master_destroy_domains(master);
   449     ec_master_destroy_domains(master);
   441 
   450 
   442     master->request_cb = NULL;
   451     master->request_cb = NULL;
  1317             return -1;
  1326             return -1;
  1318         }
  1327         }
  1319         domain_offset += domain->data_size;
  1328         domain_offset += domain->data_size;
  1320     }
  1329     }
  1321 
  1330 
  1322     // execute master FSM until termination
  1331     // configure all slaves
  1323     while (ec_fsm_exec(fsm)) {
       
  1324         ec_master_sync_io(master);
       
  1325     }
       
  1326 
       
  1327     if (!ec_fsm_success(fsm)) {
       
  1328         EC_ERR("Error in master state machine.\n");
       
  1329         return -1;
       
  1330     }
       
  1331 
       
  1332     // check, if all slaves have been configured
       
  1333     list_for_each_entry(slave, &master->slaves, list) {
  1332     list_for_each_entry(slave, &master->slaves, list) {
  1334         if (slave->error_flag || !slave->online) {
  1333         fsm->slave = slave;
       
  1334         fsm->slave_state = ec_fsm_slaveconf_start;
       
  1335 
       
  1336         do {
       
  1337             fsm->slave_state(fsm);
       
  1338             ec_master_sync_io(master);
       
  1339         }
       
  1340         while (fsm->slave_state != ec_fsm_slave_end
       
  1341                && fsm->slave_state != ec_fsm_slave_error);
       
  1342 
       
  1343         if (fsm->slave_state == ec_fsm_slave_error) {
  1335             EC_ERR("Failed to configure slave %i!\n", slave->ring_position);
  1344             EC_ERR("Failed to configure slave %i!\n", slave->ring_position);
  1336             return -1;
  1345             return -1;
  1337         }
  1346         }
  1338     }
  1347     }
  1339 
  1348