Measure (several) single wires.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "351515d6",
   "metadata": {},
   "source": [
    "# Before use: please run following cells once with connection to gas bottle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "818218b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import RPi.GPIO as GPIO\n",
    "import time\n",
    "\n",
    "import os\n",
    "import sounddevice as sd\n",
    "from scipy.io.wavfile import write, read\n",
    "import RPi.GPIO as GPIO\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import scipy.fft\n",
    "from scipy.signal import find_peaks, peak_widths, savgol_filter\n",
    "import statistics\n",
    "import math\n",
    "\n",
    "\n",
    "from IPython.display import clear_output\n",
    "import time\n",
    "import pickle\n",
    "\n",
    "GPIO.setmode(GPIO.BCM)\n",
    "\n",
    "# Raspberry Pi Pin-Belegung für TB6600 Treiber\n",
    "DIR = 13\n",
    "PUL = 19\n",
    "ENA = 26\n",
    "\n",
    "DIR_Left = GPIO.HIGH\n",
    "DIR_Right = GPIO.LOW\n",
    "\n",
    "ENA_Locked = GPIO.LOW\n",
    "ENA_Released = GPIO.HIGH\n",
    "\n",
    "GPIO.setwarnings(False)\n",
    "GPIO.setup(DIR, GPIO.OUT)\n",
    "GPIO.setup(PUL, GPIO.OUT)\n",
    "GPIO.setup(ENA, GPIO.OUT)\n",
    "\n",
    "GPIO.setmode(GPIO.BCM)\n",
    "GPIO.setup(21, GPIO.OUT)\n",
    "plt.rc('font', family='serif')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "db7c2afb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# opens valve to fill gas system\n",
    "GPIO.output(21, GPIO.HIGH)\n",
    "time.sleep(.5)\n",
    "GPIO.output(21, GPIO.LOW)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9846b876",
   "metadata": {},
   "source": [
    "## Different movements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "18d819df",
   "metadata": {},
   "outputs": [],
   "source": [
    "def move_to_wire(steps,position,t=0.001):\n",
    "    '''\n",
    "    moves sled to set position (over/near wire)\n",
    "    - steps (int):    steps movement has to do\n",
    "    - position (int): actual position (in steps), from where the movement starts\n",
    "    - t (int):        step-time for stepper-motor, sets speed\n",
    "    \n",
    "    returns: position (in steps) after movement\n",
    "    '''\n",
    "    steps=int(steps)\n",
    "    # Motor aktivieren und halten\n",
    "    GPIO.output(ENA, ENA_Locked)\n",
    "\n",
    "    # Richtung abhängig von positivem oder negativem Wert\n",
    "    if (steps < 0):\n",
    "        GPIO.output(DIR, DIR_Left)\n",
    "        steps=steps*-1\n",
    "        direction=-1\n",
    "    else:\n",
    "        GPIO.output(DIR, DIR_Right)\n",
    "        direction=1\n",
    "\n",
    "    if steps>0:   \n",
    "\n",
    "        for i in range(steps):\n",
    "            GPIO.output(PUL, GPIO.HIGH)\n",
    "            time.sleep(t)\n",
    "\n",
    "            GPIO.output(PUL, GPIO.LOW)\n",
    "            time.sleep(t)\n",
    "    \n",
    "    position +=direction*steps\n",
    "    return position\n",
    "\n",
    "def auf_Anfang(position,t=0.001):\n",
    "    '''\n",
    "    moves sled to the starting position. \n",
    "    - position (int): actual position (in steps), from where the movement starts\n",
    "    - t (int):        step-time for stepper-motor, sets speed\n",
    "    \n",
    "    if starting position is not reeached: error message: help me please\n",
    "    '''\n",
    "    steps=int(-1*position)\n",
    "    # Motor aktivieren und halten\n",
    "    GPIO.output(ENA, ENA_Locked)\n",
    "\n",
    "    # Richtung abhängig von positivem oder negativem Wert\n",
    "    if (steps < 0):\n",
    "        GPIO.output(DIR, DIR_Left)\n",
    "        steps=steps*-1\n",
    "        direction=-1\n",
    "    else:\n",
    "        GPIO.output(DIR, DIR_Right)\n",
    "        direction=1\n",
    "\n",
    "    if steps>0:   \n",
    "\n",
    "        for i in range(steps):\n",
    "            GPIO.output(PUL, GPIO.HIGH)\n",
    "            time.sleep(t)\n",
    "\n",
    "            GPIO.output(PUL, GPIO.LOW)\n",
    "            time.sleep(t)\n",
    "    \n",
    "    position += direction*steps\n",
    "    if position==0:\n",
    "        print('ready again')\n",
    "    else:\n",
    "        print('help me please')\n",
    "    GPIO.output(ENA, ENA_Released) \n",
    "\n",
    "def find_wire(position,steps=60, k=0.4, corr_steps=0, tm=0.1,fs=48000, plot=False):\n",
    "    '''\n",
    "    searches for wire and positions sled over it:\n",
    "    sled moves the complete distance over the wire recording a signal: peak in recording\n",
    "    moves back until a set factor k of the peak can be measured. \n",
    "    - position (int):   actual position (in steps), from where the movement starts\n",
    "    - steps (int):      search distance (in steps) in which the wire is searched\n",
    "    - k (int):          scale factor to refind peak\n",
    "    - corr_steps (int): correcting steps (moving backwords), only if sled stops too late systematicly\n",
    "    - tm (int):         step-time for stepper-motor, sets speed\n",
    "    - fs (int):         sample of the soundcard rate for the recording\n",
    "    \n",
    "    returns: position (in steps) after movement\n",
    "    '''\n",
    "    pos=position\n",
    "    \n",
    "    steps=int(steps)\n",
    "    # activate motor and hold\n",
    "    GPIO.output(ENA, ENA_Locked)\n",
    "\n",
    "    # set direction dependant on pos. od neg. steps, pos is to the right\n",
    "    if (steps < 0):\n",
    "        GPIO.output(DIR, DIR_Left)\n",
    "        steps=steps*-1\n",
    "        direction=-1\n",
    "    else:\n",
    "        GPIO.output(DIR, DIR_Right)\n",
    "        direction=1\n",
    "\n",
    "    signal=[]\n",
    "\n",
    "    # moving over wire recording signal\n",
    "    for i in range(steps):\n",
    "        GPIO.output(PUL, GPIO.HIGH)\n",
    "        time.sleep(tm)\n",
    "    \n",
    "        signal.append(sd.rec(1, samplerate=fs, channels=1))\n",
    "    \n",
    "        GPIO.output(PUL, GPIO.LOW)\n",
    "        time.sleep(tm)\n",
    "    \n",
    "        signal.append(sd.rec(1, samplerate=fs, channels=1))\n",
    "        \n",
    "    position += direction*steps\n",
    "    \n",
    "    # looking for peak\n",
    "    signal=np.array(signal)\n",
    "    signal=signal[:,0]\n",
    "\n",
    "    x=np.where(signal==max(signal))[0]\n",
    "    y=signal[x]*k\n",
    "    \n",
    "    if plot==True:\n",
    "        x=np.arange(0,len(signal))\n",
    "        plt.plot(x,signal)\n",
    "    plt.show()\n",
    "    \n",
    "    # turn around direction\n",
    "    if direction>0:\n",
    "        GPIO.output(DIR, DIR_Left)\n",
    "        direction=-1\n",
    "    else:\n",
    "        GPIO.output(DIR, DIR_Right)\n",
    "        direction=1\n",
    "\n",
    "    #start value for while \n",
    "    signal2=abs(sd.rec(5, samplerate=fs, channels=1)[2])\n",
    "    \n",
    "    while signal2<y and pos<=position:\n",
    "        GPIO.output(PUL, GPIO.HIGH)\n",
    "        time.sleep(tm)\n",
    "    \n",
    "        GPIO.output(PUL, GPIO.LOW)\n",
    "        time.sleep(tm)\n",
    "   \n",
    "        signal2=abs(sd.rec(5, samplerate=fs, channels=1)[2])\n",
    "        position += direction\n",
    "    if pos==position:\n",
    "        print('hoppla')\n",
    "    \n",
    "    # correction steps backwords only if sled stopped too late over wire\n",
    "    if direction>0:\n",
    "        GPIO.output(DIR, DIR_Left)\n",
    "        direction=-1\n",
    "    else:\n",
    "        GPIO.output(DIR, DIR_Right)\n",
    "        direction=1\n",
    "\n",
    "    for i in range(0,corr_steps):\n",
    "        GPIO.output(PUL, GPIO.HIGH)\n",
    "        time.sleep(tm)\n",
    "    \n",
    "        GPIO.output(PUL, GPIO.LOW)\n",
    "        time.sleep(tm)\n",
    "        position += direction\n",
    "    return position\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37b12314",
   "metadata": {},
   "source": [
    "## Tension measurement software"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d9ee47cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_record(seconds=3, signalname='signal', fs=48000, plot=False):\n",
    "    '''\n",
    "    Records audio signal with sd.rec() from module sounddevice for set amount of seconds and with set \n",
    "    samplerate.\n",
    "    The signal is recorded for the set time plus 0.2 seconds. Returned is only the signal measured \n",
    "    from 0.2 seconds onwards.\n",
    "    \n",
    "    Args:\n",
    "        seconds (float): number of seconds for which signal is recorded\n",
    "        signalname(str): plotlabel of signal if plot is shown\n",
    "        fs (int):        samplerate (samples taken per second)\n",
    "        plot (bool):     if True, recorded signal is plotted over time\n",
    "        \n",
    "    '''\n",
    "    \n",
    "    t = np.arange(0, seconds, 1/fs)\n",
    "    seconds += 0.2\n",
    "    \n",
    "    #start recording    \n",
    "    recording = sd.rec(int(seconds * fs), samplerate=fs, channels=1)\n",
    "    print(\"Starting recording\")\n",
    "    sd.wait()  # Wait until recording is finished\n",
    "    print(\"finished\")\n",
    "    \n",
    "    #turn signal into list of data\n",
    "    l = [[i for i in elem] for elem in recording]\n",
    "    ll = []\n",
    "    for x in l:\n",
    "        ll+=x\n",
    "    \n",
    "    # plot signal\n",
    "    if plot == True:\n",
    "        fig_ratio=9/16\n",
    "        fig_size_x= 6.8#3.07 #inch\n",
    "\n",
    "        plt.figure(figsize=(fig_size_x,fig_size_x*fig_ratio),dpi=150)\n",
    "        plt.plot(t, ll[int(0.2*fs):], label=signalname)\n",
    "\n",
    "        plt.xlabel('t [s]',fontsize=10)\n",
    "        plt.ylabel('amplitude [a.u.]',fontsize=10)\n",
    "        plt.legend(loc='upper right',fontsize=10)\n",
    "    \n",
    "    return np.array(ll[int(0.2*fs):])\n",
    "\n",
    "def findPeaks(data, noise, fs=48000, peaks=5, name='data', plot=False, _xrange=None, expect_low=0, expect_high=10000):\n",
    "    '''\n",
    "    Turns signal over time into frequency spectrum and subtracts the background. Plots the spectrum of \n",
    "    signal and noise in one plot and the corrected spectrum in another. Then finds the normal mode \n",
    "    of the corrected spectrum and returns both the normal mode and the frequency resolution of the spectrum.\n",
    "    \n",
    "    Args:\n",
    "        data (array):      signal over time of the oscillating wire\n",
    "        noise (array):     signal over time of the background (wire without orcillation)\n",
    "        fs (int):          sample rate that was used to record data and noise\n",
    "        peaks (int):       number of highest frequency peaks taken into account for the identification of the \n",
    "                           normal mode\n",
    "        name (str):        plotlabel of the data signal shown in plot\n",
    "        plot (bool):       if True, plots of frequency spectrums are shown\n",
    "        _xrange (list):    lower and upper limit for x-axis for plot\n",
    "        _yrange (list):    lower and upper limit for y-axis fot plot\n",
    "        expect_low (int):  lower limit for peak search to reduce false peaks from unexpected frequencies\n",
    "        expect_high (int): upper limit for peak search to reduce false peaks from unexpected frequencies\n",
    "        \n",
    "    Returns:\n",
    "        normalMode (float): identified normal mode of corrected spectrum\n",
    "        Δf (float):         frequncy resolution (bin width) of frequency spectrum\n",
    "        \n",
    "    '''\n",
    "    \n",
    "    N = len(data)  # = t * fs\n",
    "    T = 1 / fs\n",
    "    Δf = fs/(N) # [Hz]\n",
    "    expect_low=int(expect_low/Δf)\n",
    "    expect_high=int(expect_high/Δf)\n",
    "    \n",
    "    # Fourier transform of data and noise\n",
    "    fft_data = scipy.fft.fft(data)\n",
    "    fft_background = scipy.fft.fft(noise)\n",
    "    max_freq = int( fs / 2 ) # Nyquist theorem: only frequencies up to 0.5*fs\n",
    "    \n",
    "    \n",
    "    fft_abs = 2/N * abs(fft_data[:int(N/2)])\n",
    "    fft_noise = 2/N * abs(fft_background[:int(N/2)])\n",
    "    fft_corr = list(fft_abs - fft_noise)\n",
    "    fft_freq = np.arange(0, max_freq, Δf)\n",
    "    \n",
    "        \n",
    "    print(f'Frequency resolution is {Δf = } Hz')\n",
    "        \n",
    "    \n",
    "    ###########################################################################\n",
    "    # search frequency spectrum for amount of peaks given by parameter 'peaks'\n",
    "    ###########################################################################\n",
    "    \n",
    "    peak_count = 0\n",
    "    f_list = list()\n",
    "    a_list = list()\n",
    "    fft_orig = fft_corr.copy() # save copy of original corrected spectrum\n",
    "    while peak_count < peaks: \n",
    "        \n",
    "        # identify max peak and its width and collect frequency and amplitude in f_list and a_list\n",
    "        peak_idx = np.where(fft_corr == max(fft_corr[expect_low:expect_high]))[0][0]\n",
    "        width = int(peak_widths(fft_corr, [peak_idx], 0.9)[0][0])+1\n",
    "        max_f = fft_freq[peak_idx]\n",
    "        max_a = fft_corr[peak_idx]\n",
    "        f_list.append(max_f)\n",
    "        a_list.append(max_a)\n",
    "        \n",
    "        \n",
    "        # Savitzky-Golay filter to smooth peak data\n",
    "        window = 4*(2*int(width/2))+1\n",
    "        poly = 1\n",
    "        n = 0\n",
    "        success = False\n",
    "        while success == False and n < 10:\n",
    "            try:\n",
    "                fitted_peak = savgol_filter(fft_corr, window, poly, mode='constant', cval=0)\n",
    "                success = True\n",
    "            except ValueError:\n",
    "                window += 2\n",
    "                print('ValueError, trying to expand window:')\n",
    "                print(f'{window=}, {poly=}')\n",
    "                n += 1\n",
    "        \n",
    "        # max peak and width of filtered data\n",
    "        try:\n",
    "            if peak_idx <= width/2:\n",
    "                fitted_peak_idx = np.where(fitted_peak == max(fitted_peak[0:peak_idx+2*width+1]))[0][0]\n",
    "            else:    \n",
    "                fitted_peak_idx = np.where(fitted_peak == max(fitted_peak[peak_idx-1-width:peak_idx+1+width]))[0][0]\n",
    "        except ValueError: # break if no further peaks could be found because of ugly spectrum\n",
    "            break\n",
    "                \n",
    "        fitted_width = int(peak_widths(fitted_peak, [fitted_peak_idx], 0.8)[0][0]) + 2\n",
    "        if fitted_width <25/Δf:      # set minimum peak width to x Hz = x/Δf\n",
    "            fitted_width = int(25/Δf)\n",
    "        \n",
    "        # list containing fitted peak\n",
    "        fitted_peak_list = fft_corr[peak_idx-int(fitted_width/2):peak_idx+int(fitted_width/2)+1]\n",
    "        fitted_peak_length = len(fitted_peak_list)\n",
    "\n",
    "        # eliminate peak from fft_corr spectrum\n",
    "        fft_corr = fft_corr[:peak_idx-int(fitted_width/2)] + fitted_peak_length * [0] + fft_corr[peak_idx+int(fitted_width/2)+1:]\n",
    "             \n",
    "        peak_count += 1\n",
    "        # repeat process until all peaks are found and eliminated from fft_corr\n",
    "        \n",
    "    peaks = peak_count # number of found peaks\n",
    "    print(f_list)\n",
    "    \n",
    "    ##############################################################################\n",
    "    # Find normal mode of frequency peaks\n",
    "    ##############################################################################\n",
    "    \n",
    "    # sort f_list and a_list by frequency\n",
    "    f_list_sIdx = np.argsort(f_list)\n",
    "    f_list = [f_list[i] for i in f_list_sIdx]\n",
    "    a_list = [a_list[i] for i in f_list_sIdx]\n",
    "    \n",
    "    foundPeaks = f_list.copy()  # copy of list with frequencies of all identified peaks\n",
    "    afoundPeaks = a_list.copy() # copy of list with amplitudes of all identified peaks\n",
    "    \n",
    "    # calculate distances between peaks\n",
    "    l1 = f_list.copy()\n",
    "    a1 = a_list.copy()\n",
    "    l1.append(0)\n",
    "    a1.append(0)\n",
    "    l2 = f_list.copy()\n",
    "    a2 = a_list.copy()\n",
    "    l2.insert(0, 0)\n",
    "    a2.insert(0, 0)\n",
    "    \n",
    "    freqDistances = [l1[i]-l2[i] for i in range(len(l1)-1)]\n",
    "    aDistances = [(l1[i]-l2[i])/2 for i in range(len(l1)-1)]\n",
    "    fD_sIdx = np.argsort(freqDistances)\n",
    "    freqDistances = [freqDistances[i] for i in fD_sIdx]\n",
    "    aDistances = [aDistances[i] for i in fD_sIdx]\n",
    "    \n",
    "\n",
    "    # calculate mean of freqDistances that are within 5Hz of each other\n",
    "    meanlist  = []\n",
    "    meanalist = []\n",
    "    while freqDistances != []:\n",
    "        refFreq = min(freqDistances)\n",
    "        freqDistances.remove(refFreq)\n",
    "        meana = aDistances.pop(0)\n",
    "        mean = refFreq\n",
    "        count = 1\n",
    "        freqDistances_c = freqDistances.copy()\n",
    "        for d in freqDistances_c:\n",
    "            if d <= refFreq+5:\n",
    "                mean += d\n",
    "                meana += aDistances[freqDistances.index(d)]\n",
    "                count += 1\n",
    "                aDistances.pop(freqDistances.index(d))\n",
    "                freqDistances.remove(d)\n",
    "        for f in f_list:\n",
    "            if f <= refFreq+5:\n",
    "                mean += f\n",
    "                meana += a_list[f_list.index(f)]\n",
    "                count += 1\n",
    "                a_list.pop(f_list.index(f))\n",
    "                f_list.remove(f)\n",
    "        meanlist.append(mean/count)\n",
    "        meanalist.append(meana/count)\n",
    "\n",
    "    # make list of possible normal modes\n",
    "    possNormalModes = f_list + meanlist\n",
    "    aNormalModes = a_list + meanalist\n",
    "    pNM_sIdx = np.argsort(possNormalModes)\n",
    "    possNormalModes = [possNormalModes[i] for i in pNM_sIdx]\n",
    "    aNormalModes = [aNormalModes[i] for i in pNM_sIdx]\n",
    "    \n",
    "    if possNormalModes[0] < 0.1:   # because code doesn't work when 0 is contained in possNormalModes\n",
    "        possNormalModes.pop(0)\n",
    "        aNormalModes.pop(0)\n",
    "    \n",
    "    # starting from the lowest frequency in possNormalModes, check which of the other \n",
    "    # frequencies are multiples of the first (and therefore harmonics) and put them all \n",
    "    # in list newFreqGroup. Then collect newFreqGroup lists in harmonics list.\n",
    "    possNormalModes_c = possNormalModes.copy()\n",
    "    harmonics = []\n",
    "    totalAmp = 0\n",
    "    \n",
    "    #print(possNormalModes)\n",
    "\n",
    "    while possNormalModes != []:\n",
    "        newFreq = min(possNormalModes)\n",
    "        newFreqGroup = []\n",
    "        t_max = math.floor(max(possNormalModes)/newFreq)\n",
    "        totalAmp = 0\n",
    "        for f in possNormalModes_c:\n",
    "            for t in np.arange(1, t_max+1, 1):\n",
    "                if int(f)-2 <= int(t*newFreq) <= int(f)+2:\n",
    "                    try:\n",
    "                        possNormalModes.remove(f)\n",
    "                        newFreqGroup.append(f)\n",
    "                        totalAmp += aNormalModes[possNormalModes_c.index(f)]\n",
    "                        break\n",
    "                    except ValueError:\n",
    "                        break\n",
    "                    \n",
    "        newFreqGroup.insert(0, totalAmp*1e-6)\n",
    "        harmonics.append(newFreqGroup)\n",
    "\n",
    "    # sort lists in 'harmonics' by how many harmonics were found\n",
    "    harmonics.sort(key=len)\n",
    "    \n",
    "    try:\n",
    "        if len(harmonics[-1]) == len(harmonics[-2]):\n",
    "            # sort by total Amplitude    \n",
    "            harmonics.sort(key = lambda harmonics: harmonics[0])\n",
    "    except IndexError:\n",
    "        print('All peaks belong to same normal Mode')\n",
    "\n",
    "    normalMode = harmonics[-1][1]\n",
    "    n_harmonics = len(harmonics[-1])\n",
    "\n",
    "    ############################################################################\n",
    "    # Plot spectrum and peaks and normal mode\n",
    "    ############################################################################\n",
    "    \n",
    "    if plot == True:   \n",
    "        fig, axs = plt.subplots(1, 2, figsize=(11, 3.84))\n",
    "\n",
    "        ax = axs[0]\n",
    "        ax.axvline(normalMode, color='r', linestyle='--', label=f'{normalMode}')\n",
    "        ax.plot(fft_freq, fft_abs, label=name)\n",
    "        ax.plot(fft_freq, fft_noise, label='noise')\n",
    "\n",
    "        if _xrange is not None:\n",
    "            ax.set_xlim(_xrange[0],_xrange[1])\n",
    "        else:\n",
    "            #ax.set_xlim(min_freq-0.1*freq_span, max_freq+0.1*freq_span)\n",
    "            ax.set_xlim(0, 5000)\n",
    "        ax.set_xlabel('frequency [Hz]',fontsize=10)\n",
    "        ax.set_ylabel('amplitude a.u.',fontsize=10)\n",
    "        ax.legend()\n",
    "\n",
    "        ax = axs[1]\n",
    "        ax.plot(fft_freq, fft_orig, label='peaks')\n",
    "        #ax.plot(fft_freq, fft_corr, label='corrected spectrum')\n",
    "        ax.axvline(normalMode, color='r', linestyle='--', label='normal Mode')\n",
    "\n",
    "        if peaks == 1:\n",
    "            min_freq = foundPeaks[0] - 10\n",
    "            max_freq = foundPeaks[0] + 10\n",
    "        else:\n",
    "            min_freq = min(list(foundPeaks)+[normalMode])\n",
    "            max_freq = max(list(foundPeaks)+[normalMode])\n",
    "\n",
    "        freq_span = max_freq - min_freq\n",
    "\n",
    "        for f, a in zip(foundPeaks, afoundPeaks):\n",
    "            if f >= 0.5*freq_span + min_freq:\n",
    "                plt.annotate(f'{int(f)}Hz', (f, a), (f-0.15*freq_span, a), xycoords='data', \n",
    "                             arrowprops=dict(arrowstyle=\"->\"), ha='center', va='center')\n",
    "            else:\n",
    "                plt.annotate(f'{int(f)}Hz', (f, a), (f+0.15*freq_span, a), xycoords='data',\n",
    "                             arrowprops=dict(arrowstyle=\"->\"), ha='center', va='center')\n",
    "\n",
    "\n",
    "        \n",
    "        ax.set_xlim(min_freq-0.1*freq_span, max_freq+0.1*freq_span)\n",
    "        #ax.set_xlim(0,4000)\n",
    "        ax.set_xlabel('frequency [Hz]',fontsize=10)\n",
    "        ax.set_ylabel('amplitude a.u.',fontsize=10)\n",
    "        ax.legend(fontsize=10)\n",
    "        plt.show()\n",
    "    \n",
    "    print('possible normal modes:', possNormalModes_c)    \n",
    "    print('Maxima at:', foundPeaks, 'Hz')\n",
    "    print(f'{normalMode=}')\n",
    "    \n",
    "    return normalMode, Δf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c2524b2",
   "metadata": {},
   "source": [
    "# Measurement of several single wires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "64ee302a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def measureWire(picklename, senconds=int(3)):\n",
    "    '''\n",
    "    laser, nozzle and diode move to wire, position is entered for each wire\n",
    "    Record background and wire oscillation for wires of different tension, which are set with the wire clamp.\n",
    "    After every measurement, the recorded spectrum is shown and three different chioces can be made:\n",
    "        'c' (continue): the last measurement is saved and a new one will be taken\n",
    "        's' (stop):     the last measurement is saved and the measurement series finished\n",
    "        'r' (repeat):   the last measurement is not saved and a new measurement will be taken\n",
    "    When the measurement series is finished, the recorded signals as well as the wire parameters and steps of \n",
    "    the wire clamp are saved as a pickle file.\n",
    "    \n",
    "    Args:\n",
    "        picklename (str): name of pickle file in which measurement series is saved\n",
    "        s (float):        amount of time for which signals (both background and oscillation) are recorded\n",
    "        \n",
    "    The measurement series is saved as a pickle file containing the list [params, U, data] where\n",
    "        params (list): list containing initial length l of the wire, its diameter d and the weight m_0 with\n",
    "                       which it was initially set up in the wire clamp, all in SI units\n",
    "        U (list):      list containing the position of the threaded rod of the wire clamp, given in fractions \n",
    "                       of one full turn. One full turn elongates the wire by 1mm, therefore U also gives the \n",
    "                       elongation of the wire in mm.\n",
    "        data (list):   list containing lists [signal, noise] for every set value in U. signal is the measured\n",
    "                       signal while the wire was oscillating whereas noise is the signal measured while\n",
    "                       the wire was still.       \n",
    "    \n",
    "    '''\n",
    "    \n",
    "    U = []\n",
    "    s = []\n",
    "    data = []\n",
    "    toDo = 'c'\n",
    "    params = []\n",
    "    F=[]\n",
    "    dF=[]\n",
    "    \n",
    "    l = input('Wire length in millimeters:') #[mm]\n",
    "    d = input('Wire diameter in meters:') #[m]\n",
    "    m_0 = input('additional information') #[kg]\n",
    "    \n",
    "    params.append(l)\n",
    "    params.append(d)\n",
    "    params.append(m_0)\n",
    "    \n",
    "    while toDo == 'c':\n",
    "        position=0\n",
    "        newU = float(input('Type in current steps on rod turn '))/32 #one full turn of rod consists of 32 steps\n",
    "        steps=float(input('approx. Postion of wire in mm'))*3.35\n",
    "        #move to wire\n",
    "        position=move_to_wire((steps-20),position)\n",
    "        position=find_wire(position, steps=40, k=0.3, corr_steps=1, plot=False)\n",
    "        \n",
    "        #measure\n",
    "        noise = new_record(seconds=seconds)\n",
    "        GPIO.output(21, GPIO.HIGH)\n",
    "        time.sleep(.1)\n",
    "        GPIO.output(21, GPIO.LOW)\n",
    "        time.sleep(.1)\n",
    "        signal = new_record(seconds=seconds)\n",
    "        try:\n",
    "            f,df=findPeaks(signal, noise, peaks=5, plot=True, expect_low=50)\n",
    "        except ValueError:\n",
    "            print('ValueError')\n",
    "            \n",
    "        #move on starting position\n",
    "        auf_Anfang(position)\n",
    "        \n",
    "        toDo = input('type c for continue, s for stop or r for repeat')\n",
    "        if toDo == 'c':\n",
    "            clear_output()\n",
    "            print(f'Saving the last recording at wire number{newU}')\n",
    "            U.append(newU)\n",
    "            s.append(steps/3.35)\n",
    "            data.append([signal, noise])\n",
    "            F.append(f)\n",
    "            dF.append(df)\n",
    "            with open(picklename, 'wb') as f:\n",
    "                pickle.dump([params, U, s,  F, dF, data] , f)\n",
    "            \n",
    "        elif toDo == 'r':\n",
    "            clear_output()\n",
    "            print(f'Not saving the last recording wire number {newU}')\n",
    "            toDo = 'c'\n",
    "        elif toDo == 's':\n",
    "            clear_output()\n",
    "            F.append(f)\n",
    "            dF.append(df)\n",
    "            U.append(newU)\n",
    "            s.append(steps/3.35)\n",
    "            data.append([signal, noise])\n",
    "            print(f'Saving the last recording at wire number {newU} and stopping measurement')\n",
    "     # save measurement series with pickle\n",
    "    with open(picklename, 'wb') as f:\n",
    "        pickle.dump([params, U, s, F, dF, data] , f) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ac29c448",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wire length in millimeters:1\n",
      "Wire diameter in meters:0.22\n",
      "additional information\n",
      "Type in current steps on rod turn 0\n",
      "approx. Postion of wire in mm875\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'seconds' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-64dea833546f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmeasureWire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'test 1'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-19-b0b3eddbdb91>\u001b[0m in \u001b[0;36mmeasureWire\u001b[0;34m(picklename, senconds)\u001b[0m\n\u001b[1;32m     51\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     52\u001b[0m         \u001b[0;31m#measure\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m         \u001b[0mnoise\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_record\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseconds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseconds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     54\u001b[0m         \u001b[0mGPIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m21\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGPIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHIGH\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m         \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'seconds' is not defined"
     ]
    }
   ],
   "source": [
    "measureWire('test 1')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cfd581e",
   "metadata": {},
   "source": [
    "# Measurement of a single wire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e48702d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "approx. Postion of wire in mm875\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting recording\n",
      "finished\n",
      "Starting recording\n",
      "finished\n",
      "Frequency resolution is Δf = 0.3333333333333333 Hz\n",
      "[53.666666666666664, 124.33333333333333, 86.0, 154.66666666666666, 202.33333333333331]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x276.48 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "possible normal modes: [31.333333333333332, 38.33333333333333, 47.66666666666666, 53.666666666666664, 86.0, 124.33333333333333, 154.66666666666666, 202.33333333333331]\n",
      "Maxima at: [53.666666666666664, 86.0, 124.33333333333333, 154.66666666666666, 202.33333333333331] Hz\n",
      "normalMode=31.333333333333332\n",
      "ready again\n"
     ]
    }
   ],
   "source": [
    "position=0\n",
    "steps=float(input('approx. Postion of wire in mm'))*3.35 #eigentlich 3,57\n",
    "#search in approx. 1cm \n",
    "position=move_to_wire((steps-20),position)\n",
    "position=find_wire(position, steps=40, k=0.3, corr_steps=1, plot=True)\n",
    "\n",
    "background=new_record(seconds=3, plot=False)\n",
    "\n",
    "GPIO.output(21, GPIO.HIGH)\n",
    "time.sleep(.08)\n",
    "GPIO.output(21, GPIO.LOW)\n",
    "time.sleep(.2)\n",
    "recording=new_record(seconds=3, plot=False)\n",
    "\n",
    "findPeaks(recording, background, peaks=5, plot=True, _xrange=[0,4000],expect_low=20)\n",
    "\n",
    "auf_Anfang(position)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b71e63bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Release the stepper motor to move sled by hand or if not use for a longer time\n",
    "GPIO.output(ENA, ENA_Released) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b322baa4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}