How to calculate runout errors of drills?

Question

Context: For university I have to write a program that calculates the position and value of a runout error for drills.

Idea: My idea is with Fourier transformation I only look at the noise and calculate the runout error only of that signal

Problem: The values of the error are way too small to be true. The series I copied below is made with a "Concentricity standard" (translated with google. basically a bar with 4/100 mm error). You could use min max functions here but not with a real drill

Values below are in 1/1000 mm The calculated error here is 4.0689482653531e-17

You have to look at the graphics manually and find a point for the cutoff.

Do you have ideas to improve this or an even better way to solve this problem?

def fourier_analysis(data, cutoff = 10_000):
    n = len(data.Degree)
    fhat = np.fft.fft(data.Distance, n )
    PSD = fhat * np.conj(fhat) / n
    freq = (1 / n) * np.arange(n)
    L = np.arange(1,np.floor(n/2), dtype='int')
    
    
    # Frequenzen filtern 
    yf = np.fft.fft(data['Distance'].values)
    filtered_yf = np.where(np.abs(fft(data['Distance'].values)) < cutoff, 0, yf)
    filtered_noise = np.where(np.abs(fft(data['Distance'].values)) > cutoff, 0, yf)
    
    # Inverse FFT  
    reconstructed_signal = ifft(filtered_yf)
    noise_signal = ifft(filtered_noise)
    return noise_signal , reconstructed_signal , PSD, L , freq

def calc_runout_error(noise_signal):
    df = pd.DataFrame()
    noise = np.real(noise_signal)
    for i , j in enumerate(noise):
        df.loc[i,'x'] = j * np.cos(math.radians(i))
        df.loc[i,'y'] = j * np.sin(math.radians(i))
    center_x = np.mean(df['x'])
    center_y = np.mean(df['y'])
    
    deg = math.degrees(math.atan2(center_y, center_x))

    if deg < 0:
        deg += 360
    
    distance = math.sqrt(center_x**2 + center_y**2)
    
    return deg , distance , df

def show_runout_error(df, cutoff=10_000, plots = False, y_lim_value=500, x_lim_left= -0.01, x_lim_right= 0.1):
    print(df.loc[0,'Filename'])
    # Analysis
    noise_signal , reconstructed_signal , PSD, L , freq = fourier_analysis(df,cutoff)
    deg , distance, df_error = calc_runout_error(noise_signal)
    
    if plots == True:
        min_val = min(df['Distance'].min(), np.real(reconstructed_signal).min()) 
        max_val = max(df['Distance'].max(), np.real(reconstructed_signal).max()) 
    
        # plot results
        fig = plt.figure(figsize=(10,16))
    
        # show original
        plt.subplot(3, 2, 1)
        plt.plot(df['Degree'], df['Distance'])
        plt.title('original data')
        plt.xlabel('deg')
        plt.ylabel('distance')
        plt.ylim(min_val, max_val)
    
        # show filtered
        plt.subplot(3, 2, 2)
        plt.plot(df['Degree'], np.real(reconstructed_signal))
        plt.title('filtered data')
        plt.xlabel('deg')
        plt.ylabel('distance')
        plt.ylim(min_val, max_val)
    
        #show fourier
        plt.subplot(3, 2, 3)
        plt.plot(freq[L], np.real(PSD[L]), color='r', linewidth=2)
        plt.ylim(0,y_lim_value)
        plt.xlim(x_lim_left, x_lim_right)
        plt.title('fourier transformation')
        plt.xlabel('frequency')
        plt.ylabel('power spectrum density (PSD)')
    
        # show scatter
        plt.subplot(3, 2, 4)
        plt.scatter(x=df_error['x'], y=df_error['y'], color='blue', s=5)
        plt.xlabel('x-coordinate')
        plt.ylabel('y-coordinate')
        plt.title('runout error in cartesian')
        plt.grid(True)
        
        # Noise
        plt.subplot(3, 1, 3)
        plt.plot(df.Degree, np.real(noise_signal), color='red')
        plt.title('runout error (noise)')
        plt.xlabel('deg')
        plt.ylabel('distance')
        
        plt.show()
        print('Degree: ', deg , ' Distance: ', distance)

    
    return deg , distance, reconstructed_signal

deg,distance,  reconstructed_signal = show_runout_error(list_df[5],
                        cutoff=2500,
                        plots=True,
                        y_lim_value=20_000,
                        x_lim_right=0.1
                       )

fourier-graphics

I know what runout is, but I do not know what "runout error" is, nor do I understand why you need to calculate something you can measure. — Tiger Guy, Commented Jun 4 at 21:57
What are your sensors actually measuring? Are you trying to replace a dial gauge with something like a range finder? Simply spinning the drill may not be enough- what about axially shifting? What about the cutting flutes? — Abel, Commented Jun 12 at 3:25
1. We measure the distance between the range finder and the drill 2. The drills are very short so we have to measure on the height of the cutting edges. 3. Using a dial gauge was never really an optiom becuase of wear and damage to the drills 4. We want to find the runout error to "remove" it (restore concentricity) 5. We were hoping to solve this problem by measuring only once, but because of lack of progress we i will try it with multiple measurements 6. What do you mean with your last question? — Starfighter 1074, Commented Jun 12 at 18:36

Stack Exchange Network

How to calculate runout errors of drills?

0

Browse other questions tagged
mechanical-engineering
or ask your own question.

Hot Network Questions

How to calculate runout errors of drills?

0

Know someone who can answer? Share a link to this question via email, Twitter, or Facebook.

Browse other questions tagged mechanical-engineering or ask your own question.

Related

Hot Network Questions

Browse other questions tagged
mechanical-engineering
or ask your own question.