55 void ec_fsm_slave_config_state_dc_cycle(ec_fsm_slave_config_t *);

    56 void ec_fsm_slave_config_state_dc_start(ec_fsm_slave_config_t *);

    57 void ec_fsm_slave_config_state_dc_assign(ec_fsm_slave_config_t *);

    69 void ec_fsm_slave_config_enter_dc_cycle(ec_fsm_slave_config_t *);

    70 void ec_fsm_slave_config_enter_dc_assign(ec_fsm_slave_config_t *);

   610 	// FIXME check for config

   870 	ec_fsm_slave_config_enter_dc_cycle(fsm);

   871 }

   872 

   873 /*****************************************************************************/

   874 

   875 /** Check for DCs to be configured.

   876  */

   877 void ec_fsm_slave_config_enter_dc_cycle(

   878         ec_fsm_slave_config_t *fsm /**< slave state machine */

   879         )

   880 {

   881     ec_datagram_t *datagram = fsm->datagram;

   882     ec_slave_t *slave = fsm->slave;

   883     ec_slave_config_t *config = slave->config;

   884 

   885     if (config->dc_assign_activate) {

   886         if (!slave->base_dc_supported) {

   887             EC_WARN("Attempt to enable synchronized mode for slave %u,"

   888                     " that seems not to support distributed clocks!\n",

   889                     slave->ring_position);

   890         }

   891 

   892         // set DC cycle times

   893         ec_datagram_fpwr(datagram, slave->station_address, 0x09A0, 8);

   894         EC_WRITE_U32(datagram->data, config->dc_sync_cycle_times[0]);

   895         EC_WRITE_U32(datagram->data + 4, config->dc_sync_cycle_times[1]);

   896         fsm->retries = EC_FSM_RETRIES;

   897         fsm->state = ec_fsm_slave_config_state_dc_cycle;

   898     } else {

   899         ec_fsm_slave_config_enter_dc_assign(fsm);

   900     }

   901 }

   902 

   903 /*****************************************************************************/

   904 

   905 /** Slave configuration state: DC CYCLE.

   906  */

   907 void ec_fsm_slave_config_state_dc_cycle(

   908         ec_fsm_slave_config_t *fsm /**< slave state machine */

   909         )

   910 {

   911     ec_datagram_t *datagram = fsm->datagram;

   912     ec_slave_t *slave = fsm->slave;

   913 

   914     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)

   915         return;

   916 

   917     if (datagram->state != EC_DATAGRAM_RECEIVED) {

   918         fsm->state = ec_fsm_slave_config_state_error;

   919         EC_ERR("Failed to receive DC cycle times datagram for slave %u"

   920                 " (datagram state %u).\n",

   921                 slave->ring_position, datagram->state);

   922         return;

   923     }

   924 

   925     if (datagram->working_counter != 1) {

   926         slave->error_flag = 1;

   927         fsm->state = ec_fsm_slave_config_state_error;

   928         EC_ERR("Failed to set DC cycle times of slave %u: ",

   929                 slave->ring_position);

   930         ec_datagram_print_wc_error(datagram);

   931         return;

   932     }

   933 

   934     // set DC start time

   935     ec_datagram_fpwr(datagram, slave->station_address, 0x0990, 8);

   936     EC_WRITE_U64(datagram->data, 0x37E11D600ULL); // 15 s, FIXME

   937     fsm->retries = EC_FSM_RETRIES;

   938     fsm->state = ec_fsm_slave_config_state_dc_start;

   939 }

   940 

   941 /*****************************************************************************/

   942 

   943 /** Slave configuration state: DC START.

   944  */

   945 void ec_fsm_slave_config_state_dc_start(

   946         ec_fsm_slave_config_t *fsm /**< slave state machine */

   947         )

   948 {

   949     ec_datagram_t *datagram = fsm->datagram;

   950     ec_slave_t *slave = fsm->slave;

   951 

   952     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)

   953         return;

   954 

   955     if (datagram->state != EC_DATAGRAM_RECEIVED) {

   956         fsm->state = ec_fsm_slave_config_state_error;

   957         EC_ERR("Failed to receive DC start time datagram for slave %u"

   958                 " (datagram state %u).\n",

   959                 slave->ring_position, datagram->state);

   960         return;

   961     }

   962 

   963     if (datagram->working_counter != 1) {

   964         slave->error_flag = 1;

   965         fsm->state = ec_fsm_slave_config_state_error;

   966         EC_ERR("Failed to set DC start time of slave %u: ",

   967                 slave->ring_position);

   968         ec_datagram_print_wc_error(datagram);

   969         return;

   970     }

   971 

   972     ec_fsm_slave_config_enter_dc_assign(fsm);

   973 }

   974 

   975 /*****************************************************************************/

   976 

   977 /** Set the DC AssignActivate word.

   978  */

   979 void ec_fsm_slave_config_enter_dc_assign(

   980         ec_fsm_slave_config_t *fsm /**< slave state machine */

   981         )

   982 {

   983     ec_datagram_t *datagram = fsm->datagram;

   984     ec_slave_t *slave = fsm->slave;

   985     ec_slave_config_t *config = slave->config;

   986 

   987     // assign sync unit to EtherCAT or PDI

   988     ec_datagram_fpwr(datagram, slave->station_address, 0x0980, 2);

   989     EC_WRITE_U16(datagram->data, config->dc_assign_activate);

   990     fsm->retries = EC_FSM_RETRIES;

   991     fsm->state = ec_fsm_slave_config_state_dc_assign;

   992 }

   993 

   994 /*****************************************************************************/

   995 

   996 /** Slave configuration state: DC ASSIGN.

   997  */

   998 void ec_fsm_slave_config_state_dc_assign(

   999         ec_fsm_slave_config_t *fsm /**< slave state machine */

  1000         )

  1001 {

  1002     ec_datagram_t *datagram = fsm->datagram;

  1003     ec_slave_t *slave = fsm->slave;

  1004 

  1005     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)

  1006         return;

  1007 

  1008     if (datagram->state != EC_DATAGRAM_RECEIVED) {

  1009         fsm->state = ec_fsm_slave_config_state_error;

  1010         EC_ERR("Failed to receive DC activation datagram for slave %u"

  1011                 " (datagram state %u).\n",

  1012                 slave->ring_position, datagram->state);

  1013         return;

  1014     }

  1015 

  1016     if (datagram->working_counter != 1) {

  1017         slave->error_flag = 1;

  1018         fsm->state = ec_fsm_slave_config_state_error;

  1019         EC_ERR("Failed to set DC cyclia operation state of slave %u: ",

  1020                 slave->ring_position);

  1021         ec_datagram_print_wc_error(datagram);

  1022         return;

  1023     }

  1024