Retrofitting Mikron WF41C: Distance coded homing success

# HOME_DISTANCE_CODED enables / disables support for homing of distance coded glasscales
HOME_DISTANCE_CODED = 1
# HOME_DISTANCE_CODED_N specifies the nominal number of steps the coding marks are separated
HOME_DISTANCE_CODED_N = 1000
# HOME_DISTANCE_CODED_SP specifies the signal period of the analog signal coming from the glasscale
HOME_DISTANCE_CODED_SP = 0.02

joint.N.motor-pos-raw-fb

# activating distance coded homing (@andypugh I there is more than one parameter assiciated with distance coded homing I kept the explicit activation)
HOME_DISTANCE_CODED = 1
# Nominal steps between two index marks on the equally spaced index sequence
HOME_DISTANCE_CODED_N = 1000
# amount of pulses consumed by the control during one analog signal period (typically interpolation factor times 4 for quadrature)
HOME_DISTANCE_CODED_OS = 20
# width of index-pulse as provided to LinuxCNC (see comments below)
HOME_DISTANCE_CODED_PW = 2

case HOME_SET_INDEX_POSITION:

    if((H[joint_num].home_flags & HOME_DISTANCE_CODED) && (nr_ref_marks < 1)) {
        /* Searches for the first reference mark and store its raw encoder position
        in 'raw_trigger_1'. Then it resets the homing state to HOMEO_INDEX_SEARCH_START
        to look for the the second homing mark */

        raw_trigger_1 = joint->motor_pos_raw_fb - round(joint->pos_fb * H[joint_num].encoder_scale);
        ++nr_ref_marks;
        H[joint_num].home_state = HOME_INDEX_SEARCH_START; //sent it back to index mark search

    }else if((H[joint_num].home_flags & HOME_DISTANCE_CODED)  && (nr_ref_marks < 2)){

        raw_trigger_2 = joint->motor_pos_raw_fb - round(joint->pos_fb * H[joint_num].encoder_scale);
        ++nr_ref_marks;

        // calculate and set the 'home_offset' based on raw_trigger_pos_1, raw_trigger_pos_2 		
        int position = distance_coded_position(
                              raw_trigger_1, 
                              raw_trigger_2, 
                              H[joint_num].home_distance_coded_n, 
                              H[joint_num].home_distance_coded_os,
                              H[joint_num].home_distance_coded_pw
                               );
        H[joint_num].home_offset = (double)position / H[joint_num].encoder_scale;  
			
    }else{
        /* This state is called when the encoder has been reset at
        the index pulse position.  It sets the current joint 
        position to 'home_offset', which is the location of the
        index pulse in joint coordinates. */
        /* set the current position to 'home_offset' */
        joint->motor_offset = - H[joint_num].home_offset;
        joint->pos_fb = joint->motor_pos_fb -
        (joint->backlash_filt + joint->motor_offset);
        joint->pos_cmd = joint->pos_fb;
        joint->free_tp.curr_pos = joint->pos_fb;

        if (H[joint_num].home_flags & HOME_INDEX_NO_ENCODER_RESET) {
        /* Special case: encoder does not reset on index pulse.
        This moves the internal position but does not affect
        the motor position */
        offset = H[joint_num].home_offset - joint->pos_fb;
        joint->pos_cmd          += offset;
        joint->pos_fb           += offset;
        joint->free_tp.curr_pos += offset;
        joint->motor_offset     -= offset;
        }

        /* next state */
        H[joint_num].home_state = HOME_FINAL_MOVE_START;
        immediate_state = 1;
        nr_ref_marks = 0;
        break;
    }

int distance_coded_position(double raw_trigger_1, 
                   double raw_trigger_2,
                   int nominal_steps, 
                   int over_sampling,
                   int index_pulswidth)
{
	/* This function calculates the absolut position of the second trigger signal 
	on a distance coded glasscale (e.g. Heidenhain LS***C) as a integer number of 
	signal pulses after interpolation and quadrature if enabled. 'raw_trigger_1' is
	the raw encoder position of the first index-mark found during homing and 
	'raw_trigger_2' that of the second one. 'nominal_steps' is the nominal number
	of analog signals (before interpolation and quadrature) between constant space 
	series of index mark on the glasscale (approximately twice the distance between
	two neighbouring index marks). 'over_sampling' defines how many signals LinuxCNC
	receives while travling over one analog signal period i.e. the interpolation 
	factor times four if quadrature is enabled. 'index_pulswidth' is the width of 
	the index-signal after interpolation and quadrature in units of regular distance
	pulses (typically the value is two). */

	int Mrr = (round(raw_trigger_1) - round(raw_trigger_2)) / over_sampling;
	int R = 2 * ABS(Mrr) - nominal_steps;
	int P1 = ((ABS(R) - SGN(R) - 1) * nominal_steps / 2 
             + (SGN(R) - SGN(Mrr)) * ABS(Mrr) / 2) * over_sampling 
             + SGN(Mrr) * index_pulswidth / 2;

	return P1;
}