double_pendulum.utils.filters

Submodules

double_pendulum.utils.filters.butterworth

double_pendulum.utils.filters.butterworth.butterworth_filter(data_measured, order, cutoff)

creates a 3. order Butterworth lowpass filter with a cutoff of 0.2 times the Nyquist frequency or 200 Hz, returning enumerator (b) and denominator (a) polynomials for a Infinite Impulse Response (IIR) filter

The result should be approximately xlow, with no phase shift. >>> b, a = signal.butter(8, 0.125) >>> y = signal.filtfilt(b, a, x, padlen=150) >>> np.abs(y - xlow).max() 9.1086182074789912e-06

double_pendulum.utils.filters.fast_fourier_transform

double_pendulum.utils.filters.fast_fourier_transform.fast_fourier_transform(data_measured, data_desired, n, t)

double_pendulum.utils.filters.fast_fourier_transform.scipy_fft(data_measured, smooth_freq=100)

double_pendulum.utils.filters.identity

class double_pendulum.utils.filters.identity.identity_filter: Bases: object

double_pendulum.utils.filters.kalman_filter

double_pendulum.utils.filters.kalman_filter.kalman_filter(data_measured, control_input, dt): Kalman Filter Filter that tracks position and velocity using a sensor that only reads position. State vector: [q1 q2 q1_dot q2_dot] Reference: https://filterpy.readthedocs.io/en/latest/kalman/KalmanFilter.html

class double_pendulum.utils.filters.kalman_filter.kalman_filter_rt(A, B, dim_x=4, dim_u=2, x0=array([0., 0., 0., 0.]), dt=0.01, process_noise=[0.0, 0.0, 0.0, 0.0], measurement_noise=[0.001, 0.001, 0.1, 0.1], covariance_matrix=array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]]))

Bases: object

kalman filter for realtime data processing

double_pendulum.utils.filters.kalman_filter.main()

double_pendulum.utils.filters.low_pass

class double_pendulum.utils.filters.low_pass.butter_filter_rt(dof=2, cutoff=0.5, dt=0.002, x0=[0.0, 0.0, 0.0, 0.0]): Bases: object

double_pendulum.utils.filters.low_pass.lowpass_filter(data_measured, alpha): choose an alpha value between 0 and 1, where 1 is equivalent to unfiltered data

class double_pendulum.utils.filters.low_pass.lowpass_filter_rt(dim_x=4, alpha=[1.0, 1.0, 0.3, 0.3], x0=[0.0, 0.0, 0.0, 0.0]): Bases: object

double_pendulum.utils.filters.running_mean

double_pendulum.utils.filters.running_mean.data_filter_realtime_1(data_measured_list, data_measured, window=10)

double_pendulum.utils.filters.running_mean.data_filter_realtime_2(i, data_measured_list, window=10)

double_pendulum.utils.filters.running_mean.running_mean_filter(x, N)

“” # Example: # Create arrays from 1 to 100 with step size 0.1, can be changed to random # values time_vec = np.arrange(1, 100.1, 0.1) torque = np.arrange(1, 100.1, 0.1) desired_torque = np.arrange(1, 100.1, 0.1)

# Filter the arrays with the running_mean_filter filtered_torque = running_mean_filter(np.array(torque), 10) time_vec_filtered = running_mean_filter(np.array(time_vec), 10) filtered_desired_torque = running_mean_filter(np.array(desired_torque), 10)

# plot the filtered data plt.plot(time_vec_filtered, filtered_torque) plt.plot(time_vec_filtered, filtered_desired_torque) plt.xlabel(“Time (s)”) plt.ylabel(“Torque (Nm)”) plt.title(“Filtered Torque (Nm) vs Time (s)

with moving average filter (window = 100)”)

plt.legend([‘Measured’, ‘Desired’]) plt.show()

double_pendulum.utils.filters.savitzky_golay

double_pendulum.utils.filters.savitzky_golay.savitzky_golay_filter(data_measured, window, degree): Savitzky-Golay Filter Local least-squares polynomial approximation. Delay = (window-1)/2 * delta_t

double_pendulum.utils.filters.unscented_kalman_filter

double_pendulum.utils.filters.unscented_kalman_filter.iden(x)

class double_pendulum.utils.filters.unscented_kalman_filter.unscented_kalman_filter_rt(dim_x=4, x0=array([0., 0., 0., 0.]), dt=0.01, measurement_noise=[0.001, 0.001, 0.1, 0.1], process_noise=[0.0, 0.0, 0.0, 0.0], fx=None): Bases: object