Threading Index Varies With Speed

/**  * Run position mode synchronization.  * Updates requested velocity for a trajectory segment to track the spindle's position.  */ STATIC void tpSyncPositionMode(TP_STRUCT * const tp, TC_STRUCT * const tc,         TC_STRUCT * const nexttc ) {     double spindle_pos = tpGetSignedSpindlePosition(&emcmotStatus->spindle_status[tp->spindle.spindle_num]);     tp_debug_print("Spindle at %f\n",spindle_pos);     double spindle_vel, target_vel;     double oldrevs = tp->spindle.revs;     if ((tc->motion_type == TC_RIGIDTAP) && (tc->coords.rigidtap.state == RETRACTION ||                 tc->coords.rigidtap.state == FINAL_REVERSAL)) {             tp->spindle.revs = tc->coords.rigidtap.spindlerevs_at_reversal -                 spindle_pos;     } else {         tp->spindle.revs = spindle_pos;     }     double pos_desired = (tp->spindle.revs - tp->spindle.offset) * tc->uu_per_rev;     double pos_error = pos_desired - tc->progress;     if(nexttc) {         pos_error -= nexttc->progress;     }     if(tc->sync_accel) {         // detect when velocities match, and move the target accordingly.         // acceleration will abruptly stop and we will be on our new target.         // FIX: this is driven by TP cycle time, not the segment cycle time         double dt = fmax(tp->cycleTime, TP_TIME_EPSILON);         spindle_vel = tp->spindle.revs / ( dt * tc->sync_accel++);         target_vel = spindle_vel * tc->uu_per_rev;         if(tc->currentvel >= target_vel) {             tc_debug_print("Hit accel target in pos sync\n");             // move target so as to drive pos_error to 0 next cycle             tp->spindle.offset = tp->spindle.revs - tc->progress / tc->uu_per_rev;             tc->sync_accel = 0;             tc->target_vel = target_vel;         } else {             tc_debug_print("accelerating in pos_sync\n");             // beginning of move and we are behind: accel as fast as we can             tc->target_vel = tc->maxvel;         }     } else {         // we have synced the beginning of the move as best we can -         // track position (minimize pos_error).         tc_debug_print("tracking in pos_sync\n");         double errorvel;         spindle_vel = (tp->spindle.revs - oldrevs) / tp->cycleTime;         target_vel = spindle_vel * tc->uu_per_rev;         errorvel = pmSqrt(fabs(pos_error) * tcGetTangentialMaxAccel(tc));         if(pos_error<0) {             errorvel *= -1.0;         }         tc->target_vel = target_vel + errorvel;     }     //Finally, clip requested velocity at zero     if (tc->target_vel < 0.0) {         tc->target_vel = 0.0;     }     if (nexttc && nexttc->synchronized) {         //If the next move is synchronized too, then match it's         //requested velocity to the current move         nexttc->target_vel = tc->target_vel;     } }

The G76 canned cycle is based on the G33 Spindle Synchronized Motion. For more information see the G33 [url=https://linuxcnc.org/docs/devel/html/gcode/g-code.html#gcode:g33-tech-info]Technical Info[/url].

Technical InfoAt the beginning of each G33 pass, LinuxCNC uses the spindle speed and the machine acceleration limits to calculate how long it will take Z to accelerate after the index pulse, and determines how many degrees the spindle will rotate during that time. It then adds that angle to the index position and computes the Z position using the corrected spindle angle. That means that Z will reach the correct position just as it finishes accelerating to the proper speed, and can immediately begin cutting a good thread.