master/fsm_slave.c
branchstable-1.3
changeset 1745 07fd94c5119d
parent 1744 7bc131b92039
child 1746 72e7507b3f1b
equal deleted inserted replaced
1744:7bc131b92039 1745:07fd94c5119d
   224     }
   224     }
   225 
   225 
   226     if (datagram->working_counter != 1) {
   226     if (datagram->working_counter != 1) {
   227         fsm->slave->error_flag = 1;
   227         fsm->slave->error_flag = 1;
   228         fsm->state = ec_fsm_slave_state_error;
   228         fsm->state = ec_fsm_slave_state_error;
   229         EC_ERR("Failed to write station address - slave %i did not respond.\n",
   229         EC_ERR("Failed to write station address on slave %i: ",
   230                fsm->slave->ring_position);
   230                fsm->slave->ring_position);
       
   231         ec_datagram_print_wc_error(datagram);
   231         return;
   232         return;
   232     }
   233     }
   233 
   234 
   234     // Read AL state
   235     // Read AL state
   235     ec_datagram_nprd(datagram, fsm->slave->station_address, 0x0130, 2);
   236     ec_datagram_nprd(datagram, fsm->slave->station_address, 0x0130, 2);
   241 
   242 
   242 /**
   243 /**
   243    Slave scan state: STATE.
   244    Slave scan state: STATE.
   244 */
   245 */
   245 
   246 
   246 void ec_fsm_slave_scan_state_state(ec_fsm_slave_t *fsm /**< slave state machine */)
   247 void ec_fsm_slave_scan_state_state(
       
   248         ec_fsm_slave_t *fsm /**< slave state machine */
       
   249         )
   247 {
   250 {
   248     ec_datagram_t *datagram = fsm->datagram;
   251     ec_datagram_t *datagram = fsm->datagram;
   249     ec_slave_t *slave = fsm->slave;
   252     ec_slave_t *slave = fsm->slave;
   250 
   253 
   251     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
   254     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
   260     }
   263     }
   261 
   264 
   262     if (datagram->working_counter != 1) {
   265     if (datagram->working_counter != 1) {
   263         fsm->slave->error_flag = 1;
   266         fsm->slave->error_flag = 1;
   264         fsm->state = ec_fsm_slave_state_error;
   267         fsm->state = ec_fsm_slave_state_error;
   265         EC_ERR("Failed to read AL state - slave %i did not respond.\n",
   268         EC_ERR("Failed to read AL state of slave %i: ",
   266                fsm->slave->ring_position);
   269                fsm->slave->ring_position);
       
   270         ec_datagram_print_wc_error(datagram);
   267         return;
   271         return;
   268     }
   272     }
   269 
   273 
   270     slave->current_state = EC_READ_U8(datagram->data);
   274     slave->current_state = EC_READ_U8(datagram->data);
   271     if (slave->current_state & EC_SLAVE_STATE_ACK_ERR) {
   275     if (slave->current_state & EC_SLAVE_STATE_ACK_ERR) {
   304     }
   308     }
   305 
   309 
   306     if (datagram->working_counter != 1) {
   310     if (datagram->working_counter != 1) {
   307         fsm->slave->error_flag = 1;
   311         fsm->slave->error_flag = 1;
   308         fsm->state = ec_fsm_slave_state_error;
   312         fsm->state = ec_fsm_slave_state_error;
   309         EC_ERR("Failed to read base data - slave %i did not respond.\n",
   313         EC_ERR("Failed to read base data from slave %i: ",
   310                slave->ring_position);
   314                slave->ring_position);
       
   315         ec_datagram_print_wc_error(datagram);
   311         return;
   316         return;
   312     }
   317     }
   313 
   318 
   314     slave->base_type       = EC_READ_U8 (datagram->data);
   319     slave->base_type       = EC_READ_U8 (datagram->data);
   315     slave->base_revision   = EC_READ_U8 (datagram->data + 1);
   320     slave->base_revision   = EC_READ_U8 (datagram->data + 1);
   350     }
   355     }
   351 
   356 
   352     if (datagram->working_counter != 1) {
   357     if (datagram->working_counter != 1) {
   353         fsm->slave->error_flag = 1;
   358         fsm->slave->error_flag = 1;
   354         fsm->state = ec_fsm_slave_state_error;
   359         fsm->state = ec_fsm_slave_state_error;
   355         EC_ERR("Failed to read DL status - slave %i did not respond.\n",
   360         EC_ERR("Failed to read DL status from slave %i: ",
   356                slave->ring_position);
   361                slave->ring_position);
       
   362         ec_datagram_print_wc_error(datagram);
   357         return;
   363         return;
   358     }
   364     }
   359 
   365 
   360     dl_status = EC_READ_U16(datagram->data);
   366     dl_status = EC_READ_U16(datagram->data);
   361     for (i = 0; i < 4; i++) {
   367     for (i = 0; i < 4; i++) {
   642     }
   648     }
   643 
   649 
   644     if (datagram->working_counter != 1) {
   650     if (datagram->working_counter != 1) {
   645         fsm->slave->error_flag = 1;
   651         fsm->slave->error_flag = 1;
   646         fsm->state = ec_fsm_slave_state_error;
   652         fsm->state = ec_fsm_slave_state_error;
   647         EC_ERR("Failed to clear FMMUs - slave %i did not respond.\n",
   653         EC_ERR("Failed to clear FMMUs of slave %i: ",
   648                fsm->slave->ring_position);
   654                fsm->slave->ring_position);
       
   655         ec_datagram_print_wc_error(datagram);
   649         return;
   656         return;
   650     }
   657     }
   651 
   658 
   652     ec_fsm_slave_conf_enter_mbox_sync(fsm);
   659     ec_fsm_slave_conf_enter_mbox_sync(fsm);
   653 }
   660 }
   724     }
   731     }
   725 
   732 
   726     if (datagram->working_counter != 1) {
   733     if (datagram->working_counter != 1) {
   727         slave->error_flag = 1;
   734         slave->error_flag = 1;
   728         fsm->state = ec_fsm_slave_state_error;
   735         fsm->state = ec_fsm_slave_state_error;
   729         EC_ERR("Failed to set sync managers - slave %i did not respond.\n",
   736         EC_ERR("Failed to set sync managers of slave %i: ",
   730                slave->ring_position);
   737                slave->ring_position);
       
   738         ec_datagram_print_wc_error(datagram);
   731         return;
   739         return;
   732     }
   740     }
   733 
   741 
   734     ec_fsm_slave_conf_enter_preop(fsm);
   742     ec_fsm_slave_conf_enter_preop(fsm);
   735 }
   743 }
   939     }
   947     }
   940 
   948 
   941     if (datagram->working_counter != 1) {
   949     if (datagram->working_counter != 1) {
   942         slave->error_flag = 1;
   950         slave->error_flag = 1;
   943         fsm->state = ec_fsm_slave_state_error;
   951         fsm->state = ec_fsm_slave_state_error;
   944         EC_ERR("Failed to set process data sync managers - slave %i did not"
   952         EC_ERR("Failed to set process data sync managers of slave %i: ",
   945                " respond.\n", slave->ring_position);
   953                 slave->ring_position);
       
   954         ec_datagram_print_wc_error(datagram);
   946         return;
   955         return;
   947     }
   956     }
   948 
   957 
   949     ec_fsm_slave_conf_enter_fmmu(fsm);
   958     ec_fsm_slave_conf_enter_fmmu(fsm);
   950 }
   959 }
  1000     }
  1009     }
  1001 
  1010 
  1002     if (datagram->working_counter != 1) {
  1011     if (datagram->working_counter != 1) {
  1003         slave->error_flag = 1;
  1012         slave->error_flag = 1;
  1004         fsm->state = ec_fsm_slave_state_error;
  1013         fsm->state = ec_fsm_slave_state_error;
  1005         EC_ERR("Failed to set FMMUs - slave %i did not respond.\n",
  1014         EC_ERR("Failed to set FMMUs of slave %i: ",
  1006                slave->ring_position);
  1015                slave->ring_position);
       
  1016         ec_datagram_print_wc_error(datagram);
  1007         return;
  1017         return;
  1008     }
  1018     }
  1009 
  1019 
  1010     ec_fsm_slave_conf_enter_saveop(fsm);
  1020     ec_fsm_slave_conf_enter_saveop(fsm);
  1011 }
  1021 }